A get API

src/Plots.jl

@@ -122,6 +122,7 @@ export
     BezierCurve,
 
     plotattr,
+    getattr,
     scalefontsize,
     scalefontsizes,
     resetfontsizes

src/pipeline.jl

@@ -456,7 +456,7 @@ function _add_the_series(plt, sp, plotattributes)
         throw(ArgumentError("Unsupported type for extra keyword arguments"))
     end
     warn_on_unsupported(plt.backend, plotattributes)
-    series = Series(plotattributes)
+    series = Series(length(plt.series_list) + 1, sp, plotattributes)
     push!(plt.series_list, series)
     if (z_order = plotattributes[:z_order]) === :front
         push!(sp.series_list, series)

src/plotattr.jl

@@ -99,3 +99,69 @@ function plotattr(attrtype::Symbol, attribute::Symbol)
         def == "" ? "" : ", defaults to `$def`.",
     )
 end
+
+function getattr(plt::Plot, s::Symbol)
+    attribute = get(_keyAliases, s, s)
+    _getattr(plt, plt.subplots, plt.series_list, attribute)
+end
+function getattr(sp::Subplot, s::Symbol)
+    attribute = get(_keyAliases, s, s)
+    _getattr(sp.plt, [sp], sp.series_list, attribute)
+end
+function getattr(axis::Axis, s::Symbol)
+    attribute = get(_keyAliases, s, s)
+    if attribute in _axis_args
+        attribute = get_attr_symbol(axis[:letter], attribute)
+    end
+    _getattr(only(axis.sps).plt, axis.sps, only(axis.sps).series_list, attribute)
+end
+
+function getattr(series::Series, s::Symbol)
+    attribute = get(_keyAliases, s, s)
+    _getattr(series.subplot.plt, [series.subplot], [series], attribute)
+end
+
+function _getattr(plt::Plot, subplots::Vector{<:Subplot}, serieses::Vector{<:Series}, attribute::Symbol)
+    if attribute ∈ _all_plot_args
+        return plt[attribute]
+    elseif attribute ∈ _all_subplot_args && attribute ∉ _magic_subplot_args
+        return reduce(hcat, getindex.(subplots, attribute))
+    elseif (attribute ∈ _all_axis_args || attribute ∈ _lettered_all_axis_args) && attribute ∉ _magic_axis_args
+        if attribute ∈ _lettered_all_axis_args
+            letters = collect(String(attribute))
+            letter = Symbol(first(letters))
+            attribute = Symbol(letters[2:end]...)
+            axis = get_attr_symbol(letter, :axis)
+            reduce(hcat, getindex.(getindex.(subplots, axis), attribute))
+        else
+            axes = (:xaxis, :yaxis, :zaxis)
+            return map(subplots) do sp
+                return NamedTuple(axis => sp[axis][attribute] for axis in axes)
+            end
+        end
+    elseif attribute ∈ _all_series_args && attribute ∉ _magic_series_args
+        return reduce(hcat, map(serieses) do series
+            series[attribute]
+        end)
+    else
+        if attribute in _all_magic_args
+            @info "$attribute is a magic argument. These are not present in the Plot object. Please use the more specific attribute, such as `linestyle` instead of `line`."
+            return missing
+        end
+        extra_kwargs = Dict(
+            :plot =>
+                haskey(plt[:extra_plot_kwargs], attribute) ?
+                plt[:extra_plot_kwargs][attribute] : [],
+            :subplots => [
+                i => sp[:extra_kwargs][attribute] for
+                (i, sp) in enumerate(subplots) if haskey(sp[:extra_kwargs], attribute)
+            ],
+            :series => [
+                series.id => series[:extra_kwargs][attribute] for series in serieses if
+                haskey(series[:extra_kwargs], attribute)
+            ],
+        )
+        !all(isempty, values(extra_kwargs)) && return extra_kwargs
+        throw(ArgumentError("Attribute not found."))
+    end
+end

src/types.jl

@@ -15,7 +15,9 @@ struct InputWrapper{T}
     obj::T
 end
 
-mutable struct Series
+mutable struct Series{S}
+    id::Int
+    subplot::S
     plotattributes::DefaultsDict
 end
 
@@ -44,6 +46,7 @@ mutable struct Subplot{T<:AbstractBackend} <: AbstractLayout
     )
 end
 
