pyclass dev

Author: Christopher Doris

docs/src/pythoncall.md

@@ -110,9 +110,7 @@ pyfrozenset
 pydict
 pyslice
 pyrange
-pymethod
 pytype
-pyclass
 ```
 
 ### Builtins
@@ -244,6 +242,19 @@ pyge
 pygt
 ```
 
+## Create classes
+
+These functions can be used to create new Python classes where the functions are implemented
+in Julia. You can instead use [`@pyeval`](@ref) etc. to create pure-Python classes.
+
+```@docs
+pyclass
+pyfunc
+pyclassmethod
+pystaticmethod
+pyproperty
+```
+
 ## [Installing Python packages](@id python-deps)
 
 PythonCall uses [CondaPkg.jl](https://github.com/cjdoris/CondaPkg.jl) to manage its

docs/src/releasenotes.md

@@ -1,9 +1,12 @@
 # Release Notes
 
 ## Unreleased
+* **Breaking:** Removes `pymethod`.
+* **Breaking:** Any member passed to `pyclass` which is a `Function` is automatically
+  wrapped with `pyfunc`, making it an instance method.
+* Adds `pyfunc`, `pyclassmethod`, `pystaticmethod` and `pyproperty`.
 * `pyconvert_add_rule` is now documented. Its semantics have changed, including the
-  separator of the first argument from `/` to `:` (not breaking because it was previously
-  undocumented).
+  separator of the first argument from `/` to `:`.
 * Bug fixes.
 
 ## v0.6.1 (2022-02-21)

src/PythonCall.jl

@@ -37,7 +37,6 @@ include("concrete/range.jl")
 include("concrete/none.jl")
 include("concrete/type.jl")
 include("concrete/fraction.jl")
-include("concrete/method.jl")
 include("concrete/datetime.jl")
 include("concrete/code.jl")
 include("concrete/ctypes.jl")

src/concrete/method.jl

@@ -4,17 +4,75 @@
 The Python `type` of `x`.
 """
 pytype(x) = pynew(errcheck(@autopy x C.PyObject_Type(getptr(x_))))
-pytype(name, bases, dict) = pybuiltins.type(name, ispy(bases) && pyistype(bases) ? pytuple((bases,)) : pytuple(bases), pydict(dict))
 export pytype
 
+"""
+    pytype(name, bases, dict)
+
+Create a new type. Equivalent to `type(name, bases, dict)` in Python.
+
+See [`pyclass`](@ref) for a more convenient syntax.
+"""
+pytype(name, bases, dict) = pybuiltins.type(name, ispy(bases) ? bases : pytuple(bases), ispy(dict) ? dict : pydict(dict))
+
 """
     pyclass(name, bases=(); members...)
 
 Construct a new Python type with the given name, bases and members.
 
-Equivalent to `pytype(name, bases, members)`.
+The `bases` may be a Python type or a tuple of Python types.
+
+Any `members` which are Julia functions are interpreted as instance methods (equivalent to
+wrapping the function in [`pyfunc`](@ref)). To create class methods, static methods or
+properties, wrap the function in [`pyclassmethod`](@ref), [`pystaticmethod`](@ref) or
+[`pyproperty`](@ref).
+
+Note that the arguments to any method or property are passed as `Py`, i.e. they are not
+converted first.
+
+# Example
+
+```
+Foo = pyclass("Foo",
+    __init__ = function (self, x, y = nothing)
+        self.x = x
+        self.y = y
+        nothing
+    end,
+
+    __repr__ = function (self)
+        "Foo(\$(self.x), \$(self.y))"
+    end,
+
+    frompair = function (cls, xy)
+        cls(xy...)
+    end
+    |> pyclassmethod,
+
+    hello = function (name)
+        println("Hello, \$name")
+    end
+    |> pystaticmethod,
+
+    xy = pyproperty(
+        get = function (self)
+            (self.x, self.y)
+        end,
+        set = function (self, xy)
+            (x, y) = xy
+            self.x = x
+            self.y = y
+            nothing
+        end,
+    ),
+)
+```
 """
-pyclass(name, bases=(); dict...) = pytype(name, bases, pystrdict_fromiter(dict))
+function pyclass(name, bases=(); members...)
+    bases2 = ispy(bases) && pyistype(bases) ? pytuple((bases,)) : pytuple(bases)
+    members2 = pydict(pystr(k) => v isa Function ? pyfunc(v) : Py(v) for (k, v) in members)
+    pytype(name, bases2, members2)
+end
 export pyclass
 
 pyistype(x) = pytypecheckfast(x, C.Py_TPFLAGS_TYPE_SUBCLASS)

src/concrete/type.jl

@@ -3,7 +3,7 @@ const pyjlcallbacktype = pynew()
 
 pyjlcallback_repr(self) = Py("<jl $(repr(self))>")
 
-pyjlcallback_str(self) = Py(string(self))
+pyjlcallback_str(self) = Py(sprint(print, self))
 
 function pyjlcallback_call(self, args_::Py, kwargs_::Py)
     if pylen(kwargs_) > 0
@@ -44,18 +44,73 @@ function init_jlwrap_callback()
 end
 
 pyjlcallback(f) = pyjl(pyjlcallbacktype, f)
-export pyjlcallback
 
-function pycallback(f; name=nothing, doc=nothing)
-    f2 = pyjlcallback(f)
+"""
+    pyfunc(f; [name], [doc])
+
+Wrap the callable `f` as an ordinary Python function.
+
+Its name and docstring can be given with `name` and `doc`.
+
+Unlike `Py(f)` (or `pyjl(f)`), the arguments passed to `f` are always of type `Py`, i.e.
+they are never converted.
+"""
+function pyfunc(f; name=nothing, doc=nothing)
+    f2 = ispy(f) ? f : pyjlcallback(f)
     f3 = pywrapcallback(f2)
     pydel!(f2)
     if name !== nothing
         f3.__name__ = f3.__qualname__ = name
+    else
+        f3.__name__ = f3.__qualname__ = "<lambda>"
     end
     if doc !== nothing
         f3.__doc__ = doc
     end
     return f3
 end
-export pycallback
+export pyfunc
+
+"""
+    pyclassmethod(f)
+
+Convert callable `f` to a Python class method.
+
+If `f` is not a Python object (e.g. if `f` is a `Function`) then it is converted to one with
+[`pyfunc`](@ref). In particular this means the arguments passed to `f` are always of type
+`Py`.
+"""
+pyclassmethod(f) = pybuiltins.classmethod(ispy(f) ? f : pyfunc(f))
+export pyclassmethod
+
+"""
+    pystaticmethod(f)
+
+Convert callable `f` to a Python static method.
+
+If `f` is not a Python object (e.g. if `f` is a `Function`) then it is converted to one with
+[`pyfunc`](@ref). In particular this means the arguments passed to `f` are always of type
+`Py`.
+"""
+pystaticmethod(f) = pybuiltins.staticmethod(ispy(f) ? f : pyfunc(f))
+export pystaticmethod
+
+"""
+    pyproperty(; get=nothing, set=nothing, del=nothing, doc=nothing)
+    pyproperty(get)
+
+Create a Python `property` with the given getter, setter and deleter.
+
+If `get`, `set` or `del` is not a Python object (e.g. if it is a `Function`) then it is
+converted to one with [`pyfunc`](@ref). In particular this means the arguments passed to it
+are always of type `Py`.
+"""
+pyproperty(; get=nothing, set=nothing, del=nothing, doc=nothing) =
+    pybuiltins.property(
+        fget = ispy(get) || get === nothing ? get : pyfunc(get),
+        fset = ispy(set) || set === nothing ? set : pyfunc(set),
+        fdel = ispy(del) || del === nothing ? del : pyfunc(del),
+        doc = doc,
+    )
+pyproperty(get) = pyproperty(get=get)
+export pyproperty

src/jlwrap/callback.jl

@@ -2,7 +2,7 @@ const pyjlrawtype = pynew()
 
 pyjlraw_repr(self) = Py("<jl $(repr(self))>")
 
-pyjlraw_str(self) = Py(string(self))
+pyjlraw_str(self) = Py(sprint(print, self))
 
 pyjl_attr_py2jl(k::String) = replace(k, r"_[b]+$" => (x -> "!"^(length(x) - 1)))
 

src/jlwrap/raw.jl

@@ -1,5 +1,5 @@
 # TODO:
-# - function definition (wrap the function like a pycallback)
+# - function definition (wrap the function like a pyfunc)
 # - class definition (e.g. `struct User <: BaseModel; id::int=0; name::str=""; end`)
 # - property syntax (e.g. `classmethod |> function foo(cls); cls(); end`)
 # - with syntax (`@with`)