pytype tweaks

Author: Christopher Doris

docs/src/pythoncall.md

@@ -84,7 +84,6 @@ Notable exceptions are:
 - [`pyconvert`](@ref) to convert a Python object to a Julia object.
 - [`pyimport`](@ref) to import a Python module.
 - [`pyjl`](@ref) to directly wrap a Julia object as a Python object.
-- [`pyclass`](@ref) to construct a new class.
 - [`pywith`](@ref) to emulate the Python `with` statement.
 
 If a Julia value is passed as an argument to one of these functions, it is converted to a

src/concrete/type.jl

@@ -13,7 +13,8 @@ Create a new type. Equivalent to `type(name, bases, dict)` in Python.
 
 If `bases` is not a Python object, it is converted to one using `pytuple`.
 
-If `dict` is not a Python object, it is converted to one using `pydict`.
+The `dict` may either by a Python object or a Julia iterable. In the latter case, each item
+may either be a `name => value` pair or a Python object with a `__name__` attribute.
 
 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),
@@ -24,7 +25,10 @@ to the function always have type `Py`. See the example below.
 
 ```
 Foo = pytype("Foo", (), [
-    "__init__" => pyfunc(
+    "__module__" => "__main__",
+
+    pyfunc(
+        name = "__init__",
         doc = \"\"\"
         Specify x and y to store in the Foo.
 
@@ -37,19 +41,22 @@ Foo = pytype("Foo", (), [
         end,
     ),
 
-    "__repr__" => function (self)
-        return "Foo(\$(self.x), \$(self.y))"
-    end |> pyfunc,
+    pyfunc(
+        name = "__repr__",
+        self -> "Foo(\$(self.x), \$(self.y))",
+    ),
 
-    "frompair" => pyclassmethod(
+    pyclassmethod(
+        name = "frompair",
         doc = "Construct a Foo from a tuple of length two.",
         (cls, xy) -> cls(xy...),
     ),
 
-    "hello" => pystaticmethod(
+    pystaticmethod(
+        name = "hello",
         doc = "Prints a friendly greeting.",
         (name) -> println("Hello, \$name"),
-    )
+    ),
 
     "xy" => pyproperty(
         doc = "A tuple of x and y.",
@@ -66,7 +73,7 @@ Foo = pytype("Foo", (), [
 """
 function pytype(name, bases, dict)
     bases2 = ispy(bases) ? bases : pytuple(bases)
-    dict2 = ispy(dict) ? dict : pydict(dict)
+    dict2 = ispy(dict) ? dict : pydict(ispy(item) ? (pygetattr(item, "__name__") => item) : item for item in dict)
     pybuiltins.type(name, bases2, dict2)
 end
 

src/jlwrap/callback.jl

@@ -46,7 +46,7 @@ end
 pyjlcallback(f) = pyjl(pyjlcallbacktype, f)
 
 """
-    pyfunc(f; [name], [doc])
+    pyfunc(f; name=nothing, doc=nothing)
 
 Wrap the callable `f` as an ordinary Python function.
 

test/concrete.jl

@@ -248,11 +248,6 @@ end
     @test pyeq(Bool, x.__name__, "Foo")
     @test pyeq(Bool, x.foo, 1)
     @test pyeq(Bool, x.bar, 2)
-    x = pyclass("Bar", (), foo=3, bar=4)
-    @test pyisinstance(x, pybuiltins.type)
-    @test pyeq(Bool, x.__name__, "Bar")
-    @test pyeq(Bool, x.foo, 3)
-    @test pyeq(Bool, x.bar, 4)
 end
 
 @testset "fraction" begin