Allow @PyDEF to define classes with class variables (#605)

* Allow @PyDEF to define classes with class variables

Before this commit, `@pydef` and `@pydef_object` did not support the creation of
python classes with [class variables][1]. I have expanded `@pydef` to support
class variables with the following syntax:

```julia
@PyDEF mutable struct ObjectCounter
    obj_count = 0 # Class variable
    function __init__(::PyObject)
        ObjectCounter[:obj_count] += 1
    end
end
```

closes #513

[1]: https://docs.python.org/3/tutorial/classes.html#class-and-instance-variables

* Be more careful about checking expression in parse_pydef

Author: galenlynch

README.md

@@ -461,6 +461,16 @@ Here's another example using [Tkinter](https://wiki.python.org/moin/TkInter):
     app = SampleApp()
     app[:mainloop]()
 
+Class variables are also supported:
+
+    using PyCall
+    @pydef mutable struct ObjectCounter
+        obj_count = 0 # Class variable
+        function __init__(::PyObject)
+            ObjectCounter[:obj_count] += 1
+        end
+    end
+
 ### GUI Event Loops
 
 For Python packages that have a graphical user interface (GUI),

src/pyclass.jl

@@ -23,7 +23,7 @@ Arguments
 Return value: the created class (`::PyTypeObject`)
 """
 function def_py_class(type_name::AbstractString, methods::Vector;
-                      base_classes=[], getsets::Vector=[])
+                      base_classes=[], getsets::Vector=[], class_vars=[])
     # Only create new-style classes
     base_classes = union(base_classes, [pybuiltin("object")])
     methods = Dict(py_name => jlfun2pyfun(jl_fun::Function)
@@ -32,7 +32,7 @@ function def_py_class(type_name::AbstractString, methods::Vector;
                                                 jlfun2pyfun(setter))
                           for (py_name::Symbol, getter, setter) in getsets)
     return pybuiltin("type")(type_name, tuple(base_classes...),
-                             merge(methods, getter_setters))
+                             merge(methods, getter_setters, Dict(class_vars)))
 end
 
 ######################################################################
@@ -58,6 +58,11 @@ function parse_pydef_toplevel(expr)
     return class_name::Symbol, base_classes, lines
 end
 
+# From MacroTools
+function isfunction(expr)
+    @capture(MacroTools.longdef1(expr), function (fcall_ | fcall_) body_ end)
+end
+
 function parse_pydef(expr)
     class_name, base_classes, lines = parse_pydef_toplevel(expr)
     # Now we parse every method definition / getter / setter
@@ -66,8 +71,12 @@ function parse_pydef(expr)
     getter_dict = Dict{Any, Symbol}() # python_var => jl_getter_name
     setter_dict = Dict{Any, Symbol}()
     method_syms = Dict{Any, Symbol}() # see below
+    class_vars = Dict{Symbol, Any}()
     for line in lines
-        if !isa(line, LineNumberNode) && line.head != :line # need to skip those
+        line isa LineNumberNode && continue
+        line isa Expr || error("Malformed line: $line")
+        line.head == :line && continue
+        if isfunction(line)
             def_dict = splitdef(line)
             py_f = def_dict[:name]
             # The dictionary of the new Julia-side definition. 
@@ -101,11 +110,23 @@ function parse_pydef(expr)
                 error("Malformed line: $line")
             end
             push!(function_defs, combinedef(jl_def_dict))
+        elseif line.head == :(=) # Non function assignment
+            class_vars[line.args[1]] = line.args[2]
+        else
+            error("Malformed line: $line")
         end
     end
     @assert(isempty(setdiff(keys(setter_dict), keys(getter_dict))),
             "All .set attributes must have a .get")
-    class_name, base_classes, methods, getter_dict, setter_dict, function_defs
+    return (
+        class_name,
+        base_classes,
+        methods,
+        getter_dict,
+        setter_dict,
+        function_defs,
+        class_vars
+    )
 end
 
 """
@@ -159,20 +180,30 @@ metaclass as a `PyObject` instead of binding it to the class name.
 It's side-effect-free, except for the definition of the class methods.
 """
 macro pydef_object(class_expr)
-    class_name, base_classes, methods_, getter_dict, setter_dict, function_defs=
+    class_name,
+    base_classes,
+    methods_,
+    getter_dict,
+    setter_dict,
+    function_defs,
+    class_vars =
         parse_pydef(class_expr)
     methods = [:($(Expr(:quote, py_name::Symbol)), $(esc(jl_fun::Symbol)))
                for (py_name, jl_fun) in methods_]
     getsets = [:($(Expr(:quote, attribute)),
                  $(esc(getter)),
                  $(esc(get(setter_dict, attribute, nothing))))
                for (attribute, getter) in getter_dict]
+    class_var_pairs = [
+        :($(Expr(:quote, py_name)), $(esc(val_expr)))
+        for (py_name, val_expr) in class_vars
+    ]
     :(begin
         $(map(esc, function_defs)...)
         # This line doesn't have any side-effect, it just returns the Python
         # (meta-)class, as a PyObject
         def_py_class($(string(class_name)), [$(methods...)];
                      base_classes=[$(map(esc, base_classes)...)],
-                     getsets=[$(getsets...)])
+                     getsets=[$(getsets...)], class_vars = [$(class_var_pairs...)])
     end)
 end

test/runtests.jl

@@ -573,6 +573,14 @@ end
     end
 end
 
+# @pydef with class variable
+@pydef mutable struct ObjectCounter
+    obj_count = 1 - 1
+    function __init__(::PyObject)
+        ObjectCounter[:obj_count] += 1
+    end
+end
+
 @testset "pydef" begin
     d = Doubler(5)
     @test d[:x] == 5
@@ -583,6 +591,10 @@ end
 
     @test_throws ErrorException @pywith IgnoreError(false) error()
     @test (@pywith IgnoreError(true) error(); true)
+
+    @test ObjectCounter[:obj_count] == 0
+    a = ObjectCounter()
+    @test ObjectCounter[:obj_count] == 1
 end
 
 @testset "callback" begin