remove pyclass

Author: Christopher Doris

docs/src/pythoncall.md

@@ -96,60 +96,60 @@ These functions construct Python objects of builtin types from Julia values.
 
 ```@docs
 pybool
-pyint
-pyfloat
-pycomplex
-pystr
+pycollist
 pybytes
-pytuple
+pycomplex
+pydict
+pyfloat
+pyfrozenset
+pyint
 pylist
-pycollist
+pyrange
 pyrowlist
 pyset
-pyfrozenset
-pydict
 pyslice
-pyrange
-pytype
+pystr
+pytuple
 ```
 
 ### Builtins
 
 These functions mimic the Python builtin functions or keywords of the same name.
 
 ```@docs
-pyimport
-pywith
-pyis
-pyrepr
+pyall
+pyany
 pyascii
-pyhasattr
-pygetattr
-pysetattr
-pydelattr
-pydir
 pycall
-pylen
+pycallable
+pycompile
 pycontains
-pyin
-pygetitem
-pysetitem
+pydelattr
 pydelitem
-pyissubclass
-pyisinstance
+pydir
+pyeval
+@pyeval
+pyexec
+@pyexec
+pygetattr
+pygetitem
+pyhasattr
 pyhash
+pyhelp
+pyimport
+pyin
+pyis
+pyisinstance
+pyissubclass
 pyiter
+pylen
 pynext
-pyhelp
 pyprint
-pyall
-pyany
-pycallable
-pyeval
-pyexec
-pycompile
-@pyeval
-@pyexec
+pyrepr
+pysetattr
+pysetitem
+pytype(::Any)
+pywith
 ```
 
 ### Conversion to Julia
@@ -173,8 +173,8 @@ pyjl
 pyjlraw
 pyisjl
 pyjlvalue
-pytextio
 pybinaryio
+pytextio
 ```
 
 ### Arithmetic
@@ -248,7 +248,7 @@ These functions can be used to create new Python classes where the functions are
 in Julia. You can instead use [`@pyeval`](@ref) etc. to create pure-Python classes.
 
 ```@docs
-pyclass
+pytype(::Any, ::Any, ::Any)
 pyfunc
 pyclassmethod
 pystaticmethod

docs/src/releasenotes.md

@@ -1,9 +1,8 @@
 # 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.
+* **Breaking:** Removes `pymethod` and `pyclass`. In the future, `pyclass` may become sugar
+  for `types.new_class` (namely you can specify a metaclass).
 * 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 `:`.

src/concrete/type.jl

@@ -11,69 +11,64 @@ export pytype
 
 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...)
+If `bases` is not a Python object, it is converted to one using `pytuple`.
 
-Construct a new Python type with the given name, bases and members.
+If `dict` is not a Python object, it is converted to one using `pydict`.
 
-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.
+In order to use a Julia `Function` as an instance method, it must be wrapped into a Python
+function with [`pyfunc`](@ref). Similarly, see also [`pyclassmethod`](@ref),
+[`pystaticmethod`](@ref) or [`pyproperty`](@ref). In all these cases, the arguments passed
+to the function always have type `Py`. See the example below.
 
 # Example
 
 ```
-Foo = pyclass("Foo",
-    __init__ = function (self, x, y = nothing)
-        self.x = x
-        self.y = y
-        nothing
-    end,
+Foo = pytype("Foo", (), [
+    "__init__" => pyfunc(
+        doc = \"\"\"
+        Specify x and y to store in the Foo.
+
+        If omitted, y defaults to None.
+        \"\"\",
+        function (self, x, y = nothing)
+            self.x = x
+            self.y = y
+            return
+        end,
+    ),
 
-    __repr__ = function (self)
-        "Foo(\$(self.x), \$(self.y))"
-    end,
+    "__repr__" => function (self)
+        return "Foo(\$(self.x), \$(self.y))"
+    end |> pyfunc,
 
-    frompair = function (cls, xy)
-        cls(xy...)
-    end
-    |> pyclassmethod,
+    "frompair" => pyclassmethod(
+        doc = "Construct a Foo from a tuple of length two.",
+        (cls, xy) -> cls(xy...),
+    ),
 
-    hello = function (name)
-        println("Hello, \$name")
-    end
-    |> pystaticmethod,
+    "hello" => pystaticmethod(
+        doc = "Prints a friendly greeting.",
+        (name) -> println("Hello, \$name"),
+    )
 
-    xy = pyproperty(
-        get = function (self)
-            (self.x, self.y)
-        end,
+    "xy" => pyproperty(
+        doc = "A tuple of x and y.",
+        get = (self) -> (self.x, self.y),
         set = function (self, xy)
             (x, y) = xy
             self.x = x
             self.y = y
             nothing
         end,
     ),
-)
+])
 ```
 """
-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)
+function pytype(name, bases, dict)
+    bases2 = ispy(bases) ? bases : pytuple(bases)
+    dict2 = ispy(dict) ? dict : pydict(dict)
+    pybuiltins.type(name, bases2, dict2)
 end
-export pyclass
 
 pyistype(x) = pytypecheckfast(x, C.Py_TPFLAGS_TYPE_SUBCLASS)
 

src/jlwrap/callback.jl

@@ -72,27 +72,27 @@ end
 export pyfunc
 
 """
-    pyclassmethod(f)
+    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`.
+`Py`. Keyword arguments are passed to `pyfunc`.
 """
-pyclassmethod(f) = pybuiltins.classmethod(ispy(f) ? f : pyfunc(f))
+pyclassmethod(f; kw...) = pybuiltins.classmethod(ispy(f) ? f : pyfunc(f; kw...))
 export pyclassmethod
 
 """
-    pystaticmethod(f)
+    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`.
+`Py`. Any keyword arguments are passed to `pyfunc`.
 """
-pystaticmethod(f) = pybuiltins.staticmethod(ispy(f) ? f : pyfunc(f))
+pystaticmethod(f; kw...) = pybuiltins.staticmethod(ispy(f) ? f : pyfunc(f; kw...))
 export pystaticmethod
 
 """