Merge dev with first release candidate to master

.circleci/config.yml

@@ -0,0 +1,58 @@
+version: 2
+
+jobs:
+
+  test:
+    working_directory: ~/dashjl 
+    docker:
+      - image: plotly/julia:ci 
+        environment:
+          PERCY_PARALLEL_TOTAL: '-1'
+          PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: 'True'
+
+    steps:
+      - checkout
+
+      - run:
+          name: ℹ️  CI Context
+          command: |
+            echo "TRIGGERER: ${CIRCLE_USERNAME}"
+            echo "BUILD_NUMBER: ${CIRCLE_BUILD_NUM}"
+            echo "BUILD_URL: ${CIRCLE_BUILD_URL}"
+            echo "BRANCH: ${CIRCLE_BRANCH}"
+            echo "RUNNING JOB: ${CIRCLE_JOB}"
+            echo "JOB PARALLELISM: ${CIRCLE_NODE_TOTAL}"
+            echo "CIRCLE_REPOSITORY_URL: ${CIRCLE_REPOSITORY_URL}"
+            echo $CIRCLE_JOB > circlejob.txt
+
+      - run:
+          name: 🔎 Unit tests
+          command: |
+            julia test/ci_prepare.jl 
+
+      - run:
+          name: ⚙️  Integration tests
+          command: |
+            python -m venv venv
+            . venv/bin/activate
+            git clone --depth 1 https://github.com/plotly/dash.git -b dev dash-main
+            cd dash-main && pip install -e .[dev,testing] --progress-bar off && cd ~/dashjl 
+            export PATH=$PATH:/home/circleci/.local/bin/
+            pytest --headless --nopercyfinalize --junitxml=test-reports/dashjl.xml --percy-assets=test/assets/ test/integration/
+      - store_artifacts:
+          path: test-reports
+      - store_test_results:
+          path: test-reports
+      - store_artifacts:
+          path: /tmp/dash_artifacts
+
+      - run:
+          name: 🦔 percy finalize
+          command: npx percy finalize --all
+          when: always
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      - "test"

.gitattributes

@@ -0,0 +1 @@
+resources/* linguist-vendored

.github/workflows/lint.yml

@@ -0,0 +1,15 @@
+name: Lint Markdown
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js
+        uses: actions/setup-node@v1
+        with:
+          node-version: '12.x'
+      - run: npm install -g [email protected]
+      - run: markdownlint '**/*.md' --ignore node_modules

.gitignore

