Julia for Pythonistas

module ColorBase

abstract type AbstractColor end

struct RGB{T} <: AbstractColor
  r::T
  g::T
  b::T
end

Base.Tuple(rgb::RGB) = (rgb.r, rgb.g, rgb.b)

function Base.:(+)(a::T, b::T) where T <: AbstractColor
  tuple = (Tuple(a) .+ Tuple(b))
  return T(tuple...)
end

export AbstractColor

end

module ColorExtensions

using ..ColorBase # Syntax for using module in same namespace

struct XYZSpace{T} <: AbstractColor
  x::T
  y::T
  z::T
end

Base.Tuple(hsl::XYZSpace) = (hsl.x, hsl.y, hsl.z)
export XYZSpace

end;

using .ColorExtensions, .ColorBase

xyz = XYZSpace(0.1, 0.33, 0.5) + XYZSpace(0.1, 0.2, 0.3)

using CSV, DataFrames, Plots, StatsPlots
theme(:wong)
data = CSV.read(
emissions.csv
)
data.co2 = data.co2 ./ 10^9;
co2max = by(data, :country, :co2 => maximum)
sort!(co2max, :co2_maximum, rev = true)
bad_countries = co2max.country[1:10]
the_worst = filter(data) do row
  row.country in bad_countries
end
@df the_worst plot(
  :Year, :co2, group = :country, legend = :topleft, linewidth = 4,
  title = "Total Accumulative Emission"
)

using FileIO, Query, VegaLite, Dates
data |>
  @mutate(co2 = _.co2, year = Date(_.Year)) |>
  @groupby({_.country}) |>
  @orderby_descending(maximum(_.co2)) |>
  @take(5) |>
  @mapmany(_, __) |>  # This is essentially ungroup
  DataFrame |>
  @vlplot(
    :line, x=:year, y=:co2, color=:country, title="Emissions",
    width = 500, height = 300
  )

using Flux
using Flux: crossentropy, normalise, onecold, onehotbatch, params
using Statistics: mean

labels = Flux.Data.Iris.labels()
features = Flux.Data.Iris.features()

normed_features = normalise(features, dims=2)
klasses = sort(unique(labels))
onehot_labels = onehotbatch(labels, klasses)

train_indices = [1:3:150 ; 2:3:150]
X_train = normed_features[:, train_indices]
y_train = onehot_labels[:, train_indices]
X_test = normed_features[:, 3:3:150]
y_test = onehot_labels[:, 3:3:150]

model = Chain(
    Dense(4, 3), # A normal Julia type, predefined in Flux
    softmax # A normal julia function
)

loss(x, y) = crossentropy(model(x), y)
accuracy(x, y) = mean(onecold(model(x)) .== onecold(y))

data_iterator = Iterators.repeated((X_train, y_train), 110)
Flux.train!(loss, params(model), data_iterator, Descent(0.5))

accuracy_score = accuracy(X_test, y_test)
accuracy_score > 0.8

using Cassette
Cassette.@context Ctx
# this prehook implements simple trace logging for overdubbed functions
Cassette.prehook(::Ctx, f, args...) = println(f, args)
Cassette.overdub(Ctx(), *, 1, 2.0)

Cassette.overdub(::Ctx, ::typeof(convert), ::Type{Float64}, x::Float64) = x * 3.0

Cassette.overdub(Ctx(), *, 1, 2.0)

using Mimi, MimiDICE2013
using AbstractPlotting, WGLMakie, Markdown
using Observables, Hyperscript, JSServe
using JSServe: with_session, Slider
using JSServe.DOM
using AbstractPlotting: scatter, scatter!
set_theme!(markersize = 5,font = "Dejavu Sans", resolution = (500, 400))

baseline = MimiDICE2013.get_model()
run(baseline)
interacted = MimiDICE2013.get_model()

with_session() do session
  time_tatm = getdataframe(baseline, :climatedynamics, :TATM)
  time = time_tatm.time
  control_rate_s = JSServe.Slider(LinRange(0, 1, 100))
  control_rate = map(control_rate_s) do r
    round(r, digits = 3)
  end
  year = JSServe.Slider(1:length(time))
  data = map(control_rate) do control
    set_param!(interacted, :emissions, :MIU, fill(control, 60))
		run(interacted)
  	return something.(interacted[:climatedynamics, :TATM], 0.0)
  end
  scene = scatter(time, something.(time_tatm.TATM, 0.0))
  scatter!(time, data, color = :red)
  scene[Axis].names.axisnames = ("Year", "Temperature Increase")
  scene[Axis].names.textsize = (8, 8)
  dmg_estimated = map(year, control_rate) do year_idx, _
    round(interacted[:damages, :DAMAGES][year_idx], digits = 4)
  end
	selected_year = map(i-> time[i], year)
  b = DOM.font("● baseline", color = :black)
  ec = DOM.font("● with emission control", color = :red)
  return md"""
    # Explore Climate

    Set amount of emission control: $(control_rate_s) $(control_rate)
    # Temperature Increase

    $b | $ec

    $(scene)

    # Estimated damage in year $(selected_year)

    $(year)

    $(dmg_estimated) trillion USD per year.
  """
end