remove using and As and add convert

Author: Christopher Doris

docs/src/conversion-to-julia.md

@@ -12,7 +12,6 @@ From Python, the arguments to a Julia function will be converted according to th
 | :----------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------- |
 | **Top priority (wrapped values).**                                                                           |                                                             |
 | `juliacall.AnyValue`                                                                                         | `Any`                                                       |
-| `juliacall.As`                                                                                               | `Any`                                                       |
 | **Very high priority (arrays).**                                                                             |                                                             |
 | Objects satisfying the buffer or array interface (inc. `bytes`, `bytearray`, `array.array`, `numpy.ndarray`) | `PyArray`                                                   |
 | **High priority (canonical conversions).**                                                                   |                                                             |

docs/src/juliacall.md

@@ -89,27 +89,15 @@ See [JuliaPkg](https://github.com/cjdoris/PyJuliaPkg) for more details.
 ## Utilities
 
 `````@customdoc
-juliacall.using - Function
+juliacall.convert - Function
 
 ```python
-using(globals, module, attrs=None, prefix='jl', rename=None)
+convert(T, x)
 ```
 
-Import the Julia `module` into `globals`.
+Convert `x` to a Julia object of type `T`.
 
-If `attrs` is given, the given attributes are imported from the module instead of the
-module itself. It may be a list of strings or a space-separated string.
-
-Each item imported is renamed before being added to `globals`. By default a `prefix` is
-added. You more generally supply a `rename` function which maps a string to a string.
-
-In the following example we import some items from `Base` to do some vector operations:
-```python
-juliacall.using(locals(), 'Base', 'Vector Int push! pop!', rename=lambda x:'jl'+x.replace('!',''))
-x = jlVector[jlInt]()
-jlpush(x, 1, 2, 3)
-jlpop(x)  # 3
-```
+You can use this to pass an argument to a Julia function of a specific type.
 `````
 
 `````@customdoc
@@ -121,13 +109,3 @@ newmodule(name)
 
 A new module with the given name.
 `````
-
-`````@customdoc
-juliacall.As - Class
-
-```python
-As(x, T)
-```
-
-When passed as an argument to a Julia function, is interpreted as `x` converted to Julia type `T`.
-`````

docs/src/releasenotes.md

@@ -1,13 +1,15 @@
 # Release Notes
 
-## v0.7.0 (2022-03-17)
+## v0.7.1 (2022-03-17)
 * **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 `:`.
 * A pandas `<NA>` value is now converted to `missing`.
 * A `NaN` in a `PyPandasDataFrame` is converted to `missing`.
+* **Breaking:** Removes `using` and `As` from JuliaCall.
+* Adds `convert` to JuliaCall (replacing `As`).
 * Bug fixes.
 
 ## v0.6.1 (2022-02-21)

python/juliacall/__init__.py

@@ -7,50 +7,14 @@ def newmodule(name):
     "A new module with the given name."
     return Base.Module(Base.Symbol(name))
 
-def using(globals, module, attrs=None, prefix='jl', rename=None):
-    """Import a module into globals.
-
-    Args:
-        globals: A dict to import into (usually 'locals()').
-        module: The name of the module to import.
-        attrs: If given, import these attributes from the module instead of
-            the module itself. A list of strings or a space-separated string.
-        prefix: A prefix added to the name of each imported item.
-        rename: If given, a function mapping names to the name assigned in globals.
-    """
-    # rename
-    if rename is None:
-        rename = lambda name: prefix + name
-    # import the module
-    path = module.split('.')
-    mname = path[0]
-    if mname == 'Base':
-        module = Base
-    elif mname == 'Core':
-        module = Core
-    elif mname == 'Main':
-        module = Main
-    else:
-        module = Base.require(Base.Main, Base.Symbol(mname))
-    for attr in path[1:]:
-        module = Base.getproperty(module, Base.Symbol(attr))
-    # export
-    if attrs is None:
-        globals[rename(path[-1])] = module
-    else:
-        if isinstance(attrs, str):
-            attrs = attrs.split()
-        for attr in attrs:
-            globals[rename(attr)] = getattr(module, attr)
-
-class As:
-    "Interpret 'value' as type 'type' when converting to Julia."
-    __slots__ = ("value", "type")
-    def __init__(self, value, type):
-        self.value = value
-        self.type = type
-    def __repr__(self):
-        return "juliacall.As({!r}, {!r})".format(self.value, self.type)
+_convert = None
+
+def convert(T, x):
+    "Convert x to a Julia T."
+    global _convert
+    if _convert is None:
+        _convert = PythonCall.seval("pyjlcallback((T,x)->pyjl(pyconvert(pyjlvalue(T)::Type,x)))")
+    return _convert(T, x)
 
 class JuliaError(Exception):
     "An error arising in Julia code."

python/juliacall/juliapkg.json

@@ -3,7 +3,9 @@
     "packages": {
         "PythonCall": {
             "uuid": "6099a3de-0909-46bc-b1f4-468b9a2dfc0d",
-            "version": "0.7.0"
+            "version": "0.7.0",
+            "dev": true,
+            "path": "../.."
         }
     }
 }

src/convert.jl

@@ -403,7 +403,6 @@ function init_pyconvert()
     push!(PYCONVERT_EXTRATYPES, pyimport("collections.abc" => ("Iterable", "Sequence", "Set", "Mapping"))...)
 
     priority = PYCONVERT_PRIORITY_WRAP
-    pyconvert_add_rule("juliacall:As", Any, pyconvert_rule_jlas, priority)
     pyconvert_add_rule("juliacall:ValueBase", Any, pyconvert_rule_jlvalue, priority)
 
     priority = PYCONVERT_PRIORITY_ARRAY

src/jlwrap/callback.jl

@@ -12,7 +12,15 @@ function pyjlcallback_call(self, args_::Py, kwargs_::Py)
         Py(self(args...; kwargs...))
     elseif pylen(args_) > 0
         args = pyconvert(Vector{Py}, args_)
-        Py(self(args...))
+        if length(args) == 1
+            Py(self(args[1]))
+        elseif length(args) == 2
+            Py(self(args[1], args[2]))
+        elseif length(args) == 3
+            Py(self(args[1], args[2], args[3]))
+        else
+            Py(self(args...))
+        end
     else
         Py(self())
     end

src/juliacall.jl

@@ -36,29 +36,7 @@ function init_juliacall_2()
     jl.Core = Core
     jl.Base = Base
     jl.Pkg = Pkg
+    jl.PythonCall = PythonCall
     pycopy!(pyJuliaError, jl.JuliaError)
     C.POINTERS.PyExc_JuliaError = incref(getptr(pyJuliaError))
 end
-
-function pyconvert_rule_jlas(::Type{T}, x::Py) where {T}
-    # get the type
-    t = x.type
-    if !pyisjl(t)
-        pydel!(t)
-        return pyconvert_unconverted()
-    end
-    S = _pyjl_getvalue(t)
-    pydel!(t)
-    S isa Type || return pyconvert_unconverted()
-    # convert x.value to S, then to T
-    v = x.value
-    r = pytryconvert(S, v)
-    pydel!(v)
-    if pyconvert_isunconverted(r)
-        return pyconvert_unconverted()
-    elseif T == Any || S <: T
-        return r
-    else
-        return pyconvert_tryconvert(T, pyconvert_result(r))
-    end
-end