WIP: Use property (#420)

* Use property

* Define property methods for wrapper objects

* updated requirements to PyPlot 1.90, dropped Compat since we now require julia 0.7, fixed getproperty in plot3d

* eliminate unnecessary PyObject(f) calls

* rm more obsolete compatibility code

* rm 0.6 testing

* need newer PyCall to import Base.hasproperty in Julia 1.2

Author: tkf

.travis.yml

@@ -2,7 +2,6 @@ language: julia
 os:
     - linux
 julia:
-    - 0.6
     - 0.7
     - 1.0
     - nightly

README.md

@@ -107,7 +107,7 @@ version number is returned by `PyPlot.version`.
 
 Only the currently documented `matplotlib.pyplot` API is exported.  To use
 other functions in the module, you can also call `matplotlib.pyplot.foo(...)`
-as `plt[:foo](...)`.  For example, `plt[:plot](x, y)` also works.  (And
+as `plt.foo(...)`.  For example, `plt.plot(x, y)` also works.  (And
 the raw `PyObject` for the `matplotlib` modules is also accessible
 as `PyPlot.matplotlib`.)
 

REQUIRE

@@ -1,6 +1,5 @@
-julia 0.6
-PyCall 1.6.2
+julia 0.7
+PyCall 1.90.0
 Colors
 LaTeXStrings
-Compat 0.65.0
 VersionParsing

appveyor.yml

@@ -1,7 +1,5 @@
 environment:
   matrix:
-  - julia_version: 0.6
-    PYTHON: "Conda"
   - julia_version: 0.7
     PYTHON: "Conda"
   - julia_version: 1

src/PyPlot.jl

@@ -4,19 +4,18 @@ module PyPlot
 
 using PyCall
 import PyCall: PyObject, pygui, pycall, pyexists
+import PyCall: hasproperty # Base.hasproperty in Julia 1.2
 import Base: convert, ==, isequal, hash, getindex, setindex!, haskey, keys, show
+using Base: @deprecate
 export Figure, plt, matplotlib, pygui, withfig
 
-using Compat
-import Base.show
-
 ###########################################################################
 # Julia 0.4 help system: define a documentation object
 # that lazily looks up help from a PyObject via zero or more keys.
 # This saves us time when loading PyPlot, since we don't have
 # to load up all of the documentation strings right away.
 struct LazyHelp
-    o # a PyObject or similar object supporting getindex with a __doc__ key
+    o # a PyObject or similar object supporting getindex with a __doc__ property
     keys::Tuple{Vararg{String}}
     LazyHelp(o) = new(o, ())
     LazyHelp(o, k::AbstractString) = new(o, (k,))
@@ -28,8 +27,8 @@ function show(io::IO, ::MIME"text/plain", h::LazyHelp)
     for k in h.keys
         o = o[k]
     end
-    if haskey(o, "__doc__")
-        print(io, convert(AbstractString, o["__doc__"]))
+    if hasproperty(o, "__doc__")
+        print(io, convert(AbstractString, o."__doc__"))
     else
         print(io, "no Python docstring found for ", h.k)
     end
@@ -53,46 +52,46 @@ include("init.jl")
 mutable struct Figure
     o::PyObject
 end
-PyObject(f::Figure) = f.o
+PyObject(f::Figure) = getfield(f, :o)
 convert(::Type{Figure}, o::PyObject) = Figure(o)
-==(f::Figure, g::Figure) = f.o == g.o
-==(f::Figure, g::PyObject) = f.o == g
-==(f::PyObject, g::Figure) = f == g.o
-hash(f::Figure) = hash(f.o)
-pycall(f::Figure, args...; kws...) = pycall(f.o, args...; kws...)
-(f::Figure)(args...; kws...) = pycall(f.o, PyAny, args...; kws...)
-Base.Docs.doc(f::Figure) = Base.Docs.doc(f.o)
-
-getindex(f::Figure, x) = getindex(f.o, x)
-setindex!(f::Figure, v, x) = setindex!(f.o, v, x)
-haskey(f::Figure, x) = haskey(f.o, x)
-keys(f::Figure) = keys(f.o)
+==(f::Figure, g::Figure) = PyObject(f) == PyObject(g)
+==(f::Figure, g::PyObject) = PyObject(f) == g
+==(f::PyObject, g::Figure) = f == PyObject(g)
+hash(f::Figure) = hash(PyObject(f))
+pycall(f::Figure, args...; kws...) = pycall(PyObject(f), args...; kws...)
+(f::Figure)(args...; kws...) = pycall(PyObject(f), PyAny, args...; kws...)
+Base.Docs.doc(f::Figure) = Base.Docs.doc(PyObject(f))
+
+# Note: using `Union{Symbol,String}` produces ambiguity.
+Base.getproperty(f::Figure, s::Symbol) = getproperty(PyObject(f), s)
+Base.getproperty(f::Figure, s::AbstractString) = getproperty(PyObject(f), s)
+Base.setproperty!(f::Figure, s::Symbol, x) = setproperty!(PyObject(f), s, x)
+Base.setproperty!(f::Figure, s::AbstractString, x) = setproperty!(PyObject(f), s, x)
+hasproperty(f::Figure, s::Symbol) = hasproperty(PyObject(f), s)
+Base.propertynames(f::Figure) = propertynames(PyObject(f))
+haskey(f::Figure, x) = haskey(PyObject(f), x)
+
+@deprecate getindex(f::Figure, x) getproperty(f, x)
+@deprecate setindex!(f::Figure, v, x) setproperty!(f, v, x)
+@deprecate keys(f::Figure) propertynames(f)
 
 for (mime,fmt) in aggformats
     @eval function show(io::IO, m::MIME{Symbol($mime)}, f::Figure)
-        if !haskey(pycall(f.o["canvas"]["get_supported_filetypes"], PyDict),
+        if !haskey(pycall(f."canvas"."get_supported_filetypes", PyDict),
                    $fmt)
             throw(MethodError(show, (io, m, f)))
         end
-        f.o["canvas"]["print_figure"](io, format=$fmt, bbox_inches="tight")
+        f."canvas"."print_figure"(io, format=$fmt, bbox_inches="tight")
     end
     if fmt != "svg"
-        if isdefined(Base, :showable)
-            @eval Base.showable(::MIME{Symbol($mime)}, f::Figure) = !isempty(f) && haskey(pycall(f.o["canvas"]["get_supported_filetypes"], PyDict), $fmt)
-        else
-            @eval Base.mimewritable(::MIME{Symbol($mime)}, f::Figure) = !isempty(f) && haskey(pycall(f.o["canvas"]["get_supported_filetypes"], PyDict), $fmt)
-        end
+        @eval Base.showable(::MIME{Symbol($mime)}, f::Figure) = !isempty(f) && haskey(pycall(f."canvas"."get_supported_filetypes", PyDict), $fmt)
     end
 end
 
 # disable SVG output by default, since displaying large SVGs (large datasets)
 # in IJulia is slow, and browser SVG display is buggy.  (Similar to IPython.)
 const SVG = [false]
-if isdefined(Base, :showable)
-    Base.showable(::MIME"image/svg+xml", f::Figure) = SVG[1] && !isempty(f) && haskey(pycall(f.o["canvas"]["get_supported_filetypes"], PyDict), "svg")
-else
-    Base.mimewritable(::MIME"image/svg+xml", f::Figure) = SVG[1] && !isempty(f) && haskey(pycall(f.o["canvas"]["get_supported_filetypes"], PyDict), "svg")
-end
+Base.showable(::MIME"image/svg+xml", f::Figure) = SVG[1] && !isempty(f) && haskey(pycall(f."canvas"."get_supported_filetypes", PyDict), "svg")
 svg() = SVG[1]
 svg(b::Bool) = (SVG[1] = b)
 
@@ -103,7 +102,7 @@ svg(b::Bool) = (SVG[1] = b)
 # since the user is keeping track of these in some other way,
 # e.g. for interactive widgets.
 
-Base.isempty(f::Figure) = isempty(pycall(f["get_axes"], PyVector))
+Base.isempty(f::Figure) = isempty(pycall(f."get_axes", PyVector))
 
 # We keep a set of figure numbers for the figures used in withfig, because
 # for these figures we don't want to auto-display or auto-close them
@@ -114,23 +113,23 @@ const withfig_fignums = Set{Int}()
 
 function display_figs() # called after IJulia cell executes
     if isjulia_display[1]
-        for manager in Gcf["get_all_fig_managers"]()
-            f = manager["canvas"]["figure"]
-            if f[:number] ∉ withfig_fignums
+        for manager in Gcf."get_all_fig_managers"()
+            f = manager."canvas"."figure"
+            if f.number ∉ withfig_fignums
                 fig = Figure(f)
                 isempty(fig) || display(fig)
-                pycall(plt["close"], PyAny, f)
+                pycall(plt."close", PyAny, f)
             end
         end
     end
 end
 
 function close_figs() # called after error in IJulia cell
     if isjulia_display[1]
-        for manager in Gcf["get_all_fig_managers"]()
-            f = manager["canvas"]["figure"]
-            if f[:number] ∉ withfig_fignums
-                pycall(plt["close"], PyAny, f)
+        for manager in Gcf."get_all_fig_managers"()
+            f = manager."canvas"."figure"
+            if f.number ∉ withfig_fignums
+                pycall(plt."close", PyAny, f)
             end
         end
     end
@@ -166,39 +165,39 @@ export acorr,annotate,arrow,autoscale,autumn,axhline,axhspan,axis,axvline,axvspa
 # overlap with standard Julia functions:
 #          close, connect, fill, hist, xcorr
 import Base: close, fill, step
-import Compat.Sockets: connect
+import Sockets: connect
 
 const plt_funcs = (:acorr,:annotate,:arrow,:autoscale,:autumn,:axes,:axhline,:axhspan,:axis,:axvline,:axvspan,:bar,:barbs,:barh,:bone,:box,:boxplot,:broken_barh,:cla,:clabel,:clf,:clim,:cohere,:colorbar,:colors,:contour,:contourf,:cool,:copper,:csd,:delaxes,:disconnect,:draw,:errorbar,:eventplot,:figaspect,:figimage,:figlegend,:figtext,:fill_between,:fill_betweenx,:findobj,:flag,:gca,:gci,:get_current_fig_manager,:get_figlabels,:get_fignums,:get_plot_commands,:ginput,:gray,:grid,:hexbin,:hlines,:hold,:hot,:hsv,:imread,:imsave,:imshow,:ioff,:ion,:ishold,:jet,:legend,:locator_params,:loglog,:margins,:matshow,:minorticks_off,:minorticks_on,:over,:pause,:pcolor,:pcolormesh,:pie,:pink,:plot,:plot_date,:plotfile,:polar,:prism,:psd,:quiver,:quiverkey,:rc,:rc_context,:rcdefaults,:rgrids,:savefig,:sca,:scatter,:sci,:semilogx,:semilogy,:set_cmap,:setp,:specgram,:spectral,:spring,:spy,:stackplot,:stem,:streamplot,:subplot,:subplot2grid,:subplot_tool,:subplots,:subplots_adjust,:summer,:suptitle,:table,:text,:thetagrids,:tick_params,:ticklabel_format,:tight_layout,:title,:tricontour,:tricontourf,:tripcolor,:triplot,:twinx,:twiny,:vlines,:waitforbuttonpress,:winter,:xkcd,:xlabel,:xlim,:xscale,:xticks,:ylabel,:ylim,:yscale,:yticks,:hist,:xcorr,:isinteractive)
 
 for f in plt_funcs
     sf = string(f)
     @eval @doc LazyHelp(plt,$sf) function $f(args...; kws...)
-        if !haskey(plt, $sf)
+        if !hasproperty(plt, $sf)
             error("matplotlib ", version, " does not have pyplot.", $sf)
         end
-        return pycall(plt[$sf], PyAny, args...; kws...)
+        return pycall(plt.$sf, PyAny, args...; kws...)
     end
 end
 
-@doc LazyHelp(plt,"step") step(x, y; kws...) = pycall(plt["step"], PyAny, x, y; kws...)
+@doc LazyHelp(plt,"step") step(x, y; kws...) = pycall(plt."step", PyAny, x, y; kws...)
 
-Base.show(; kws...) = begin pycall(plt["show"], PyObject; kws...); nothing; end
+Base.show(; kws...) = begin pycall(plt."show", PyObject; kws...); nothing; end
 
-close(f::Figure) = close(f[:number])
+close(f::Figure) = close(f.number)
 function close(f::Integer)
     pop!(withfig_fignums, f, f)
-    pycall(plt["close"], PyAny, f)
+    pycall(plt."close", PyAny, f)
 end
-close(f::Union{AbstractString,Symbol}) = pycall(plt["close"], PyAny, f)
-@doc LazyHelp(plt,"close") close() = pycall(plt["close"], PyAny)
+close(f::Union{AbstractString,Symbol}) = pycall(plt."close", PyAny, f)
+@doc LazyHelp(plt,"close") close() = pycall(plt."close", PyAny)
 
-@doc LazyHelp(plt,"connect") connect(s::Union{AbstractString,Symbol}, f::Function) = pycall(plt["connect"], PyAny, s, f)
+@doc LazyHelp(plt,"connect") connect(s::Union{AbstractString,Symbol}, f::Function) = pycall(plt."connect", PyAny, s, f)
 
 @doc LazyHelp(plt,"fill") fill(x::AbstractArray,y::AbstractArray, args...; kws...) =
-    pycall(plt["fill"], PyAny, x, y, args...; kws...)
+    pycall(plt."fill", PyAny, x, y, args...; kws...)
 
 # consistent capitalization with mplot3d, avoid conflict with Base.hist2d
-@doc LazyHelp(plt,"hist2d") hist2D(args...; kws...) = pycall(plt["hist2d"], PyAny, args...; kws...)
+@doc LazyHelp(plt,"hist2d") hist2D(args...; kws...) = pycall(plt."hist2d", PyAny, args...; kws...)
 
 include("colormaps.jl")
 
@@ -212,9 +211,9 @@ function bar(x::AbstractVector{T}, y; kws...) where T<:AbstractString
     end
     p = bar(xi, y; kws...)
     ax = any(kw -> kw[1] == :orientation && lowercase(kw[2]) == "horizontal",
-             kws) ? gca()["yaxis"] : gca()["xaxis"]
-    ax["set_ticks"](xi)
-    ax["set_ticklabels"](x)
+             kws) ? gca()."yaxis" : gca()."xaxis"
+    ax."set_ticks"(xi)
+    ax."set_ticklabels"(x)
     return p
 end
 
@@ -274,9 +273,9 @@ end
 
 function withfig(actions::Function, f::Figure; clear=true)
     ax_save = gca()
-    push!(withfig_fignums, f[:number])
-    figure(f[:number])
-    @compat finalizer(close, f)
+    push!(withfig_fignums, f.number)
+    figure(f.number)
+    finalizer(close, f)
     try
         if clear && !isempty(f)
             clf()

src/colormaps.jl

@@ -11,23 +11,31 @@ mutable struct ColorMap
     o::PyObject
 end
 
-PyObject(c::ColorMap) = c.o
+PyObject(c::ColorMap) = getfield(c, :o)
 convert(::Type{ColorMap}, o::PyObject) = ColorMap(o)
-==(c::ColorMap, g::ColorMap) = c.o == g.o
-==(c::PyObject, g::ColorMap) = c == g.o
-==(c::ColorMap, g::PyObject) = c.o == g
-hash(c::ColorMap) = hash(c.o)
-pycall(c::ColorMap, args...; kws...) = pycall(c.o, args...; kws...)
-(c::ColorMap)(args...; kws...) = pycall(c.o, PyAny, args...; kws...)
-Base.Docs.doc(c::ColorMap) = Base.Docs.doc(c.o)
-
-getindex(c::ColorMap, x) = getindex(c.o, x)
-setindex!(c::ColorMap, v, x) = setindex!(c.o, v, x)
-haskey(c::ColorMap, x) = haskey(c.o, x)
-keys(c::ColorMap) = keys(c.o)
+==(c::ColorMap, g::ColorMap) = PyObject(c) == PyObject(g)
+==(c::PyObject, g::ColorMap) = c == PyObject(g)
+==(c::ColorMap, g::PyObject) = PyObject(c) == g
+hash(c::ColorMap) = hash(PyObject(c))
+pycall(c::ColorMap, args...; kws...) = pycall(PyObject(c), args...; kws...)
+(c::ColorMap)(args...; kws...) = pycall(PyObject(c), PyAny, args...; kws...)
+Base.Docs.doc(c::ColorMap) = Base.Docs.doc(PyObject(c))
+
+# Note: using `Union{Symbol,String}` produces ambiguity.
+Base.getproperty(c::ColorMap, s::Symbol) = getproperty(PyObject(c), s)
+Base.getproperty(c::ColorMap, s::AbstractString) = getproperty(PyObject(c), s)
+Base.setproperty!(c::ColorMap, s::Symbol, x) = setproperty!(PyObject(c), s, x)
+Base.setproperty!(c::ColorMap, s::AbstractString, x) = setproperty!(PyObject(c), s, x)
+Base.propertynames(c::ColorMap) = propertynames(PyObject(c))
+hasproperty(c::ColorMap, s::Union{Symbol,AbstractString}) = hasproperty(PyObject(c), s)
+haskey(c::ColorMap, x) = haskey(PyObject(c), x)
+
+@deprecate getindex(c::ColorMap, x) getproperty(c, x)
+@deprecate setindex!(c::ColorMap, s, x) setproperty!(c, s, x)
+@deprecate keys(c::ColorMap) propertynames(c)
 
 function show(io::IO, c::ColorMap)
-    print(io, "ColorMap \"$(c[:name])\"")
+    print(io, "ColorMap \"$(c.name)\"")
 end
 
 # all Python dependencies must be initialized at runtime (not when precompiled)
@@ -42,15 +50,15 @@ function init_colormaps()
     copy!(colorsm, pyimport("matplotlib.colors"))
     copy!(cm, pyimport("matplotlib.cm"))
 
-    pytype_mapping(colorsm["Colormap"], ColorMap)
+    pytype_mapping(colorsm."Colormap", ColorMap)
 
-    copy!(LinearSegmentedColormap, colorsm["LinearSegmentedColormap"])
+    copy!(LinearSegmentedColormap, colorsm."LinearSegmentedColormap")
 
-    copy!(cm_get_cmap, cm["get_cmap"])
-    copy!(cm_register_cmap, cm["register_cmap"])
+    copy!(cm_get_cmap, cm."get_cmap")
+    copy!(cm_register_cmap, cm."register_cmap")
 
-    copy!(ScalarMappable, cm["ScalarMappable"])
-    copy!(Normalize01, pycall(colorsm["Normalize"],PyAny,vmin=0,vmax=1))
+    copy!(ScalarMappable, cm."ScalarMappable")
+    copy!(Normalize01, pycall(colorsm."Normalize",PyAny,vmin=0,vmax=1))
 end
 
 ########################################################################
@@ -149,7 +157,7 @@ register_cmap(n::Union{AbstractString,Symbol}, c::ColorMap) = pycall(cm_register
 get_cmaps() =
     ColorMap[get_cmap(c) for c in
              sort(filter!(c -> !endswith(c, "_r"),
-                          AbstractString[c for (c,v) in PyDict(PyPlot.cm["datad"])]),
+                          AbstractString[c for (c,v) in PyDict(PyPlot.cm."datad")]),
                   by=lowercase)]
 
 ########################################################################
@@ -158,8 +166,8 @@ get_cmaps() =
 function show(io::IO, ::MIME"image/svg+xml", cs::AbstractVector{ColorMap})
     n = 256
     nc = length(cs)
-    a = Compat.range(0; stop=1, length=n)
-    namelen = mapreduce(c -> length(c[:name]), max, cs)
+    a = range(0; stop=1, length=n)
+    namelen = mapreduce(c -> length(c.name), max, cs)
     width = 0.5
     height = 5
     pad = 0.5
@@ -175,9 +183,9 @@ function show(io::IO, ::MIME"image/svg+xml", cs::AbstractVector{ColorMap})
     for j = 1:nc
         c = cs[j]
         y = (j-1) * (height+pad)
-        write(io, """<text x="$(n*width+1)mm" y="$(y+3.8)mm" font-size="3mm">$(c[:name])</text>""")
+        write(io, """<text x="$(n*width+1)mm" y="$(y+3.8)mm" font-size="3mm">$(c.name)</text>""")
         rgba = pycall(pycall(ScalarMappable, PyObject, cmap=c,
-                             norm=Normalize01)["to_rgba"], PyArray, a)
+                             norm=Normalize01)."to_rgba", PyArray, a)
         for i = 1:n
             write(io, """<rect x="$((i-1)*width)mm" y="$(y)mm" width="$(width)mm" height="$(height)mm" fill="#$(hex(RGB(rgba[i,1],rgba[i,2],rgba[i,3])))" stroke="none" />""")
         end