Merge branch 'master' into patch-1

Author: helgee

.github/workflows/tests.yml

@@ -54,7 +54,7 @@ jobs:
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
         env:
-          JULIA_DEBUG: Python
+          JULIA_DEBUG: PythonCall
       - uses: julia-actions/julia-processcoverage@v1
       - uses: codecov/codecov-action@v1
         with:
@@ -88,8 +88,8 @@ jobs:
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
         env:
-          JULIA_DEBUG: Python
-          PYTHONJL_EXE: CONDA
+          JULIA_DEBUG: PythonCall
+          JULIA_PYTHONCALL_EXE: CONDA
       - uses: julia-actions/julia-processcoverage@v1
       - uses: codecov/codecov-action@v1
         with:
@@ -111,8 +111,8 @@ jobs:
       - run: |
           julia --project=docs -e '
             using Documenter: doctest
-            using Python
-            doctest(Python)'
+            using PythonCall
+            doctest(PythonCall)'
       - run: julia --project=docs docs/make.jl
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Project.toml

@@ -1,4 +1,4 @@
-name = "Python"
+name = "PythonCall"
 uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"
 authors = ["Christopher Doris <github.com/cjdoris>"]
 version = "0.1.0"

README.md

@@ -1,9 +1,9 @@
-![Python.jl logo](https://raw.githubusercontent.com/cjdoris/Python.jl/master/logo-text.svg)
+![PythonCall.jl logo](https://raw.githubusercontent.com/cjdoris/PythonCall.jl/master/logo-text.svg)
 ---
-[![Stable Docs](https://img.shields.io/badge/docs-stable-blue.svg)](https://cjdoris.github.io/Python.jl/stable)
-[![Dev Docs](https://img.shields.io/badge/docs-dev-blue.svg)](https://cjdoris.github.io/Python.jl/dev)
-[![Test Status](https://github.com/cjdoris/Python.jl/workflows/Tests/badge.svg)](https://github.com/cjdoris/Python.jl/actions?query=workflow%3ATests)
-[![Codecov](https://codecov.io/gh/cjdoris/Python.jl/branch/master/graph/badge.svg?token=A813UUIHGS)](https://codecov.io/gh/cjdoris/Python.jl)
+[![Stable Docs](https://img.shields.io/badge/docs-stable-blue.svg)](https://cjdoris.github.io/PythonCall.jl/stable)
+[![Dev Docs](https://img.shields.io/badge/docs-dev-blue.svg)](https://cjdoris.github.io/PythonCall.jl/dev)
+[![Test Status](https://github.com/cjdoris/PythonCall.jl/workflows/Tests/badge.svg)](https://github.com/cjdoris/PythonCall.jl/actions?query=workflow%3ATests)
+[![Codecov](https://codecov.io/gh/cjdoris/PythonCall.jl/branch/master/graph/badge.svg?token=A813UUIHGS)](https://codecov.io/gh/cjdoris/PythonCall.jl)
 
 Bringing [**Python®**](https://www.python.org/) and [**Julia**](https://julialang.org/) together in seamless harmony:
 - Call Python code from Julia and Julia code from Python via a symmetric interface.
@@ -16,22 +16,22 @@ Bringing [**Python®**](https://www.python.org/) and [**Julia**](https://juliala
 
 ⭐ If you like this, a GitHub star would be lovely thank you. ⭐
 
-To get started, read the [documentation](https://cjdoris.github.io/Python.jl/stable).
+To get started, read the [documentation](https://cjdoris.github.io/PythonCall.jl/stable).
 
 ## Example 1: Calling Python from Julia
 
-In this example, we use `Python.jl` from an IJulia notebook to inspect the Iris dataset:
+In this example, we use `PythonCall.jl` from an IJulia notebook to inspect the Iris dataset:
 - We load the Iris dataset as a Julia `DataFrame` using `RDatasets.jl`.
 - We use `pypandasdataframe(df)` to convert it to a Python `pandas.DataFrame`.
 - We use the Python package `seaborn` to produce a pair-plot, which is automatically displayed.
 
-![Seaborn example screenshot](https://raw.githubusercontent.com/cjdoris/Python.jl/master/examples/seaborn.png)
+![Seaborn example screenshot](https://raw.githubusercontent.com/cjdoris/PythonCall.jl/master/examples/seaborn.png)
 
 ## Example 2: Calling Julia from Python
 
-In this example we use the Python module `juliaaa` from an IPython notebook to train a simple neural network:
+In this example we use the Python module `juliacall` from an IPython notebook to train a simple neural network:
 - We generate some random training data using Python's `numpy`.
 - We construct and train a neural network model using Julia' `Flux`.
 - We plot some sample output from the model using Python's `matplotlib.pyplot`.
 
-![Flux example screenshot](https://raw.githubusercontent.com/cjdoris/Python.jl/master/examples/flux.png)
+![Flux example screenshot](https://raw.githubusercontent.com/cjdoris/PythonCall.jl/master/examples/flux.png)

docs/Project.toml

@@ -1,3 +1,3 @@
 [deps]
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
-Python = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"
+PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"

docs/make.jl

@@ -1,5 +1,18 @@
-using Documenter, Python, Markdown
+using Documenter, PythonCall, Markdown
 
+# This is a bit of a hack to let us insert documentation blocks with custom content.
+# It means we can document Python things directly in the documentation source, and they
+# are searchable.
+#
+# It's a hack because of the `doccat` overload, requiring a special kind of "signature"
+# to embed the information we want.
+#
+# The first line is of the form "name - category", the rest is Markdown documentation.
+# For example:
+# ```@customdoc
+# foo - Function
+# Documentation for `foo`.
+# ```
 struct CustomCat{cat} end
 Documenter.Utilities.doccat(::Base.Docs.Binding, ::Type{CustomCat{cat}}) where {cat} = string(cat)
 struct CustomDocBlocks <: Documenter.Expanders.ExpanderPipeline end
@@ -18,19 +31,19 @@ Documenter.Expanders.Selectors.runner(::Type{CustomDocBlocks}, x, page, doc) = b
 end
 
 makedocs(
-    sitename = "Python.jl",
-    modules = [Python],
+    sitename = "PythonCall.jl",
+    modules = [PythonCall],
     pages = [
         "Home" => "index.md",
         "getting-started.md",
-        "pythonjl.md",
-        "juliapy.md",
+        "pythoncall.md",
+        "juliacall.md",
         "conversion.md",
         "compat.md",
         "pycall.md",
     ]
 )
 
 deploydocs(
-    repo = "github.com/cjdoris/Python.jl.git",
+    repo = "github.com/cjdoris/PythonCall.jl.git",
 )

docs/src/compat.md

@@ -6,7 +6,7 @@ Some of these are "fixes" that are silently applied for you, and some are just e
 
 ## Stdlib
 
-Whenever a Python exception is displayed by Julia, `sys.last_traceback` and friends are set. This allows the post-mortem debugger `pdb.pm()` to work. Disable by setting `Python.CONFIG.sysautolasttraceback = false`.
+Whenever a Python exception is displayed by Julia, `sys.last_traceback` and friends are set. This allows the post-mortem debugger `pdb.pm()` to work. Disable by setting `PythonCall.CONFIG.sysautolasttraceback = false`.
 
 ## Tabular data & Pandas
 
@@ -26,7 +26,7 @@ pypandasdataframe
 pyplotshow
 ```
 
-If Julia is running an IJulia kernel, `pyplotshow()` is automatically called after executing a cell, so that plots generated in a cell are always shown (similar to IPython). It can be disabled by setting `Python.CONFIG.pyplotautoshow = false`.
+If Julia is running an IJulia kernel, `pyplotshow()` is automatically called after executing a cell, so that plots generated in a cell are always shown (similar to IPython). It can be disabled by setting `PythonCall.CONFIG.pyplotautoshow = false`.
 
 ## GUIs (including MatPlotLib)
 
@@ -35,8 +35,8 @@ If Julia is running an IJulia kernel, `pyplotshow()` is automatically called aft
 If for example you wish to use PyPlot in interactive mode (`matplotlib.pyplot.ion()`) then activating the correct event loop will allow it to work.
 
 ```@docs
-Python.event_loop_on
-Python.event_loop_off
+PythonCall.event_loop_on
+PythonCall.event_loop_off
 ```
 
 ### Interaction
@@ -50,7 +50,7 @@ pyinteract
 ### Qt path fix
 
 ```@docs
-Python.fix_qt_plugin_path
+PythonCall.fix_qt_plugin_path
 ```
 
 ## IPython

docs/src/conversion.md

@@ -24,18 +24,18 @@ The user can always explicitly choose a different conversion (e.g. by calling `p
 | Standard integer range (`AbstractRange{T}`, `T` a standard integer) | `range`                                             |
 | `Date`, `Time`, `DateTime` (from `Dates`)                           | `date`, `time`, `datetime` (from `datetime`)        |
 | `Second`, `Millisecond`, `Microsecond`, `Nanosecond` (from `Dates`) | `timedelta` (from `datetime`)                       |
-| `Number`                                                            | `juliaaa.NumberValue`, `juliaaa.ComplexValue`, etc. |
-| `AbstractArray`                                                     | `juliaaa.ArrayValue`, `juliaaa.VectorValue`         |
-| `AbstractDict`                                                      | `juliaaa.DictValue`                                 |
-| `AbstractSet`                                                       | `juliaaa.SetValue`                                  |
-| `IO`                                                                | `juliaaa.BufferedIOValue`                           |
-| `Module`                                                            | `juliaaa.ModuleValue`                               |
-| `Type`                                                              | `juliaaa.TypeValue`                                 |
-| Anything else                                                       | `juliaaa.AnyValue`                                  |
+| `Number`                                                            | `juliacall.NumberValue`, `juliacall.ComplexValue`, etc. |
+| `AbstractArray`                                                     | `juliacall.ArrayValue`, `juliacall.VectorValue`         |
+| `AbstractDict`                                                      | `juliacall.DictValue`                                 |
+| `AbstractSet`                                                       | `juliacall.SetValue`                                  |
+| `IO`                                                                | `juliacall.BufferedIOValue`                           |
+| `Module`                                                            | `juliacall.ModuleValue`                               |
+| `Type`                                                              | `juliacall.TypeValue`                                 |
+| Anything else                                                       | `juliacall.AnyValue`                                  |
 
-The `juliaaa.*Value` types are all subtypes of `juliaaa.AnyValue`. They wrap a Julia value, providing access to Julia semantics: it can be called, indexed, and so on. Subtypes add additional Pythonic semantics. Read more [here](@ref julia-wrappers).
+The `juliacall.*Value` types are all subtypes of `juliacall.AnyValue`. They wrap a Julia value, providing access to Julia semantics: it can be called, indexed, and so on. Subtypes add additional Pythonic semantics. Read more [here](@ref julia-wrappers).
 
-This conversion policy is defined/implemented by `Python.C.PyObject_From` and `Python.C.PyJuliaValue_From`. Package authors can (carefully) overload these with additional rules for custom types.
+This conversion policy is defined/implemented by `PythonCall.C.PyObject_From` and `PythonCall.C.PyJuliaValue_From`. Package authors can (carefully) overload these with additional rules for custom types.
 
 ## [Python to Julia](@id py2jl)
 
@@ -54,7 +54,7 @@ The following table specifies the conversion rules in place. If the initial Pyth
 | From                                                                                                         | To                                                          |
 | :----------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------- |
 | **Top priority (wrapped values).**                                                                           |                                                             |
-| `juliaaa.AnyValue`                                                                                           | `Any`                                                       |
+| `juliacall.AnyValue`                                                                                           | `Any`                                                       |
 | **Very high priority (arrays).**                                                                             |                                                             |
 | Objects satisfying the buffer or array interface (inc. `bytes`, `bytearray`, `array.array`, `numpy.ndarray`) | `PyArray`                                                   |
 | **High priority (canonical conversions).**                                                                   |                                                             |
@@ -96,4 +96,4 @@ The following table specifies the conversion rules in place. If the initial Pyth
 | Objects satisfying the buffer interface                                                                      | `PyBuffer`                                                  |
 | Anything                                                                                                     | `PyRef`                                                     |
 
-Package authors can (carefully) add extra rules by calling `Python.C.PyObject_TryConvert_AddRule` in `__init__`.
+Package authors can (carefully) add extra rules by calling `PythonCall.C.PyObject_TryConvert_AddRule` in `__init__`.

docs/src/getting-started.md

@@ -2,46 +2,48 @@
 
 ## You will need
 
-* Julia 1.0 or higher.
-* Python 3.5 or higher.
+* Julia 1.0 or higher — download [here](https://julialang.org/downloads).
+* Python 3.5 or higher — download [here](https://www.python.org/downloads) or set `JULIA_PYTHONCALL_EXE=CONDA` (see below).
 
-## Install the Julia package
+## Install the Julia package `PythonCall`
 
 ```julia
 using Pkg
-pkg"add Python"
+pkg"add PythonCall"
 ```
 
-## Install the Python package (optional)
+## Install the Python package `juliacall` (optional)
 
 This step is only required if you wish to call Julia from Python.
 
-Currently the Python package `juliaaa` is shipped with the source of the Julia package, and must be
+Currently `juliacall` is shipped with the source of the Julia package, and must be
 pip-installed manually. The following should work in most shells (including PowerShell):
 
 ```bash
-pip install --upgrade $(julia -e "using Python; print(dirname(dirname(pathof(Python))))")
+pip install $(julia -e "using PythonCall; print(PythonCall.juliacall_pipdir)")
 ```
 
-The package has no dependencies, so you can also just copy it to somewhere in your PYTHONPATH.
+Alternatively you can just copy the package (at `PythonCall.juliacall_dir`) to somewhere in your PYTHONPATH.
 
-Note that this is a [very small](https://github.com/cjdoris/Python.jl/blob/master/juliaaa/__init__.py)
+Note that this is a [very small](https://github.com/cjdoris/PythonCall.jl/blob/master/juliacall/__init__.py)
 "bootstrap" package whose sole job is to locate and load Julia; the main functionality is in
-the main Julia package. Hence it is not necessary to upgrage `juliaaa` every time
-you upgrade `Python`.
+the main Julia package. Hence it is not necessary to upgrage `juliacall` every time
+you upgrade `PythonCall`.
 
-Note also that regardless of installing `juliaaa`, a module called `juliaaa` will
-always be loaded into the interpreter by `Python`. This means that other Python
-packages can always `import juliaaa`.
+Note also that regardless of installing `juliacall`, a module called `juliacall` will
+always be loaded into the interpreter by `PythonCall`. This means that other Python
+packages can always `import juliacall`.
 
 ## Environment variables
 
 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.
-- `PYTHONJL_EXE`: Path to the Python executable. Or the special value `CONDA` which uses
+- `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.
-- `PYTHONJL_LIB`: Path to the Python library. Normally this is inferred from the Python
+  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_LIB`: Path to the Python library. Normally this is inferred from the Python
   executable, but can be over-ridden.
-- `JULIAPY_EXE`: Path to the Julia executable.
-- `JULIAPY_LIB`: Path to the Julia library. Normally this is inferred from the Julia
+- `PYTHON_JULIACALL_EXE`: Path to the Julia executable.
+- `PYTHON_JULIACALL_LIB`: Path to the Julia library. Normally this is inferred from the Julia
   executable, but can be over-ridden.

docs/src/index.md

@@ -1,4 +1,4 @@
-# Python.jl
+# PythonCall.jl
 
 Bringing [**Python®**](https://www.python.org/) and [**Julia**](https://julialang.org/) together in seamless harmony:
 - Call Python code from Julia and Julia code from Python via a symmetric interface.
@@ -9,4 +9,4 @@ Bringing [**Python®**](https://www.python.org/) and [**Julia**](https://juliala
 - Beautiful stack-traces.
 - Works anywhere: tested on Windows, MacOS and Linux, 32- and 64-bit, Julia 1.0 upwards and Python 3.5 upwards.
 
-This is actually two modules working in harmony: a Julia one called `Python` and a [tiny](https://github.com/cjdoris/Python.jl/blob/master/juliaaa/__init__.py) Python one called `juliaaa`.
+This is actually two modules working together: a Julia one called `PythonCall` and a [tiny](https://github.com/cjdoris/PythonCall.jl/blob/master/juliacall/__init__.py) Python one called `juliacall`.