Merge pull request #3352 from daschw/release

new release

.github/workflows/SnoopCompile.yml

@@ -41,10 +41,10 @@ jobs:
 
       # TESTCMD
       - name: Default TESTCMD
-        run: echo ::set-env name=TESTCMD::"julia"
+        run: echo "TESTCMD=julia" >> $GITHUB_ENV
       - name: Ubuntu TESTCMD
         if: startsWith(matrix.os,'ubuntu')
-        run: echo ::set-env name=TESTCMD::"xvfb-run --auto-servernum julia"
+        run: echo "TESTCMD=xvfb-run --auto-servernum julia" >> $GITHUB_ENV
 
       # Generate precompile files
       - name: Generating precompile files
@@ -78,7 +78,7 @@ jobs:
           commit-message: Update precompile_*.jl file
           title: "[AUTO] Update precompiles"
           labels: SnoopCompile
-          branch: "SnoopCompile_AutoPR"
+          branch: "Test_SnoopCompile_AutoPR_${{ github.ref }}"
 
 
   Skip:

.github/workflows/benchmark.yml

@@ -0,0 +1,34 @@
+name: Run benchmarks
+
+on:
+  pull_request:
+
+jobs:
+  Benchmark:
+    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    env:
+      GKS_ENCODING: "utf8"
+      GKSwstype: "100"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: 1
+
+      ## Setup
+      - name: Ubuntu TESTCMD
+        run: echo "TESTCMD=xvfb-run --auto-servernum julia" >> $GITHUB_ENV
+      - name: Install Plots dependencies
+        uses: julia-actions/julia-buildpkg@latest
+      - name: Install Benchmarking dependencies
+        run: julia -e 'using Pkg; pkg"add PkgBenchmark BenchmarkCI@0.1"'
+
+      - name: Run benchmarks
+        run: $TESTCMD -e 'using BenchmarkCI; BenchmarkCI.judge()'
+      - name: Print judgement
+        run: julia -e 'using BenchmarkCI; BenchmarkCI.displayjudgement()'
+      - name: Post results
+        run: julia -e 'using BenchmarkCI; BenchmarkCI.postjudge()'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -13,6 +13,7 @@ jobs:
     if: "!contains(github.event.head_commit.message, '[skip ci]')"
     env:
       GKS_ENCODING: "utf8"
+      GKSwstype: "100"
 
     name: Julia ${{ matrix.version }} - ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
@@ -59,10 +60,10 @@ jobs:
 
       # TESTCMD
       - name: Default TESTCMD
-        run: echo ::set-env name=TESTCMD::"julia"
+        run: echo "TESTCMD=julia" >> $GITHUB_ENV
       - name: Ubuntu TESTCMD
         if: startsWith(matrix.os,'ubuntu')
-        run: echo ::set-env name=TESTCMD::"xvfb-run --auto-servernum julia"
+        run: echo "TESTCMD=xvfb-run --auto-servernum julia" >> $GITHUB_ENV
 
       # Julia Dependencies
       - name: Install Julia dependencies

.gitignore

@@ -10,3 +10,5 @@ deps/deps.jl
 Manifest.toml
 dev/
 test/tmpplotsave.hdf5
