Merge pull request #46 from plotly/callback_context

Callback context

Author: waralex

.circleci/config.yml

@@ -28,7 +28,7 @@ jobs:
       - run:
           name: 🔎 Unit tests
           command: |
-            julia -e 'using Pkg; Pkg.update(); Pkg.add(PackageSpec(url="https://github.com/plotly/Dash.jl.git", rev=ENV["CIRCLE_BRANCH"])); Pkg.add(PackageSpec(url="https://github.com/waralex/dash-html-components.git", rev="jl_generator_test")); Pkg.add(PackageSpec(url="https://github.com/waralex/dash-core-components.git", rev="jl_generator_test")); Pkg.build("Dash"); Pkg.build("DashHtmlComponents"); Pkg.build("DashCoreComponents"); Pkg.test("Dash", coverage=true); function precompile_pkgs(); for pkg in collect(keys(Pkg.installed())); if !isdefined(Symbol(pkg), :Symbol) && pkg != "Compat.jl"; @info("Importing $(pkg)..."); try (@eval import $(Symbol(pkg))) catch end; end; end; end; precompile_pkgs()'
+            julia test/ci_prepare.jl 
 
       - run:
           name: ⚙️  Integration tests

Project.toml

@@ -30,4 +30,4 @@ julia = "1.1"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test"]
+test = ["Test"]

src/Contexts/Contexts.jl

@@ -0,0 +1,61 @@
+module Contexts
+
+using DataStructures: Stack
+
+export TaskContextStorage, with_context, has_context, get_context
+
+mutable struct ContextItem{T}
+    value::T
+    ContextItem(value::T) where {T} = new{T}(value)
+end
+
+struct TaskContextStorage
+    storage::Dict{UInt64, Stack{ContextItem}}
+    guard::ReentrantLock
+    TaskContextStorage() = new(Dict{UInt64, Stack{ContextItem}}(), ReentrantLock())
+end
+
+#threads are runing as tasks too, so this id also unique for different threads
+curr_task_id() = objectid(current_task())
+
+#thread unsafe should be used under locks
+get_curr_stack!(context::TaskContextStorage) = get!(context.storage, curr_task_id(), Stack{ContextItem}())
+
+
+function Base.push!(context::TaskContextStorage, item::ContextItem)
+    lock(context.guard) do
+        push!(get_curr_stack!(context), item)
+    end
+end
+
+function Base.pop!(context::TaskContextStorage)
+    return lock(context.guard) do
+        return pop!(get_curr_stack!(context))
+    end
+end
+
+function Base.isempty(context::TaskContextStorage)
+    return lock(context.guard) do
+        return isempty(get_curr_stack!(context))
+    end
+end
+
+function with_context(f, context::TaskContextStorage, item::ContextItem)
+    push!(context, item)
+    result = f()
+    pop!(context)
+    return result
+end
+
+with_context(f, context::TaskContextStorage, item) = with_context(f, context, ContextItem(item))
+
+has_context(context::TaskContextStorage) = !isempty(context)
+
+function get_context(context::TaskContextStorage)
+    return lock(context.guard) do
+        isempty(context) && throw(ArgumentError("context is not set"))
+        return first(get_curr_stack!(context)).value
+    end
+end
+
+end

src/Dash.jl

@@ -1,27 +1,27 @@
 module Dash
 import HTTP, JSON2, CodecZlib, MD5
 using Sockets
-using MacroTools
 const ROOT_PATH = realpath(joinpath(@__DIR__, ".."))
 include("Components.jl")
 include("Front.jl")
+include("HttpHelpers/HttpHelpers.jl")
 import .Front
 using .Components
+using .HttpHelpers
 
 export dash, Component, Front, callback!,
 enable_dev_tools!, ClientsideFunction,
 run_server, PreventUpdate, no_update, @var_str,
-Input, Output, State, make_handler
+Input, Output, State, make_handler, callback_context
 