@@ -8,4 +8,7 @@ components/*
 lib/*
 Manifest.toml
 .DS_Store
-docs/build
+docs/build
+venv
+*.pyc
+tmp

.markdownlint.yml

@@ -0,0 +1,14 @@
+# MD001 Header levels should only increment by one level at a time
+MD001: false
+
+# MD013 Line length
+MD013: false
+
+# MD022 Headers should be surrounded by blank lines
+MD022: false
+
+# MD026 Trailing punctuation in header
+MD026: false
+
+# MD032 Lists should be surrounded by blank lines
+MD032: false

CHANGELOG.md

@@ -0,0 +1,30 @@
+# Change Log for Dash for Julia
+All notable changes to this project will be documented in this file. This project adheres to Semantic Versioning.
+
+## [UNRELEASED]
+### Added
+- Support for client side callbacks [#30](https://github.com/plotly/Dash.jl/pull/30)
+- Support for hot reloading on application or asset changes [#25](https://github.com/plotly/Dash.jl/pull/25)
+- Asset serving of CSS, JavaScript, and other resources [#18](https://github.com/plotly/Dash.jl/pull/18)
+- Support for passing functions as layouts [#18](https://github.com/plotly/Dash.jl/pull/18)
+- Resource registry for component assets [#18](https://github.com/plotly/Dash.jl/pull/18)
+- Asynchronous component loading & fingerprinting component assets [#18](https://github.com/plotly/Dash.jl/pull/18)
+- Developer tools UI support [#18](https://github.com/plotly/Dash.jl/pull/18)
+- Dash environment variables are now supported [#18](https://github.com/plotly/Dash.jl/pull/18)
+- Index page/layout validation now performed [#18](https://github.com/plotly/Dash.jl/pull/18)
+- Support for `gzip` compression [#14](https://github.com/plotly/Dash.jl/pull/14)
+- Parity with core Dash API parameters [#12](https://github.com/plotly/Dash.jl/pull/12)
+- Integration tests are now supported, server startup message appears on app initialization [#21](https://github.com/plotly/Dash.jl/pull/21)
+
+### Changed
+- Dash.jl now starts via `run_server` with `host` and `port` arguments [#2](https://github.com/plotly/Dash.jl/issues/2)
+- Defining layouts in Dash.jl now occurs similarly to Dash for Python/R [#1](https://github.com/plotly/Dash.jl/issues/1)
+
+### Removed
+- `make_handler` no longer used to start Dash server [#2](https://github.com/plotly/Dash.jl/issues/2)
+- `layout_maker` has been removed [#18](https://github.com/plotly/Dash.jl/pull/18)
+- `layout_maker` is no longer called by the app developer to define the layout [#1](https://github.com/plotly/Dash.jl/issues/1)
+
+### Fixed
+- Request headers are now properly specified [#28](https://github.com/plotly/Dash.jl/issues/28)
+- Unspecified `children` now passed as `nothing` rather than undefined [#27](https://github.com/plotly/Dash.jl/issues/27)

Project.toml

@@ -4,23 +4,35 @@ authors = ["Alexandr Romanenko"]
 version = "0.1.0"
 
 [deps]
+CodecZlib = "944b1d66-785c-5afd-91f1-9de20f533193"
+DashBase = "03207cf0-e2b3-4b91-9ca8-690cf0fb507e"
+DashCoreComponents = "1b08a953-4be3-4667-9a23-9da06441d987"
+DashHtmlComponents = "1b08a953-4be3-4667-9a23-24100242a84a"
+DashTable = "1b08a953-4be3-4667-9a23-f0e2ba4deb9a"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3"
 JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
 JSON2 = "2535ab7d-5cd8-5a07-80ac-9b1792aadce3"
-LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
+MD5 = "6ac74813-4b46-53a4-afec-0b5dc9d7885c"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 PlotlyBase = "a03496cd-edff-5a9b-9e67-9cda94a718b5"
+Sockets = "6462fe0b-24de-5631-8697-dd941f90decc"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 
 [compat]
-julia = "1.1"
+CodecZlib = "0.7.0"
+DashBase = "0.1.0"
+DashCoreComponents = "1.10.2"
+DashHtmlComponents = "1.0.3"
+DashTable = "4.9.0"
 DataStructures = "0.17.5"
-HTTP = "0.8.6"
+HTTP = "0.8.10"
 JSON = "0.21.0"
 JSON2 = "0.3.1"
 MacroTools = "0.5.1"
 PlotlyBase = "0.3.0"
+julia = "1.1"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

README.md

@@ -1,4 +1,4 @@
-## Dash for Julia
+# Dash for Julia
 
 #### Create beautiful, analytic applications in Julia.
 
@@ -8,11 +8,23 @@ Built on top of Plotly.js, React and HTTP.jl, [Dash](https://plotly.com/dash/) t
 
 ## Installation
 
-Julia version >= 1.2 is required.
-It also works in 1.1 now, but I do not plan testing and support for versions under 1.2
+Please ensure that you are using a version of Julia >= 1.2.
+
+To install the most recently released version:
+
+```julia
+using Pkg; Pkg.add(PackageSpec(url="https://github.com/plotly/Dash.jl.git"))
+```
+
+To install the latest (stable) development version instead:
 
 ```julia
-import Pkg; Pkg.add(Pkg.PackageSpec(url = "https://github.com/plotly/Dash.jl.git"))
+using Pkg
+Pkg.add(PackageSpec(url="https://github.com/plotly/DashBase.jl.git"))
+Pkg.add(PackageSpec(url="https://github.com/plotly/dash-html-components.git", rev="master"))
+Pkg.add(PackageSpec(url="https://github.com/plotly/dash-core-components.git", rev="master"))
+Pkg.add(PackageSpec(url="https://github.com/plotly/dash-table.git", rev="master"))
+Pkg.add(PackageSpec(url="https://github.com/plotly/Dash.jl.git", rev="dev"))
 ```
 
 ## Usage
@@ -21,8 +33,11 @@ import Pkg; Pkg.add(Pkg.PackageSpec(url = "https://github.com/plotly/Dash.jl.git
 
 ```jldoctest
 julia> using Dash
-julia> app = dash("Test app", external_stylesheets = ["https://codepen.io/chriddyp/pen/bWLwgP.css"])
-
+julia> using DashHtmlComponents
+julia> using DashCoreComponents
+
+julia> app = dash(external_stylesheets = ["https://codepen.io/chriddyp/pen/bWLwgP.css"])
+
 julia> app.layout = html_div() do
         html_h1("Hello Dash"),
         html_div("Dash.jl: Julia interface for Dash"),
@@ -37,71 +52,79 @@ julia> app.layout = html_div() do
             )
         )
     end
+
 julia> run_server(app, "0.0.0.0", 8080)
 ```
-* The `DashApp` struct represent dashboard application.
-* To make `DashApp` struct use `dash(layout_maker::Function, name::String;  external_stylesheets::Vector{String} = Vector{String}(), url_base_pathname="/", assets_folder::String = "assets")`` where `layout_maker` is a function with signature ()::Component
-* Unlike the python version where each Dash component is represented as a separate class, all components in Dash.jl are represented by struct `Component`.
-* You can create `Component` specific for concrete Dash component by the set of functions in the form ``lowercase(<component package>)_lowercase(<component name>)``. For example, in python html `<div>` element is represented as `HTML.Div` in Dasboards it is created using function `html_div`
-* The list of all supported components is available in docstring for Dasboards module
-* All functions for a component creation have the signature `(;kwargs...)::Component`. List of key arguments specific for the concrete component is available in the docstring for each function
-* Functions for creation components which have `children` property have two additional methods ``(children::Any; kwargs...)::Component`` and ``(children_maker::Function; kwargs..)::Component``. `children` must by string or number or single component or collection of components
-* ``make_handler(app::Dash; debug::Bool = false)`` makes handler function for using in HTTP package
 
+* The `DashApp` struct represents a dashboard application.
+* To make `DashApp` struct use `dash(layout_maker::Function, name::String;  external_stylesheets::Vector{String} = Vector{String}(), url_base_pathname="/", assets_folder::String = "assets")` where `layout_maker` is a function with signature ()::Component
+* Unlike the Python version where each Dash component is represented as a separate class, all components in Dash.jl are represented by struct `Component`.
+* You can create `Component` specific for concrete Dash component by the set of functions in the form ``lowercase(<component package>)_lowercase(<component name>)``. For example, in Python html `<div>` element is represented as `HTML.Div` in Dashboards it is created using function `html_div`
+* The list of all supported components is available in docstring for Dashboards module.
+* All functions for a component creation have the signature `(;kwargs...)::Component`. List of key arguments specific for the concrete component is available in the docstring for each function.
+* Functions for creation components which have `children` property have two additional methods ``(children::Any; kwargs...)::Component`` and ``(children_maker::Function; kwargs..)::Component``. `children` must by string or number or single component or collection of components.
+* ``make_handler(app::Dash; debug::Bool = false)`` makes a handler function for using in HTTP package.
 
 __Once you have run the code to create the Dashboard, go to `http://127.0.0.1:8080` in your browser to view the Dashboard!__
 
 ### Basic Callback
+
 ```jldoctest
 
 julia> using Dash
-julia> app = dash("Test app", external_stylesheets = ["https://codepen.io/chriddyp/pen/bWLwgP.css"])
+julia> using DashHtmlComponents
+julia> using DashCoreComponents
+
+julia> app = dash(external_stylesheets = ["https://codepen.io/chriddyp/pen/bWLwgP.css"])
 
 julia> app.layout = html_div() do
         dcc_input(id = "my-id", value="initial value", type = "text"),
-        html_div(id = "my-div")        
+        html_div(id = "my-div")
     end
 
-julia> callback!(app, callid"my-id.value => my-div.children") do input_value
+julia> callback!(app, Output("my-div", "children"), Input("my-id", "value")) do input_value
     "You've entered $(input_value)"
 end
-julia> run_server(app, "0.0.0.0", 8080)
 
+julia> run_server(app, "0.0.0.0", 8080)
 ```
-* You can make your dashboard interactive by register callbacks for changes in frontend with function ``callback!(func::Function, app::Dash, id::CallbackId)``
-* Inputs and outputs (and states, see below) of callback are described by struct `CallbackId` which can easily created by string macro `callid""`
-* `callid""` parse string in form ``"[{state1 [,...]}] input1[,...] => output1[,...]"`` where all items is ``"<element id>.<property name>"``
-* Callback function must have the signature(states..., inputs...) and return data for output
+
+* You can make your dashboard interactive by register callbacks for changes in frontend with function ``callback!(func::Function, app::Dash, output, input, state)``
+* Inputs and outputs (and states, see below) of callback can be `Input`, `Output`, `State` objects or vectors of this objects
+* Callback function must have the signature(inputs..., states...), and provide a return value comparable (in terms of number of elements) to the outputs being updated.
 
 ### States and Multiple Outputs
+
 ```jldoctest
 julia> using Dash
-julia> app = dash("Test app", external_stylesheets = ["https://codepen.io/chriddyp/pen/bWLwgP.css"])
-
+julia> using DashHtmlComponents
+julia> using DashCoreComponents
+
+julia> app = dash(external_stylesheets = ["https://codepen.io/chriddyp/pen/bWLwgP.css"])
+
 julia> app.layout = html_div() do
         dcc_input(id = "my-id", value="initial value", type = "text"),
         html_div(id = "my-div"),
-        html_div(id = "my-div2")        
+        html_div(id = "my-div2")
     end
 
-julia> callback!(app, callid"{my-id.type} my-id.value => my-div.children, my-div2.children") do state_value, input_value
+julia> callback!(app, [Output("my-div","children"), Output("my-div2","children")], Input("my-id", "value"), State("my-id", "type")) do input_value, state_value
     "You've entered $(input_value) in input with type $(state_value)",
     "You've entered $(input_value)"
 end
 julia> run_server(app, "0.0.0.0", 8080)
 ```
-* For multiple output callback must return any collection with element for each output
 
-## Comparation with original python syntax
+## Comparison with original Python syntax
 
 ### component naming:
 
 `html.Div` => `html_div`, `dcc.Graph` => `dcc_graph` and etc
 
 ### component creation:
 
-Just like in Python, functions for creating components have keywords arguments, which are the same as in Python. ``html_div(id="my-id", children="Simple text")``.
-For components that have `children` prop, two additional signatures are available. ``(children; kwargs..)`` and ``(children_maker::Function; kwargs...)`` so You can write ``html_div("Simple text", id="my-id")``  for simple elements or avoid the hell of nested brackets with `do` syntax for complex elements:
+Just as in Python, functions for declaring components have keyword arguments, which are the same as in Python. ``html_div(id="my-id", children="Simple text")``.
+For components which declare `children`, two additional signatures are available. ``(children; kwargs..)`` and ``(children_maker::Function; kwargs...)`` so one can write ``html_div("Simple text", id="my-id")`` for simple elements, or choose an abbreviated syntax with `do` syntax for complex elements:
 
 ```julia
 html_div(id="outer-div") do
@@ -111,25 +134,30 @@ html_div(id="outer-div") do
     end
 end
 ```
+
 ### application and layout:
 
 * python:
+
 ```python
 app = dash.Dash("Test", external_stylesheets=external_stylesheets)
 app.layout = html.Div(children=[....])
 ```
 
 * Dash.jl:
+
 ```julia
-app = dash("Test", external_stylesheets=external_stylesheets) 
+app = dash("Test", external_stylesheets=external_stylesheets)
 
 app.layout = html_div() do
     ......
    end
-
 ```
+
 ### callbacks:
-* python:
+
+* Python:
+
 ```python
 @app.callback(Output('output', 'children'),
               [Input('submit-button', 'n_clicks')],
@@ -139,15 +167,22 @@ def update_output(n_clicks, state1, state2):
 .....
 
 ```
+
 * Dash.jl:
+
 ```julia
-callback!(app, callid"""{state1.value, state2.value}
-                                   submit-button.n_clicks
-                                   => output.children""" ) do state1, state2, n_clicks
+callback!(app, Output("output", "children"),
+              [Input("submit-button", "n_clicks")],
+              [State("state-1", "value"),
+               State("state-2", "value")]) do  n_clicks, state1, state2
 .....
 end
 ```
-Be careful - in Dash.jl states came first in arguments list
 
-### json:
-I use JSON2 for json serialization/deserialization, so in callbacks all json objects are NamedTuples not Dicts. In component props you can use both Dicts and NamedTuples for json objects. But be careful with single property objects: `layout = (title = "Test graph")` is not interpreted as NamedTuple by Julia  - you need add comma at the end `layout = (title = "Test graph",)`
+Be careful - in Dash.jl states come first in an arguments list.
+
+### JSON:
+
+I use JSON2.jl for JSON serialization/deserialization, so in callbacks all JSON objects are `NamedTuples` rather than dictionaries. Within component properties you can use both `Dict` and `NamedTuple` for JSON objects.
+
+Note when declaring elements with a single properly that `layout = (title = "Test graph")` is not interpreted as a `NamedTuple` by Julia  - you'll need to add a comma when declaring the layout, e.g. `layout = (title = "Test graph",)`