+
 # simple wrapper around a KW so we can hold all attributes pertaining to the axis in one place
 mutable struct Axis
     sps::Vector{Subplot}

test/test_plotattr.jl

@@ -0,0 +1,95 @@
+using Plots, Test
+
+tplot = plot(
+    repeat([1:5, 2:6], inner = 3),
+    layout = @layout([a b; c]),
+    this = :that,
+    line = (5, :dash),
+    title = ["A" "B"],
+    xlims = [:auto (0, Inf)],
+)
+@testset "Get attributes" begin
+    @testset "From Plot" begin
+        @test getattr(tplot, :size) == default(:size) == getattr(tplot, :sizes)
+        @test getattr(tplot, :linestyle) == permutedims(fill(:dash, 6))
+        @test getattr(tplot, :title) == ["A" "B" "A"]
+        @test getattr(tplot, :xlims) == [:auto (0, Inf) :auto] #Note: this is different from Plots.xlims.(tplot.subplots)
+        @test getattr(tplot, :lims) == [
+            (xaxis = :auto, yaxis = :auto, zaxis = :auto),
+            (xaxis = (0, Inf), yaxis = :auto, zaxis = :auto),
+            (xaxis = :auto, yaxis = :auto, zaxis = :auto),
+        ]
+        @test getattr(tplot, :this) == Dict(
+            :series =>
+                [1 => :that, 2 => :that, 3 => :that, 4 => :that, 5 => :that, 6 => :that],
+            :subplots => Any[],
+            :plot => Any[],
+        )
+        @test (@test_logs (
+            :info,
+            r"line is a magic argument",
+        ) getattr(tplot, :line)) === missing
+        @test_throws ArgumentError getattr(tplot, :nothere)
+    end
+    @testset "From Sublot" begin
+        sp = tplot[2]
+        @test getattr(sp, :size) == default(:size) == getattr(sp, :sizes)
+        @test getattr(sp, :linestyle) == permutedims(fill(:dash, 2))
+        @test getattr(sp, :title) == "B"
+        @test getattr(sp, :xlims) == (0, Inf)
+        @test getattr(sp, :lims) == [
+            (xaxis = (0, Inf), yaxis = :auto, zaxis = :auto),
+        ]
+        @test getattr(sp, :this) == Dict(
+            :series =>
+                [2 => :that, 5 => :that],
+            :subplots => Any[],
+            :plot => Any[],
+        )
+        @test (@test_logs (
+            :info,
+            r"line is a magic argument",
+        ) getattr(sp, :line)) === missing
+        @test_throws ArgumentError getattr(sp, :nothere)
+    end
+    @testset "From Axis" begin
+        axis = tplot[3][:yaxis]
+        @test getattr(axis, :size) == default(:size) == getattr(axis, :sizes)
+        @test getattr(axis, :linestyle) == permutedims(fill(:dash, 2))
+        @test getattr(axis, :title) == "A"
+        @test getattr(axis, :xlims) === :auto # TODO: is this expected?
+        @test getattr(axis, :lims) == :auto
+        @test getattr(axis, :this) == Dict(
+            :series =>
+                [3 => :that, 6 => :that],
+            :subplots => Any[],
+            :plot => Any[],
+        )
+        @test (@test_logs (
+            :info,
+            r"line is a magic argument",
+        ) getattr(axis, :line)) === missing
+        @test_throws ArgumentError getattr(axis, :nothere)
+    end
+    @testset "From Series" begin
+        series = tplot[1][1]
+        @test getattr(series, :size) == default(:size) == getattr(series, :sizes)
+        @test getattr(series, :linestyle) == :dash
+        @test getattr(series, :title) == "A"
+        @test getattr(series, :xlims) == :auto
+        @test getattr(series, :lims) == [
+            (xaxis = :auto, yaxis = :auto, zaxis = :auto),
+        ]
+        @test getattr(series, :this) == Dict(
+            :series =>
+                [1 => :that],
+            :subplots => Any[],
+            :plot => Any[],
+        )
+        @test (@test_logs (
+            :info,
+            r"line is a magic argument",
+        ) getattr(series, :line)) === missing
+        @test_throws ArgumentError getattr(series, :nothere)
+    end
+end