adds PYCALL option

Author: Christopher Doris

docs/src/getting-started.md

@@ -38,10 +38,15 @@ packages can always `import juliacall`.
 
 If Julia and Python are in your PATH, then no further set-up is required.
 Otherwise, the following environment variables control how the package finds these.
-- `JULIA_PYTHONCALL_EXE`: Path to the Python executable. Or the special value `CONDA` which uses
-  Python from the default conda environment, or `CONDA:{env}` to use the given environment.
-  In this case, if `conda` is not detected then `Conda.jl` will automatically install
-  [`miniconda`](https://docs.conda.io/en/latest/miniconda.html) in your Julia depot.
+- `JULIA_PYTHONCALL_EXE`: Path to the Python executable. Or one of the following special
+  values:
+  - `CONDA`: Use Python from the default conda environment. In this case, if `conda` is not
+    detected then `Conda.jl` will automatically install
+    [`miniconda`](https://docs.conda.io/en/latest/miniconda.html) in your Julia depot.
+  - `CONDA:{env}`: Use Python from the given conda environment. Also automatically installs
+    miniconda.
+  - `PYCALL`: Import [`PyCall`](https://github.com/JuliaPy/PyCall.jl) and use whichever
+    Python that uses.
 - `JULIA_PYTHONCALL_LIB`: Path to the Python library. Normally this is inferred from the Python
   executable, but can be over-ridden.
 - `PYTHON_JULIACALL_EXE`: Path to the Julia executable.

docs/src/pycall.md

@@ -1,6 +1,11 @@
 # Comparison to PyCall
 
-The existing package [`PyCall`](https://github.com/JuliaPy/PyCall.jl) is another similar interface to Python. Here is a comparison of the designs:
+The existing package [`PyCall`](https://github.com/JuliaPy/PyCall.jl) is another similar interface to Python.
+
+You can use both `PythonCall` and `PyCall` in the same session, provided they are both using the same Python library.
+One way to ensure this is to set `JULIA_PYTHONCALL_EXE=PYCALL` (see [Environment variables](@ref)).
+
+Here is a comparison of the designs:
 - **Flexibility of conversion.** The mechanisms for data conversion from Python to Julia are different. In `PyCall`, conversion to `T` (via `convert(T,::PyObject)`) essentially only takes `T` into account, so for example when `T=Real` then the input will always be converted to a Python `float`, which is then converted to a `Cdouble`. In `PythonCall`, conversion takes into account both the target type `T` and the Python type of the Python object, and an extensible system allows one to declare conversions for any combination. Many conversions for overlapping combinations can be defined and the most specific one takes precedence. Hence in `PythonCall`, converting to a `Real` might return an `Int` (e.g. the input is a `int`), or `Cdouble` (e.g. the input is `float`), or `Rational{BigInt}`, or...
 - **Lossiness of conversion from Python.** In `PyCall`, the default `PyAny` conversion from Python to Julia can be lossy in the sense that it is impossible to recover the original value exactly. For example a list of ints is converted to a `Vector{Int}` which is a copy of the data, and therefore modifying the original list is not possible. It is also a source of off-by-one errors, since `Vector` and `list` have different indexing semantics. In `PythonCall`, the default conversion is to `PyObject` (non-lossy), and even if you convert to `Any` then by default this will be non-lossy: for example a `list` will be converted to a `PyList` which is a `Vector`-like view of the list.
 - **Lossiness of conversion to Python.** Similarly, in `PyCall` the default conversion from Julia to Python can be lossy: a `Vector{Int}` will be converted to a `list` of `int`s for example, losing mutability of the original vector. In `PythonCall`, only immutable values are truly converted to Python, everything else is wrapped into a Python wrapper around the Julia value: a `Vector{Int}` is wrapped into a `juliacall.VectorValue` which is a `list`-like sequence type

src/init.jl

@@ -1,3 +1,6 @@
+const PYCALL_UUID = Base.UUID("438e738f-606a-5dbb-bf0a-cddfbfd45ab0")
+const PYCALL_PKGID = Base.PkgId(PYCALL_UUID, "PyCall")
+
 check_libpath(PyCall) = begin
     if realpath(PyCall.libpython) == realpath(CONFIG.libpath)
         # @info "libpython path agrees between PythonCall and PyCall" PythonCall.CONFIG.libpath PyCall.libpython
@@ -16,6 +19,23 @@ end
         # Check Python is initialized
         C.Py_IsInitialized() == 0 && error("Python is not already initialized.")
         CONFIG.isinitialized = CONFIG.preinitialized = true
+    elseif get(ENV, "JULIA_PYTHONCALL_EXE", "") == "PYCALL"
+        # Import PyCall and use its choices for libpython
+        PyCall = get(Base.loaded_modules, PYCALL_PKGID, nothing)
+        if PyCall === nothing
+            PyCall = Base.require(PYCALL_PKGID)
+        end
+        CONFIG.exepath = PyCall.python
+        CONFIG.libpath = PyCall.libpython
+        CONFIG.libptr = dlopen_e(CONFIG.libpath, CONFIG.dlopenflags)
+        if CONFIG.libptr == C_NULL
+            error("Python library $(repr(CONFIG.libpath)) (from PyCall) could not be opened.")
+        end
+        CONFIG.pyprogname = PyCall.pyprogramname
+        CONFIG.pyhome = PyCall.PYTHONHOME
+        # Check Python is initialized
+        C.Py_IsInitialized() == 0 && error("Python is not already initialized.")
+        CONFIG.isinitialized = CONFIG.preinitialized = true
     else
         # Find Python executable
         exepath = something(
@@ -52,7 +72,7 @@ end
 
                 Ensure either:
                 - python3 or python is in your PATH
-                - JULIA_PYTHONCALL_EXE is "CONDA" or "CONDA:<env>"
+                - JULIA_PYTHONCALL_EXE is "CONDA", "CONDA:<env>" or "PYCALL"
                 - JULIA_PYTHONCALL_EXE is the path to the Python executable
                 """)
         end
@@ -96,7 +116,7 @@ end
         end
 
         # Compare libpath with PyCall
-        PyCall = get(Base.loaded_modules, Base.PkgId(Base.UUID("438e738f-606a-5dbb-bf0a-cddfbfd45ab0"), "PyCall"), nothing)
+        PyCall = get(Base.loaded_modules, PYCALL_PKGID, nothing)
         if PyCall === nothing
             @require PyCall="438e738f-606a-5dbb-bf0a-cddfbfd45ab0" check_libpath(PyCall)
         else