+/.benchmarkci
+/benchmark/*.json

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.8.1"
+version = "1.11.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -36,7 +36,7 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 Contour = "0.5"
 FFMPEG = "0.2, 0.3, 0.4"
 FixedPointNumbers = "0.6, 0.7, 0.8"
-GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53"
+GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55"
 GeometryBasics = "0.2, 0.3.1"
 JSON = "0.21, 1"
 Latexify = "0.14"
@@ -45,8 +45,8 @@ NaNMath = "0.3"
 PlotThemes = "2"
 PlotUtils = "1"
 RecipesBase = "1"
-RecipesPipeline = "0.2"
-Reexport = "0.2"
+RecipesPipeline = "0.3"
+Reexport = "0.2, 1.0"
 Requires = "1"
 Scratch = "1"
 Showoff = "0.3.1"
@@ -68,8 +68,9 @@ StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+TestImages = "5e47fb64-e119-507b-a336-dd2b206d9990"
 UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"
 
 [targets]
-test = ["Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "UnicodePlots", "VisualRegressionTests"]
+test = ["Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]

benchmark/Project.toml

@@ -0,0 +1,5 @@
+[deps]
+BenchmarkCI = "20533458-34a3-403d-a444-e18f38190b5b"
+BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
+PkgBenchmark = "32113eaa-f34f-5b0d-bd6c-c81e245fc73d"
+Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"

benchmark/benchmarks.jl

@@ -0,0 +1,10 @@
+using BenchmarkTools
+using Plots
+
+const SUITE = BenchmarkGroup()
+julia_cmd = split(get(ENV, "TESTCMD", Base.JLOptions().julia_bin))
+
+SUITE["load_plot_display"] = @benchmarkable run(`$julia_cmd --startup-file=no --project -e 'using Plots; display(plot(1:0.1:10, sin.(1:0.1:10)))'`)
+SUITE["load"] = @benchmarkable run(`$julia_cmd --startup-file=no --project -e 'using Plots'`)
+SUITE["plot"] = @benchmarkable p = plot(1:0.1:10, sin.(1:0.1:10)) samples=1 evals=1
+SUITE["display"] = @benchmarkable display(p) setup=(p = plot(1:0.1:10, sin.(1:0.1:10))) samples=1 evals=1

deps/SnoopCompile/precompile/linux/1.5/precompile_Plots.jl

@@ -1,386 +0,0 @@
-const __bodyfunction__ = Dict{Method,Any}()
-
-# Find keyword "body functions" (the function that contains the body
-# as written by the developer, called after all missing keyword-arguments
-# have been assigned values), in a manner that doesn't depend on
-# gensymmed names.
-# `mnokw` is the method that gets called when you invoke it without
-# supplying any keywords.
-function __lookup_kwbody__(mnokw::Method)
-    function getsym(arg)
-        isa(arg, Symbol) && return arg
-        @assert isa(arg, GlobalRef)
-        return arg.name
-    end
-
-    f = get(__bodyfunction__, mnokw, nothing)
-    if f === nothing
-        fmod = mnokw.module
-        # The lowered code for `mnokw` should look like
-        #   %1 = mkw(kwvalues..., #self#, args...)
-        #        return %1
-        # where `mkw` is the name of the "active" keyword body-function.
-        ast = Base.uncompressed_ast(mnokw)
-        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
-            callexpr = ast.code[end-1]
-            if isa(callexpr, Expr) && callexpr.head == :call
-                fsym = callexpr.args[1]
-                if isa(fsym, Symbol)
-                    f = getfield(fmod, fsym)
-                elseif isa(fsym, GlobalRef)
-                    if fsym.mod === Core && fsym.name === :_apply
-                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
-                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
-                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
-                    else
-                        f = getfield(fsym.mod, fsym.name)
-                    end
-                else
-                    f = missing
-                end
-            else
-                f = missing
-            end
-        else
-            f = missing
-        end
-        __bodyfunction__[mnokw] = f
-    end
-    return f
-end
-
-function _precompile_()
-    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:label, :blank),Tuple{Symbol,Bool}},Type{Plots.EmptyLayout}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:label, :width, :height),Tuple{Symbol,Symbol,Measures.Length{:pct,Float64}}},Type{Plots.EmptyLayout}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:parent,),Tuple{Plots.GridLayout}},Type{Plots.Subplot},Plots.GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:parent,),Tuple{Plots.GridLayout}},Type{Plots.Subplot},Plots.PlotlyBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:parent,),Tuple{Plots.Subplot{Plots.GRBackend}}},Type{Plots.Subplot},Plots.GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.Type)),NamedTuple{(:parent,),Tuple{Plots.Subplot{Plots.PlotlyBackend}}},Type{Plots.Subplot},Plots.PlotlyBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots._make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Array{Int64,1}}},typeof(Plots._make_hist),Tuple{Array{Float64,1}},Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots._make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(Plots._make_hist),Tuple{Array{Float64,1},Array{Float64,1}},Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots._make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(Plots._make_hist),Tuple{Array{Float64,1}},Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:flip,),Tuple{Bool}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:formatter,),Tuple{typeof(RecipesPipeline.datetimeformatter)}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:grid, :lims),Tuple{Bool,Tuple{Int64,Int64}}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:grid, :lims, :flip),Tuple{Bool,Tuple{Int64,Int64},Bool}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid),Tuple{Int64,Bool,Float64,Symbol,RGBA{Float64}}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:guide,),Tuple{String}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:lims, :flip, :ticks, :guide),Tuple{Tuple{Int64,Int64},Bool,StepRange{Int64,Int64},String}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:lims,),Tuple{Tuple{Float64,Float64}}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:lims,),Tuple{Tuple{Int64,Float64}}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:lims,),Tuple{Tuple{Int64,Int64}}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:rotation,),Tuple{Int64}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:scale, :guide),Tuple{Symbol,String}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.attr!)),NamedTuple{(:ticks,),Tuple{UnitRange{Int64}}},typeof(attr!),Plots.Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid),Tuple{Tuple{Int64,String},Int64,Tuple{Int64,Symbol},Tuple{Int64,Symbol},String,Symbol,Bool}},typeof(default)})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),Array{Int64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),StepRange{Int64,Int64},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),UnitRange{Int64},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(Plots.gr_polyline),UnitRange{Int64},UnitRange{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.heatmap)),Any,typeof(heatmap),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.hline!)),Any,typeof(hline!),Any})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.lens!)),Any,typeof(lens!),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Array{GeometryBasics.Point{2,Float64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,Plots.PlotText},1}}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plots.Plot{Plots.GRBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:markersize, :c, :seriestype),Tuple{Int64,Symbol,Symbol}},typeof(plot!),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,Measures.BoundingBox{Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}},Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}}}}}},typeof(plot!),Array{Int64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,Measures.BoundingBox{Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}},Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}}}}}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Int64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,Measures.BoundingBox{Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}},Tuple{Measures.Length{:w,Float64},Measures.Length{:h,Float64}}}}}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{Int64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:title,),Tuple{String}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Float64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:xgrid,),Tuple{Tuple{Symbol,Symbol,Int64,Symbol,Float64}}},typeof(plot!),Plots.Plot{Plots.GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:yaxis,),Tuple{Tuple{String,Symbol}}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plots.Plot{Plots.GRBackend},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plots.Plot{Plots.PlotlyBackend},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:annotations, :leg),Tuple{Tuple{Int64,Float64,Plots.PlotText},Bool}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:arrow,),Tuple{Int64}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:aspect_ratio, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{String,1},Array{String,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:bins, :weights, :seriestype),Tuple{Symbol,Array{Int64,1},Symbol}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:color, :line, :marker),Tuple{Array{Symbol,2},Tuple{Symbol,Int64},Tuple{Array{Symbol,2},Int64,Float64,Plots.Stroke}}},typeof(plot),Array{Array{T,1} where T,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:connections, :seriestype),Tuple{Tuple{Array{Int64,1},Array{Int64,1},Array{Int64,1}},Symbol}},typeof(plot),Array{Int64,1},Array{Int64,1},Vararg{Array{Int64,1},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:fill, :seriestype),Tuple{Bool,Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype),Tuple{Array{Symbol,2},Array{String,2},Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64,String,Int64,UnitRange{Int64},Symbol}},typeof(plot),Array{Array{Float64,1},1},Array{Array{Float64,1},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:grid, :title),Tuple{Tuple{Symbol,Symbol,Symbol,Int64,Float64},String}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:lab, :w, :palette, :fill, :α),Tuple{String,Int64,PlotUtils.ContinuousColorGradient,Int64,Float64}},typeof(plot),StepRange{Int64,Int64},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend),Tuple{Array{String,2},String,String,Int64,Symbol}},typeof(plot),Array{Function,1},Float64,Vararg{Float64,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:label,),Tuple{Array{String,2}}},typeof(plot),Array{AbstractArray{Float64,1},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :group, :linetype, :linecolor),Tuple{Plots.GridLayout,Array{String,1},Array{Symbol,2},Symbol}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha),Tuple{Tuple{Int64,Int64},String,Int64,Float64}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Vararg{Plots.Plot{Plots.GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha),Tuple{Tuple{Int64,Int64},String,Int64,Float64}},typeof(plot),Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend},Vararg{Plots.Plot{Plots.PlotlyBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :link),Tuple{Int64,Symbol}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :link),Tuple{Int64,Symbol}},typeof(plot),Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :palette, :bg_inside),Tuple{Int64,Array{PlotUtils.ContinuousColorGradient,2},Array{Symbol,2}}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border),Tuple{Plots.GridLayout,Array{Symbol,2},Bool,Nothing,Symbol}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation),Tuple{Plots.GridLayout,Array{String,2},Symbol,Array{Measures.Length{:mm,Float64},2},Measures.Length{:mm,Float64},Int64}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:layout, :xlims),Tuple{Plots.GridLayout,Tuple{Int64,Float64}}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Vararg{Plots.Plot{Plots.GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:legend,),Tuple{Bool}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Vararg{Plots.Plot{Plots.GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:legend,),Tuple{Bool}},typeof(plot),Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend},Vararg{Plots.Plot{Plots.PlotlyBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Array{Tuple{Int64,Real},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend},Vararg{Plots.Plot{Plots.GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend},Vararg{Plots.Plot{Plots.PlotlyBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:line, :lab, :ms),Tuple{Tuple{Array{Symbol,2},Int64},Array{String,2},Int64}},typeof(plot),Array{Array{T,1} where T,1},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:line, :label, :legendtitle),Tuple{Tuple{Int64,Array{Symbol,2}},Array{String,2},String}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:line, :leg, :fill),Tuple{Int64,Bool,Tuple{Int64,Symbol}}},typeof(plot),Function,Function,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg),Tuple{Tuple{Int64,Symbol,Symbol},Tuple{Shape,Int64,RGBA{Float64}},Symbol,Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Bool}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:line_z, :linewidth, :legend),Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Int64,Bool}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:m, :lab, :bg, :xlim, :ylim, :seriestype),Tuple{Tuple{Int64,Symbol},Array{String,2},Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:marker,),Tuple{Bool}},typeof(plot),Array{Union{Missing, Int64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype),Tuple{typeof(+),Symbol,Bool,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:nbins, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype),Tuple{Tuple{Int64,Int64},Bool,Bool,Int64,Symbol}},typeof(plot),Array{Complex{Float64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:proj, :m),Tuple{Symbol,Int64}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:projection, :seriestype),Tuple{Symbol,Symbol}},typeof(plot),Array{Int64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:reg, :fill),Tuple{Bool,Tuple{Int64,Symbol}}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:ribbon,),Tuple{Tuple{LinRange{Float64},LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:ribbon,),Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color),Tuple{Array{Symbol,2},Array{Symbol,1},Int64,Array{Symbol,1}}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),Array{Dates.DateTime,1},UnitRange{Int64},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),Array{OHLC,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel),Tuple{Symbol,String,String,String}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title, :l, :seriestype),Tuple{String,Float64,Symbol}},typeof(plot),Array{String,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plots.Plot{Plots.GRBackend},Plots.Plot{Plots.GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plots.Plot{Plots.PlotlyBackend},Plots.Plot{Plots.PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title,),Tuple{String}},typeof(plot),Plots.Plot{Plots.GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:title,),Tuple{String}},typeof(plot),Plots.Plot{Plots.PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:xaxis, :background_color, :leg),Tuple{Tuple{String,Tuple{Int64,Int64},StepRange{Int64,Int64},Symbol},RGB{Float64},Bool}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w),Tuple{StepRange{Int64,Int64},Tuple{Int64,Float64,Symbol,Plots.Stroke},Bool,Bool,Int64}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.scatter!)),Any,typeof(scatter!),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.scatter!)),Any,typeof(scatter!),Any})
-    Base.precompile(Tuple{Core.kwftype(typeof(Plots.test_examples)),NamedTuple{(:skip,),Tuple{Array{Int64,1}}},typeof(test_examples),Symbol})
-    Base.precompile(Tuple{Type{Plots.GridLayout},Int64,Vararg{Int64,N} where N})
-    Base.precompile(Tuple{Type{Shape},Array{Tuple{Float64,Float64},1}})
-    Base.precompile(Tuple{typeof(Base.Broadcast.copyto_nonleaf!),Array{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},1},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.contour_levels),Tuple{Base.Broadcast.Extruded{Array{Any,1},Tuple{Bool},Tuple{Int64}},Base.RefValue{Tuple{Float64,Float64}}}},Base.OneTo{Int64},Int64,Int64})
-    Base.precompile(Tuple{typeof(Base.Broadcast.materialize),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.contour_levels),Tuple{Array{Any,1},Base.RefValue{Tuple{Float64,Float64}}}}})
-    Base.precompile(Tuple{typeof(Base.Broadcast.materialize),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Plots.get_linecolor),Tuple{Array{Any,1},Base.RefValue{Tuple{Float64,Float64}}}}})
-    Base.precompile(Tuple{typeof(Base.collect_similar),Array{AbstractLayout,2},Base.Generator{Array{AbstractLayout,2},typeof(Plots._update_min_padding!)}})
-    Base.precompile(Tuple{typeof(Base.vect),Tuple{Int64,Float64,Plots.PlotText},Vararg{Tuple{Int64,Float64,Plots.PlotText},N} where N})
-    Base.precompile(Tuple{typeof(Plots._bin_centers),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
-    Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{Int64,1},String})
-    Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{Nothing,1},String})
-    Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{PlotUtils.ContinuousColorGradient,1},String})
-    Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},1},String})
-    Base.precompile(Tuple{typeof(Plots._cbar_unique),Array{Symbol,1},String})
-    Base.precompile(Tuple{typeof(Plots._cycle),Array{Float64,1},Array{Int64,1}})
-    Base.precompile(Tuple{typeof(Plots._cycle),Array{Float64,1},StepRange{Int64,Int64}})
-    Base.precompile(Tuple{typeof(Plots._cycle),Array{Float64,1},UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(Plots._cycle),Base.OneTo{Int64},Array{Int64,1}})
-    Base.precompile(Tuple{typeof(Plots._cycle),StepRange{Int64,Int64},Array{Int64,1}})
-    Base.precompile(Tuple{typeof(Plots._do_plot_show),Plots.Plot{Plots.GRBackend},Bool})
-    Base.precompile(Tuple{typeof(Plots._do_plot_show),Plots.Plot{Plots.PlotlyBackend},Bool})
-    Base.precompile(Tuple{typeof(Plots._heatmap_edges),Array{Float64,1},Bool})
-    Base.precompile(Tuple{typeof(Plots._plot!),Plots.Plot,Any,Any})
-    Base.precompile(Tuple{typeof(Plots._preprocess_barlike),RecipesPipeline.DefaultsDict,Base.OneTo{Int64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(Plots._preprocess_binlike),RecipesPipeline.DefaultsDict,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(Plots._replace_markershape),Array{Symbol,1}})
-    Base.precompile(Tuple{typeof(Plots._update_min_padding!),Plots.GridLayout})
-    Base.precompile(Tuple{typeof(Plots._update_subplot_args),Plots.Plot{Plots.GRBackend},Plots.Subplot{Plots.GRBackend},Dict{Symbol,Any},Int64,Bool})
-    Base.precompile(Tuple{typeof(Plots._update_subplot_args),Plots.Plot{Plots.PlotlyBackend},Plots.Subplot{Plots.PlotlyBackend},Dict{Symbol,Any},Int64,Bool})
-    Base.precompile(Tuple{typeof(Plots.build_layout),Plots.GridLayout,Int64})
-    Base.precompile(Tuple{typeof(Plots.convert_to_polar),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Int64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.create_grid),Expr})
-    Base.precompile(Tuple{typeof(Plots.discrete_value!),Plots.Axis,Array{String,1}})
-    Base.precompile(Tuple{typeof(Plots.error_coords),Array{Float64,1},Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(Plots.fakedata),Int64,Vararg{Int64,N} where N})
-    Base.precompile(Tuple{typeof(Plots.get_clims),Plots.Subplot{Plots.GRBackend},Plots.Series,Function})
-    Base.precompile(Tuple{typeof(Plots.get_minor_ticks),Plots.Subplot{Plots.GRBackend},Plots.Axis,Tuple{Array{Float64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(Plots.get_minor_ticks),Plots.Subplot{Plots.GRBackend},Plots.Axis,Tuple{Array{Int64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(Plots.get_series_color),Array{Symbol,1},Plots.Subplot{Plots.GRBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(Plots.get_series_color),Array{Symbol,1},Plots.Subplot{Plots.PlotlyBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(Plots.get_xy),Array{OHLC,1}})
-    Base.precompile(Tuple{typeof(Plots.gr_add_legend),Plots.Subplot{Plots.GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),NTuple{9,Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(Plots.gr_add_legend),Plots.Subplot{Plots.GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),Tuple{Int64,Float64,Float64,Float64,Int64,Float64,Float64,Float64,Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(Plots.gr_display),Plots.Subplot{Plots.GRBackend},Measures.Length{:mm,Float64},Measures.Length{:mm,Float64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_colorbar),Plots.GRColorbar,Plots.Subplot{Plots.GRBackend},Tuple{Float64,Float64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_contour),Plots.Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_grid),Plots.Subplot{Plots.GRBackend},Plots.Axis,Segments{Tuple{Float64,Float64}}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_heatmap),Plots.Series,Array{Float64,1},Array{Float64,1},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_heatmap),Plots.Series,Base.OneTo{Int64},Base.OneTo{Int64},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Array{Int64,1},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,Base.OneTo{Int64},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_markers),Plots.Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_segments),Plots.Series,Array{Float64,1},Array{Float64,1},Int64,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_segments),Plots.Series,Base.OneTo{Int64},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_segments),Plots.Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_draw_segments),Plots.Series,StepRange{Int64,Int64},Array{Float64,1},Int64,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(Plots.gr_get_ticks_size),Tuple{Array{Float64,1},Array{Any,1}},Int64})
-    Base.precompile(Tuple{typeof(Plots.gr_get_ticks_size),Tuple{Array{Float64,1},Array{String,1}},Int64})
-    Base.precompile(Tuple{typeof(Plots.gr_get_ticks_size),Tuple{Array{Int64,1},Array{String,1}},Int64})
-    Base.precompile(Tuple{typeof(Plots.gr_label_ticks),Plots.Subplot{Plots.GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(Plots.gr_label_ticks_3d),Plots.Subplot{Plots.GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(Plots.gr_polaraxes),Int64,Float64,Plots.Subplot{Plots.GRBackend}})
-    Base.precompile(Tuple{typeof(Plots.gr_set_gradient),PlotUtils.ContinuousColorGradient})
-    Base.precompile(Tuple{typeof(Plots.heatmap_edges),Array{Float64,1},Symbol})
-    Base.precompile(Tuple{typeof(Plots.heatmap_edges),Base.OneTo{Int64},Symbol,Base.OneTo{Int64},Symbol,Tuple{Int64,Int64}})
-    Base.precompile(Tuple{typeof(Plots.heatmap_edges),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Symbol})
-    Base.precompile(Tuple{typeof(Plots.heatmap_edges),UnitRange{Int64},Symbol})
-    Base.precompile(Tuple{typeof(Plots.ignorenan_minimum),Array{Int64,1}})
-    Base.precompile(Tuple{typeof(Plots.layout_args),Int64})
-    Base.precompile(Tuple{typeof(Plots.make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
-    Base.precompile(Tuple{typeof(Plots.make_steps),Base.OneTo{Int64},Symbol})
-    Base.precompile(Tuple{typeof(Plots.optimal_ticks_and_labels),Plots.Subplot{Plots.GRBackend},Plots.Axis,StepRange{Int64,Int64}})
-    Base.precompile(Tuple{typeof(Plots.optimal_ticks_and_labels),Plots.Subplot{Plots.GRBackend},Plots.Axis,UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(Plots.processGridArg!),Dict{Symbol,Any},Symbol,Symbol})
-    Base.precompile(Tuple{typeof(Plots.processGridArg!),RecipesPipeline.DefaultsDict,Bool,Symbol})
-    Base.precompile(Tuple{typeof(Plots.processLineArg),Dict{Symbol,Any},Array{Symbol,2}})
-    Base.precompile(Tuple{typeof(Plots.processLineArg),Dict{Symbol,Any},Symbol})
-    Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Array{Symbol,2}})
-    Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Plots.Stroke})
-    Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},RGBA{Float64}})
-    Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Shape})
-    Base.precompile(Tuple{typeof(Plots.processMarkerArg),Dict{Symbol,Any},Symbol})
-    Base.precompile(Tuple{typeof(Plots.process_annotation),Plots.Subplot{Plots.GRBackend},Int64,Float64,Plots.PlotText})
-    Base.precompile(Tuple{typeof(Plots.process_annotation),Plots.Subplot{Plots.PlotlyBackend},Int64,Float64,Plots.PlotText})
-    Base.precompile(Tuple{typeof(Plots.process_axis_arg!),Dict{Symbol,Any},StepRange{Int64,Int64},Symbol})
-    Base.precompile(Tuple{typeof(Plots.process_axis_arg!),Dict{Symbol,Any},Symbol,Symbol})
-    Base.precompile(Tuple{typeof(Plots.process_axis_arg!),Dict{Symbol,Any},Tuple{Int64,Int64},Symbol})
-    Base.precompile(Tuple{typeof(Plots.reset_axis_defaults_byletter!)})
-    Base.precompile(Tuple{typeof(Plots.slice_arg),Array{Measures.Length{:mm,Float64},2},Int64})
-    Base.precompile(Tuple{typeof(Plots.slice_arg),Array{PlotUtils.ContinuousColorGradient,2},Int64})
-    Base.precompile(Tuple{typeof(Plots.slice_arg),Array{RGBA{Float64},2},Int64})
-    Base.precompile(Tuple{typeof(Plots.slice_arg),Array{String,2},Int64})
-    Base.precompile(Tuple{typeof(Plots.slice_arg),Array{Symbol,2},Int64})
-    Base.precompile(Tuple{typeof(Plots.slice_arg),Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64})
-    Base.precompile(Tuple{typeof(Plots.straightline_data),Tuple{Float64,Float64},Tuple{Float64,Float64},Array{Float64,1},Array{Float64,1},Int64})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},AbstractArray{OHLC,1}})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Array{Complex{Float64},1}})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Plots.PortfolioComposition})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:barhist}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:bar}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:histogram2d}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:hline}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:pie}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:spy}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:sticks}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:xerror}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesPipeline._finish_userrecipe!),Plots.Plot{Plots.GRBackend},Array{Dict{Symbol,Any},1},RecipeData})
-    Base.precompile(Tuple{typeof(RecipesPipeline._finish_userrecipe!),Plots.Plot{Plots.PlotlyBackend},Array{Dict{Symbol,Any},1},RecipeData})
-    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plots.Plot{Plots.GRBackend},RecipesPipeline.DefaultsDict})
-    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plots.Plot{Plots.PlotlyBackend},RecipesPipeline.DefaultsDict})
-    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.postprocess_axis_args!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Symbol})
-    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plots.Plot{Plots.GRBackend},RecipesPipeline.DefaultsDict})
-    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plots.Plot{Plots.GRBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plots.Plot{Plots.PlotlyBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Array{GeometryBasics.Point{2,Float64},1}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Array{RecipeData,1},Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},Dict{Symbol,Any},Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.GRBackend},RecipesPipeline.DefaultsDict,Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Array{RecipeData,1},Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},Dict{Symbol,Any},Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plots.Plot{Plots.PlotlyBackend},RecipesPipeline.DefaultsDict,Symbol,String})
-    Base.precompile(Tuple{typeof(backend),Plots.PlotlyBackend})
-    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
-    Base.precompile(Tuple{typeof(bbox),Measures.Length{:mm,Float64},Measures.Length{:mm,Float64},Measures.Length{:mm,Float64},Measures.Length{:mm,Float64}})
-    Base.precompile(Tuple{typeof(contour),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_colorgradient),Tuple{Array{Any,1}}}})
-    Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_fillalpha),Tuple{Array{Any,1}}}})
-    Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linestyle),Tuple{Array{Any,1}}}})
-    Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Tuple{Base.OneTo{Int64}},typeof(Plots.get_linewidth),Tuple{Array{Any,1}}}})
-    Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2},Tuple{Base.OneTo{Int64},Base.OneTo{Int64}},typeof(Plots.gr_color),Tuple{Array{RGBA{Float64},2}}}})
-    Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple},Nothing,typeof(string),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple},Nothing,typeof(typeof),Tuple{Tuple{Plots.PortfolioComposition}}}}}})
-    Base.precompile(Tuple{typeof(copy),Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple},Nothing,typeof(string),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple},Nothing,typeof(typeof),Tuple{Tuple{Plots.Spy}}}}}})
-    Base.precompile(Tuple{typeof(font),String,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(frame),Animation,Plots.Plot{Plots.GRBackend}})
-    Base.precompile(Tuple{typeof(iter_segments),Array{Float64,1},Array{Float64,1},UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(iter_segments),Base.OneTo{Int64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(merge),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,Plots.PlotText},1}}},Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}})
-    Base.precompile(Tuple{typeof(merge),NamedTuple{(:zcolor, :m, :ms, :lab),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Plots.Stroke},Array{Float64,1},String}},NamedTuple{(:seriestype,),Tuple{Symbol}}})
-    Base.precompile(Tuple{typeof(plot!),Any})
-    Base.precompile(Tuple{typeof(plot),Any,Any})
-    Base.precompile(Tuple{typeof(plot),Any})
-    Base.precompile(Tuple{typeof(push!),Plots.Plot{Plots.GRBackend},Float64,Array{Float64,1}})
-    Base.precompile(Tuple{typeof(setindex!),Dict{Any,Any},Plots.Plot{Plots.PlotlyBackend},Int64})
-    Base.precompile(Tuple{typeof(setindex!),Dict{Plots.Subplot,Any},Dict{Symbol,Any},Plots.Subplot{Plots.GRBackend}})
-    Base.precompile(Tuple{typeof(spy),Any})
-    Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(text),String,Int64,Symbol,Vararg{Symbol,N} where N})
-    Base.precompile(Tuple{typeof(text),String,Symbol,Int64,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(title!),AbstractString})
-    Base.precompile(Tuple{typeof(vcat),Array{Any,1},Array{Tuple{Int64,Float64,Plots.PlotText},1}})
-    Base.precompile(Tuple{typeof(vcat),Array{Any,1},Tuple{Int64,Float64,Plots.PlotText}})
-    Base.precompile(Tuple{typeof(vline!),Any})
-    Base.precompile(Tuple{typeof(xgrid!),Plots.Plot{Plots.GRBackend},Symbol,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(yaxis!),Any,Any})
-    let fbody = try __lookup_kwbody__(which(Plots.gr_polyline, (Array{Float64,1},Array{Float64,1},typeof(GR.fillarea),))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Symbol,Symbol,typeof(Plots.gr_polyline),Array{Float64,1},Array{Float64,1},typeof(GR.fillarea),))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(Plots.text, (String,Int64,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Int64,Vararg{Any,N} where N,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(Plots.text, (String,Symbol,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Symbol,Vararg{Any,N} where N,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(Plots.title!, (AbstractString,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(title!),AbstractString,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(Plots.vline!, (Any,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(vline!),Any,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(Plots.yaxis!, (Any,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any,N} where N,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(RecipesBase.plot!, ())) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot!),))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(RecipesBase.plot!, (Any,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot!),Any,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(RecipesBase.plot!, (Any,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot!),Any,Vararg{Any,N} where N,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Any,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Any,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Any,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Any,Vararg{Any,N} where N,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Plots.Plot,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Plots.Plot,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Plots.Plot,Plots.Plot,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Plots.Plot,Plots.Plot,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(RecipesBase.plot, (Plots.Plot,Plots.Plot,Vararg{Plots.Plot,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Plots.Plot,Plots.Plot,Vararg{Plots.Plot,N} where N,))
-        end
-    end
-end

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -0,0 +1,404 @@
+# Use
+#    @warnpcfail precompile(args...)
+# if you want to be warned when a precompile directive fails
+macro warnpcfail(ex::Expr)
+    modl = __module__
+    file = __source__.file === nothing ? "?" : String(__source__.file)
+    line = __source__.line
+    quote
+        $(esc(ex)) || @warn """precompile directive
+     $($(Expr(:quote, ex)))
+ failed. Please report an issue in $($modl) (after checking for duplicates) or remove this directive.""" _file=$file _line=$line
+    end
+end
+
+
+const __bodyfunction__ = Dict{Method,Any}()
+
+# Find keyword "body functions" (the function that contains the body
+# as written by the developer, called after all missing keyword-arguments
+# have been assigned values), in a manner that doesn't depend on
+# gensymmed names.
+# `mnokw` is the method that gets called when you invoke it without
+# supplying any keywords.
+function __lookup_kwbody__(mnokw::Method)
+    function getsym(arg)
+        isa(arg, Symbol) && return arg
+        @assert isa(arg, GlobalRef)
+        return arg.name
+    end
+
+    f = get(__bodyfunction__, mnokw, nothing)
+    if f === nothing
+        fmod = mnokw.module
+        # The lowered code for `mnokw` should look like
+        #   %1 = mkw(kwvalues..., #self#, args...)
+        #        return %1
+        # where `mkw` is the name of the "active" keyword body-function.
+        ast = Base.uncompressed_ast(mnokw)
+        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
+            callexpr = ast.code[end-1]
+            if isa(callexpr, Expr) && callexpr.head == :call
+                fsym = callexpr.args[1]
+                if isa(fsym, Symbol)
+                    f = getfield(fmod, fsym)
+                elseif isa(fsym, GlobalRef)
+                    if fsym.mod === Core && fsym.name === :_apply
+                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
+                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
+                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
+                    else
+                        f = getfield(fsym.mod, fsym.name)
+                    end
+                else
+                    f = missing
+                end
+            else
+                f = missing
+            end
+        else
+            f = missing
+        end
+        __bodyfunction__[mnokw] = f
+    end
+    return f
+end
+
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :blank),Tuple{Symbol,Bool}},Type{EmptyLayout}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :width, :height),Tuple{Symbol,Symbol,Length{:pct,Float64}}},Type{EmptyLayout}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{GridLayout}},Type{Subplot},GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Array{Int64,1}}},typeof(_make_hist),Tuple{Array{Float64,1}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1},Array{Float64,1}},Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,),Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,),Tuple{Symbol}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,),Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims),Tuple{Bool,Tuple{Float64,Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip),Tuple{Bool,Tuple{Float64,Float64},Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,),Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid),Tuple{Int64,Bool,Float64,Symbol,RGBA{Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,),Tuple{String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide),Tuple{Tuple{Int64,Int64},Bool,StepRange{Int64,Int64},String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,),Tuple{Tuple{Float64,Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,),Tuple{Tuple{Int64,Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,),Tuple{Tuple{Int64,Int64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,),Tuple{Int64}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:scale, :guide),Tuple{Symbol,String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,),Tuple{Nothing}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,),Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid),Tuple{Tuple{Int64,String},Int64,Tuple{Int64,Symbol},Tuple{Int64,Symbol},String,Symbol,Bool}},typeof(default)})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),Array{Int64,1},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),StepRange{Int64,Int64},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),UnitRange{Int64},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(heatmap)),Any,typeof(heatmap),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(hline!)),Any,typeof(hline!),Any})
+    Base.precompile(Tuple{Core.kwftype(typeof(lens!)),Any,typeof(lens!),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Array{GeometryBasics.Point{2,Float64},1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Plot{GRBackend},Array{GeometryBasics.Point{2,Float64},1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,PlotText},1}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Plot{PlotlyBackend},Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color),Tuple{Int64,Symbol}},typeof(plot!),Function,Float64,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color),Tuple{Int64,Symbol}},typeof(plot!),Plot{GRBackend},Function,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plot{GRBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype),Tuple{Int64,Symbol,Symbol}},typeof(plot!),Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,BoundingBox{Tuple{Length{:w,Float64},Length{:h,Float64}},Tuple{Length{:w,Float64},Length{:h,Float64}}}}}},typeof(plot!),Array{Int64,1},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,BoundingBox{Tuple{Length{:w,Float64},Length{:h,Float64}},Tuple{Length{:w,Float64},Length{:h,Float64}}}}}},typeof(plot!),Plot{GRBackend},Array{Int64,1},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,BoundingBox{Tuple{Length{:w,Float64},Length{:h,Float64}},Tuple{Length{:w,Float64},Length{:h,Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Array{Int64,1},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Array{Int64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,),Tuple{String}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Plot{GRBackend},Array{Float64,1},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,),Tuple{Tuple{Symbol,Symbol,Int64,Symbol,Float64}}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis,),Tuple{Tuple{String,Symbol}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plot{GRBackend},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plot{PlotlyBackend},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg),Tuple{Tuple{Int64,Float64,PlotText},Bool}},typeof(plot),Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,),Tuple{Int64}},typeof(plot),Array{Float64,1},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{String,1},Array{String,1},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype),Tuple{Symbol,Array{Int64,1},Symbol}},typeof(plot),Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker),Tuple{Array{Symbol,2},Tuple{Symbol,Int64},Tuple{Array{Symbol,2},Int64,Float64,Stroke}}},typeof(plot),Array{Array{T,1} where T,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :seriestype),Tuple{Tuple{Array{Int64,1},Array{Int64,1},Array{Int64,1}},Symbol}},typeof(plot),Array{Int64,1},Array{Int64,1},Vararg{Array{Int64,1},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype),Tuple{Bool,Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype),Tuple{Array{Symbol,2},Array{String,2},Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64,String,Int64,UnitRange{Int64},Symbol}},typeof(plot),Array{Array{Float64,1},1},Array{Array{Float64,1},1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title),Tuple{Tuple{Symbol,Symbol,Symbol,Int64,Float64},String}},typeof(plot),Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α),Tuple{String,Int64,PlotUtils.ContinuousColorGradient,Int64,Float64}},typeof(plot),StepRange{Int64,Int64},Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend),Tuple{Array{String,2},String,String,Int64,Symbol}},typeof(plot),Array{Function,1},Float64,Vararg{Float64,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,),Tuple{Array{String,2}}},typeof(plot),Array{AbstractArray{Float64,1},1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor),Tuple{GridLayout,Array{String,1},Array{Symbol,2},Symbol}},typeof(plot),Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha),Tuple{Tuple{Int64,Int64},String,Int64,Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha),Tuple{Tuple{Int64,Int64},String,Int64,Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link),Tuple{Int64,Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link),Tuple{Int64,Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :palette, :bg_inside),Tuple{Int64,Array{PlotUtils.ContinuousColorGradient,2},Array{Symbol,2}}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border),Tuple{GridLayout,Array{Symbol,2},Bool,Nothing,Symbol}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation),Tuple{GridLayout,Array{String,2},Symbol,Array{Length{:mm,Float64},2},Length{:mm,Float64},Int64}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims),Tuple{GridLayout,Tuple{Int64,Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Bool}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Bool}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Array{Tuple{Int64,Real},1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :lab, :ms),Tuple{Tuple{Array{Symbol,2},Int64},Array{String,2},Int64}},typeof(plot),Array{Array{T,1} where T,1},Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :label, :legendtitle),Tuple{Tuple{Int64,Array{Symbol,2}},Array{String,2},String}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill),Tuple{Int64,Bool,Tuple{Int64,Symbol}}},typeof(plot),Function,Function,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg),Tuple{Tuple{Int64,Symbol,Symbol},Tuple{Shape,Int64,RGBA{Float64}},Symbol,Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Bool}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line_z, :linewidth, :legend),Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Int64,Bool}},typeof(plot),Array{Float64,1},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :lab, :bg, :xlim, :ylim, :seriestype),Tuple{Tuple{Int64,Symbol},Array{String,2},Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker,),Tuple{Bool}},typeof(plot),Array{Union{Missing, Int64},1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype),Tuple{typeof(+),Symbol,Bool,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :markersize, :marker_z, :line_z, :linewidth),Tuple{Array{Symbol,2},Array{Int64,2},Array{Int64,2},Array{Int64,2},Array{Int64,2}}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype),Tuple{Tuple{Int64,Int64},Bool,Bool,Int64,Symbol}},typeof(plot),Array{Complex{Float64},1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:proj, :m),Tuple{Symbol,Int64}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype),Tuple{Symbol,Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},UnitRange{Int64},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype),Tuple{Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}},Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill),Tuple{Bool,Tuple{Int64,Symbol}}},typeof(plot),Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,),Tuple{Int64}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,),Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,),Tuple{Tuple{LinRange{Float64},LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,),Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color),Tuple{Array{Symbol,2},Array{Symbol,1},Int64,Array{Symbol,1}}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),Array{DateTime,1},UnitRange{Int64},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),Array{OHLC,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel),Tuple{Symbol,String,String,String}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :l, :seriestype),Tuple{String,Float64,Symbol}},typeof(plot),Array{String,1},Array{Float64,1}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{String}},typeof(plot),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{String}},typeof(plot),Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:xaxis, :background_color, :leg),Tuple{Tuple{String,Tuple{Int64,Int64},StepRange{Int64,Int64},Symbol},RGB{Float64},Bool}},typeof(plot),Array{Float64,2}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:yflip, :aspect_ratio),Tuple{Bool,Symbol}},typeof(plot),Array{Float64,1},Array{Int64,1},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w),Tuple{StepRange{Int64,Int64},Tuple{Int64,Float64,Symbol,Stroke},Bool,Bool,Int64}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any})
+    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip, :disp),Tuple{Array{Int64,1},Bool}},typeof(test_examples),Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,),Tuple{Array{Int64,1}}},typeof(test_examples),Symbol})
+    Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64,N} where N})
+    Base.precompile(Tuple{Type{Shape},Array{Tuple{Float64,Float64},1}})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},AbstractArray{OHLC,1}})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Array{Complex{Float64},1}})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},PortfolioComposition})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:barhist}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:bar}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:histogram2d}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:hline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:pie}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:quiver}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:spy}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:sticks}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:xerror}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{GRBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{PlotlyBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},DefaultsDict,Symbol,Any})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},Dict{Symbol,Any},Symbol,Any})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},DefaultsDict,Symbol,Any})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},Dict{Symbol,Any},Symbol,Any})
+    Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
+    Base.precompile(Tuple{typeof(_cbar_unique),Array{Int64,1},String})
+    Base.precompile(Tuple{typeof(_cbar_unique),Array{Nothing,1},String})
+    Base.precompile(Tuple{typeof(_cbar_unique),Array{PlotUtils.ContinuousColorGradient,1},String})
+    Base.precompile(Tuple{typeof(_cbar_unique),Array{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},1},String})
+    Base.precompile(Tuple{typeof(_cbar_unique),Array{Symbol,1},String})
+    Base.precompile(Tuple{typeof(_cycle),Array{Float64,1},Array{Int64,1}})
+    Base.precompile(Tuple{typeof(_cycle),Array{Float64,1},StepRange{Int64,Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Array{Float64,1},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Array{Int64,1}})
+    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64,Int64},Array{Int64,1}})
+    Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
+    Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
+    Base.precompile(Tuple{typeof(_heatmap_edges),Array{Float64,1},Bool,Bool})
+    Base.precompile(Tuple{typeof(_plot!),Plot,Any,Any})
+    Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(_replace_markershape),Array{Symbol,1}})
+    Base.precompile(Tuple{typeof(_update_min_padding!),GridLayout})
+    Base.precompile(Tuple{typeof(_update_subplot_args),Plot{GRBackend},Subplot{GRBackend},Dict{Symbol,Any},Int64,Bool})
+    Base.precompile(Tuple{typeof(_update_subplot_args),Plot{PlotlyBackend},Subplot{PlotlyBackend},Dict{Symbol,Any},Int64,Bool})
+    Base.precompile(Tuple{typeof(backend),PlotlyBackend})
+    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
+    Base.precompile(Tuple{typeof(bbox),Length{:mm,Float64},Length{:mm,Float64},Length{:mm,Float64},Length{:mm,Float64}})
+    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64})
+    Base.precompile(Tuple{typeof(contour),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Int64,Float64}})
+    Base.precompile(Tuple{typeof(create_grid),Expr})
+    Base.precompile(Tuple{typeof(error_coords),Array{Float64,1},Array{Float64,1},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(error_zipit),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}})
+    Base.precompile(Tuple{typeof(expand_extrema!),Axis,StepRange{Int64,Int64}})
+    Base.precompile(Tuple{typeof(fakedata),Int64,Vararg{Int64,N} where N})
+    Base.precompile(Tuple{typeof(font),String,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(get_clims),Subplot{GRBackend},Series,Function})
+    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Float64,1},Array{String,1}}})
+    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Int64,1},Array{String,1}}})
+    Base.precompile(Tuple{typeof(get_series_color),Array{Symbol,1},Subplot{GRBackend},Int64,Symbol})
+    Base.precompile(Tuple{typeof(get_series_color),Array{Symbol,1},Subplot{PlotlyBackend},Int64,Symbol})
+    Base.precompile(Tuple{typeof(get_xy),Array{OHLC,1}})
+    Base.precompile(Tuple{typeof(get_xy),OHLC{Float64},Int64,Float64})
+    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),NTuple{9,Float64}},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),Tuple{Int64,Float64,Float64,Float64,Int64,Float64,Float64,Float64,Float64}},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},Length{:mm,Float64},Length{:mm,Float64},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64,Float64},Array{Float64,1}})
+    Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_grid),Subplot{GRBackend},Axis,Segments{Tuple{Float64,Float64}}})
+    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Array{Float64,1},Array{Float64,1},Array{Float64,2},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Array{Int64,1},Array{Float64,1},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Array{Float64,1},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Float64,1},Array{Float64,1},Int64,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Int64,1},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Int64,1},Array{Int64,1},Nothing,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Array{Float64,1},Int64,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Array{Float64,1},Array{Float64,1}},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64,Int64},Array{Float64,1},Int64,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Array{Float64,1},Array{Float64,1},Array{Float64,1},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Array{Float64,1},Array{Float64,1},Array{Float64,2},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Float64,1},Array{Any,1}},Int64})
+    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Float64,1},Array{String,1}},Int64})
+    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Int64,1},Array{String,1}},Int64})
+    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
+    Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
+    Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
+    Base.precompile(Tuple{typeof(gr_polyline),Array{Float64,1},Array{Float64,1},Function})
+    Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
+    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Array{Float64,1},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),NTuple{9,Float64}}})
+    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Array{Float64,1},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),Tuple{Int64,Float64,Float64,Float64,Int64,Float64,Float64,Float64,Float64}}})
+    Base.precompile(Tuple{typeof(heatmap_edges),Array{Float64,1},Symbol})
+    Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
+    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Symbol})
+    Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
+    Base.precompile(Tuple{typeof(ignorenan_minimum),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(layout_args),Int64})
+    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Subplot{GRBackend},Axis,StepRange{Int64,Int64}})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Subplot{GRBackend},Axis,UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(plot!),Any})
+    Base.precompile(Tuple{typeof(plot),Any,Any})
+    Base.precompile(Tuple{typeof(plot),Any})
+    Base.precompile(Tuple{typeof(processGridArg!),DefaultsDict,Bool,Symbol})
+    Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol,Any},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Array{Symbol,2}})
+    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Int64})
+    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Symbol})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Array{Symbol,2}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},RGBA{Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Shape})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Stroke})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Symbol})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,PlotText})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol,Any},StepRange{Int64,Int64},Symbol})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol,Any},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol,Any},Tuple{Int64,Int64},Symbol})
+    Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Array{Float64,1}})
+    Base.precompile(Tuple{typeof(quiver_using_arrows),DefaultsDict})
+    Base.precompile(Tuple{typeof(quiver_using_hack),DefaultsDict})
+    Base.precompile(Tuple{typeof(reset_axis_defaults_byletter!)})
+    Base.precompile(Tuple{typeof(slice_arg),Array{Int64,2},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Array{Length{:mm,Float64},2},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Array{PlotUtils.ContinuousColorGradient,2},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Array{RGBA{Float64},2},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Array{String,2},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Array{Symbol,2},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(spy),Any})
+    Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64,Float64},Tuple{Float64,Float64},Array{Float64,1},Array{Float64,1},Int64})
+    Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(text),String,Int64,Symbol,Vararg{Symbol,N} where N})
+    Base.precompile(Tuple{typeof(text),String,Symbol,Int64,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(title!),AbstractString})
+    Base.precompile(Tuple{typeof(unzip),Array{GeometryBasics.Point{2,Float64},1}})
+    Base.precompile(Tuple{typeof(vline!),Any})
+    Base.precompile(Tuple{typeof(wireframe),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
+    Base.precompile(Tuple{typeof(yaxis!),Any,Any})
+    let fbody = try __lookup_kwbody__(which(gr_polyline, (Array{Float64,1},Array{Float64,1},typeof(GR.fillarea),))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Array{Float64,1},Array{Float64,1},typeof(GR.fillarea),))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(plot!, ())) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot!),))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot!),Any,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot!),Any,Vararg{Any,N} where N,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(plot, (Any,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Any,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Any,Vararg{Any,N} where N,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(plot, (Plot,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Plot,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(plot, (Plot,Plot,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Plot,Plot,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(plot, (Plot,Plot,Vararg{Plot,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(plot),Plot,Plot,Vararg{Plot,N} where N,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(text, (String,Int64,Vararg{Any,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Int64,Vararg{Any,N} where N,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(text, (String,Symbol,Vararg{Any,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Symbol,Vararg{Any,N} where N,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(title!, (AbstractString,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(title!),AbstractString,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(vline!, (Any,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(vline!),Any,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any,N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any,N} where N,))
+        end
+    end
+end

deps/SnoopCompile/snoop_bench.jl

@@ -3,9 +3,6 @@ using CompileBot
 snoop_bench(
     BotConfig(
         "Plots",
-        yml_path= "SnoopCompile.yml",
-        else_os = "linux",
-        else_version = "1.5",
     ),
     joinpath(@__DIR__, "precompile_script.jl"),
 )

deps/SnoopCompile/snoop_bot.jl

@@ -3,9 +3,6 @@ using CompileBot
 snoop_bot(
     BotConfig(
         "Plots",
-        yml_path= "SnoopCompile.yml",
-        else_os = "linux",
-        else_version = "1.5",
     ),
     joinpath(@__DIR__, "precompile_script.jl"),
 )

src/Plots.jl

@@ -187,6 +187,10 @@ import RecipesPipeline: SliceIt,
     datetimeformatter,
     timeformatter
 
+# Use fixed version of Plotly instead of the latest one for stable dependency
+# Ref: https://github.com/JuliaPlots/Plots.jl/pull/2779
+const _plotly_min_js_filename = "plotly-1.57.1.min.js"
+
 include("types.jl")
 include("utils.jl")
 include("axes.jl")
@@ -207,6 +211,7 @@ include("output.jl")
 include("ijulia.jl")
 include("fileio.jl")
 include("init.jl")
+include("legend.jl")
 
 include("backends/plotly.jl")
 include("backends/gr.jl")

src/animation.jl

@@ -98,7 +98,7 @@ function buildanimation(anim::Animation, fn::AbstractString,
             ffmpeg_exe(`-v $verbose_level -framerate $framerate -i $(animdir)/%06d.png -i "$(animdir)/palette.bmp" -lavfi "paletteuse=dither=sierra2_4a" -loop $loop -y $fn`)
         end
     else
-        ffmpeg_exe(`-v $verbose_level -framerate $framerate -i $(animdir)/%06d.png -loop $loop -y $fn`)
+        ffmpeg_exe(`-v $verbose_level -framerate $framerate -i $(animdir)/%06d.png -vf format=yuv420p -loop $loop -y $fn`)
     end
 
     show_msg && @info("Saved animation to ", fn)

src/arg_desc.jl

@@ -90,7 +90,7 @@ const _arg_desc = KW(
 :foreground_color_legend  => "Color Type or `:match` (matches `:foreground_color_subplot`).  Foreground color of the legend.",
 :foreground_color_title   => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of subplot title.",
 :color_palette            => "Vector of colors (cycle through) or color gradient (generate list from gradient) or `:auto` (generate a color list using `Colors.distiguishable_colors` and custom seed colors chosen to contrast with the background).  The color palette is a color list from which series colors are automatically chosen.",
-:legend                   => "Bool (show the legend?) or (x,y) tuple or Symbol (legend position). Bottom left corner of legend is placed at (x,y).  Symbol values: `:none`; `:best`; `:inline`; `:inside`; `:legend`; any valid combination of `:(outer ?)(top/bottom ?)(right/left ?)`, i.e.: `:top`, `:topright`, `:outerleft`, `:outerbottomright` ... (note: only some may be supported in each backend)",
+:legend                   => "Bool (show the legend?) or (x,y) tuple or Symbol (legend position) or angle or (angle,inout) tuple. Bottom left corner of legend is placed at (x,y).  Symbol values: `:none`; `:best`; `:inline`; `:inside`; `:legend`; any valid combination of `:(outer ?)(top/bottom ?)(right/left ?)`, i.e.: `:top`, `:topright`, `:outerleft`, `:outerbottomright` ... (note: only some may be supported in each backend). Legend is positioned at (angle degrees) (so (90,:outer) is roughly equivalent to :outertop), close to the inside of the axes or the outside if inout=:outer.",
 :legendfontfamily         => "String or Symbol. Font family of legend entries.",
 :legendfontsize           => "Integer. Font pointsize of legend entries.",
 :legendfonthalign         => "Symbol. Font horizontal alignment of legend entries: :hcenter, :left, :right or :center",

src/args.jl

@@ -1262,6 +1262,8 @@ end
 convertLegendValue(val::Bool) = val ? :best : :none
 convertLegendValue(val::Nothing) = :none
 convertLegendValue(v::Tuple{S,T}) where {S<:Real, T<:Real} = v
+convertLegendValue(v::Tuple{<:Real,Symbol}) = v
+convertLegendValue(v::Real) = v
 convertLegendValue(v::AbstractArray) = map(convertLegendValue, v)
 
 # -----------------------------------------------------------------------------

src/axes.jl

@@ -94,6 +94,12 @@ function attr!(axis::Axis, args...; kw...)
                 for vi in v
                     discrete_value!(axis, vi)
                 end
+            #could perhaps use TimeType here, as Date and DateTime are both subtypes of TimeType
+            # or could perhaps check if dateformatter or datetimeformatter is in use
+            elseif k == :lims && isa(v, Tuple{Date,Date})
+                plotattributes[k] = (v[1].instant.periods.value, v[2].instant.periods.value)
+            elseif k == :lims && isa(v, Tuple{DateTime,DateTime})
+                plotattributes[k] = (v[1].instant.periods.value, v[2].instant.periods.value)
             else
                 plotattributes[k] = v
             end
@@ -809,7 +815,7 @@ function axis_drawing_info_3d(sp, letter)
                     t = invf(f(na0) + 0.006 * (f(na1) - f(na0)) * ticks_in)
                     (na0, t)
                 end
-                for tick in minorticks
+                for tick in minor_ticks
                     if ax[:showaxis]
                         push!(
                             tick_segments,
@@ -847,4 +853,4 @@ end
 reverse_if(x, cond) = cond ? reverse(x) : x
 axis_tuple(x, y, letter) = reverse_if((x, y), letter === :y)
 
-axes_shift(t, i) = i % 3 == 0 ? t : i % 3 == 1 ? (t[3], t[1], t[2]) : (t[2], t[3], t[1])
+axes_shift(t, i) = i % 3 == 0 ? t : i % 3 == 1 ? (t[3], t[1], t[2]) : (t[2], t[3], t[1])

src/backends.jl

@@ -842,6 +842,7 @@ const _pgfplotsx_marker = [
     :rtriangle,
     :cross,
     :xcross,
+    :x,
     :star5,
     :pentagon,
     :hline,

src/backends/gr.jl

@@ -219,7 +219,7 @@ gr_inqtext(x, y, s) = gr_inqtext(x, y, string(s))
 function gr_inqtext(x, y, s::AbstractString)
     if length(s) >= 2 && s[1] == '$' && s[end] == '$'
         GR.inqmathtex(x, y, s[2:end-1])
-    elseif findfirst(isequal('\\'), s) !== nothing || occursin("10^{", s)
+    elseif occursin('\\', s) || occursin("10^{", s)
         GR.inqtextext(x, y, s)
     else
         GR.inqtext(x, y, s)
@@ -231,7 +231,7 @@ gr_text(x, y, s) = gr_text(x, y, string(s))
 function gr_text(x, y, s::AbstractString)
     if length(s) >= 2 && s[1] == '$' && s[end] == '$'
         GR.mathtex(x, y, s[2:end-1])
-    elseif findfirst(isequal('\\'), s) !== nothing || occursin("10^{", s)
+    elseif occursin('\\', s) || occursin("10^{", s)
         GR.textext(x, y, s)
     else
         GR.text(x, y, s)
@@ -908,10 +908,10 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     viewport_plotarea = gr_viewport_from_bbox(sp, plotarea(sp), w, h, viewport_canvas)
 
     # update viewport_plotarea
-    gr_update_viewport_ratio!(viewport_plotarea, sp)
     leg = gr_get_legend_geometry(viewport_plotarea, sp)
     gr_update_viewport_legend!(viewport_plotarea, sp, leg)
-    
+    gr_update_viewport_ratio!(viewport_plotarea, sp)
+
     # fill in the plot area background
     gr_fill_plotarea(sp, viewport_plotarea)
 
@@ -1047,7 +1047,24 @@ end
 
 function gr_legend_pos(sp::Subplot, leg, viewport_plotarea)
     s = sp[:legend]
-    typeof(s) <: Symbol || return gr_legend_pos(s, viewport_plotarea)
+    s isa Real && return gr_legend_pos(s, leg, viewport_plotarea)
+    if s isa Tuple{<:Real,Symbol}
+        if s[2] !== :outer
+            return gr_legend_pos(s[1], leg, viewport_plotarea)
+        end
+
+        xaxis, yaxis = sp[:xaxis], sp[:yaxis]
+        xmirror = xaxis[:guide_position] == :top || (xaxis[:guide_position] == :auto && xaxis[:mirror] == true)
+        ymirror = yaxis[:guide_position] == :right || (yaxis[:guide_position] == :auto && yaxis[:mirror] == true)
+        axisclearance = [
+                         !ymirror*gr_axis_width(sp, sp[:yaxis]),
+                         ymirror*gr_axis_width(sp,sp[:yaxis]),
+                         !xmirror*gr_axis_height(sp,sp[:xaxis]),
+                         xmirror*gr_axis_height(sp,sp[:xaxis]),
+                        ]
+        return gr_legend_pos(s[1], leg, viewport_plotarea; axisclearance)
+    end
+    s isa Symbol || return gr_legend_pos(s, viewport_plotarea)
     str = string(s)
     if str == "best"
         str = "topright"
@@ -1081,7 +1098,7 @@ function gr_legend_pos(sp::Subplot, leg, viewport_plotarea)
         end
     elseif occursin("bottom", str)
         if s == :outerbottom
-            ypos = viewport_plotarea[3] - leg.yoffset - leg.h - !xmirror * gr_axis_height(sp, sp[:xaxis])
+            ypos = viewport_plotarea[3] - leg.yoffset  - leg.dy - !xmirror * gr_axis_height(sp, sp[:xaxis])
         else
             ypos = viewport_plotarea[3] + leg.yoffset + leg.h
         end
@@ -1098,6 +1115,27 @@ function gr_legend_pos(v::Tuple{S,T}, viewport_plotarea) where {S<:Real, T<:Real
     (xpos,ypos)
 end
 
+function gr_legend_pos(theta::Real, leg, viewport_plotarea; axisclearance=nothing)
+    xcenter = +(viewport_plotarea[1:2]...)/2
+    ycenter = +(viewport_plotarea[3:4]...)/2
+
+    if isnothing(axisclearance)
+        # Inner
+        # rectangle where the anchor can legally be
+        xmin = viewport_plotarea[1] + leg.xoffset + leg.leftw
+        xmax = viewport_plotarea[2] - leg.xoffset - leg.rightw - leg.textw
+        ymin = viewport_plotarea[3] + leg.yoffset + leg.h
+        ymax = viewport_plotarea[4] - leg.yoffset - leg.dy
+    else
+        # Outer
+        xmin = viewport_plotarea[1] - leg.xoffset - leg.rightw - leg.textw - axisclearance[1]
+        xmax = viewport_plotarea[2] + leg.xoffset + leg.leftw + axisclearance[2]
+        ymin = viewport_plotarea[3] - leg.yoffset - leg.dy - axisclearance[3]
+        ymax = viewport_plotarea[4] + leg.yoffset + leg.h + axisclearance[4]
+    end
+    return legend_pos_from_angle(theta,xmin,xcenter,xmax,ymin,ycenter,ymax)
+end
+
 function gr_get_legend_geometry(viewport_plotarea, sp)
     legendn = 0
     legendw = 0
@@ -1154,12 +1192,28 @@ end
 ## Viewport, window and scale
 
 function gr_update_viewport_legend!(viewport_plotarea, sp, leg)
-    leg_str = string(sp[:legend])
+    s = sp[:legend]
 
     xaxis, yaxis = sp[:xaxis], sp[:yaxis]
     xmirror = xaxis[:guide_position] == :top || (xaxis[:guide_position] == :auto && xaxis[:mirror] == true)
     ymirror = yaxis[:guide_position] == :right || (yaxis[:guide_position] == :auto && yaxis[:mirror] == true)
 
+    if s isa Tuple{<:Real,Symbol}
+        if s[2] === :outer
+            (x,y) = gr_legend_pos(sp, leg, viewport_plotarea) # Dry run, to figure out
+            if x < viewport_plotarea[1]
+                viewport_plotarea[1] += leg.leftw + leg.textw + leg.rightw + leg.xoffset + !ymirror * gr_axis_width(sp, sp[:yaxis])
+            elseif x > viewport_plotarea[2]
+                viewport_plotarea[2] -= leg.leftw + leg.textw + leg.rightw + leg.xoffset
+            end
+            if y < viewport_plotarea[3]
+                viewport_plotarea[3] += leg.h + leg.dy + leg.yoffset + !xmirror * gr_axis_height(sp, sp[:xaxis])
+            elseif y > viewport_plotarea[4]
+                viewport_plotarea[4] -= leg.h + leg.dy + leg.yoffset
+            end
+        end
+    end
+    leg_str = string(s)
     if occursin("outer", leg_str)
         if occursin("right", leg_str)
             viewport_plotarea[2] -= leg.leftw + leg.textw + leg.rightw + leg.xoffset
@@ -1171,7 +1225,7 @@ function gr_update_viewport_legend!(viewport_plotarea, sp, leg)
             viewport_plotarea[3] += leg.h + leg.dy + leg.yoffset + !xmirror * gr_axis_height(sp, sp[:xaxis])
         end
     end
-    if sp[:legend] == :inline
+    if s === :inline
         if sp[:yaxis][:mirror]
             viewport_plotarea[1] += leg.w
         else
@@ -1432,12 +1486,11 @@ function gr_label_axis(sp, letter, viewport_plotarea)
     axis = sp[Symbol(letter, :axis)]
     # guide
     if axis[:guide] != ""
-        isy = letter === :y
         GR.savestate()
         gr_set_font(guidefont(axis), sp)
         guide_position = axis[:guide_position]
-        if isy
-            w = 0.02 + gr_axis_width(sp, axis)
+        if letter === :y
+            w = 0.03 + gr_axis_width(sp, axis)
             GR.setcharup(-1, 0)
             if guide_position == :right || (guide_position == :auto && axis[:mirror])
                 GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
@@ -1447,7 +1500,7 @@ function gr_label_axis(sp, letter, viewport_plotarea)
                 gr_text(viewport_plotarea[1] - w, gr_view_ycenter(viewport_plotarea), axis[:guide])
             end
         else
-            h = 0.01 + gr_axis_height(sp, axis)
+            h = 0.015 + gr_axis_height(sp, axis)
             if guide_position == :top || (guide_position == :auto && axis[:mirror])
                 GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
                 gr_text(gr_view_xcenter(viewport_plotarea), viewport_plotarea[4] + h, axis[:guide])
@@ -1465,10 +1518,10 @@ function gr_label_axis_3d(sp, letter)
     if ax[:guide] != ""
         near_letter = letter in (:x, :z) ? :y : :x
         far_letter = letter in (:x, :y) ? :z : :x
-    
+
         nax = sp[Symbol(near_letter, :axis)]
         fax = sp[Symbol(far_letter, :axis)]
-    
+
         amin, amax = axis_limits(sp, letter)
         namin, namax = axis_limits(sp, near_letter)
         famin, famax = axis_limits(sp, far_letter)
@@ -1492,7 +1545,7 @@ function gr_label_axis_3d(sp, letter)
             x_offset = letter === :x ? -h : h
             y_offset = -h
         else
-            x_offset = -gr_axis_width(sp, ax)
+            x_offset = -0.03 - gr_axis_width(sp, ax)
             y_offset = 0
         end
         letter === :z && GR.setcharup(-1, 0)
@@ -1562,7 +1615,7 @@ function gr_add_series(sp, series)
             gr_draw_markers(series, x, y, clims)
         end
     elseif st === :shape
-        gr_draw_shapes(series, x, y, clims)
+        gr_draw_shapes(series, clims)
     elseif st in (:path3d, :scatter3d)
         gr_draw_segments_3d(series, x, y, z, clims)
         if st === :scatter3d || series[:markershape] !== :none
@@ -1578,16 +1631,12 @@ function gr_add_series(sp, series)
         sp[:legend] = :none
         GR.gr3.clear()
         dmin, dmax = GR.gr3.volume(y.v, 0)
-    elseif st in (:heatmap, :image)
-        if !ispolar(series)
-            # `z` is already transposed, so we need to reverse before passing its size.
-            x, y = heatmap_edges(x, xscale, y, yscale, reverse(size(z)))
-        end
-        if st === :heatmap
-            gr_draw_heatmap(series, x, y, z, clims)
-        else
-            gr_draw_image(series, x, y, z, clims)
-        end
+    elseif st === :heatmap
+        # `z` is already transposed, so we need to reverse before passing its size.
+        x, y = heatmap_edges(x, xscale, y, yscale, reverse(size(z)), ispolar(series))
+        gr_draw_heatmap(series, x, y, z, clims)
+    elseif st === :image
+        gr_draw_image(series, x, y, z, clims)
     end
 
     # this is all we need to add the series_annotations text
@@ -1618,12 +1667,13 @@ end
 function gr_draw_segments(series, x, y, fillrange, clims)
     st = series[:seriestype]
     if x !== nothing && length(x) > 1
-        segments = iter_segments(series, st)
+        segments = series_segments(series, st)
         # do area fill
         if fillrange !== nothing
             GR.setfillintstyle(GR.INTSTYLE_SOLID)
             fr_from, fr_to = (is_2tuple(fillrange) ? fillrange : (y, fillrange))
-            for (i, rng) in enumerate(segments)
+            for segment in segments
+                i, rng = segment.attr_index, segment.range
                 fc = get_fillcolor(series, clims, i)
                 gr_set_fillcolor(fc)
                 fx = _cycle(x, vcat(rng, reverse(rng)))
@@ -1635,7 +1685,8 @@ function gr_draw_segments(series, x, y, fillrange, clims)
 
         # draw the line(s)
         if st in (:path, :straightline)
-            for (i, rng) in enumerate(segments)
+            for segment in segments
+                i, rng = segment.attr_index, segment.range
                 lc = get_linecolor(series, clims, i)
                 gr_set_line(
                     get_linewidth(series, i), get_linestyle(series, i), lc, series
@@ -1653,8 +1704,9 @@ end
 function gr_draw_segments_3d(series, x, y, z, clims)
     if series[:seriestype] === :path3d && length(x) > 1
         lz = series[:line_z]
-        segments = iter_segments(series, :path3d)
-        for (i, rng) in enumerate(segments)
+        segments = series_segments(series, :path3d)
+        for segment in segments
+            i, rng = segment.attr_index, segment.range
             lc = get_linecolor(series, clims, i)
             gr_set_line(
                 get_linewidth(series, i), get_linestyle(series, i), lc, series
@@ -1679,8 +1731,9 @@ function gr_draw_markers(
 
     shapes = series[:markershape]
     if shapes != :none
-        for (i, rng) in enumerate(iter_segments(series, :scatter))
-            rng = intersect(eachindex(x), rng)
+        for segment in series_segments(series, :scatter)
+            i = segment.attr_index
+            rng = intersect(eachindex(x), segment.range)
             if !isempty(rng)
                 ms = get_thickness_scaling(series) * _cycle(msize, i)
                 msw = get_thickness_scaling(series) * _cycle(strokewidth, i)
@@ -1693,9 +1746,10 @@ function gr_draw_markers(
     end
 end
 
-function gr_draw_shapes(series, x, y, clims)
+function gr_draw_shapes(series, clims)
     x, y = shape_data(series)
-    for (i,rng) in enumerate(iter_segments(x, y))
+    for segment in series_segments(series, :shape)
+        i, rng = segment.attr_index, segment.range
         if length(rng) > 1
             # connect to the beginning
             rng = vcat(rng, rng[1])
@@ -1737,15 +1791,18 @@ function gr_draw_contour(series, x, y, z, clims)
 end
 
 function gr_draw_surface(series, x, y, z, clims)
+
     if series[:seriestype] === :surface
+        fillalpha = get_fillalpha(series)
+        fillcolor = get_fillcolor(series)
         if length(x) == length(y) == length(z)
-            GR.trisurface(x, y, z)
+            x, y, z = GR.gridit(x, y, z, 200, 200)
+        end
+        if (!isnothing(fillalpha) && fillalpha < 1) || alpha(first(fillcolor)) < 1
+            gr_set_transparency(fillcolor, fillalpha)
+            GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
         else
-            try
-                GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
-            catch
-                GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
-            end
+            GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
         end
     else # wireframe
         GR.setfillcolorind(0)
@@ -1755,42 +1812,33 @@ end
 
 function gr_draw_heatmap(series, x, y, z, clims)
     fillgrad = _as_gradient(series[:fillcolor])
-    if !ispolar(series)
-        GR.setspace(clims..., 0, 90)
-        w, h = length(x) - 1, length(y) - 1
-        if is_uniformly_spaced(x) && is_uniformly_spaced(y)
-            # For uniformly spaced data use GR.drawimage, which can be
-            # much faster than GR.nonuniformcellarray, especially for
-            # pdf output, and also supports alpha values.
-            # Note that drawimage draws uniformly spaced data correctly
-            # even on log scales, where it is visually non-uniform.
-            colors = plot_color.(get(fillgrad, z, clims), series[:fillalpha])
-            rgba = gr_color.(colors)
-            GR.drawimage(first(x), last(x), last(y), first(y), w, h, rgba)
-        else
-            if something(series[:fillalpha], 1) < 1
-                @warn "GR: transparency not supported in non-uniform heatmaps. Alpha values ignored."
-            end
-            z_normalized = get_z_normalized.(z, clims...)
-            rgba = Int32[round(Int32, 1000 + _i * 255) for _i in z_normalized]
-            GR.nonuniformcellarray(x, y, w, h, rgba)
-        end
+    GR.setspace(clims..., 0, 90)
+    w, h = length(x) - 1, length(y) - 1
+    if !ispolar(series) && is_uniformly_spaced(x) && is_uniformly_spaced(y)
+        # For uniformly spaced data use GR.drawimage, which can be
+        # much faster than GR.nonuniformcellarray, especially for
+        # pdf output, and also supports alpha values.
+        # Note that drawimage draws uniformly spaced data correctly
+        # even on log scales, where it is visually non-uniform.
+        colors = plot_color.(get(fillgrad, z, clims), series[:fillalpha])
+        rgba = gr_color.(colors)
+        GR.drawimage(first(x), last(x), last(y), first(y), w, h, rgba)
     else
-        phimin, phimax = 0.0, 360.0 # nonuniform polar array is not yet supported in GR.jl
-        nx, ny = length(series[:x]), length(series[:y])
-        xmin, xmax, ymin, ymax = gr_xy_axislims(series[:subplot])
-        GR.setwindow(-ymax, ymax, -ymax, ymax)
-        if ymin > 0
-            @warn "'ymin[1] > 0' (rmin) is not yet supported."
-        end
-        if series[:y][end] != ny
-            @warn "Right now only the maximum value of y (r) is taken into account."
+        if something(series[:fillalpha], 1) < 1
+            @warn "GR: transparency not supported in non-uniform heatmaps. Alpha values ignored."
         end
         z_normalized = get_z_normalized.(z, clims...)
         rgba = Int32[round(Int32, 1000 + _i * 255) for _i in z_normalized]
-        GR.polarcellarray(0, 0, phimin, phimax, 0, ymax, nx, ny, rgba)
-        # Right now only the maximum value of y (r) is taken into account.
-        # This is certainly not perfect but nonuniform polar array is not yet supported in GR.jl
+        if !ispolar(series)
+            GR.nonuniformcellarray(x, y, w, h, rgba)
+        else
+            if y[1] < 0
+                @warn "'y[1] < 0' (rmin) is not yet supported."
+            end
+            xmin, xmax, ymin, ymax = gr_xy_axislims(series[:subplot])
+            GR.setwindow(-ymax, ymax, -ymax, ymax)
+            GR.nonuniformpolarcellarray(rad2deg.(x), y, w, h, rgba)
+        end
     end
 end
 

src/backends/hdf5.jl

@@ -46,7 +46,7 @@ import Dates
 
 #Plots.jl imports HDF5 to main:
 import ..HDF5
-import ..HDF5: HDF5Group, HDF5Dataset
+import ..HDF5: Group, Dataset
 
 import ..Colors, ..Colorant
 import ..PlotUtils.ColorSchemes.ColorScheme
@@ -159,40 +159,40 @@ _type_for_map(::Type{T}) where T<:Surface = Surface
 
 #==Read/write things like type name in attributes
 ===============================================================================#
-function _write_datatype_attr(ds::Union{HDF5Group, HDF5Dataset}, ::Type{T}) where T
+function _write_datatype_attr(ds::Union{Group, Dataset}, ::Type{T}) where T
     typestr = HDF5PLOT_MAP_TELEM2STR[T]
-    HDF5.attrs(ds)["TYPE"] = typestr
+    HDF5.attributes(ds)["TYPE"] = typestr
 end
-function _read_datatype_attr(ds::Union{HDF5Group, HDF5Dataset})
-    if !HDF5.exists(HDF5.attrs(ds), "TYPE")
+function _read_datatype_attr(ds::Union{Group, Dataset})
+    if !Base.haskey(HDF5.attributes(ds), "TYPE")
         return HDF5_AutoDetect
     end
 
-    typestr = HDF5.read(HDF5.attrs(ds)["TYPE"])
+    typestr = HDF5.read(HDF5.attributes(ds)["TYPE"])
     return HDF5PLOT_MAP_STR2TELEM[typestr]
 end
 
 #Type parameter attributes:
-function _write_typeparam_attr(ds::HDF5Dataset, v::Length{T}) where T
-    HDF5.attrs(ds)["TYPEPARAM"] = string(T) #Need to add units for Length
+function _write_typeparam_attr(ds::Dataset, v::Length{T}) where T
+    HDF5.attributes(ds)["TYPEPARAM"] = string(T) #Need to add units for Length
 end
-_read_typeparam_attr(ds::HDF5Dataset) = HDF5.read(HDF5.attrs(ds)["TYPEPARAM"])
+_read_typeparam_attr(ds::Dataset) = HDF5.read(HDF5.attributes(ds)["TYPEPARAM"])
 
-function _write_length_attr(grp::HDF5Group, v::Vector) #of a vector
-    HDF5.attrs(grp)["LENGTH"] = length(v)
+function _write_length_attr(grp::Group, v::Vector) #of a vector
+    HDF5.attributes(grp)["LENGTH"] = length(v)
 end
-_read_length_attr(::Type{Vector}, grp::HDF5Group) = HDF5.read(HDF5.attrs(grp)["LENGTH"])
+_read_length_attr(::Type{Vector}, grp::Group) = HDF5.read(HDF5.attributes(grp)["LENGTH"])
 
-function _write_size_attr(grp::HDF5Group, v::Array) #of an array
-    HDF5.attrs(grp)["SIZE"] = [size(v)...]
+function _write_size_attr(grp::Group, v::Array) #of an array
+    HDF5.attributes(grp)["SIZE"] = [size(v)...]
 end
-_read_size_attr(::Type{Array}, grp::HDF5Group) = tuple(HDF5.read(HDF5.attrs(grp)["SIZE"])...)
+_read_size_attr(::Type{Array}, grp::Group) = tuple(HDF5.read(HDF5.attributes(grp)["SIZE"])...)
 
 
 #==_write_typed(): Simple (leaf) datatypes. (Labels with type name.)
 ===============================================================================#
 #= No: write out struct instead!
-function _write_typed(grp::HDF5Group, name::String, v::T) where T
+function _write_typed(grp::Group, name::String, v::T) where T
     tstr = string(T)
     path = HDF5.name(grp) * "/" * name
     @info("Type not supported: $tstr\npath: $path")
@@ -200,41 +200,41 @@ function _write_typed(grp::HDF5Group, name::String, v::T) where T
 end
 =#
 #Default behaviour: Assumes value is supported by HDF5 format
-function _write_typed(grp::HDF5Group, name::String, v::HDF5_SupportedTypes)
+function _write_typed(grp::Group, name::String, v::HDF5_SupportedTypes)
     grp[name] = v
     return #No need to _write_datatype_attr
 end
-function _write_typed(grp::HDF5Group, name::String, v::Nothing)
+function _write_typed(grp::Group, name::String, v::Nothing)
     grp[name] = "nothing" #Redundancy check/easier to read HDF5 file
     _write_datatype_attr(grp[name], Nothing)
 end
-function _write_typed(grp::HDF5Group, name::String, v::Symbol)
+function _write_typed(grp::Group, name::String, v::Symbol)
     grp[name] = String(v)
     _write_datatype_attr(grp[name], Symbol)
 end
-function _write_typed(grp::HDF5Group, name::String, v::Colorant)
+function _write_typed(grp::Group, name::String, v::Colorant)
     vstr = "#" * Colors.hex(v, :RRGGBBAA)
     grp[name] = vstr
     _write_datatype_attr(grp[name], Colorant)
 end
-function _write_typed(grp::HDF5Group, name::String, v::Extrema)
+function _write_typed(grp::Group, name::String, v::Extrema)
     grp[name] = [v.emin, v.emax] #More compact than writing struct
     _write_datatype_attr(grp[name], Extrema)
 end
-function _write_typed(grp::HDF5Group, name::String, v::Length)
+function _write_typed(grp::Group, name::String, v::Length)
     grp[name] = v.value
     _write_datatype_attr(grp[name], Length)
     _write_typeparam_attr(grp[name], v)
 end
-function _write_typed(grp::HDF5Group, name::String, v::typeof(datetimeformatter))
+function _write_typed(grp::Group, name::String, v::typeof(datetimeformatter))
     grp[name] = string(v) #Just write something that helps reader
    _write_datatype_attr(grp[name], typeof(datetimeformatter))
 end
-function _write_typed(grp::HDF5Group, name::String, v::Array{T}) where T<:Number #Default for arrays
+function _write_typed(grp::Group, name::String, v::Array{T}) where T<:Number #Default for arrays
     grp[name] = v
     return #No need to _write_datatype_attr
 end
-function _write_typed(grp::HDF5Group, name::String, v::AbstractRange)
+function _write_typed(grp::Group, name::String, v::AbstractRange)
     _write_typed(grp, name, collect(v)) #For now
 end
 
@@ -244,8 +244,8 @@ end
 ===============================================================================#
 
 #Write an array using HDF5 hierarchy (when not using simple numeric eltype):
-function _write_harray(grp::HDF5Group, name::String, v::Array)
-    sgrp = HDF5.g_create(grp, name)
+function _write_harray(grp::Group, name::String, v::Array)
+    sgrp = HDF5.create_group(grp, name)
     sz = size(v)
     lidx = LinearIndices(sz)
 
@@ -260,8 +260,8 @@ function _write_harray(grp::HDF5Group, name::String, v::Array)
 end
 
 #Write Dict without tagging with type:
-function _write(grp::HDF5Group, name::String, d::AbstractDict)
-    sgrp = HDF5.g_create(grp, name)
+function _write(grp::Group, name::String, d::AbstractDict)
+    sgrp = HDF5.create_group(grp, name)
     for (k, v) in d
         kstr = string(k)
         _write_typed(sgrp, kstr, v)
@@ -270,7 +270,7 @@ function _write(grp::HDF5Group, name::String, d::AbstractDict)
 end
 
 #Write out arbitrary `struct`s:
-function _writestructgeneric(grp::HDF5Group, obj::T) where T
+function _writestructgeneric(grp::Group, obj::T) where T
     for fname in fieldnames(T)
        v = getfield(obj, fname)
        _write_typed(grp, String(fname), v)
@@ -283,7 +283,7 @@ end
 ===============================================================================#
 
 #Catch-all (default behaviour for `struct`s):
-function _write_typed(grp::HDF5Group, name::String, v::T) where T
+function _write_typed(grp::Group, name::String, v::T) where T
     #NOTE: need "name" parameter so that call signature is same with built-ins
     MT = _type_for_map(T)
     try #Check to see if type is supported
@@ -294,27 +294,27 @@ function _write_typed(grp::HDF5Group, name::String, v::T) where T
     end
 
     #If attribute is supported and no writer is defined, then this should work:
-    objgrp = HDF5.g_create(grp, name)
+    objgrp = HDF5.create_group(grp, name)
     _write_datatype_attr(objgrp, MT)
     _writestructgeneric(objgrp, v)
 end
 
-function _write_typed(grp::HDF5Group, name::String, v::Array{T}) where T
+function _write_typed(grp::Group, name::String, v::Array{T}) where T
     _write_harray(grp, name, v)
     _write_datatype_attr(grp[name], Array) #{Any}
 end
 
-function _write_typed(grp::HDF5Group, name::String, v::Tuple, ::Type{ELT}) where ELT<: Number #Basic Tuple
+function _write_typed(grp::Group, name::String, v::Tuple, ::Type{ELT}) where ELT<: Number #Basic Tuple
     _write_typed(grp, name, [v...])
     _write_datatype_attr(grp[name], Tuple)
 end
-function _write_typed(grp::HDF5Group, name::String, v::Tuple, ::Type) #CplxTuple
+function _write_typed(grp::Group, name::String, v::Tuple, ::Type) #CplxTuple
     _write_harray(grp, name, [v...])
     _write_datatype_attr(grp[name], CplxTuple)
 end
-_write_typed(grp::HDF5Group, name::String, v::Tuple) = _write_typed(grp, name, v, eltype(v))
+_write_typed(grp::Group, name::String, v::Tuple) = _write_typed(grp, name, v, eltype(v))
 
-function _write_typed(grp::HDF5Group, name::String, v::Dict)
+function _write_typed(grp::Group, name::String, v::Dict)
 #=
     tstr = string(Dict)
     path = HDF5.name(grp) * "/" * name
@@ -323,27 +323,27 @@ function _write_typed(grp::HDF5Group, name::String, v::Dict)
 =#
     #No support for structures with Dicts yet
 end
-function _write_typed(grp::HDF5Group, name::String, d::DefaultsDict) #Typically for plot attributes
+function _write_typed(grp::Group, name::String, d::DefaultsDict) #Typically for plot attributes
     _write(grp, name, d)
     _write_datatype_attr(grp[name], DefaultsDict)
 end
 
-function _write_typed(grp::HDF5Group, name::String, v::Axis)
-    sgrp = HDF5.g_create(grp, name)
+function _write_typed(grp::Group, name::String, v::Axis)
+    sgrp = HDF5.create_group(grp, name)
     #Ignore: sps::Vector{Subplot}
     _write_typed(sgrp, "plotattributes", v.plotattributes)
     _write_datatype_attr(sgrp, Axis)
 end
 
-function _write_typed(grp::HDF5Group, name::String, v::Subplot)
+function _write_typed(grp::Group, name::String, v::Subplot)
     #Not for use in main "Plot.subplots[]" hierarchy.  Just establishes reference with subplot_index.
-    sgrp = HDF5.g_create(grp, name)
+    sgrp = HDF5.create_group(grp, name)
     _write_typed(sgrp, "index", v[:subplot_index])
     _write_datatype_attr(sgrp, Subplot)
     return
 end
 
-function _write_typed(grp::HDF5Group, name::String, v::Plot)
+function _write_typed(grp::Group, name::String, v::Plot)
     #Don't write plot references
 end
 
@@ -352,10 +352,10 @@ end
 NOTE: No need to write out type information (inferred from hierarchy)
 ===============================================================================#
 
-function _write(grp::HDF5Group, sp::Subplot{HDF5Backend})
+function _write(grp::Group, sp::Subplot{HDF5Backend})
     _write_typed(grp, "attr", sp.attr)
 
-    listgrp = HDF5.g_create(grp, "series_list")
+    listgrp = HDF5.create_group(grp, "series_list")
     _write_length_attr(listgrp, sp.series_list)
     for (i, series) in enumerate(sp.series_list)
         #Just write .plotattributes part:
@@ -365,13 +365,13 @@ function _write(grp::HDF5Group, sp::Subplot{HDF5Backend})
     return
 end
 
-function _write(grp::HDF5Group, plt::Plot{HDF5Backend})
+function _write(grp::Group, plt::Plot{HDF5Backend})
     _write_typed(grp, "attr", plt.attr)
 
-    listgrp = HDF5.g_create(grp, "subplots")
+    listgrp = HDF5.create_group(grp, "subplots")
     _write_length_attr(listgrp, plt.subplots)
     for (i, sp) in enumerate(plt.subplots)
-        sgrp = HDF5.g_create(listgrp, "$i")
+        sgrp = HDF5.create_group(listgrp, "$i")
         _write(sgrp, sp)
     end
 
@@ -380,8 +380,8 @@ end
 
 function hdf5plot_write(plt::Plot{HDF5Backend}, path::AbstractString; name::String="_unnamed")
     HDF5.h5open(path, "w") do file
-        HDF5.d_write(file, "VERSION_INFO", _get_Plots_versionstr())
-        grp = HDF5.g_create(file, h5plotpath(name))
+        HDF5.write_dataset(file, "VERSION_INFO", _get_Plots_versionstr())
+        grp = HDF5.create_group(file, h5plotpath(name))
         _write(grp, plt)
     end
 end
@@ -391,45 +391,45 @@ end
 ===============================================================================#
 
 #Types with built-in HDF5 support:
-_read(::Type{HDF5_AutoDetect}, ds::HDF5Dataset) = HDF5.read(ds)
+_read(::Type{HDF5_AutoDetect}, ds::Dataset) = HDF5.read(ds)
 
-function _read(::Type{Nothing}, ds::HDF5Dataset)
+function _read(::Type{Nothing}, ds::Dataset)
     nstr = "nothing"
     v = HDF5.read(ds)
     if nstr != v
         path = HDF5.name(ds)
-        throw(Meta.ParseError("_read(::Nothing, ::HDF5Group): Read $v != $nstr:\n$path"))
+        throw(Meta.ParseError("_read(::Nothing, ::Group): Read $v != $nstr:\n$path"))
     end
     return nothing
 end
-_read(::Type{Symbol}, ds::HDF5Dataset) = Symbol(HDF5.read(ds))
-_read(::Type{Colorant}, ds::HDF5Dataset) = parse(Colorant, HDF5.read(ds))
-_read(::Type{Tuple}, ds::HDF5Dataset) = tuple(HDF5.read(ds)...)
-function _read(::Type{Extrema}, ds::HDF5Dataset)
+_read(::Type{Symbol}, ds::Dataset) = Symbol(HDF5.read(ds))
+_read(::Type{Colorant}, ds::Dataset) = parse(Colorant, HDF5.read(ds))
+_read(::Type{Tuple}, ds::Dataset) = tuple(HDF5.read(ds)...)
+function _read(::Type{Extrema}, ds::Dataset)
     v = HDF5.read(ds)
     return Extrema(v[1], v[2])
 end
-function _read(::Type{Length}, ds::HDF5Dataset)
+function _read(::Type{Length}, ds::Dataset)
     TUNIT = Symbol(_read_typeparam_attr(ds))
     v = HDF5.read(ds)
     T = typeof(v)
     return Length{TUNIT,T}(v)
 end
-_read(::Type{typeof(datetimeformatter)}, ds::HDF5Dataset) = datetimeformatter
+_read(::Type{typeof(datetimeformatter)}, ds::Dataset) = datetimeformatter
 
 
 #== Helper functions for reading in complex data structures
 ===============================================================================#
 
 #When type is unknown, _read_typed() figures it out:
-function _read_typed(grp::HDF5Group, name::String)
+function _read_typed(grp::Group, name::String)
     ds = grp[name]
     t = _read_datatype_attr(ds)
     return _read(t, ds)
 end
 
 #_readstructgeneric: Needs object values to be written out with _write_typed():
-function _readstructgeneric(::Type{T}, grp::HDF5Group) where T
+function _readstructgeneric(::Type{T}, grp::Group) where T
     vlist = Array{Any}(nothing, fieldcount(T))
     for (i, fname) in enumerate(fieldnames(T))
         vlist[i] = _read_typed(grp, String(fname))
@@ -438,10 +438,10 @@ function _readstructgeneric(::Type{T}, grp::HDF5Group) where T
 end
 
 #Read KW from group:
-function _read(::Type{KW}, grp::HDF5Group)
+function _read(::Type{KW}, grp::Group)
     d = KW()
-    gnames = names(grp)
-    for k in gnames
+    gkeys = keys(grp)
+    for k in gkeys
         try
             v = _read_typed(grp, k)
             d[Symbol(k)] = v
@@ -459,9 +459,9 @@ end
 ===============================================================================#
 
 #Catch-all (default behaviour for `struct`s):
-_read(T::Type, grp::HDF5Group) = _readstructgeneric(T, grp)
+_read(T::Type, grp::Group) = _readstructgeneric(T, grp)
 
-function _read(::Type{Array}, grp::HDF5Group) #Array{Any}
+function _read(::Type{Array}, grp::Group) #Array{Any}
     sz = _read_size_attr(Array, grp)
     if tuple(0) == sz; return []; end
     result = Array{Any}(undef, sz)
@@ -479,9 +479,9 @@ function _read(::Type{Array}, grp::HDF5Group) #Array{Any}
     return reshape(result, sz)
 end
 
-_read(::Type{CplxTuple}, grp::HDF5Group) = tuple(_read(Array, grp)...)
+_read(::Type{CplxTuple}, grp::Group) = tuple(_read(Array, grp)...)
 
-function _read(::Type{GridLayout}, grp::HDF5Group)
+function _read(::Type{GridLayout}, grp::Group)
     #parent = _read_typed(grp, "parent") #Can't use generic reader
     parent = RootLayout() #TODO: support parent???
     minpad = _read_typed(grp, "minpad")
@@ -494,17 +494,17 @@ function _read(::Type{GridLayout}, grp::HDF5Group)
     return GridLayout(parent, minpad, bbox, grid, widths, heights, attr)
 end
 #Defaults depends on context. So: user must constructs with defaults, then read.
-function _read(::Type{DefaultsDict}, grp::HDF5Group)
+function _read(::Type{DefaultsDict}, grp::Group)
     #User should set DefaultsDict.defaults to one of:
     #   _plot_defaults, _subplot_defaults, _axis_defaults, _series_defaults
     path = HDF5.name(ds)
     @warn("Cannot yet read DefaultsDict using _read_typed():\n    $path\nCannot fully reconstruct plot.")
 end
-function _read(::Type{Axis}, grp::HDF5Group)
+function _read(::Type{Axis}, grp::Group)
     #1st arg appears to be ref to subplots. Seems to work without it.
     return Axis([], DefaultsDict(_read(KW, grp["plotattributes"]), _axis_defaults))
 end
-function _read(::Type{Subplot}, grp::HDF5Group)
+function _read(::Type{Subplot}, grp::Group)
     #Not for use in main "Plot.subplots[]" hierarchy.  Just establishes reference with subplot_index.
     idx = _read_typed(grp, "index")
     return HDF5PLOT_PLOTREF.ref.subplots[idx]
@@ -514,12 +514,12 @@ end
 #== _read(): Main plot structures
 ===============================================================================#
 
-function _read(grp::HDF5Group, sp::Subplot)
-    listgrp = HDF5.g_open(grp, "series_list")
+function _read(grp::Group, sp::Subplot)
+    listgrp = HDF5.open_group(grp, "series_list")
     nseries = _read_length_attr(Vector, listgrp)
 
     for i in 1:nseries
-        sgrp = HDF5.g_open(listgrp, "$i")
+        sgrp = HDF5.open_group(listgrp, "$i")
         seriesinfo = _read(KW, sgrp)
 
         plot!(sp, seriesinfo[:x], seriesinfo[:y]) #Add data & create data structures
@@ -527,25 +527,25 @@ function _read(grp::HDF5Group, sp::Subplot)
     end
 
     #Perform after adding series... otherwise values get overwritten:
-    agrp = HDF5.g_open(grp, "attr")
+    agrp = HDF5.open_group(grp, "attr")
     _hdf5_merge!(sp.attr, _read(KW, agrp))
 
     return sp
 end
 
-function _read_plot(grp::HDF5Group)
-    listgrp = HDF5.g_open(grp, "subplots")
+function _read_plot(grp::Group)
+    listgrp = HDF5.open_group(grp, "subplots")
     n = _read_length_attr(Vector, listgrp)
 
     #Construct new plot, +allocate subplots:
     plt = plot(layout=n)
     HDF5PLOT_PLOTREF.ref = plt #Used when reading "layout"
 
-    agrp = HDF5.g_open(grp, "attr")
+    agrp = HDF5.open_group(grp, "attr")
     _hdf5_merge!(plt.attr, _read(KW, agrp))
 
     for (i, sp) in enumerate(plt.subplots)
-        sgrp = HDF5.g_open(listgrp, "$i")
+        sgrp = HDF5.open_group(listgrp, "$i")
         _read(sgrp, sp)
     end
 
@@ -554,7 +554,7 @@ end
 
 function hdf5plot_read(path::AbstractString; name::String="_unnamed")
     HDF5.h5open(path, "r") do file
-        grp = HDF5.g_open(file, h5plotpath("_unnamed"))
+        grp = HDF5.open_group(file, h5plotpath("_unnamed"))
         return _read_plot(grp)
     end
 end

src/backends/inspectdr.jl

@@ -79,6 +79,58 @@ end
 
 # ---------------------------------------------------------------------------
 
+function _inspectdr_getaxisticks(ticks, gridlines, xfrm)
+    TickCustom = InspectDR.TickCustom
+    _xfrm(coord) = InspectDR.axis2aloc(Float64(coord), xfrm.spec) #Ensure Float64 - in case
+
+    ttype = ticksType(ticks)
+    if ticks == :native
+        #keep current
+    elseif ttype == :ticks_and_labels
+        pos = ticks[1]; labels = ticks[2]; nticks = length(ticks[1])
+        newticks = TickCustom[TickCustom(_xfrm(pos[i]), labels[i]) for i in 1:nticks]
+        gridlines = InspectDR.GridLinesCustom(gridlines)
+        gridlines.major = newticks
+        gridlines.minor = []
+        gridlines.displayminor = false
+    elseif ttype == :ticks
+        nticks = length(ticks)
+        gridlines.major = Float64[_xfrm(t) for t in ticks]
+        gridlines.minor = []
+        gridlines.displayminor = false
+    elseif isnothing(ticks)
+        gridlines.major = []
+        gridlines.minor = []
+    else #Assume ticks == :native
+        #keep current
+    end
+
+    return gridlines #keep current
+end
+
+function _inspectdr_setticks(sp::Subplot, plot, strip, xaxis, yaxis)
+    InputXfrm1D = InspectDR.InputXfrm1D
+    _get_ticks(axis) = :native == axis[:ticks] ? (:native) : get_ticks(sp, axis)
+    wantnative(ticks) = (:native == ticks)
+
+    xticks = _get_ticks(xaxis)
+    yticks = _get_ticks(yaxis)
+
+    if wantnative(xticks) && wantnative(yticks)
+        #Don't "eval" tick values
+        return
+    end
+
+    #TODO: Allow InspectDR to independently "eval" x or y ticks
+    ext = InspectDR.getextents_aloc(plot, 1)
+    grid = InspectDR._eval(strip.grid, plot.xscale, strip.yscale, ext)
+    grid.xlines = _inspectdr_getaxisticks(xticks, grid.xlines, InputXfrm1D(plot.xscale))
+    grid.ylines = _inspectdr_getaxisticks(yticks, grid.ylines, InputXfrm1D(strip.yscale))
+    strip.grid = grid
+end
+
+# ---------------------------------------------------------------------------
+
 function _inspectdr_getscale(s::Symbol, yaxis::Bool)
 #TODO: Support :asinh, :sqrt
     kwargs = yaxis ? (:tgtmajor=>8, :tgtminor=>2) : () #More grid lines on y-axis
@@ -167,6 +219,7 @@ function _series_added(plt::Plot{InspectDRBackend}, series::Series)
     st = series[:seriestype]
     sp = series[:subplot]
     plot = sp.o
+    clims = get_clims(sp, series)
 
     #Don't do anything without a "subplot" object:  Will process later.
     if nothing == plot; return; end
@@ -256,8 +309,8 @@ For st in :shape:
         wfrm.glyph = InspectDR.glyph(
             shape = _inspectdr_mapglyph(series[:markershape]),
             size = _inspectdr_mapglyphsize(series[:markersize]),
-            color = _inspectdr_mapcolor(plot_color(series[:markerstrokecolor], series[:markerstrokealpha])),
-            fillcolor = _inspectdr_mapcolor(plot_color(series[:markercolor], series[:markeralpha])),
+            color = _inspectdr_mapcolor(plot_color(get_markerstrokecolor(series), get_markerstrokealpha(series))),
+            fillcolor = _inspectdr_mapcolor(plot_color(get_markercolor(series, clims), get_markeralpha(series))),
         )
     end
 
@@ -288,8 +341,8 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
     ygrid_show = yaxis[:grid]
 
     strip.grid = InspectDR.GridRect(
-    	vmajor=xgrid_show, # vminor=xgrid_show,
-    	hmajor=ygrid_show, # hminor=ygrid_show,
+        vmajor=xgrid_show, # vminor=xgrid_show,
+        hmajor=ygrid_show, # hminor=ygrid_show,
     )
 
         plot.xscale = _inspectdr_getscale(xaxis[:scale], false)
@@ -302,18 +355,27 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
             xmin, xmax = -rmax, rmax
             ymin, ymax = -rmax, rmax
         end
-        plot.xext = InspectDR.PExtents1D() #reset
-        strip.yext = InspectDR.PExtents1D() #reset
         plot.xext_full = InspectDR.PExtents1D(xmin, xmax)
         strip.yext_full = InspectDR.PExtents1D(ymin, ymax)
+        #Set current extents = full extents (needed for _eval(strip.grid,...))
+        plot.xext = plot.xext_full
+        strip.yext = strip.yext_full
+        _inspectdr_setticks(sp, plot, strip, xaxis, yaxis)
+
     a = plot.annotation
         a.title = sp[:title]
         a.xlabel = xaxis[:guide]; a.ylabels = [yaxis[:guide]]
 
     l = plot.layout
+        #IMPORTANT: Don't forget to actually register changes
+        #(TODO: need to find a better way to set layout properties)
         l[:frame_canvas].fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
+            l[:frame_canvas] = l[:frame_canvas] #register changes
         l[:frame_data].fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
+            l[:frame_data] = l[:frame_data] #register changes
+
         l[:frame_data].line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
+            l[:frame_data] = l[:frame_data] #register changes
         l[:font_title] = InspectDR.Font(sp[:titlefontfamily],
             _inspectdr_mapptsize(sp[:titlefontsize]),
             color = _inspectdr_mapcolor(sp[:titlefontcolor])
@@ -334,6 +396,7 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
             color = _inspectdr_mapcolor(sp[:legendfontcolor])
         )
         l[:frame_legend].fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
+            l[:frame_legend] = l[:frame_legend] #register changes
 end
 
 # called just before updating layout bounding boxes... in case you need to prep
@@ -347,8 +410,9 @@ function _before_layout_calcs(plt::Plot{InspectDRBackend})
         #Don't use window_title... probably not what you want.
         #mplot.title = plt[:window_title]
     end
-    mplot.layout[:frame].fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
 
+    mplot.layout[:frame].fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
+        mplot.layout[:frame] = mplot.layout[:frame] #register changes
     resize!(mplot.subplots, length(plt.subplots))
     nsubplots = length(plt.subplots)
     for (i, sp) in enumerate(plt.subplots)

src/backends/pgfplotsx.jl

@@ -163,11 +163,12 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                     ) => nothing,
                     "fill" => cstr,
                     "fill opacity" => a,
-                    "text opacity" =>     alpha(plot_color(sp[:legendfontcolor])),
+                    "text opacity" => alpha(plot_color(sp[:legendfontcolor])),
                     "font" => pgfx_font(
                         sp[:legendfontsize],
                         pgfx_thickness_scaling(sp),
                     ),
+                    "text" => plot_color(sp[:legendfontcolor]),
                 ),
                 "axis background/.style" => PGFPlotsX.Options(
                     "fill" => bgc_inside,
@@ -282,7 +283,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                 )
                 extra_series, extra_series_opt = pgfx_split_extra_opts(series[:extra_kwargs])
                 series_opt = merge(series_opt, PGFPlotsX.Options(extra_series_opt...))
-                if RecipesPipeline.is3d(series) || st in (:heatmap, :contour)
+                if RecipesPipeline.is3d(series) || st in (:heatmap, :contour) || (st == :quiver && opt[:z] !== nothing)
                     series_func = PGFPlotsX.Plot3
                 else
                     series_func = PGFPlotsX.Plot
@@ -338,9 +339,10 @@ end
 
 function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, opt)
     # treat segments
-    segments = iter_segments(series, series[:seriestype])
+    segments = collect(series_segments(series, series[:seriestype]))
     sf = opt[:fillrange]
-    for (i, rng) in enumerate(segments)
+    for segment in segments
+        i, rng = segment.attr_index, segment.range
         segment_opt = PGFPlotsX.Options()
         segment_opt = merge(segment_opt, pgfx_linestyle(opt, i))
         if opt[:markershape] != :none
@@ -496,6 +498,7 @@ function pgfx_add_series!(::Val{:surface}, axis, series_opt, series, series_func
         "mesh/rows" => length(opt[:x]),
         "mesh/cols" => length(opt[:y]),
         "z buffer" => "sort",
+        "opacity" => get_fillalpha(series),
     )
     pgfx_add_series!(axis, series_opt, series, series_func, opt)
 end
@@ -568,6 +571,7 @@ function pgfx_add_series!(::Val{:contour3d}, axis, series_opt, series, series_fu
         series_opt,
         "contour prepared" => PGFPlotsX.Options("labels" => opt[:contour_labels]),
     )
+    series_opt = merge( series_opt, pgfx_linestyle(opt) )
     args = pgfx_series_arguments(series, opt)
     series_plot = series_func(series_opt, PGFPlotsX.Table(Contour.contours(args..., opt[:levels])))
     push!(axis, series_plot)
@@ -586,12 +590,26 @@ function pgfx_add_series!(::Val{:quiver}, axis, series_opt, series, series_func,
         )
         x = opt[:x]
         y = opt[:y]
-        table = PGFPlotsX.Table([
-            :x => x,
-            :y => y,
-            :u => opt[:quiver][1],
-            :v => opt[:quiver][2],
-        ])
+        z = opt[:z]
+        if z !== nothing
+            push!(series_opt["quiver"], "w" => "\\thisrow{w}")
+            pgfx_axis!(axis.options, series[:subplot], :z)
+            table = PGFPlotsX.Table([
+                :x => x,
+                :y => y,
+                :z => z,
+                :u => opt[:quiver][1],
+                :v => opt[:quiver][2],
+                :w => opt[:quiver][3],
+            ])
+        else
+            table = PGFPlotsX.Table([
+                :x => x,
+                :y => y,
+                :u => opt[:quiver][1],
+                :v => opt[:quiver][2],
+            ])
+        end
     end
     series_plot = series_func(series_opt, table)
     push!(axis, series_plot)
@@ -752,8 +770,26 @@ pgfx_get_legend_pos(k) = get(
     Symbol(k),
     ("at" => string((1.02, 1)), "anchor" => "north west"),
 )
-pgfx_get_legend_pos(t::Tuple) = ("at" => "{$(string(t))}", "anchor" => "north west")
+pgfx_get_legend_pos(t::Tuple{S,T}) where {S<:Real,T<:Real} = ("at" => "{$(string(t))}", "anchor" => "north west")
 pgfx_get_legend_pos(nt::NamedTuple) = ("at" => "{$(string(nt.at))}", "anchor" => string(nt.anchor))
+pgfx_get_legend_pos(theta::Real) = pgfx_get_legend_pos((theta,:inner))
+function pgfx_get_legend_pos(v::Tuple{S,Symbol}) where S <: Real
+    (s,c) = sincosd(v[1])
+    anchors = [
+               "south west" "south" "south east";
+               "west" "center" "east";
+               "north west" "north" "north east";
+              ]
+
+    if v[2] === :inner
+        rect = (0.07,0.5,1.0,0.07,0.52,1.0)
+        anchor = anchors[legend_anchor_index(s),legend_anchor_index(c)]
+    else
+        rect = (-0.15,0.5,1.05,-0.15,0.52,1.1)
+        anchor = anchors[4-legend_anchor_index(s),4-legend_anchor_index(c)]
+    end
+    return ("at"=>"$(string(legend_pos_from_angle(v[1],rect...)))", "anchor"=>anchor)
+end
 
 pgfx_get_colorbar_pos(s) =
     get((left = " left", bottom = " horizontal", top = " horizontal"), s, "")
@@ -820,7 +856,7 @@ function pgfx_colormap(v::Vector{<:Colorant})
 end
 function pgfx_colormap(cg::ColorGradient)
     join(map(1:length(cg)) do i
-        @sprintf("rgb(%.8fcm)=(%.8f,%.8f,%.8f)", cg.values[i], red(cg.colors[i]), green(cg.colors[i]), blue(cg.colors[i]))
+        @sprintf("rgb(%.8f)=(%.8f,%.8f,%.8f)", cg.values[i], red(cg.colors[i]), green(cg.colors[i]), blue(cg.colors[i]))
     end, "\n")
 end
 
@@ -872,6 +908,13 @@ function pgfx_font(fontsize, thickness_scaling = 1, font = "\\selectfont")
     return string("{\\fontsize{", fs, " pt}{", 1.3fs, " pt}", font, "}")
 end
 
+# If a particular fontsize parameter is `nothing`, produce a figure that doesn't specify the
+# font size, and therefore uses whatever fontsize is utilised by the doc in which the
+# figure is located.
+function pgfx_font(fontsize::Nothing, thickness_scaling = 1, font = "\\selectfont")
+    return string("{", font, "}")
+end
+
 function pgfx_should_add_to_legend(series::Series)
     series.plotattributes[:primary] &&
     !(
@@ -1338,7 +1381,7 @@ function _update_plot_object(plt::Plot{PGFPlotsXBackend})
     plt.o(plt)
 end
 
-for mime in ("application/pdf", "image/png", "image/svg+xml")
+for mime in ("application/pdf", "image/svg+xml")
     @eval function _show(
         io::IO,
         mime::MIME{Symbol($mime)},
@@ -1349,6 +1392,18 @@ for mime in ("application/pdf", "image/png", "image/svg+xml")
     end
 end
 
+    function _show(
+        io::IO,
+        mime::MIME{Symbol("image/png")},
+        plt::Plot{PGFPlotsXBackend},
+    )
+        plt.o.was_shown = true
+        plt_file = tempname() * ".png"
+        PGFPlotsX.pgfsave(plt_file, plt.o.the_plot; dpi=plt[:dpi])
+        write(io, read(plt_file))
+        rm(plt_file; force = true)
+    end
+
 function _show(
     io::IO,
     mime::MIME{Symbol("application/x-tex")},

src/backends/plotly.jl

@@ -384,6 +384,25 @@ end
 
 plotly_legend_pos(v::Tuple{S,T}) where {S<:Real, T<:Real} = (coords=v, xanchor="left", yanchor="top")
 
+plotly_legend_pos(theta::Real) = plotly_legend_pos((theta, :inner))
+
+function plotly_legend_pos(v::Tuple{S,Symbol}) where S<:Real
+    (s,c) = sincosd(v[1])
+    xanchors = ["left", "center", "right"]
+    yanchors = ["bottom", "middle", "top"]
+
+    if v[2] === :inner
+        rect = (0.07,0.5,1.0,0.07,0.52,1.0)
+        xanchor = xanchors[legend_anchor_index(c)]
+        yanchor = yanchors[legend_anchor_index(s)]
+    else
+        rect = (-0.15,0.5,1.05,-0.15,0.52,1.1)
+        xanchor = xanchors[4-legend_anchor_index(c)]
+        yanchor = yanchors[4-legend_anchor_index(s)]
+    end
+    return (coords=legend_pos_from_angle(v[1],rect...), xanchor=xanchor, yanchor=yanchor)
+end
+
 
 function plotly_layout_json(plt::Plot)
     JSON.json(plotly_layout(plt), 4)
@@ -595,9 +614,9 @@ function plotly_series(plt::Plot, series::Series)
     elseif st == :mesh3d
 	plotattributes_out[:type] = "mesh3d"
         plotattributes_out[:x], plotattributes_out[:y], plotattributes_out[:z] = x, y, z
-       
+
 	if series[:connections] !== nothing
-		if typeof(series[:connections]) <: Tuple{Array,Array,Array} 
+		if typeof(series[:connections]) <: Tuple{Array,Array,Array}
 			i,j,k = series[:connections]
 			if !(length(i) == length(j) == length(k))
 				throw(ArgumentError("Argument connections must consist of equally sized arrays."))
@@ -643,7 +662,7 @@ function plotly_series(plt::Plot, series::Series)
 end
 
 function plotly_series_shapes(plt::Plot, series::Series, clims)
-    segments = iter_segments(series)
+    segments = collect(series_segments(series))
     plotattributes_outs = Vector{KW}(undef, length(segments))
 
     # TODO: create a plotattributes_out for each polygon
@@ -662,7 +681,8 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
         for (letter, data) in zip((:x, :y), shape_data(series, 100))
     )
 
-    for (i,rng) in enumerate(segments)
+    for segment in segments
+        i, rng = segment.attr_index, segment.range
         length(rng) < 2 && continue
 
         # to draw polygons, we actually draw lines with fill
@@ -705,14 +725,16 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
     hasfillrange = st in (:path, :scatter, :scattergl, :straightline) &&
         (isa(series[:fillrange], AbstractVector) || isa(series[:fillrange], Tuple))
 
-    segments = iter_segments(series, st)
+    segments = collect(series_segments(series, st))
     plotattributes_outs = fill(KW(), (hasfillrange ? 2 : 1 ) * length(segments))
 
     needs_scatter_fix = !isscatter && hasmarker && !any(isnan,y) && length(segments) > 1
 
-    for (i,rng) in enumerate(segments)
+    for (k, segment) in enumerate(segments)
+        i, rng = segment.attr_index, segment.range
+        
         plotattributes_out = deepcopy(plotattributes_base)
-        plotattributes_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
+        plotattributes_out[:showlegend] = k==1 ? should_add_to_legend(series) : false
         plotattributes_out[:legendgroup] = series[:label]
 
         # set the type
@@ -805,9 +827,9 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
                 delete!(plotattributes_out, :fillcolor)
             end
 
-            plotattributes_outs[(2 * i - 1):(2 * i)] = [plotattributes_out_fillrange, plotattributes_out]
+            plotattributes_outs[(2k-1):(2k)] = [plotattributes_out_fillrange, plotattributes_out]
         else
-            plotattributes_outs[i] = plotattributes_out
+            plotattributes_outs[k] = plotattributes_out
         end
     end
 
@@ -883,30 +905,19 @@ plotly_series_json(plt::Plot) = JSON.json(plotly_series(plt), 4)
 html_head(plt::Plot{PlotlyBackend}) = plotly_html_head(plt)
 html_body(plt::Plot{PlotlyBackend}) = plotly_html_body(plt)
 
-const ijulia_initialized = Ref(false)
-
 function plotly_html_head(plt::Plot)
     plotly =
-        use_local_dependencies[] ? ("file:///" * plotly_local_file_path[]) : "https://cdn.plot.ly/plotly-1.57.1.min.js"
+        use_local_dependencies[] ? ("file:///" * plotly_local_file_path[]) : "https://cdn.plot.ly/$(_plotly_min_js_filename)"
 
     include_mathjax = get(plt[:extra_plot_kwargs], :include_mathjax, "")
     mathjax_file = include_mathjax != "cdn" ? ("file://" * include_mathjax) : "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-MML-AM_CHTML"
     mathjax_head = include_mathjax == "" ? "" : "<script src=\"$mathjax_file\"></script>\n\t\t"
 
-    if isijulia() && !ijulia_initialized[]
-        # using requirejs seems to be key to load a js depency in IJulia!
-        # https://requirejs.org/docs/start.html
-        # https://github.com/JuliaLang/IJulia.jl/issues/345
-        display("text/html", """
-            <script type="text/javascript">
-                requirejs([$(repr(plotly))], function(p) {
-                    window.Plotly = p
-                });
-            </script>
-        """)
-        ijulia_initialized[] = true
+    if isijulia()
+        mathjax_head
+    else
+        "$mathjax_head<script src=$(repr(plotly))></script>"
     end
-    return "$mathjax_head<script src=$(repr(plotly))></script>"
 end
 
 function plotly_html_body(plt, style = nothing)
@@ -914,12 +925,34 @@ function plotly_html_body(plt, style = nothing)
         w, h = plt[:size]
         style = "width:$(w)px;height:$(h)px;"
     end
+
+    requirejs_prefix = ""
+    requirejs_suffix = ""
+    if isijulia()
+        # require.js adds .js automatically
+        plotly_no_ext =
+            use_local_dependencies[] ? ("file:///" * plotly_local_file_path[]) : "https://cdn.plot.ly/$(_plotly_min_js_filename)"
+        plotly_no_ext = plotly_no_ext[1:end-3]
+
+        requirejs_prefix = """
+            requirejs.config({
+                paths: {
+                    Plotly: '$(plotly_no_ext)'
+                }
+            });
+            require(['Plotly'], function (Plotly) {
+        """
+        requirejs_suffix = "});"
+    end
+
     uuid = UUIDs.uuid4()
     html = """
         <div id=\"$(uuid)\" style=\"$(style)\"></div>
         <script>
+        $(requirejs_prefix)
         PLOT = document.getElementById('$(uuid)');
         Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
+        $(requirejs_suffix)
         </script>
     """
     html

src/backends/pyplot.jl

@@ -205,9 +205,15 @@ function fix_xy_lengths!(plt::Plot{PyPlotBackend}, series::Series)
     end
 end
 
-py_linecolormap(series::Series)       = py_colormap(series[:linecolor])
-py_markercolormap(series::Series)     = py_colormap(series[:markercolor])
-py_fillcolormap(series::Series)       = py_colormap(series[:fillcolor])
+function py_linecolormap(series::Series)
+    py_colormap(cgrad(get_linecolor(series), alpha=get_linealpha(series)))
+end
+function py_markercolormap(series::Series)
+    py_colormap(cgrad(get_markercolor(series), alpha=get_markeralpha(series)))
+end
+function py_fillcolormap(series::Series)
+    py_colormap(cgrad(get_fillcolor(series), alpha=get_fillalpha(series)))
+end
 
 # ---------------------------------------------------------------------------
 
@@ -372,8 +378,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     vmin, vmax = clims = get_clims(sp, series)
 
     # Dict to store extra kwargs
-    if st == :wireframe
-        extrakw = KW()          # vmin, vmax cause an error for wireframe plot
+    if st == :wireframe || st == :hexbin
+        # vmin, vmax cause an error for wireframe plot
+        # We are not supporting clims for hexbin as calculation of bins is not trivial
+        extrakw = KW()
     else
         extrakw = KW(:vmin => vmin, :vmax => vmax)
     end
@@ -432,9 +440,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             #     end
             #     push!(handles, handle)
             # else
-            for (i, rng) in enumerate(iter_segments(series, st))
+            for (k, segment) in enumerate(series_segments(series, st))
+                i, rng = segment.attr_index, segment.range
                 handle = ax."plot"((arg[rng] for arg in xyargs)...;
-                                   label = i == 1 ? series[:label] : "",
+                                   label = k == 1 ? series[:label] : "",
                                    zorder = series[:series_plotindex],
                                    color = py_color(single_color(get_linecolor(series, clims, i)), get_linealpha(series, i)),
                                    linewidth = py_thickness_scale(plt, get_linewidth(series, i)),
@@ -478,17 +487,18 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     if series[:markershape] != :none && st in (
         :path, :scatter, :path3d, :scatter3d, :steppre, :steppost, :bar
     )
-        for (i, rng) in enumerate(iter_segments(series, :scatter))
+        for segment in series_segments(series, :scatter)
+            i, rng = segment.attr_index, segment.range
             xyargs = if st == :bar && !isvertical(series)
                 if RecipesPipeline.is3d(sp)
                     y[rng], x[rng], z[rng]
                 else
                     y[rng], x[rng]
-                end        
+                end
             else
                 if RecipesPipeline.is3d(sp)
                     x[rng], y[rng], z[rng]
-                else 
+                else
                     x[rng], y[rng]
                 end
             end
@@ -508,16 +518,17 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     end
 
     if st == :hexbin
-        handle = ax."hexbin"(x, y,
+        extrakw[:mincnt] = get(series[:extra_kwargs], :mincnt, nothing)
+        extrakw[:edgecolors] = get(series[:extra_kwargs], :edgecolors, py_color(get_linecolor(series)))
+        handle = ax."hexbin"(x, y;
             label = series[:label],
             C = series[:weights],
             gridsize = series[:bins]==:auto ? 100 : series[:bins],  # 100 is the default value
             linewidths = py_thickness_scale(plt, series[:linewidth]),
-            edgecolors = py_color(get_linecolor(series)),
             alpha = series[:fillalpha],
             cmap = py_fillcolormap(series),  # applies to the pcolorfast object
             zorder = series[:series_plotindex],
-            # extrakw...  # We are not supporting clims for hexbin as calculation of bins is not trivial
+            extrakw...
         )
         push!(handles, handle)
     end
@@ -670,7 +681,8 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
 
     if st == :shape
         handle = []
-        for (i, rng) in enumerate(iter_segments(series))
+        for segment in series_segments(series)
+            i, rng = segment.attr_index, segment.range
             if length(rng) > 1
                 path = pypath."Path"(hcat(x[rng], y[rng]))
                 patches = pypatches."PathPatch"(
@@ -697,7 +709,8 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     # handle area filling
     fillrange = series[:fillrange]
     if fillrange !== nothing && st != :contour
-        for (i, rng) in enumerate(iter_segments(series))
+        for segment in series_segments(series)
+            i, rng = segment.attr_index, segment.range
             f, dim1, dim2 = if isvertical(series)
                 :fill_between, x[rng], y[rng]
             else
@@ -799,6 +812,9 @@ function py_set_scale(ax, sp::Subplot, axis::Axis)
     letter = axis[:letter]
     scale in supported_scales() || return @warn("Unhandled scale value in pyplot: $scale")
     func = getproperty(ax, Symbol("set_", letter, "scale"))
+    if PyPlot.version ≥ v"3.3" # https://matplotlib.org/3.3.0/api/api_changes.html
+        letter = Symbol("")
+    end
     kw = KW()
     arg = if scale == :identity
         "linear"
@@ -917,10 +933,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             end
             kw[:spacing] = "proportional"
 
-            fig = plt.o
-
             if RecipesPipeline.is3d(sp) || ispolar(sp)
-                cbax = fig."add_axes"([0.9, 0.1, 0.03, 0.8])
+                cbax = fig."add_axes"([0.9, 0.1, 0.03, 0.8], label=string("cbar", sp[:subplot_index]))
                 cb = fig."colorbar"(handle; cax=cbax, kw...)
             else
                 # divider approach works only with 2d plots
@@ -945,7 +959,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                     colorbar_orientation="horizontal"
                 end
 
-                cbax = divider.append_axes(colorbar_position, size="5%", pad=colorbar_pad)  # Reasonable value works most of the usecases
+                cbax = divider.append_axes(colorbar_position, size="5%", pad=colorbar_pad, label=string("cbar", sp[:subplot_index]))  # Reasonable value works most of the usecases
                 cb = fig."colorbar"(handle; cax=cbax, orientation = colorbar_orientation, kw...)
 
                 if sp[:colorbar] == :left
@@ -964,28 +978,61 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             cb."formatter".set_powerlimits((-Inf, Inf))
             cb."update_ticks"()
 
-            for lab in cb."ax"."yaxis"."get_ticklabels"()
-                  lab."set_fontsize"(py_thickness_scale(plt, sp[:yaxis][:tickfontsize]))
-                  lab."set_family"(sp[:yaxis][:tickfontfamily])
-                  lab."set_color"(py_color(sp[:yaxis][:tickfontcolor]))
+            if sp[:colorbar] in (:top, :bottom)
+                axis = sp[:xaxis]  # colorbar inherits from x axis
+                cbar_axis = cb."ax"."xaxis"
+            else
+                axis = sp[:yaxis]  # colorbar inherits from y axis
+                cbar_axis = cb."ax"."yaxis"
             end
+
+            for lab in cbar_axis."get_ticklabels"()
+                  lab."set_fontsize"(py_thickness_scale(plt, axis[:tickfontsize]))
+                  lab."set_family"(axis[:tickfontfamily])
+                  lab."set_color"(py_color(axis[:tickfontcolor]))
+            end
+
+            # Adjust thickness of the cbar ticks
+            intensity = 0.5
+            cbar_axis."set_tick_params"(
+                direction = axis[:tick_direction] == :out ? "out" : "in",
+                width=py_thickness_scale(plt, intensity),
+                length= 5 * py_thickness_scale(plt, intensity)
+            )
+
+
+
+            cb.outline."set_linewidth"(py_thickness_scale(plt, 1))
+
             sp.attr[:cbar_handle] = cb
             sp.attr[:cbar_ax] = cbax
         end
 
+
         # framestyle
         if !ispolar(sp) && !RecipesPipeline.is3d(sp)
-            ax.spines["left"]."set_linewidth"(py_thickness_scale(plt, 1))
-            ax.spines["bottom"]."set_linewidth"(py_thickness_scale(plt, 1))
+            for pos in ("left", "right", "top", "bottom")
+                # Scale all axes by default first
+                ax.spines[pos]."set_linewidth"(py_thickness_scale(plt, 1))
+            end
+
+            # Then set visible some of them
             if sp[:framestyle] == :semi
                 intensity = 0.5
-                ax.spines["right"]."set_alpha"(intensity)
-                ax.spines["top"]."set_alpha"(intensity)
-                ax.spines["right"]."set_linewidth"(py_thickness_scale(plt, intensity))
-                ax.spines["top"]."set_linewidth"(py_thickness_scale(plt, intensity))
+
+                spine = sp[:yaxis][:mirror] ? "left" : "right"
+                ax.spines[spine]."set_alpha"(intensity)
+                ax.spines[spine]."set_linewidth"(py_thickness_scale(plt, intensity))
+
+                spine = sp[:xaxis][:mirror] ? "bottom" : "top"
+                ax.spines[spine]."set_linewidth"(py_thickness_scale(plt, intensity))
+                ax.spines[spine]."set_alpha"(intensity)
+            elseif sp[:framestyle] == :box
+                ax.tick_params(top=true)   # Add ticks too
+                ax.tick_params(right=true) # Add ticks too
             elseif sp[:framestyle] in (:axes, :origin)
-                ax.spines["right"]."set_visible"(false)
-                ax.spines["top"]."set_visible"(false)
+                sp[:xaxis][:mirror] ? ax.spines["bottom"]."set_visible"(false) : ax.spines["top"]."set_visible"(false)
+                sp[:yaxis][:mirror] ? ax.spines["left"]."set_visible"(false) : ax.spines["right"]."set_visible"(false)
                 if sp[:framestyle] == :origin
                     ax.spines["bottom"]."set_position"("zero")
                     ax.spines["left"]."set_position"("zero")
@@ -999,6 +1046,16 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                     ax."axvline"(x = 0, color = py_color(sp[:yaxis][:foreground_color_axis]), lw = py_thickness_scale(plt, 0.75))
                 end
             end
+
+            if sp[:xaxis][:mirror]
+                ax.xaxis."set_label_position"("top")     # the guides
+                sp[:framestyle] == :box ? nothing : ax.xaxis."tick_top"()
+            end
+
+            if sp[:yaxis][:mirror]
+                ax.yaxis."set_label_position"("right")     # the guides
+                sp[:framestyle] == :box ? nothing : ax.yaxis."tick_right"()
+            end
         end
 
         # axis attributes
@@ -1007,15 +1064,11 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             PyPlot.PyCall.hasproperty(ax, axissym) || continue
             axis = sp[axissym]
             pyaxis = getproperty(ax, axissym)
-            if axis[:mirror] && letter != :z
-                pos = letter == :x ? "top" : "right"
-                pyaxis."set_label_position"(pos)     # the guides
-                pyaxis."set_ticks_position"("both")  # the hash marks
-                getproperty(pyaxis, Symbol(:tick_, pos))()        # the tick labels
-            end
+
             if axis[:guide_position] != :auto && letter != :z
                 pyaxis."set_label_position"(axis[:guide_position])
             end
+
             py_set_scale(ax, sp, axis)
             axis[:ticks] == :native ? nothing : py_set_lims(ax, sp, axis)
             if ispolar(sp) && letter == :y
@@ -1190,6 +1243,7 @@ function _update_min_padding!(sp::Subplot{PyPlotBackend})
     toppad    = 0mm
     rightpad  = 0mm
     bottompad = 0mm
+
     for bb in (py_bbox_axis(ax, "x"), py_bbox_axis(ax, "y"), py_bbox_title(ax), py_bbox_legend(ax))
         if ispositive(width(bb)) && ispositive(height(bb))
             leftpad   = max(leftpad,   left(plotbb) - left(bb))
@@ -1199,11 +1253,23 @@ function _update_min_padding!(sp::Subplot{PyPlotBackend})
         end
     end
 
+    if haskey(sp.attr, :cbar_ax) # Treat colorbar the same way
+        ax = sp.attr[:cbar_handle]."ax"
+        for bb in (py_bbox_axis(ax, "x"), py_bbox_axis(ax, "y"), py_bbox_title(ax), )
+            if ispositive(width(bb)) && ispositive(height(bb))
+                leftpad   = max(leftpad,   left(plotbb) - left(bb))
+                toppad    = max(toppad,    top(plotbb)  - top(bb))
+                rightpad  = max(rightpad,  right(bb)    - right(plotbb))
+                bottompad = max(bottompad, bottom(bb)   - bottom(plotbb))
+            end
+        end
+    end
+
+
     # optionally add the width of colorbar labels and colorbar to rightpad
-    if haskey(sp.attr, :cbar_ax)
+    if RecipesPipeline.is3d(sp) && haskey(sp.attr, :cbar_ax)
         bb = py_bbox(sp.attr[:cbar_handle]."ax"."get_yticklabels"())
         sp.attr[:cbar_width] = width(bb) + (sp[:colorbar_title] == "" ? 0px : 30px)
-        rightpad = rightpad + sp.attr[:cbar_width]
     end
 
     # add in the user-specified margin
@@ -1243,44 +1309,26 @@ end
 
 # -----------------------------------------------------------------
 
-py_legend_pos(pos::Symbol) = get(
-    (
-        right = "right",
-        left = "center left",
-        top = "upper center",
-        bottom = "lower center",
-        bottomleft = "lower left",
-        bottomright = "lower right",
-        topright = "upper right",
-        topleft = "upper left",
-        outerright = "center left",
-        outerleft = "right",
-        outertop = "lower center",
-        outerbottom = "upper center",
-        outerbottomleft = "lower right",
-        outerbottomright = "lower left",
-        outertopright = "upper left",
-        outertopleft = "upper right",
-    ),
-    pos,
-    "best",
-)
-py_legend_pos(pos) = "lower left"
+py_legend_pos(pos::Tuple{S,T}) where {S<:Real,T<:Real} = "lower left"
+
+function py_legend_pos(pos::Tuple{<:Real,Symbol})
+    (s,c) = sincosd(pos[1])
+    if pos[2] === :outer
+        s = -s
+        c = -c
+    end
+    yanchors = ["lower","center","upper"]
+    xanchors = ["left","center","right"]
+    return join([yanchors[legend_anchor_index(s)], xanchors[legend_anchor_index(c)]], ' ')
+end
+
+function py_legend_bbox(pos::Tuple{T,Symbol}) where T<:Real
+    if pos[2] === :outer
+        return legend_pos_from_angle(pos[1],-0.15,0.5,1.0,-0.15,0.5,1.0)
+    end
+    legend_pos_from_angle(pos[1],0.0,0.5,1.0,0.0,0.5,1.0)
+end
 
-py_legend_bbox(pos::Symbol) = get(
-    (
-        outerright = (1.0, 0.5, 0.0, 0.0),
-        outerleft = (-0.15, 0.5, 0.0, 0.0),
-        outertop = (0.5, 1.0, 0.0, 0.0),
-        outerbottom = (0.5, -0.15, 0.0, 0.0),
-        outerbottomleft = (-0.15, 0.0, 0.0, 0.0),
-        outerbottomright = (1.0, 0.0, 0.0, 0.0),
-        outertopright = (1.0, 1.0, 0.0, 0.0),
-        outertopleft = (-0.15, 1.0, 0.0, 0.0),
-    ),
-    pos,
-    (0.0, 0.0, 1.0, 1.0),
-)
 py_legend_bbox(pos) = pos
 
 function py_add_legend(plt::Plot, sp::Subplot, ax)
@@ -1326,6 +1374,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
 
         # if anything was added, call ax.legend and set the colors
         if !isempty(handles)
+            leg = legend_angle(leg)
             leg = ax."legend"(handles,
                 labels,
                 loc = py_legend_pos(leg),
@@ -1336,7 +1385,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                 edgecolor = py_color(sp[:foreground_color_legend]),
                 framealpha = alpha(plot_color(sp[:background_color_legend])),
                 fancybox = false,  # makes the legend box square
-                borderpad=0.8      # to match GR legendbox
+                borderpad = 0.8      # to match GR legendbox
             )
             frame = leg."get_frame"()
             frame."set_linewidth"(py_thickness_scale(plt, 1))

src/components.jl

@@ -42,15 +42,11 @@ function coords(shape::Shape)
     shape.x, shape.y
 end
 
+#coords(shapes::AVec{Shape}) = unzip(map(coords, shapes))
 function coords(shapes::AVec{Shape})
-    length(shapes) == 0 && return zeros(0), zeros(0)
-    xs = map(get_xs, shapes)
-    ys = map(get_ys, shapes)
-    x, y = map(copy, coords(shapes[1]))
-    for shape in shapes[2:end]
-        nanappend!(x, shape.x)
-        nanappend!(y, shape.y)
-    end
+    c = map(coords, shapes)
+    x = [q[1] for q in c]
+    y = [q[2] for q in c]
     x, y
 end
 

src/examples.jl

@@ -1029,23 +1029,40 @@ const _examples = PlotExample[
         "Vectors of markershapes and segments",
         "",
         [quote
+            using Base.Iterators: cycle, take
+
             yv = ones(9)
             ys = [1; 1; NaN; ones(6)]
-            plot(
-                5 .- [yv 2ys 3yv 4ys],
+            y = 5 .- [yv 2ys 3yv 4ys]
+
+            plt_color_rows = plot(
+                y,
                 seriestype = [:path :path :scatter :scatter],
-                markershape = [:utriangle, :rect],
+                markershape = collect(take(cycle((:utriangle, :rect)), 9)),
                 markersize = 8,
-                color = [:red, :black],
+                color = collect(take(cycle((:red, :black)), 9))
             )
+
+            plt_z_cols = plot(
+                y,
+                markershape = [:utriangle :x :circle :square],
+                markersize = [5 10 10 5],
+                marker_z = [5 4 3 2],
+                line_z = [1 3 3 1],
+                linewidth = [1 10 5 1]
+            )
+
+            plot(plt_color_rows, plt_z_cols)
         end]
     ),
     PlotExample( # 49
         "Polar heatmaps",
         "",
         [quote
-            z = (1:4) .+ (1:8)'
-            heatmap(z, projection = :polar)
+        x = range(0, 2π, length=9)
+        y = 0:4
+        z = (1:4) .+ (1:8)'
+        heatmap(x, y, z, projection = :polar)
         end]
     ),
     PlotExample( # 50
@@ -1055,10 +1072,10 @@ const _examples = PlotExample[
         f(x,a) = 1/x + a*x^2
         xs = collect(0.1:0.05:2.0);
         as = collect(0.2:0.1:2.0);
-        
+
         x_grid = [x for x in xs for y in as];
         a_grid = [y for x in xs for y in as];
-        
+
         plot(x_grid, a_grid, f.(x_grid,a_grid),
             st = :surface,
             xlabel = "longer xlabel",
@@ -1067,6 +1084,41 @@ const _examples = PlotExample[
         )
         end]
     ),
+    PlotExample( # 51
+        "Images with custom axes",
+        "",
+        [quote
+            using Plots
+            using TestImages
+            img = testimage("lighthouse")
+
+            # plot the image reversing the first dimension and setting yflip = false
+            plot([-π, π], [-1, 1], reverse(img, dims=1), yflip=false, aspect_ratio=:none)
+            # plot other data
+            plot!(sin, -π, π, lw=3, color=:red)
+        end]
+    ),
+    PlotExample(
+        "3d quiver",
+        "",
+        [quote
+            using Plots
+
+            ϕs = range(-π, π, length=50)
+            θs = range(0, π, length=25)
+            θqs = range(1, π-1, length=25)
+
+            x = vec([sin(θ) * cos(ϕ) for (ϕ, θ) in Iterators.product(ϕs, θs)])
+            y = vec([sin(θ) * sin(ϕ) for (ϕ, θ) in Iterators.product(ϕs, θs)])
+            z = vec([cos(θ) for (ϕ, θ) in Iterators.product(ϕs, θs)])
+
+            u = 0.1 * vec([sin(θ) * cos(ϕ) for (ϕ, θ) in Iterators.product(ϕs, θqs)])
+            v = 0.1 * vec([sin(θ) * sin(ϕ) for (ϕ, θ) in Iterators.product(ϕs, θqs)])
+            w = 0.1 * vec([cos(θ) for (ϕ, θ) in Iterators.product(ϕs, θqs)])
+
+            quiver(x,y,z, quiver=(u,v,w))
+        end]
+    ),
 ]
 
 # Some constants for PlotDocs and PlotReferenceImages
@@ -1074,8 +1126,8 @@ _animation_examples = [2, 31]
 _backend_skips = Dict(
     :gr => [25, 30, 47],
     :pyplot => [2, 25, 30, 31, 47, 49],
-    :plotlyjs => [2, 21, 24, 25, 30, 31, 49],
-    :plotly => [2, 21, 24, 25, 30, 31, 49],
+    :plotlyjs => [2, 21, 24, 25, 30, 31, 49, 51],
+    :plotly => [2, 21, 24, 25, 30, 31, 49, 51],
     :pgfplotsx => [
         2, # animation
         6, # images
@@ -1084,6 +1136,7 @@ _backend_skips = Dict(
         31, # animation
         32, # spy
         49, # polar heatmap
+        51, # image with custom axes
     ],
 )
 

src/ijulia.jl

@@ -54,9 +54,9 @@ function _ijulia_display_dict(plt::Plot)
     elseif output_type == :html
         mime = "text/html"
         out[mime] = sprint(show, MIME(mime), plt)
+        _ijulia__extra_mime_info!(plt, out)
     else
         error("Unsupported output type $output_type")
     end
-    _ijulia__extra_mime_info!(plt, out)
     out
 end

src/init.jl

@@ -79,9 +79,9 @@ function __init__()
     end
 
     if get(ENV, "PLOTS_HOST_DEPENDENCY_LOCAL", "false") == "true"
-        global plotly_local_file_path[] = joinpath(@get_scratch!("plotly"), "plotly-1.54.2.min.js")
+        global plotly_local_file_path[] = joinpath(@get_scratch!("plotly"), _plotly_min_js_filename)
         if !isfile(plotly_local_file_path[])
-            download("https://cdn.plot.ly/plotly-1.57.1.min.js", plotly_local_file_path[])
+            download("https://cdn.plot.ly/$(_plotly_min_js_filename)", plotly_local_file_path[])
         end
 
         use_local_plotlyjs[] = true

src/legend.jl

@@ -0,0 +1,59 @@
+"""
+```julia
+legend_pos_from_angle(theta, xmin, xcenter, xmax, ymin, ycenter, ymax, inout)
+```
+
+Return `(x,y)` at an angle `theta` degrees from
+`(xcenter,ycenter)` on a rectangle defined by (`xmin`,
+`xmax`, `ymin`, `ymax`).
+"""
+function legend_pos_from_angle(theta, xmin, xcenter, xmax, ymin, ycenter, ymax)
+    (s,c) = sincosd(theta)
+    x = c < 0 ? (xmin-xcenter)/c : (xmax-xcenter)/c
+    y = s < 0 ? (ymin-ycenter)/s : (ymax-ycenter)/s
+    A = min(x,y)
+    return (xcenter + A*c, ycenter + A*s)
+end
+
+
+"""
+Split continuous range `[-1,1]` evenly into an integer `[1,2,3]`
+"""
+function legend_anchor_index(x)
+    x<-1//3 && return 1
+    x<1//3 && return 2
+    return 3
+end
+
+"""
+Turn legend argument into a (theta, :inner) or (theta, :outer) tuple.
+For backends where legend position is given in normal coordinates (0,0) -- (1,1),
+so :topleft exactly corresponds to (45, :inner) etc.
+
+If `leg` is a (::Real,::Real) tuple, keep it as is.
+"""
+legend_angle(leg::Real) = (leg,:inner)
+legend_angle(leg::Tuple{S,T}) where {S<:Real,T<:Real} = leg
+legend_angle(leg::Tuple{S,Symbol}) where S<:Real = leg
+legend_angle(leg::Symbol) = get(
+                                (
+                                 topleft            =   (135,:inner),
+                                 top                =   (90, :inner),
+                                 topright           =   (45, :inner),
+                                 left               =   (180,:inner),
+                                 right              =   (0,  :inner),
+                                 bottomleft         =   (225,:inner),
+                                 bottom             =   (270,:inner),
+                                 bottomright        =   (315,:inner),
+                                 outertopleft       =   (135,:outer),
+                                 outertop           =   (90, :outer),
+                                 outertopright      =   (45, :outer),
+                                 outerleft          =   (180,:outer),
+                                 outerright         =   (0,  :outer),
+                                 outerbottomleft    =   (225,:outer),
+                                 outerbottom        =   (270,:outer),
+                                 outerbottomright   =   (315,:outer),
+                                ),
+                                leg,
+                                (45, :inner)
+                               )

src/pipeline.jl

@@ -5,13 +5,24 @@
 function RecipesPipeline.warn_on_recipe_aliases!(
     plt::Plot,
     plotattributes::AKW,
-    recipe_type,
-    signature_string
+    recipe_type::Symbol,
+    @nospecialize(args)
 )
     for k in keys(plotattributes)
         if !is_default_attribute(k)
             dk = get(_keyAliases, k, k)
             if k !== dk
+                if recipe_type == :user
+                    signature_string = RecipesPipeline.userrecipe_signature_string(args)
+                elseif recipe_type == :type
+                    signature_string = RecipesPipeline.typerecipe_signature_string(args)
+                elseif recipe_type == :plot
+                    signature_string = RecipesPipeline.plotrecipe_signature_string(args)
+                elseif recipe_type == :series
+                    signature_string = RecipesPipeline.seriesrecipe_signature_string(args)
+                else
+                    throw(ArgumentError("Invalid recipe type `$recipe_type`"))
+                end
                 @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $signature_string. To ensure expected behavior it is recommended to use the default attribute `$dk`."
             end
             plotattributes[dk] = RecipesPipeline.pop_kw!(plotattributes, k)
@@ -130,7 +141,7 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW)
 end
 
 
-RecipesPipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], letter)
+RecipesPipeline.get_axis_limits(plt::Plot, letter) = axis_limits(plt[1], letter)
 
 
 ## Plot recipes
@@ -316,7 +327,7 @@ end
 
 function _override_seriestype_check(plotattributes::AKW, st::Symbol)
     # do we want to override the series type?
-    if !RecipesPipeline.is3d(st) && !(st in (:contour, :contour3d))
+    if !RecipesPipeline.is3d(st) && !(st in (:contour, :contour3d, :quiver))
         z = plotattributes[:z]
         if !isa(z, Nothing) &&
            (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z))

src/plot.jl

@@ -43,8 +43,8 @@ The main plot command. Use `plot` to create a new plot object, and `plot!` to ad
 
 There are lots of ways to pass in data, and lots of keyword arguments... just try it and it will likely work as expected.
 When you pass in matrices, it splits by columns. To see the list of available attributes, use the `plotattr([attr])`
-function, where `attr` is the symbol `:Series:`, `:Subplot:`, `:Plot` or `:Axis`. Pass any attribute to `plotattr`
-as a String to look up its docstring; e.g. `plotattr("seriestype")`.
+function, where `attr` is the symbol `:Series`, `:Subplot`, `:Plot`, or `:Axis`. Pass any attribute to `plotattr`
+as a String to look up its docstring, e.g., `plotattr("seriestype")`.
 """
 function plot(args...; kw...)
     @nospecialize
@@ -218,4 +218,4 @@ function plot!(sp::Subplot, args...; kw...)
     @nospecialize
     plt = sp.plt
     plot!(plt, args...; kw..., subplot = findfirst(isequal(sp), plt.subplots))
-end
+end

src/precompile_includer.jl

@@ -2,33 +2,19 @@ should_precompile = true
 
 
 # Don't edit the following! Instead change the script for `snoop_bot`.
-ismultios = true
-ismultiversion = true
+ismultios = false
+ismultiversion = false
 # precompile_enclosure
 @static if !should_precompile
     # nothing
 elseif !ismultios && !ismultiversion
-    include("../deps/SnoopCompile/precompile/precompile_Plots.jl")
-    _precompile_()
-else
-    @static if Sys.islinux()
-        @static if v"1.5.0-DEV" <= VERSION <= v"1.5.9"
-            include("../deps/SnoopCompile/precompile/linux/1.5/precompile_Plots.jl")
-            _precompile_()
-        else
-            include("../deps/SnoopCompile/precompile/linux/1.5/precompile_Plots.jl")
-            _precompile_()
-        end
-
-    else
-        @static if v"1.5.0-DEV" <= VERSION <= v"1.5.9"
-            include("../deps/SnoopCompile/precompile/linux/1.5/precompile_Plots.jl")
-            _precompile_()
-        else
-            include("../deps/SnoopCompile/precompile/linux/1.5/precompile_Plots.jl")
-            _precompile_()
-        end
-
+    @static if isfile(joinpath(
+        @__DIR__,
+        "../deps/SnoopCompile/precompile/precompile_Plots.jl",
+    ))
+        include("../deps/SnoopCompile/precompile/precompile_Plots.jl")
+        _precompile_()
     end
+else
 
 end # precompile_enclosure

src/recipes.jl

@@ -268,15 +268,15 @@ end
         end
     end
     newx, newy = zeros(3n), zeros(3n)
-    newz = z!== nothing ? zeros(3n) : nothing
-    for i = 1:n
+    newz = z !== nothing ? zeros(3n) : nothing
+    for (i, (xi, yi, zi)) = enumerate(zip(x, y, z !== nothing ? z : 1:n))
         rng = (3i - 2):(3i)
-        newx[rng] = [x[i], x[i], NaN]
+        newx[rng] = [xi, xi, NaN]
         if z !== nothing
-            newy[rng] = [y[i], y[i], NaN]
-            newz[rng] = [_cycle(fr, i), z[i], NaN]
+            newy[rng] = [yi, yi, NaN]
+            newz[rng] = [_cycle(fr, i), zi, NaN]
         else
-            newy[rng] = [_cycle(fr, i), y[i], NaN]
+            newy[rng] = [_cycle(fr, i), yi, NaN]
         end
     end
     x := newx
@@ -415,6 +415,15 @@ end
         fillto = map(x -> _is_positive(x) ? typeof(baseline)(x) : baseline, fillto)
     end
 
+    if !isnothing(plotattributes[:series_annotations])
+        if isvertical(plotattributes)
+            annotations := (x,y,plotattributes[:series_annotations].strs,:bottom)
+        else
+            annotations := (y,x,plotattributes[:series_annotations].strs,:left)
+        end
+        series_annotations := nothing
+    end
+
     # create the bar shapes by adding x/y segments
     xseg, yseg = Segments(), Segments()
     for i = 1:ny
@@ -1197,35 +1206,51 @@ function quiver_using_arrows(plotattributes::AKW)
     if !isa(plotattributes[:arrow], Arrow)
         plotattributes[:arrow] = arrow()
     end
-
+    is_3d = haskey(plotattributes,:z) && !isnothing(plotattributes[:z])
     velocity = error_zipit(plotattributes[:quiver])
     xorig, yorig = plotattributes[:x], plotattributes[:y]
+    zorig = is_3d ? plotattributes[:z] : []
 
     # for each point, we create an arrow of velocity vi, translated to the x/y coordinates
     x, y = zeros(0), zeros(0)
-    for i = 1:max(length(xorig), length(yorig))
+    is_3d && ( z = zeros(0))
+    for i = 1:max(length(xorig), length(yorig), is_3d ? 0 : length(zorig))
         # get the starting position
         xi = _cycle(xorig, i)
         yi = _cycle(yorig, i)
-
+        zi = is_3d ? _cycle(zorig, i) : 0
         # get the velocity
         vi = _cycle(velocity, i)
-        vx, vy = if istuple(vi)
-            first(vi), last(vi)
-        elseif isscalar(vi)
-            vi, vi
-        elseif isa(vi, Function)
-            vi(xi, yi)
-        else
-            error("unexpected vi type $(typeof(vi)) for quiver: $vi")
+        if is_3d
+            vx, vy, vz = if istuple(vi)
+                vi[1], vi[2], vi[3]
+            elseif isscalar(vi)
+                vi, vi, vi
+            elseif isa(vi, Function)
+                vi(xi, yi, zi)
+            else
+                error("unexpected vi type $(typeof(vi)) for quiver: $vi")
+            end
+        else # 2D quiver
+            vx, vy = if istuple(vi)
+                first(vi), last(vi)
+            elseif isscalar(vi)
+                vi, vi
+            elseif isa(vi, Function)
+                vi(xi, yi)
+            else
+                error("unexpected vi type $(typeof(vi)) for quiver: $vi")
+            end
         end
-
         # add the points
         nanappend!(x, [xi, xi + vx, NaN])
         nanappend!(y, [yi, yi + vy, NaN])
+        is_3d && nanappend!(z, [zi, zi + vz, NaN])
     end
-
     plotattributes[:x], plotattributes[:y] = x, y
+    if is_3d
+        plotattributes[:z] = z
+    end
     # KW[plotattributes]
 end
 
@@ -1348,6 +1373,16 @@ end
 
 @recipe function f(shapes::AVec{Shape})
     seriestype --> :shape
+    # For backwards compatibility, column vectors of segmenting attributes are 
+    # interpreted as having one element per shape
+    for attr in union(_segmenting_array_attributes, _segmenting_vector_attributes)
+        v = get(plotattributes, attr, nothing)
+        if v isa AVec || v isa AMat && size(v,2) == 1
+            @warn "Column vector attribute `$attr` reinterpreted as row vector (one value per shape).\n" *
+                    "Pass a row vector instead (e.g. using `permutedims`) to suppress this warning."
+            plotattributes[attr] = permutedims(v)
+        end
+    end
     coords(shapes)
 end
 
@@ -1504,14 +1539,10 @@ end
     yflip := true
     aspect_ratio := 1
     rs, cs, zs = Plots.findnz(z.surf)
-    xlims := ignorenan_extrema(cs)
-    ylims := ignorenan_extrema(rs)
-    if plotattributes[:markershape] == :none
-        markershape := :circle
-    end
-    if plotattributes[:markersize] == default(:markersize)
-        markersize := 1
-    end
+    xlims := widen(ignorenan_extrema(cs)..., get(plotattributes, :xscale, :identity))
+    ylims := widen(ignorenan_extrema(rs)..., get(plotattributes, :yscale, :identity))
+    markershape --> :circle
+    markersize --> 1
     markerstrokewidth := 0
     if length(unique(zs)) == 1
         seriescolor --> :black
@@ -1615,4 +1646,4 @@ julia> areaplot(1:3, [1 2 3; 7 8 9; 4 5 6], seriescolor = [:red :green :blue], f
     end
 end
 
-@specialize
+@specialize

src/shorthands.jl

@@ -57,6 +57,7 @@ Plot a histogram.
 # Example
 ```julia-repl
 julia> histogram([1,2,1,1,4,3,8],bins=0:8)
+julia> histogram([1,2,1,1,4,3,8],bins=0:8,weights=weights([4,7,3,9,12,2,6]))
 ```
 """
 @shorthands histogram
@@ -420,13 +421,13 @@ xlabel!(s::AbstractString; kw...)                = plot!(; xlabel = s, kw...)
 ylabel!(s::AbstractString; kw...)                = plot!(; ylabel = s, kw...)
 
 "Set xlims for an existing plot"
-xlims!(lims::Tuple{T,S}; kw...) where {T<:Real,S<:Real} = plot!(; xlims = lims, kw...)
+xlims!(lims::Tuple; kw...) = plot!(; xlims = lims, kw...)
 
 "Set ylims for an existing plot"
-ylims!(lims::Tuple{T,S}; kw...) where {T<:Real,S<:Real} = plot!(; ylims = lims, kw...)
+ylims!(lims::Tuple; kw...) = plot!(; ylims = lims, kw...)
 
 "Set zlims for an existing plot"
-zlims!(lims::Tuple{T,S}; kw...) where {T<:Real,S<:Real} = plot!(; zlims = lims, kw...)
+zlims!(lims::Tuple; kw...) = plot!(; zlims = lims, kw...)
 
 xlims!(xmin::Real, xmax::Real; kw...)                     = plot!(; xlims = (xmin,xmax), kw...)
 ylims!(ymin::Real, ymax::Real; kw...)                     = plot!(; ylims = (ymin,ymax), kw...)
@@ -478,4 +479,4 @@ yaxis!(args...; kw...)                                    = plot!(; yaxis = args
 xgrid!(args...; kw...)                                    = plot!(; xgrid = args, kw...)
 ygrid!(args...; kw...)                                    = plot!(; ygrid = args, kw...)
 
-@specialize
+@specialize

src/utils.jl

@@ -53,10 +53,16 @@ function Base.push!(segments::Segments{T}, vs::AVec) where T
 end
 
 
+struct SeriesSegment
+    # indexes of this segement in series data vectors
+    range::UnitRange
+    # index into vector-valued attributes corresponding to this segment
+    attr_index::Int 
+end
+
 # -----------------------------------------------------
 # helper to manage NaN-separated segments
-
-mutable struct SegmentsIterator
+struct NaNSegmentsIterator
     args::Tuple
     n1::Int
     n2::Int
@@ -66,29 +72,47 @@ function iter_segments(args...)
     tup = Plots.wraptuple(args)
     n1 = minimum(map(firstindex, tup))
     n2 = maximum(map(lastindex, tup))
-    SegmentsIterator(tup, n1, n2)
+    NaNSegmentsIterator(tup, n1, n2)
 end
 
-function iter_segments(series::Series, seriestype::Symbol = :path)
+function series_segments(series::Series, seriestype::Symbol = :path)
     x, y, z = series[:x], series[:y], series[:z]
-    if x === nothing
-        return UnitRange{Int}[]
-    elseif has_attribute_segments(series)
-        if any(isnan,y)
-            return [iter_segments(y)...]
-        elseif seriestype in (:scatter, :scatter3d)
-            return [[i] for i in eachindex(y)]
-        else
-            return [i:(i + 1) for i in firstindex(y):lastindex(y)-1]
-        end
+    (x === nothing || isempty(x)) && return UnitRange{Int}[]
+
+    args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y)
+    nan_segments = collect(iter_segments(args...))
+
+    result = if has_attribute_segments(series)
+        Iterators.flatten(map(nan_segments) do r
+            if seriestype in (:scatter, :scatter3d)
+                (SeriesSegment(i:i, i) for i in r)
+            else
+                (SeriesSegment(i:i+1, i) for i in first(r):last(r)-1)
+            end 
+        end)
     else
-        segs = UnitRange{Int}[]
-        args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y)
-        for seg in iter_segments(args...)
-            push!(segs, seg)
+        (SeriesSegment(r, 1) for r in nan_segments)
+    end 
+
+    seg_range = UnitRange(minimum(first(seg.range) for seg in result),
+                                maximum(last(seg.range) for seg in result))
+    for attr in _segmenting_vector_attributes
+        v = get(series, attr, nothing)
+        if v isa AVec && eachindex(v) != seg_range
+            @warn "Indices $(eachindex(v)) of attribute `$attr` does not match data indices $seg_range."
+            if any(v -> !isnothing(v) && any(isnan, v), (x,y,z))
+                @info """Data contains NaNs or missing values, and indices of `$attr` vector do not match data indices.
+                    If you intend elements of `$attr` to apply to individual NaN-separated segements in the data,
+                    pass each segment in a separate vector instead, and use a row vector for `$attr`. Legend entries 
+                    may be suppressed by passing an empty label.
+                    For example,
+                        plot([1:2,1:3], [[4,5],[3,4,5]], label=["y" ""], $attr=[1 2])
+                    """
+            end
         end
-        return segs
     end
+
+    return result
 end
 
 # helpers to figure out if there are NaN values in a list of array types
@@ -97,7 +121,7 @@ anynan(args::Tuple) = i -> anynan(i,args)
 anynan(istart::Int, iend::Int, args::Tuple) = any(anynan(args), istart:iend)
 allnan(istart::Int, iend::Int, args::Tuple) = all(anynan(args), istart:iend)
 
-function Base.iterate(itr::SegmentsIterator, nextidx::Int = itr.n1)
+function Base.iterate(itr::NaNSegmentsIterator, nextidx::Int = itr.n1)
     i = findfirst(!anynan(itr.args), nextidx:itr.n2)
     i === nothing && return nothing
     nextval = nextidx + i - 1
@@ -107,6 +131,7 @@ function Base.iterate(itr::SegmentsIterator, nextidx::Int = itr.n1)
 
     nextval:nextnan-1, nextnan
 end
+Base.IteratorSize(::NaNSegmentsIterator) = Base.SizeUnknown()
 
 # Find minimal type that can contain NaN and x
 # To allow use of NaN separated segments with categorical x axis
@@ -212,24 +237,24 @@ createSegments(z) = collect(repeat(reshape(z,1,:),2,1))[2:end]
 
 sortedkeys(plotattributes::Dict) = sort(collect(keys(plotattributes)))
 
-function _heatmap_edges(v::AVec, isedges::Bool = false)
-    length(v) == 1 && return v[1] .+ [-0.5, 0.5]
+function _heatmap_edges(v::AVec, isedges::Bool = false, ispolar::Bool = false)
+    length(v) == 1 && return v[1] .+ [ispolar ? max(-v[1], -0.5) : -0.5, 0.5]
     if isedges return v end
     # `isedges = true` means that v is a vector which already describes edges
     # and does not need to be extended.
     vmin, vmax = ignorenan_extrema(v)
-    extra_min = (v[2] - v[1]) / 2
+    extra_min = ispolar ? min(v[1], (v[2] - v[1]) / 2) : (v[2] - v[1]) / 2
     extra_max = (v[end] - v[end - 1]) / 2
     vcat(vmin-extra_min, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra_max)
 end
 
 "create an (n+1) list of the outsides of heatmap rectangles"
-function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false)
+function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false, ispolar::Bool = false)
     f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale)
-    map(invf, _heatmap_edges(map(f,v), isedges))
+    map(invf, _heatmap_edges(map(f,v), isedges, ispolar))
 end
 
-function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size::Tuple{Int, Int})
+function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size::Tuple{Int, Int}, ispolar::Bool = false)
     nx, ny = length(x), length(y)
     # ismidpoints = z_size == (ny, nx) # This fails some tests, but would actually be
     # the correct check, since (4, 3) != (3, 4) and a missleading plot is produced.
@@ -241,7 +266,7 @@ function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size:
                 or `size(z) == (length(y)+1, length(x)+1))` (x & y define edges).""")
     end
     x, y = heatmap_edges(x, xscale, isedges),
-           heatmap_edges(y, yscale, isedges)
+           heatmap_edges(y, yscale, isedges, ispolar) # special handle for `r` in polar plots 
     return x, y
 end
 
@@ -572,39 +597,34 @@ function get_markerstrokewidth(series, i::Int = 1)
     _cycle(series[:markerstrokewidth], i)
 end
 
+const _segmenting_vector_attributes = (
+    :seriescolor,
+    :seriesalpha,
+    :linecolor,
+    :linealpha,
+    :linewidth,
+    :linestyle,
+    :fillcolor,
+    :fillalpha,
+    :markercolor,
+    :markeralpha,
+    :markersize,
+    :markerstrokecolor,
+    :markerstrokealpha,
+    :markerstrokewidth,
+    :markershape,
+)
+
+const _segmenting_array_attributes = (:line_z, :fill_z, :marker_z)
+
 function has_attribute_segments(series::Series)
     # we want to check if a series needs to be split into segments just because
     # of its attributes
-    for letter in (:x, :y, :z)
-        # If we have NaNs in the data they define the segments and
-        # SegmentsIterator is used
-        series[letter] !== nothing && NaN in collect(series[letter]) && return false
-    end
     series[:seriestype] == :shape && return false
-    # ... else we check relevant attributes if they have multiple inputs
-    return any(
-        (typeof(series[attr]) <: AbstractVector && length(series[attr]) > 1)
-        for
-        attr in [
-            :seriescolor,
-            :seriesalpha,
-            :linecolor,
-            :linealpha,
-            :linewidth,
-            :linestyle,
-            :fillcolor,
-            :fillalpha,
-            :markercolor,
-            :markeralpha,
-            :markersize,
-            :markerstrokecolor,
-            :markerstrokealpha,
-            :markerstrokewidth,
-            :markershape,
-        ]
-    ) || any(
-        typeof(series[attr]) <: AbstractArray for attr in (:line_z, :fill_z, :marker_z)
-    )
+    # check relevant attributes if they have multiple inputs
+    return any(series[attr] isa AbstractVector && length(series[attr]) > 1
+                for attr in _segmenting_vector_attributes
+        ) || any(series[attr] isa AbstractArray for attr in _segmenting_array_attributes)
 end
 
 function get_aspect_ratio(sp)

test/integration_dates.jl

@@ -13,4 +13,48 @@ using Plots, Test, Dates
     ref_xlims = (x[1].instant.periods.value, x[end].instant.periods.value)
     @test Plots.ylims(p) == ref_ylims
     @test Plots.xlims(p) == ref_xlims
+    #@static if (haskey(ENV, "APPVEYOR") || haskey(ENV, "CI"))
+    @static if haskey(ENV, "APPVEYOR")
+        @info "Skipping display tests on AppVeyor"
+    else
+        @test isa(display(p), Nothing) == true
+        closeall()
+    end
+end # testset
+
+@testset "Date xlims" begin
+    y=[1.0*i*i for i in 1:10]
+    x=[Date(2019,11,i) for i in 1:10]
+    span = (Date(2019,10,31), Date(2019,11,11))
+
+    ref_xlims = map(date->date.instant.periods.value, span)
+
+    p = plot(x,y, xlims=span, widen = false)
+
+    @test Plots.xlims(p) == ref_xlims
+    #@static if (haskey(ENV, "APPVEYOR") || haskey(ENV, "CI"))
+    @static if haskey(ENV, "APPVEYOR")
+        @info "Skipping display tests on AppVeyor"
+    else
+        @test isa(display(p), Nothing) == true
+        closeall()
+    end
+end # testset
+
+@testset "DateTime xlims" begin
+    y=[1.0*i*i for i in 1:10]
+    x=[DateTime(2019,11,i,11) for i in 1:10]
+    span = (DateTime(2019,10,31,11,59,59), DateTime(2019,11,11,12,01,15))
+
+    ref_xlims = map(date->date.instant.periods.value, span)
+
+    p = plot(x,y, xlims=span, widen = false)
+    @test Plots.xlims(p) == ref_xlims
+    #@static if (haskey(ENV, "APPVEYOR") || haskey(ENV, "CI"))
+    @static if haskey(ENV, "APPVEYOR")
+        @info "Skipping display tests on AppVeyor"
+    else
+        @test isa(display(p), Nothing) == true
+        closeall()
+    end
 end # testset

test/runtests.jl

@@ -4,6 +4,7 @@ using Plots
 using Random
 using StableRNGs
 using Test
+using TestImages
 using FileIO
 using Gtk
 using LibGit2
@@ -30,10 +31,12 @@ end # testset
 include("test_defaults.jl")
 include("test_axes.jl")
 include("test_axis_letter.jl")
+include("test_components.jl")
+include("test_shorthands.jl")
+include("integration_dates.jl")
 include("test_recipes.jl")
 include("test_hdf5plots.jl")
 include("test_pgfplotsx.jl")
-include("integration_dates.jl")
 
 reference_dir(args...) = joinpath(homedir(), ".julia", "dev", "PlotReferenceImages", args...)
 
@@ -130,7 +133,7 @@ const IMG_TOL = VERSION < v"1.4" && Sys.iswindows() ? 1e-1 : is_ci() ? 1e-2 : 1e
         @test isa(p, Plots.Plot) == true
         @test isa(display(p), Nothing) == true
         p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
-        annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, Plots.text("Test", :red, :center))])
+        annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, :auto)])
         hline!(p, [3.1])
         @test isa(p, Plots.Plot) == true
         @test isa(display(p), Nothing) == true
@@ -172,14 +175,8 @@ end
     @test_throws ArgumentError gif(anim)
 end
 
-@testset "Segments" begin
-    function segments(args...)
-        segs = UnitRange{Int}[]
-        for seg in iter_segments(args...)
-            push!(segs,seg)
-        end
-        segs
-    end
+@testset "NaN-separated Segments" begin
+    segments(args...) = collect(iter_segments(args...))
 
     nan10 = fill(NaN,10)
     @test segments(11:20) == [1:10]

test/test_components.jl

@@ -0,0 +1,111 @@
+using Plots, Test
+
+@testset "Shapes" begin
+    @testset "Copy" begin
+        square = Shape([(0,0),(1,0),(1,1),(0,1)])
+        square2 = Shape(square)
+        @test square2.x == square.x
+        @test square2.y == square.y
+    end
+
+    @testset "Center" begin
+        square = Shape([(0,0),(1,0),(1,1),(0,1)])
+        @test Plots.center(square) == (0.5,0.5)
+    end
+
+    @testset "Translate" begin
+        square = Shape([(0,0),(1,0),(1,1),(0,1)])
+        squareUp = Shape([(0,1),(1,1),(1,2),(0,2)])
+        squareUpRight = Shape([(1,1),(2,1),(2,2),(1,2)])
+
+        @test Plots.translate(square,0,1).x == squareUp.x
+        @test Plots.translate(square,0,1).y == squareUp.y
+
+        @test Plots.center(translate!(square,1)) == (1.5,1.5)
+    end
+
+    @testset "Rotate" begin
+        # 2 radians rotation matrix
+        R2 = [cos(2) sin(2); -sin(2) cos(2)]
+        coords = [0 0; 1 0; 1 1; 0 1]'
+        coordsRotated2 = R2*(coords.-0.5).+0.5
+
+        square = Shape([(0,0),(1,0),(1,1),(0,1)])
+
+        # make a new, rotated square
+        square2 = Plots.rotate(square, -2)
+        @test square2.x ≈ coordsRotated2[1,:]
+        @test square2.y ≈ coordsRotated2[2,:]
+
+        # unrotate the new square in place
+        rotate!(square2, 2)
+        @test square2.x ≈ coords[1,:]
+        @test square2.y ≈ coords[2,:]
+    end
+end
+
+@testset "Brush" begin
+    @testset "Colors" begin
+        baseline = brush(1, RGB(0,0,0))
+        @test brush(:black) == baseline
+        @test brush("black") == baseline
+    end
+    @testset "Weight" begin
+        @test brush(10).size == 10
+        @test brush(0.1).size == 1
+    end
+    @testset "Alpha" begin
+        @test brush(0.4).alpha == 0.4
+        @test brush(20).alpha == nothing
+    end
+    @testset "Bad Argument" begin
+        # using test_logs because test_warn seems to not work anymore
+        @test_logs (:warn,"Unused brush arg: nothing (Nothing)") begin
+            brush(nothing)
+        end
+    end
+end
+
+@testset "Fonts" begin
+    @testset "Scaling" begin
+        sizesToCheck = [:titlefontsize, :legendfontsize, :legendtitlefontsize,
+            :xtickfontsize, :ytickfontsize, :ztickfontsize,
+            :xguidefontsize, :yguidefontsize, :zguidefontsize,]
+        # get inital font sizes
+        initialSizes = [Plots.default(s) for s in sizesToCheck ]
+
+        #scale up font sizes
+        scalefontsizes(2)
+
+        # get inital font sizes
+        doubledSizes = [Plots.default(s) for s in sizesToCheck ]
+
+        @test doubledSizes == initialSizes*2
+
+        # reset font sizes
+        resetfontsizes()
+
+        finalSizes = [Plots.default(s) for s in sizesToCheck ]
+
+        @test finalSizes == initialSizes
+    end
+end
+
+@testset "Series Annotations" begin
+    square = Shape([(0,0),(1,0),(1,1),(0,1)])
+    @test_logs (:warn,"Unused SeriesAnnotations arg: triangle (Symbol)") begin
+        p = plot([1,2,3],
+            series_annotations=(["a"],
+                                 2,    # pass a scale factor
+                                 (1,4), # pass two scale factors (overwrites first one)
+                                 square, # pass a shape
+                                 font(:courier), # pass an annotation font
+                                 :triangle  # pass an incorrect argument
+                            ))
+        sa = p.series_list[1].plotattributes[:series_annotations]
+        @test sa.strs == ["a"]
+        @test sa.font.family == "courier"
+        @test sa.baseshape == square
+        @test sa.scalefactor == (1,4)
+    end
+end

test/test_recipes.jl

@@ -1,4 +1,6 @@
 using Plots, Test
+using OffsetArrays
+
 @testset "lens!" begin
     pl = plot(1:5)
     lens!(pl, [1,2], [1,2], inset = (1, bbox(0.0,0.0,0.2,0.2)), colorbar = false)
@@ -23,3 +25,9 @@ end # testset
     vsp = vspan([1,3], ylims=(-2,5), widen = false)
     @test Plots.ylims(vsp) == (-2,5)
 end # testset
+
+@testset "offset axes" begin
+    tri = OffsetVector(vcat(1:5, 4:-1:1), 11:19)
+    sticks = plot(tri, seriestype = :sticks)
+    @test length(sticks) == 1
+end

test/test_shorthands.jl

@@ -0,0 +1,48 @@
+using Plots, Test
+
+@testset "Shorthands" begin
+    @testset "Set Lims" begin
+        p = plot(rand(10))
+
+        xlims!((1,20))
+        @test xlims(p) == (1,20)
+
+        ylims!((-1,1))
+        @test ylims(p) == (-1,1)
+
+        zlims!((-1,1))
+        @test zlims(p) == (-1,1)
+
+        xlims!(-1,11)
+        @test xlims(p) == (-1,11)
+
+        ylims!((-10,10))
+        @test ylims(p) == (-10,10)
+
+        zlims!((-10,10))
+        @test zlims(p) == (-10,10)
+    end
+
+    @testset "Set Ticks" begin
+        p = plot([0,2,3,4,5,6,7,8,9,10])
+
+        xticks = 2:6
+        xticks!(xticks)
+        @test Plots.get_subplot(current(),1).attr[:xaxis][:ticks] == xticks
+
+        yticks = 0.2:0.1:0.7
+        yticks!(yticks)
+        @test Plots.get_subplot(current(),1).attr[:yaxis][:ticks] == yticks
+
+        xticks = [5,6,7.5]
+        xlabels = ["a","b","c"]
+
+        xticks!(xticks, xlabels)
+        @test Plots.get_subplot(current(),1).attr[:xaxis][:ticks] == (xticks, xlabels)
+
+        yticks = [.5,.6,.75]
+        ylabels = ["z","y","x"]
+        yticks!(yticks, ylabels)
+        @test Plots.get_subplot(current(),1).attr[:yaxis][:ticks] == (yticks, ylabels)
+    end
+end