-
-
-#ComponentPackages.@reg_components()
+include("Contexts/Contexts.jl")
 include("env.jl")
 include("utils.jl")
 include("app.jl")
 include("resources/registry.jl")
 include("resources/application.jl")
 include("handlers.jl")
+include("server.jl")
 
 @doc """
     module Dash
@@ -47,10 +47,10 @@ app = dash(external_stylesheets=["https://codepen.io/chriddyp/pen/bWLwgP.css"])
                 
     end
 end
-callback!(app, callid"{graphTitle.type} graphTitle.value => outputID.children") do type, value
+callback!(app, Output("outputID", "children"), Input("graphTitle","value"), State("graphTitle","type")) do value, type
     "You've entered: '\$(value)' into a '\$(type)' input control"
 end
-callback!(app, callid"graphTitle.value => graph.figure") do value
+callback!(app, Output("graph", "figure"), Input("graphTitle", "value")) do value
     (
         data = [
             (x = [1,2,3], y = abs.(randn(3)), type="bar"),
@@ -59,108 +59,11 @@ callback!(app, callid"graphTitle.value => graph.figure") do value
         layout = (title = value,)
     )
 end
-handle = make_handler(app, debug = true)
-run_server(handle, HTTP.Sockets.localhost, 8050)
-```
-
-""" Dashboards
-
-
-"""
-    run_server(app::DashApp, host = HTTP.Sockets.localhost, port = 8050; debug::Bool = false)
-
-Run Dash server
-
-#Arguments
-- `app` - Dash application
-- `host` - host
-- `port` - port
-- `debug::Bool = false` - Enable/disable all the dev tools
-
-#Examples
-```jldoctest
-julia> app = dash() do
-    html_div() do
-        html_h1("Test Dashboard")
-    end
-end
-julia>
-julia> run_server(handler,  HTTP.Sockets.localhost, 8050)
+run_server(app, HTTP.Sockets.localhost, 8050)
 ```
 
-"""
-function run_server(app::DashApp, host = HTTP.Sockets.localhost, port = 8050;
-            debug = nothing, 
-            dev_tools_ui = nothing,
-            dev_tools_props_check = nothing,
-            dev_tools_serve_dev_bundles = nothing,
-            dev_tools_hot_reload = nothing,
-            dev_tools_hot_reload_interval = nothing,
-            dev_tools_hot_reload_watch_interval = nothing,
-            dev_tools_hot_reload_max_retry = nothing,
-            dev_tools_silence_routes_logging = nothing,
-            dev_tools_prune_errors = nothing
-            )
-    @env_default!(debug, Bool, false)
-    enable_dev_tools!(app, 
-        debug = debug,
-        dev_tools_ui = dev_tools_ui,
-        dev_tools_props_check = dev_tools_props_check,
-        dev_tools_serve_dev_bundles = dev_tools_serve_dev_bundles,
-        dev_tools_hot_reload = dev_tools_hot_reload,
-        dev_tools_hot_reload_interval = dev_tools_hot_reload_interval,
-        dev_tools_hot_reload_watch_interval = dev_tools_hot_reload_watch_interval,
-        dev_tools_hot_reload_max_retry = dev_tools_hot_reload_max_retry,
-        dev_tools_silence_routes_logging = dev_tools_silence_routes_logging,
-        dev_tools_prune_errors = dev_tools_prune_errors
-    )
-    main_func = () -> begin
-        ccall(:jl_exit_on_sigint, Cvoid, (Cint,), 0)
-        handler = make_handler(app);
-        try
-            task = @async HTTP.serve(handler, host, port)
-            @info string("Running on http://", host, ":", port)
-            wait(task)
-        catch e
-            if e isa InterruptException
-                @info "exited"
-            else
-                rethrow(e)
-            end
-
-        end
-    end
-    start_server = () -> begin
-        handler = make_handler(app);
-        server = Sockets.listen(get_inetaddr(host, port))
-        task = @async HTTP.serve(handler, host, port; server = server)
-        @info string("Running on http://", host, ":", port)
-        return (server, task)
-    end
+""" Dash
 
-    if get_devsetting(app, :hot_reload) && !is_hot_restart_available()
-        @warn "Hot reloading is disabled for interactive sessions. Please run your app using julia from the command line to take advantage of this feature."
-    end
 
-    if get_devsetting(app, :hot_reload) && is_hot_restart_available()
-        hot_restart(start_server, check_interval = get_devsetting(app, :hot_reload_watch_interval))
-    else
-        (server, task) = start_server()
-        try
-            wait(task)
-            println(task)
-        catch e
-            close(server)
-            if e isa InterruptException 
-                println("finished")
-                return
-            else
-                rethrow(e)
-            end
-        end
-    end
-end
-get_inetaddr(host::String, port::Integer) = Sockets.InetAddr(parse(IPAddr, host), port)
-get_inetaddr(host::IPAddr, port::Integer) = Sockets.InetAddr(host, port)
 
 end # module

src/HttpHelpers/HttpHelpers.jl

@@ -0,0 +1,10 @@
+module HttpHelpers
+
+export state_handler, compress_handler, Route, Router, add_route!
+
+import HTTP, CodecZlib
+
+include("handlers.jl")
+include("router.jl")
+
+end

src/handler/base.jl renamed to src/HttpHelpers/handlers.jl

@@ -11,9 +11,6 @@ const Input = Dependency{TraitInput}
 const State = Dependency{TraitState}
 const Output = Dependency{TraitOutput}
 
-const IdProp = Tuple{Symbol, Symbol}
-
-
 
 struct CallbackDeps
     output ::Vector{Output}
@@ -36,6 +33,11 @@ struct Callback
     dependencies ::CallbackDeps
 end
 
+is_multi_out(cb::Callback) = cb.dependencies.multi_out == true
+get_output(cb::Callback) = cb.dependencies.output
+get_output(cb::Callback, i) = cb.dependencies.output[i]
+first_output(cb::Callback) = first(cb.dependencies.output)
+
 struct PreventUpdate <: Exception
 
 end

src/handler/router.jl renamed to src/HttpHelpers/router.jl

@@ -0,0 +1,46 @@
+using .Contexts
+const CallbackContextItems = Union{Nothing, Vector{NamedTuple}}
+const TriggeredParam = NamedTuple{(:prop_id, :value)}
+mutable struct CallbackContext
+    response::HTTP.Response
+    inputs::Dict{String, Any}
+    states::Dict{String, Any}
+    outputs_list::Vector{Any}
+    inputs_list::Vector{Any}
+    states_list::Vector{Any}
+    triggered::Vector{TriggeredParam}
+    function CallbackContext(response, outputs_list, inputs_list, states_list, changed_props)
+        input_values = inputs_list_to_dict(inputs_list)
+        state_values = inputs_list_to_dict(states_list)
+        triggered = TriggeredParam[(prop_id = id, value = input_values[id]) for id in changed_props]
+        return new(response, input_values, state_values, outputs_list, inputs_list, states_list, triggered)
+    end
+end
+
+const _callback_context_storage = TaskContextStorage()
+
+function with_callback_context(f, context::CallbackContext) 
+    return with_context(f, _callback_context_storage, context)
+end 
+
+"""
+    callback_context()::CallbackContext
+
+    Get context of current callback, available only inside callback processing function
+"""
+function callback_context() 
+    !has_context(_callback_context_storage) && error("callback_context() is only available from a callback processing function")
+    return get_context(_callback_context_storage)
+end
+
+function inputs_list_to_dict(list::Vector{Any})
+    result = Dict{String, Any}()
+    _item_to_dict!.(Ref(result), list)
+    return result
+end
+
+function _item_to_dict!(target::Dict{String, Any}, item)
+    target["$(item.id).$(item.property)"] = get(item, :value, nothing)
+end
+
+_item_to_dict!(target::Dict{String, Any}, item::Vector) =  _item_to_dict!.(Ref(target), item)