                     Changes in version 1.47.0.9000                     

  - Fixed an error while formatting a long Python exception message. A
    message whose first two lines already exceeded
    getOption("warning.length") made the truncation index past the end
    of the string, so the R error became basic_string::substr: __pos >
    this->size() instead of the Python message. A SyntaxError raised
    over a long source line hit this reliably.

  - Fixed KeyError: '__annotations__' when starting a reticulate Python
    console in Positron with Python 3.14 (#1930).

  - Fixed a hang (Linux) or crash (macOS) when another Python error was
    formatted while reticulate was still formatting the first Python
    error of the session, for example by RStudio listing Python objects
    in the Environment pane as the Python REPL started (#1935).

                 Changes in version 1.47.0 (2026-09-03)                 

Python requirements and environments

  - py_require() now applies late package additions atomically. Failed
    package-originated additions warn without changing the declared
    requirements. Its printed summary now shows successful requirement
    requests in chronological order, including their source and action.

  - py_require() and uv_run_tool() now accept Date and POSIXt objects
    for exclude_newer.

  - py_require() now updates sys.executable and an already-loaded
    multiprocessing launcher after a live activation, so child Python
    processes can import newly added packages.

  - RETICULATE_MAX_CACHE_AGE_DAYS can now configure the maximum age, in
    days, of reticulate's managed uv cache before it is cleared (#1905).

  - Managed uv bootstrapping now works on Windows when R inherits a
    PowerShell 7 PSModulePath, such as from GitHub Actions pwsh steps.

  - Pipenv interpreter discovery now uses a located Pipfile even when
    here cannot resolve a project root (#1909).

  - Reticulate now treats projects with a pyproject.toml but no
    [tool.poetry] section, such as uv or PEP 621 projects, as non-Poetry
    projects (#1900).

  - Reticulate now retains an expired managed uv cache when it cannot
    download the installer needed to replace it (#1876).

Conversion

  - py_to_r() now converts pandas data frames and series containing
    Arrow-backed string columns (#1910).

  - r_to_py() now preserves explicit integer row names as the index when
    converting an R data frame to a pandas data frame (#1924).

Other improvements and fixes

  - Child processes created by os.fork() now use Python's original
    output streams when output remapping is enabled.

  - Python calls to R now convert base R's built-in abort restart to a
    Python exception instead of jumping to R's top level.

  - Reticulate now builds with Clang 21 without a spurious -Wnonnull
    compiler warning (#1917).

Documentation

  - The py_require() documentation now explains how R_USER_CACHE_DIR
    configures the location of reticulate's managed uv cache (#1899).

                 Changes in version 1.46.0 (2026-04-09)                 

  - Internal updates to avoid R_NamespaceRegistry and R_UnboundValue in
    compiled code on R-devel (4.6) (#1894).

  - Internal updates to remove Rf_findVar* calls in compiled code on
    R-devel (4.6) (#1892).

  - Internal updates for Rcpp compatibility around Rf_error handling
    (#1887).

  - Fixed py_list_packages() for uv-managed environments. (#1890, #1891)

                 Changes in version 1.45.0 (2026-02-13)                 

New features

  - Positron now supports F1 help for reticulate Python objects (#1866).

  - Reticulate now supports pandas 3.0 (#1874, #1875).

  - py_require() now allows action = "add" for already-required packages
    after Python initialization, while still erroring on true version
    conflicts (@JBGruber, #1872, #1878).

  - py_to_r() now converts direct pandas categorical objects (for
    example, pd$Categorical(...)) for pandas 2.x and 3.x (#1883).

Minor improvements and fixes

  - Positron now handles reticulate-backed UI actions, such as
    restarting or creating a new session, more reliably (#1869, #1871).

  - Reticulate now avoids spurious Error: ignoring SIGPIPE signal
    messages on Unix when embedded Python writes to a closed pipe
    (#1868).

  - Reticulate no longer triggers a CRAN NOTE on R-devel (4.6) for
    relative vignette URLs (#1882).

  - virtualenv_starter() now excludes free-threaded CPython builds,
    which are not supported by reticulate (#1883).

                 Changes in version 1.44.1 (2025-11-14)                 

  - The default Python version in install_python() and conda_create() is
    now 3.12 (#1862).

  - Fix error in virtualenv_create()/virtualenv_starter() (#1861).

  - Fix display of Python variables in the Positron Variables Pane
    (#1859).

                 Changes in version 1.44.0 (2025-10-25)                 

  - Reticulate now clears its cache automatically every 120 days.
    Configure the interval in .Rprofile with:
    options(reticulate.max_cache_age = as.difftime(30, units = "days")).

  - install_miniconda() now installs miniforge instead of miniconda
    (#1800, #1820).

  - New helpers for reading and writing requirements files,
    py_write_requirements() and py_read_requirements() (#1846).

  - Adds support for requesting Python versions with a wildcard pattern
    x.x.* such as ==3.12.* in virtualenv_starter(), py_require(), and
    related functions (#1825)

  - Restored compatability with uv versions >= 0.8.0 (#1818).

  - virtualenv_starter() now discovers Python installations managed by
    external uv installations (#1849).

  - py_require() now gives a better message when a user erroneously
    declares a module from the Python standard library as a required
    package (@lazappi, #1788)

  - Positron's reticulate integration will now be automatically enabled
    when the reticulate package is loaded in Positron (#1822).

  - with() now forwards errors to Python context manager exit handlers
    (e.g., so database transactions can roll back cleanly) (#1840,
    #1841)

  - Fixed !! in string literals being wrongly expanded to a %system
    magic in repl_python(). Added support for assigning %system command
    output to multiple variables via unpacking (#1844).

  - reticulate now warns when py_require()d packages are not found in
    the selected Python virtual environment. This behavior can be
    disabled by setting the environment variable
    RETICULATE_CHECK_REQUIRED_PACKAGES=0 (#1850).

                 Changes in version 1.43.0 (2025-07-21)                 

  - Fixed usage of micromamba and mamba, next-generation conda
    environment management tools. reticulate now prefers to use
    micromamba, mamba, then conda when managing environments (@gdevenyi,
    #1771).

  - Added str(), dim(), and t() S3 methods for NumPy Arrays.

  - Fixed a segfault observed on R session exit (#1785, #1786).

  - Added check in install_miniconda() if existing files will be
    overwritten. (#1794, #1796)

  - Fixed error in install_python() under R 4.5 when the requested
    Python version has a ":latest" suffix, as it does by default.
    (#1792, #1797)

  - Fixed error in get_python_conda_info() when conda not found through
    conda-meta/history and NULL is passed to normalizePath (#1184)

  - Hotfix to pin uv version resolved by reticulate to <0.8.0. (#1812)

  - Python discovery by uv is much faster now. The internal utility
    uv_python_list() searches only for managed python environments by
    default. Users can request discovery of system pythons by setting
    UV_PYTHON_PREFERENCE. Also, uv_python_list() will now discover pyenv
    pythons and python binaries installed by install_python() if a
    system python is requested. (#1810)

                 Changes in version 1.42.0 (2025-03-25)                 

  - Fixed an issue in RStudio on Windows where interrupts were ignored
    while Python code was executing (#1753).

  - Updates for Positron to fix issues with repl_python() and Variables
    Pane (#1755).

  - Fixed an issue where [ received Python objects as slice arguments.
    e.g., x[start:end] when start or end were Python objects (#1731).

  - The [ method will now translate symbol .. to a Python Ellipsis ....
    (#1763)

  - The [ method can now accept index values greater than 2^31 (#1769)

  - Reticulate-managed uv can now resolve system-installed Pythons,
    supporting platforms where pre-built binaries are unavailable, such
    as musl-based Alpine Linux (#1751, #1752).

  - uv_run_tool() gains an exclude_newer argument (#1748).

  - py_register_load_hook() is now exported to enable usage described in
    the "Using reticulate in an R package vignette" (#1754).
    https://rstudio.github.io/reticulate/articles/package.html

  - Internal changes to support R-devel (4.5) and R API updates (#1747,
    #1774).

  - Internal fixes to prevent reticulate-managed uv from writing outside
    reticulates cache directory (#1745).

  - Fixed an issue with pointing reticulate at a pyenv shim python
    (#1758)

                 Changes in version 1.41.0 (2025-02-24)                 

  - New py_require() function for declaring Python requirements for the
    current R session. For details, see updated vignettes and help:
    
      - Installing Python Packages:
        https://rstudio.github.io/reticulate/dev/articles/python_packages.html
      - Using reticulate in an R Package:
        https://rstudio.github.io/reticulate/dev/articles/package.html
      - py_require() help:
        https://rstudio.github.io/reticulate/dev/reference/py_require.html

  - New uv_run_tool() function for running command line tools
    distributed via Python packages.

  - Raw R arrays and NumPy arrays with dtype "V1" ("void8") now convert
    between each other. Use r_to_py(as.array(x)) to efficiently convert
    raw vectors to NumPy arrays, and py_to_r(array$view("V1")) to
    efficiently convert NumPy arrays to raw vectors. (#1734)

  - Fixed an issue with using Python 3.12 on Linux (#1712, #1714).

  - Fixed an issue where virtualenv_starter() would not discover a
    custom built Python (#1704).

                 Changes in version 1.40.0 (2024-11-15)                 

  - The S3 classes for some (rarely encountered) Python objects have
    changed. Only Python objects with non-standard __module__ values are
    affected. If a Python object’s parent class’s __module__ attribute
    does not resolve to a string, reticulate:
    
      - Attempts to resolve it from the class's class, if it's a
        metaclass.
      - If no string can be resolved, reticulate no longer implicitly
        prepends 'python.builtin.' as the class prefix, instead it uses
        just the __name__. (See #1686 for more context)

  - Added support for Python 3.13. Note that Python 3.13 removed support
    for classmethod descriptors, which may affect the S3 class of some
    Python objects that use metaclass properties to resolve a class’s
    __module__ or __name__ attribute. (#1686, #1698)

  - py_is_null_xptr() and [[ now load delayed modules (#1688).

  - Fixed error when attempting to use a python venv created with uv
    (#1678)

  - Resolved an issue where py_discover_config() attempted to detect
    Windows App Store Python installations. These are now excluded from
    discovery by both py_discover_config() and virtualenv_starter()
    (#1656, #1673).

  - Fixed an error when converting an empty NumPy char array to R
    (#1662).

  - Fixed an error when using reticulate with radian (#1668, #1670).

  - Fixed a segfault encountered when running the Python session
    finalizer (#1663, #1664).

  - Resolved a segfault in RStudio when rapidly switching between R and
    Python chunks in a Quarto document (#1665).

  - Improved behavior when the conda binary used to create an
    environment cannot be resolved (contributed by @tl-hbk, #1654,
    #1659).

  - Added Positron support for the Variables Pane and repl_python()
    (#1692, #1641, #1648, #1658, #1681, #1687).

                 Changes in version 1.39.0 (2024-09-05)                 

  - Python background threads can now run in parallel with the R session
    (#1641).

  - py_main_thread_func() is deprecated; every R function can now safely
    be called from background Python threads (#1648).

  - Calls from Python threads into R now notify the main thread using
    R's native event loop, ensuring that these calls are handled even
    when the main thread is engaged in non-Python tasks (#1648).

  - The knitr engine now avoids overwriting Altair's default chart
    dimensions with the values of ut.width.px and ut.height.px. Use
    altair.fig.height, altair.fig.width, or Altair's width and height
    parameters to adjust chart dimensions (contributed by @joelostblom,
    #1646).

  - New as.character() method for python.builtin.str with support for
    handling embedded NULs in strings (#1653).

  - New as.raw() method for python.builtin.bytes (#1649, #1652).

  - as.character() method for python.builtin.bytes gains a nul argument,
    allowing for convenient handling of embedded NULs in the string
    (#1652).

  - Reticulate now uses the RETICULATE_VIRTUALENV_ROOT environment
    variable when determining where to resolve virtual environments
    (#1657).

  - conda_run2() is now exported (contributed by @dramanica, #1637).

  - The Python session is now finalized when the R session exits
    (#1648).

  - Internal updates for NumPy 2.1 (#1651).

  - Fixed error when importing a module named config (#1628).

  - Fixes for CRAN check failures on macOS-oldrel (#1645).

  - Fixed an error where opening a Python subprocess in Positron on
    Windows resulted in "OSError: [WinError 6] The handle is invalid."
    (#1658, posit-dev/positron#4457).

                 Changes in version 1.38.0 (2024-06-19)                 

  - Python Exceptions converted to R conditions are now R lists instead
    of R environments, for compatability with {rlang} and {purrr}.
    (tidyverse/purrr#1104, r-lib/rlang#1664, #1617)

  - Internal updates for NumPy 2.0 (#1621)

  - Added support for converting NumPy StringDType arrays to R character
    arrays. (#1623)

  - Internal updates for compliance with R's upcoming formalized C API.
    (#1625)

  - Fixed an issue where attempting to convert a NumPy array with a
    non-simple dtype to R would signal an error. (#1613, fixed in
    #1614).

                 Changes in version 1.37.0 (2024-05-21)                 

  - Interrupting Python no longer leads to segfaults. (#1601, fixed in
    #1602)

  - Print method for Python callables now includes the callable’s
    signature. (#1605, #1607)

  - Reticulate now installs successfully on Windows ARM64. (#1609,
    contributed by @andrjohns)

  - virtualenv_starter() no longer warns when encountering broken
    symlinks. (#1598)

  - Fixed an issue where configuration for reticulate conda_* functions
    to use the executable mamba instead of conda was ignored. (#1608,
    contributed by @AlexandreGuinaudeau)

                 Changes in version 1.36.1 (2024-04-22)                 

  - Fix issue where py_to_r() method for Pandas DataFrames would error
    if py_to_r() S3 methods were defined for Pandas subtypes, (as done
    by {anndata}) (#1591).

  - "Python Dependencies" vignette edits (@salim-b, #1586)

  - Added an option for extra command-line arguments in conda_create()
    and conda_install() (#1585).

  - Fixed issue where conda_install() would ignore user-specified
    channels during Python installation (#1594).

                 Changes in version 1.36.0 (2024-04-15)                 

  - Internal refactoring and optimizations now give a faster experience,
    especially for workflows that frequently access Python objects from
    R. For example, simple attribute access like sys$path is ~2.5x times
    faster, and a sample workload of py_to_r(np_array(1:3) +
    np_array(1:3)) benchmarks ~3.5x faster when compared to the previous
    CRAN release.

  - Fixed issue where callable python objects created with convert =
    FALSE would not be wrapped in an R function (#1522).

  - Fixed issue where py_to_r() S3 methods would not be called on
    arguments supplied to R functions being called from Python (#1522).

  - install_python() will now build optimized versions of Python on
    macOS and Linux (#1567)

  - Default Python version installed by install_python() is now 3.10
    (was 3.9) (#1574).

  - Output of reticulate::py_last_error() now includes a hint, showing
    how to access the full R call stack (#1572).

  - Fixed an issue where nested py_capture_output() calls result in a
    lost reference to the original sys.stdout and sys.stderr, resulting
    in no further visible output from Python, and eventually, a
    segfault. (#1564)

  - Fixed issues reported by rchk, as requested by CRAN (#1581).

  - py_to_r(x) now returns x unmodified if x is not a Python object,
    instead of signaling an error.

  - New as.data.frame() method exported for Python Polars DataFrames
    (#1568)

  - Fixed an issue where printing a delayed module (import("foo",
    delay_load = TRUE)) would output <pointer: 0x0>.

  - py_validate_xptr() will now attempt to resolve delayed modules
    before signaling an error (#1561).

  - R packages can now express multiple preferred Python environments to
    search for and use if they exist, by supplying a character vector to
    import(): import("foo", delay_load = list(environment = c("r-foo",
    "r-bar"))) (#1559)

  - Reticulate will no longer warn about ignored use_python(,required =
    FALSE) calls (#1562).

  - reticulate now prefers using the agg matplotlib backend when the R
    session is non-interactive. The backend can also be overridden via
    the MPLBACKEND or RETICULATE_MPLBACKEND environment variables when
    necessary (#1556).

  - attr(x, "tzone") attributes are (better) preserved when converting
    POSIXt to Python. POSIXt types with a non-empty tzone attr convert
    to a datetime.datetime, otherwise they convert to NumPy
    datetime64[ns] arrays.

  - Fixed an issue where calling py_set_item() on a subclassed dict
    would not invoke a custom __setitem__ method.

  - py_del_attr(x, name) now returns x invisibly

  - source_python() no longer exports the r symbol to the R global
    environment. (the "R Interface Object" that is used by Python code
    get a reference to the R globalenv())

  - Fixed hang encountered (sometimes) when attempting to call iterate()
    on an exhausted py_iterator() object multiple times (#1539).

  - iterate(simplify=TRUE) rewritten in C for speed improvements
    (#1539).

  - Update for Pandas 2.2 deprecation of Index.format() (#1537, #1538).

  - Updates for CRAN R-devel (R 4.4) (#1554).

  - Fixed an issue where py_discover_config() would discover python (v2)
    on the PATH in preference of python3 on the PATH. (#1547)

  - Fixed an issue where reticulate would error when using conda
    environments created with the (new) conda env create command.
    (#1535, #1543)

  - Fixed an issue where reticulate would error when using a conda
    environment where the original conda binary that was used to create
    the environment is no longer available (#1555)

  - Fixed an issue where a user would be unable to accept the prompt to
    create the default "r-reticulate" venv (#1557).

  - is_py_object() is now exported (#1573).

                 Changes in version 1.35.0 (2024-01-31)                 

  - Subclassed Python list and dict objects are no longer automatically
    converted to R vectors. Additionally, the S3 R class attribute for
    Python objects is now constructed using the Python type(object)
    directly, rather than from the object.__class__ attribute. See #1531
    for details and context.

  - R external pointers (EXTPTRSXP objects) now round-trip through
    py_to_r(r_to_py(x)) successfully. (reported in #1511, fixed in
    #1519, contributed by @llaniewski).

  - Fixed issue where virtualenv_create() would error on Ubuntu 22.04
    when using the system python as a base. (#1495, fixed in #1496).

  - Fixed issue where csc_matrix objects with unsorted indices could not
    be converted to a dgCMatrix. (related to #727, fixed in #1524,
    contributed by @rcannood).

  - Added support for partially unexpanded variables like $USER in
    XDG_DATA_HOME and similar (#1513, #1514)

Knitr Python Engine Changes:

  - The knitr python engine now formats captured python exceptions to
    include the exception type and any exception notes when chunk
    options error = TRUE is set (reported in #1520, fixed in #1527).

  - Fixed an issue where the knitr python engine would fail to include
    figures from python chunks if a custom root.dir chunk option was
    set. (reported in #1526, fixed in #1529)

  - knitr engine gains the ability to save chunk figures in multiple
    files/formats (Contributed by @Rumengol in #1507)

  - Fixed an issue where matplotlib figures generated in the initial
    chunk where matplotlib was first imported would be the wrong size
    (reported in #1523, fixed in #1530)

  - Fixed an issue where the knitr engine would not correctly display
    altair compound charts if more than one were present in a document
    (#1500, #1532).

                 Changes in version 1.34.0 (2023-10-12)                 

                       Changes in version 1.33.0                        

  - Fixed issue where asyncio, (and modules that use asyncio), would
    error on Windows when running under RStudio (#1478, #1479).

  - Added compatability with Python 3.12.

  - condaenv_exists() is now exported.

                 Changes in version 1.32.0 (2023-09-11)                 

  - reticulate now supports casting R data.frames to Pandas data.frames
    using nullable data types, allowing users to preserve NA's from R
    atomic vectors. This feature is opt-in and can be enabled by setting
    the R option reticulate.pandas_use_nullable_dtypes to TRUE. (#1439)

  - reticulate now exports a chooseOpsMethod() method, allowing for Ops
    dispatch to more specialized Ops methods defined for Python objects.

  - py_discover_config() will now warn instead of error upon
    encountering a broken Python installation. (#1441, #1459)

  - Fixed issue where Python would raise exception "OSError:
    [WinError 6] The handle is invalid" when opening a subprocess while
    running in Rstudio on Windows. (#1448, #518)

  - Fixed issue where the multiprocessing Python module would crash or
    hang when spawning a Process() on Windows. (#1430, #1346, fixed in
    #1461)

  - Fixed issue where virtualenv_create() would fail to discover a
    'virtualenv' module in the system Python installation on Ubuntu.
    Reticulate will no longer discover and attempt to use the venv
    module stub present on Ubuntu systems where the python3-venv apt
    package has not been installed. (mlverse/pysparklyr#11, #1437,
    #1455)

  - Fixed issue where the user was prompted to create an 'r-reticulate'
    venv in the RStudio IDE before reticulate was requested to
    initialize Python. (#1450, #1456)

  - Improved error message when reticulate attempts to initialize a
    virtual environment after the Python installation it was created
    from is no longer available. (#1149, #1457)

  - Improved error message on Fedora when attempting to create a virtual
    environment from the system python before running dnf install
    python3-pip.

  - Fixed issue where install_python() on macOS in the RStudio IDE would
    fail to discover and use brew for Python build dependencies.

  - Fixed error with virtualenv_create(python = "/usr/bin/python") on
    centos7. (#1467)

                  Changes in version 1.31 (2023-08-10)                  

Python Installation Management

  - reticulate will no longer prompt users to install miniconda.
    Instead, reticulate will now prompt users to create a default
    r-reticulate venv.

  - The search that reticulate conducts to select which Python
    installation to load has changed. See the updated Python "Order of
    Discover" in the "versions" vignette. vignette("versions", package =
    "reticulate").

  - Updated recommendations in the "python_dependencies" vignette for
    how R packages can approach Python dependency management.
    vignette("python_dependencies", package = "reticulate")

  - New function virtualenv_starter(), which can be used to find a
    suitable python binary for creating a virtual environment. This is
    now the default method for finding the python binary when calling
    virtualenv_create(version = <version>).

  - virtualenv_create() and virtualenv_install() gain a requirements
    argument, accepting a filepath to a python requirements file.

  - virtualenv_create() gains a force argument.

  - virtualenv_install() gains a python_version argument, allowing users
    to customize which python version is used when bootstrapping a new
    virtual environment.

  - Fixed an issue where the list of available python versions used by
    install_python() would be out-of-date.

  - install_python() now gives a better error message if git is not
    installed.

  - install_python() on macOS will now will use brew, if it's available,
    to install build dependencies, substantially speeding up python
    build times.

  - New function conda_search(), contributed by @mkoohafkan in PR #1364.

Language

  - New [ and [<- methods that invoke Python __getitem__, __setitem__
    and __delitem__. The R generics [ and [<- now accept python-style
    slice syntax like x[1:2:3]. See examples in ?py_get_item.

  - py_iterator() gains a prefetch argument, primarily to avoid
    deadlocks where the main thread is blocked, waiting for the
    iterator, which is waiting to run on the main thread, as encountered
    in TensorFlow/Keras. (#1405).

  - String columns from Pandas data frames containing None, pd.NA or
    np.nan are now simplified into character vectors and missing values
    replaced by NA (#1428).

  - Converting from Pandas data frames containing columns with Pandas
    nullable data types are now correctly converted into R data.frames
    preserving the missing values (#1427).

Knitr

  - The knitr engine gains a jupyter_compat option, enabling reticulate
    to better match the behavior of Jupyter. When this chunk option is
    set to TRUE, only the return value from the last expression in a
    chunk is auto-printed. (#1391, #1394, contributed by @matthew-brett)

  - The knitr engine now more reliably detects and displays matplotlib
    pending plots, without the need for a matplotlib artist object to be
    returned as a top-level expression. E.g., the knitr engine will now
    display plots when the matplotlib api returns something other than
    an artist object, (plt.bar()), or the matplotlib return value is not
    auto-printed due to being assigned, (x = plt.plot()), or suppressed
    with a ;, (plt.plot();). (#1391, #1401, contributed by
    @matthew-brett)

  - Fixed an issue where knitr engine would not respect chunk options
    fig.width / fig.height when rendering matplotlib plots. (#1398)

  - Fixed an issue where the reticulate knitr engine would not capture
    output printed from python. (PR #1412, fixing #1378, #331)

Miscellanous

  - Reticulate now periodically flushes python stdout and stderr buffers
    even while the main thread is blocked executing Python code.
    Streaming output from a long-running Python function call will now
    appear in the R console while the Python function is still
    executing. (Previously, output might not appear until the Python
    function had finished and control of the main thread had returned to
    R).

  - Updated sparse matrix conversion routines for compatibility with
    scipy 1.11.0.

  - Fixed an issue where a py capsule finalizer could access the R API
    from a background thread. (#1406)

  - Fixed issue where R would segfault (crash) in long-lived R sessions
    where both rpy2 and reticulate were in use (#1236).

  - Fixed an issue where exceptions from reticulate would not be
    formatted properly when running tests under testthat
    (r-lib/rlang#1637, #1413).

  - Fixed an issue where py_get_attr(silent = TRUE) would not return an
    R NULL, if the attribute was missing, as documented. (#1413)

  - Fixed an issue where py_get_attr(silent = TRUE) would leave a python
    global exception set if the attribute was missing, resulting in
    fatal errors when running python under debug mode. (#1396)

                  Changes in version 1.30 (2023-06-09)                  

  - Fix compilation error on R 3.5. Bump minimum R version dependency
    to 3.5.

                  Changes in version 1.29 (2023-06-05)                  

Exceptions and Errors:

  - R error information (call, message, other attributes) is now
    preserved as an R error condition traverses the R <-> Python
    boundary.

  - Python Exceptions now inherit from error and condition, and can be
    passed directly to base::stop() to signal an error in R and raise an
    exception in Python.

  - Raised Python Exceptions are now used directly to signal an R error.
    For example, in the following code, e is now an object that inherits
    from python.builtin.Exception as well as error and condition:
    
    e <- tryCatch(py_func_that_raises_exception(),
                  error = function(e) e)

    Use base::conditionCall() and base::conditionMessage() to access the
    original R call and error message.

  - py_last_error() return object contains r_call, r_trace and/or
    r_class if the Python Exception was raised by an R function called
    from Python.

  - The hint to run reticulate::py_last_error() after an exception is
    now clickable in the RStudio IDE.

  - Filepaths to Python files in the print output from py_last_error()
    are now clickable links in the RStudio IDE.

  - Python exceptions encountered in repl_python() are now printed with
    the full Python traceback by default. In the RStudio IDE, filepaths
    in the tracebacks are rendered as clickable links. (#1240)

Language:

  - Converted Python callables gain support for dynamic dots from the
    rlang package. New features:
    
      - splicing (unpacking) arguments: fn(!!!kwargs)
      - dynamic names: nm <- "key"; fn("{nm}" := value)
      - trailing commas ignored (matching Python syntax): fn(a, )
        identical to fn(a)

  - New Ops group generics for Python objects: +, -, *, /, ^, %%, %/%,
    &, |, !, %*%. Methods for all the Ops group generics are now defined
    for Python objects. (#1187, #1363) E.g., this now works:
    
    np <- reticulate::import("numpy", convert = FALSE)
    x <- np$array(1:5)
    y <- np$array(6:10)
    x + y

  - Fixed two issues with R comparison operator methods (==, !=, <, <=,
    >=, >):
    
      - The operators no longer error on Python objects that define
        "rich comparison" Python methods that don't return a single
        bool. (e.g., numpy arrays).
      - The operators now respect the 'convert' value of the supplied
        Python objects. Note, this may be a breaking change as, e.g, ==,
        may now no long return an R scalar logical if one of the Python
        object being compared was created with convert = FALSE. Wrap the
        result of the comparison with py_bool() to restore the previous
        behavior. (#1187, #1363)

  - R functions wrapping Python callables now have formals matching
    those of the Python callable signature, enabling better
    autocompletion in more contexts (#1361).

  - new nameOfClass() S3 method for Python types, enabling usage:
    base::inherits(x, <python-type-object>) (requires R >= 4.3.0)

  - py_run_file() and source_python() now prepend the script directory
    to the Python module search path, sys.path, while the requested
    script is executing. This allows the Python scripts to resolve
    imports of modules defined in the script directory, matching the
    behavior of python <script> at the command line. (#1347)

knitr:

  - The knitr engine now suppresses warnings from Python code if
    warning=FALSE is set in the chunk options. (quarto-dev/quarto#125,
    #1358)

  - Fixed issue where reticulate's knitr engine would attach comments in
    a code chunk to the wrong code chunk (requires Python>=3.8) (#1223).

  - The knitr Python engine now respects the strip.white option (#1273).

  - Fixed issue where the knitr engine would show an additional plot
    from a chunk if the user called matplotlib.pyplot.show() (#1380,
    #1383)

Misc:

  - py_to_r() now succeeds when converting subtypes of the built-in
    types (e.g. list, dict, str). (#1352, #1348, #1226, #1354, #1366)

  - New pillar::type_sum() method now exported for Python objects. That
    ensures the full object class name is printing in R tracebacks and
    tibbles containing Python objects.

  - py_load_object() gains a convert argument. If convert = FALSE, the
    returned Python object will not be converted to an R object.

  - Fixed error r_to_py() with Pandas>=2.0 and R data.frames with a
    factor column containing levels with NA.

  - r_to_py() now succeeds for many additional types of R objects.
    Objects that reticulate doesn't know how to convert are presented to
    the Python runtime as a pycapsule (an opaque pointer to the
    underlying R object). Previously this would error. This allows for R
    code to pass R objects that cannot be safely converted to Python
    through the Python runtime to other R code. (e.g, to an R function
    called by Python code). (#1304)

  - reticulate gains the ability to bind to micromamba Python
    installations (#1378, #1176, #1382, #1379, thanks to Zia Khan,
    @zia1138)

  - Default Python version used by install_miniconda() and friends is
    now 3.9 (was 3.8).

                  Changes in version 1.28 (2023-01-27)                  

  - Fixed issue where source_python() (and likely many other
    entrypoints) would error if reticulate was built with Rcpp 1.0.10.
    Exception and error handling has been updated to accommodate usage
    of R_ProtectUnwind(). (#1328, #1329).

  - Fixed issue where reticulate failed to discover Python 3.11 on
    Windows. (#1325)

  - Fixed issue where reticulate would error by attempting to bind to a
    cygwin/msys2 installation of Python on Windows (#1325).

                  Changes in version 1.27 (2023-01-07)                  

  - py_run_file() now ensures the __file__ dunder is visible to the
    executing python code. (#1283, #1284)

  - Fixed errors with install_miniconda() and conda_install(), on
    Windows (#1286, #1287, conda/conda#11795, #1312, #1297), and on
    Linux and macOS (#1306, conda/conda#10431)

  - Fixed error when activating a conda env from a UNC drive on Windows
    (#1303).

                  Changes in version 1.26 (2022-08-31)                  

  - Fixed issue where reticulate failed to bind to python2. (#1241,
    #1229)

  - A warning is now issued when reticulate binds to python2 that
    python2 support will be removed in an upcoming reticulate release.

  - py_id() now returns a character string, instead of an R integer
    (#1216).

  - Fixed an issue where py_to_r() would not convert elements of a
    dictionary (#1221).

  - Fixed an issue where setting RETICULATE_PYTHON or
    RETICULATE_PYTHON_FALLBACK on Windows to the pyenv-win python.bat
    shim would result in an error (#1263).

  - Fixed an issue where datetime.datetime objects with a tzinfo
    attribute was not getting converted to R correctly (#1266).

  - Fixed an issue where pandas pandas.Categorical(,ordered=True) Series
    were not correctly converted to an R ordered factor (#1234).

  - The reticulate Python engine no longer halts on error for Python
    chunks containing parse errors when the error=TRUE chunk option is
    set. (#583)

  - install_python() now leverages brew for python build dependencies
    like openssl@1.1 if brew is already installed and on the PATH,
    substantially speeding up install_python() on macOS systems with
    brew configured.

  - Fixed an issue where reticulate would fail to bind to a conda
    environment on macOS or linux if conda installed a non-POSIX
    compliant activation script into the conda environment. (#1255)

  - Fixed an issue where the python knitr engine would error when
    printing to HTML a constructor of class instances with a _repr_html_
    or to_html method (e.g., pandas.DataFrame; #1249, #1250).

  - Fixed an issue where the python knitr engine would error when
    printing a plotly figure to an HTML document in some (head-less)
    linux environments (#1250).

  - Fixed an issue where conda_install(pip=TRUE) would install packages
    into a user Python library instead of the conda env if the
    environment variable PIP_USER=true was set. py_install(),
    virtualenv_install(), and conda_install() now always specify
    --no-user when invoking pip install. (#1209)

  - Fixed issue where py_last_error() would return unconverted Python
    objects (#1233)

  - The Knitr engine now supports printing Python objects with
    _repr_markdown_ methods. (via quarto-dev/quarto-cli#1501)

  - sys.executable on Windows now correctly reports the path to the
    Python executable instead of the launching R executable. (#1258)

  - The sys module is no longer automatically imported in __main__ by
    reticulate.

  - Fixed an issue on Windows where reticulate would fail to find Python
    installations from pyenv installed via scoop.

  - Fixed an issue where configure_environment() would error on Windows.
    (#1247)

  - Updated docs for compatibility with HTML5 / R 4.2.

  - Updated r_to_py.sparseMatrix() method for compatibility with
    Matrix 1.4-2.

                  Changes in version 1.25 (2022-05-11)                  

  - Fixed an issue where reticulate would fail if R was running embedded
    under rpy2. reticulate now ensures the Python GIL is acquired before
    calling into Python. (#1188, #1203)

  - Fixed an issue where reticulate would fail to bind to an ArcGIS Pro
    conda environment (#1200, @philiporlando).

  - Fixed an issue where reticulate would fail to bind to an Anaconda
    base environment on Windows.

  - All commands that create, modify, or delete a Python environment now
    echo the system command about to be executed. Affected:
    virtualenv_{create,install,remove}
    conda_{create,clone,remove,install,update} py_install

  - install_python() and create_virtualenv() gain the ability to
    automatically select the latest patch of a requested Python version.
    e.g.: install_python("3.9:latest"), create_virtualenv("my-env",
    version = "3.9:latest")

  - install_python() version arg gains default value of "3.9:latest".
    install_python() can now be called with no arguments.

  - Fixed an issue where reticulate would fail to bind to a conda python
    if the user didn't have write permissions to the conda installation
    (#1156).

  - Fixed an issue where reticulate would fail to bind to a conda python
    if spaces were present in the file path to the associated conda
    binary (#1154).

  - use_python(, required = TRUE) now issues a warning if the request
    will be ignored (#1150).

  - New function py_repr() (#1157)

  - print() and related changes (#1148, #1157):
    
      - The default print() method for Python objects now invokes
        py_repr() instead of str().
      - All Python objects gain a default format() method that invokes
        py_str().
      - py_str() default method no longer strips the object memory
        address.
      - print() now returns the printed object invisibly, for
        composability with %>%.

  - Exception handling changes (#1142, @t-kalinowski):
    
      - R error messages from Python exceptions are now truncated
        differently to satisfy getOption("warning.length"). A hint to
        call reticulate::py_last_error() is shown if the exception
        message was truncated.
    
      - Python buffers sys.stderr and sys.stdout are now flushed when
        Python exceptions are raised.
    
    -py_last_error():
    
      - Return object is now an S3 object 'py_error', includes a default
        print method.
      - The python Exception object ('python.builtin.Exception') is
        available as an R attribute.
      - Gains the ability to restore a previous exception if provided in
        a call py_last_error(previous_error)
    
      - Python traceback objects gain a default format() S3 method.

  - Fixed py_to_r() for scipy matrices when scipy >= 1.8.0, since sparse
    matrices are now deprecated.

  - Fixed r_to_py() for small scipy matrices.

  - New maintainer: Tomasz Kalinowski

                  Changes in version 1.24 (2022-01-26)                  

  - Fixed an issue where reticulate would fail to bind to the system
    version of Python on macOS if command line tools were installed, but
    Xcode was not.

                  Changes in version 1.23 (2022-01-14)                  

  - use_condaenv() gains the ability to accept an absolute path to a
    python binary for envname.

  - All python objects gain a length() method, that returns either
    py_len(x), or if that fails, as.integer(py_bool(x)).

  - conda_create() default for python_version changed from NULL to
    miniconda_python_version() (presently, 3.8).

  - New function py_bool(), for evaluating Python "truthiness" of an
    object.

  - reticulate gains the function py_list_packages(), and can be used to
    list the Python modules available and installed in a particular
    Python environment. (#933)

  - reticulate now supports conversion of Python datatable objects.
    (#1081)

  - repl_python() gains support for invoking select magic and system
    commands like !ls and %cd <dir>. See ?repl_python() for details and
    examples.

  - The development branch for reticulate has moved to the "main"
    branch.

  - reticulate gains reticulate::conda_update(), for updating the
    version of conda in a particular conda installation.

  - reticulate gains reticulate::miniconda_uninstall(), for uninstalling
    the reticulate-managed version of Miniconda. (#1077)

  - reticulate::use_python() and friends now assume required = TRUE by
    default. For backwards compatibility, when use_python() is called as
    part of a package load hook, the default value will instead be
    FALSE.

  - reticulate now provides support for Python environments managed by
    poetry. For projects containing a pyproject.toml file, reticulate
    will attempt to find and use the virtual environment managed by
    Poetry for that project. (#1031)

  - The default version of Python used for the r-reticulate Miniconda
    environment installed via reticulate::install_miniconda() has
    changed from 3.6 to 3.8.

  - reticulate::install_miniconda() now prefers installing the latest
    arm64 builds of miniforge. See
    https://conda-forge.org/blog/posts/2020-10-29-macos-arm64/ for more
    details.

  - reticulate::conda_create() gains the environment argument, used when
    creating a new conda environment based on an exported environment
    definition (e.g. environment.yml or environment.json).

  - reticulate gains the function, conda_export(), for exporting a conda
    environment definition as YAML. Environments are exported as via the
    conda env export command. (#779)

  - reticulate::find_conda() will now locate miniforge Conda
    installations located within the default install locations.

  - Fixed an issue that caused reticulate::conda_install(pip = TRUE) to
    fail on windows. (#1053, @t-kalinowski)

                  Changes in version 1.22 (2021-09-17)                  

  - Fixed a regression that caused reticulate::conda_install(pip = TRUE)
    to fail. (#1052)

                  Changes in version 1.21 (2021-09-14)                  

  - use_condaenv("base") can now be used to activate the base Anaconda
    environment.

  - reticulate will now execute any hooks registered via
    setHook("reticulate.onPyInit", <...>) after Python has been
    initialized. This can be useful for packages that need to take some
    action after reticulate has initialized Python.

  - Further refined interrupt handling.

  - Fixed an issue where attempting to bind reticulate to
    /usr/bin/python3 on macOS could fail if Xcode was not installed.
    (#1017)

  - The reticulate Python REPL no longer exits when a top-level
    interrupt is sent (e.g. via Ctrl + C).

  - The miniconda auto-installer now supports aarch64 Linux machines.
    (#1012)

  - Fixed an issue where matplotlib plots were incorrectly overwritten
    when multiple Python chunks in the same R Markdown document included
    plot output. (#1010)

  - reticulate can now use the version of Python configured in projects
    using pipenv. If the project contains a Pipfile at the root
    directory (as understood by here::here()), then reticulate will
    invoke pipenv --venv to determine the path to the Python virtual
    environment associated with the project. Note that the
    RETICULATE_PYTHON environment variable, as well as usages of
    use_python(..., force = TRUE), will still take precedence. (#1006)

  - Fixed an issue where reticulate::py_run_string(..., local = TRUE)
    failed to return the dictionary of defined Python objects in some
    cases.

                  Changes in version 1.20 (2021-05-03)                  

  - Fixed an issue causing tests to fail on CRAN's M1mac machine.

                  Changes in version 1.19 (2021-04-21)                  

  - Fixed an issue where reticulate's interrupt handlers could cause
    issues with newer versions of Python.

  - reticulate now better handles Pandas categorical variables
    containing NA values. (#942)

  - reticulate now supports converting pandas.NA objects into R NA
    objects. (#950)

  - reticulate now sets the PYTHONIOENCODING environment variable to
    UTF-8 when running within RStudio. This should allow UTF-8 input and
    output to be handled more appropriately.

  - reticulate gains the install_python() function, used to install
    different versions of Python via pyenv (pyenv-windows on Windows).

  - Interrupt signals (e.g. those generated by Ctrl + C) are now better
    handled by reticulate. In particular, when repl_python() is active,
    Ctrl + C can be used to interrupt a pending Python computation.

  - virtualenv_create() gains the pip_version and setuptools_version
    arguments, allowing users to control the versions of pip and
    setuptools used when initializing the virtual environment. The extra
    argument can also now be used to pass arbitrary command line
    arguments when necessary.

  - virtualenv_create() gains the module argument, used to control
    whether virtualenv or venv is used to create the requested virtual
    environment.

  - py_to_r.datetime.datetime no longer errs when tzname is NULL, and
    instead assumes the time is formatted for UTC. (#876)

  - reticulate now supports the rendering of plotly plots and Altair
    charts in rendered R Markdown documents. (#711)

  - reticulate now avoids invoking property methods when inferring the
    type for Python class members, for auto-completion systems. (#907)

  - reticulate now attempts to set the QT_QPA_PLATFORM_PLUGIN_PATH
    environment variable when initializing a Conda installation of
    Python, when that associated plugins directory exists. (#586)

  - The reticulate Python engine now supports the results = "hold" knitr
    chunk option. When set, any generated outputs are "held" and then
    displayed after the associated chunk's source code. (#530)

  - conda_create() gains the python_version argument, making it easier
    to request that Conda environments are created with a pre-specified
    version of Python. (#766)

  - Fixed an issue where reticulate::conda_install() would attempt to
    re-install the default Python package, potentially upgrading or
    downgrading the version of Python used in an environment.

  - Fixed an issue where reticulate invoked its reticulate.initialized
    hook too early.

  - Fixed an issue where Python modules loaded on a separate thread
    could cause a crash. (#885)

  - conda_install() now allows version specifications for the
    python_version argument; e.g. conda_install(python_version =
    ">=3.6"). (#880)

  - Fixed an issue where conda_install() failed to pass along forge and
    channel in calls to conda_create(). (#878)

  - Fixed an issue where Python's auto-loader hooks could fail when
    binding to a Python 2.7 installation.

                  Changes in version 1.18 (2020-10-25)                  

  - Fixed an issue where python_config() could throw an error when
    attempting to query information about a Python 2.6 installation.

                  Changes in version 1.17 (2020-10-21)                  

  - reticulate now checks for and disallows installation of Python
    packages during R CMD check.

  - reticulate no longer injects the r helper object into the main
    module if another variable called r has already been defined.

  - The function py_help_handler() has now been exported, to be used by
    front-ends and other tools which need to provide help for Python
    objects in different contexts. (#864)

  - Fixed an issue where timezone information could be lost when
    converting Python datetime objects to R. (#829)

  - Fixed an issue where numeric (rather than integer) dimensions could
    cause issues when converting SciPy sparse matrices to their R
    counterparts. (#844)

  - Fixed an issue where R data.frames with non-ASCII column names could
    not be converted to Pandas DataFrames. (#834)

  - Fixed an issue where the pip_ignore_installed argument in
    conda_install() was silently being ignored.

  - Fixed an issue where reticulate::conda_install() could re-install
    Python into an environment when not explicitly requested by the
    user.

  - reticulate now sets LD_LIBRARY_PATH when discovering Python. (#836)

  - reticulate is now better at capturing Python logger streams (those
    that write to stdout or stderr) when py_capture_output() is set.
    (#825)

  - reticulate no longer calls utils::loadhistory() after each REPL
    iteration.

  - reticulate now better detects when Python modules are loaded.

  - reticulate::import_from_path() now accepts the delay_load parameter,
    allowing modules which should be loaded from a pre-specified path to
    be lazy-loaded.

  - Fixed an issue where reticulate load hooks (normally defined via
    setHook("reticulate::<module>::load", ...)) would segfault if those
    hooks attempted to load the hooked module.

  - reticulate now attempts to resolve the conda binary used to create
    the associated Conda environment in calls to py_install(). This
    should fix use cases where Conda environments are placed outside of
    the Conda installation itself.

  - reticulate now sets PYTHONPATH before loading Python, to ensure
    modules are looked up in the same locations where a regular Python
    interpreter would find them on load. This should fix issues where
    reticulate was unable to bind to a Python virtual environment in
    some cases.

  - reticulate::virtualenv_create() gains the packages argument,
    allowing one to choose a set of packages to be installed (via pip
    install) after the virtual environment has been created.

  - reticulate::virtualenv_create() gains the system_site_packages
    argument, allowing one to control whether the --system-site-packages
    flag is passed along when creating a new virtual environment. The
    default value can be customized via the
    "reticulate.virtualenv.system_site_packages" option and now defaults
    to FALSE when unset.

  - Fixed an issue where reticulate::configure_environment() would fail
    when attempting to configure an Anaconda environment. (#794)

  - reticulate now avoids presenting a Miniconda prompt for interactive
    sessions during R session initialization.

  - Fixed unsafe usages of Rprintf() and REprintf().

  - reticulate::py_install() better respects the method argument, when
    py_install() is called without an explicit environment name. (#777)

  - reticulate:::pip_freeze() now better handles pip direct references.
    (#775)

  - Fixed an issue where output generated from repl_python() would be
    buffered until the whole submitted command had completed. (#739,
    @randy3k)

  - reticulate now explicitly qualifies symbols used from TinyThread
    with tthread::, to avoid issues with symbol conflicts during
    compilation. (#773)

  - reticulate will now prefer an existing Miniconda installation over a
    conda binary on the PATH, when looking for Conda. (#790)

                  Changes in version 1.16 (2020-05-27)                  

  - TinyThread now calls Rf_error() rather than std::terminate() when an
    internal error occurs.

  - Conversion of Pandas DataFrames to R no longer emits deprecation
    warnings with pandas >= 0.25.0. (#762)

  - reticulate now properly handles the version strings returned by beta
    versions of pip. (#757)

  - conda_create() gains the forge and channel arguments, analogous to
    those already in conda_install(). (#752, @jtilly)

                  Changes in version 1.15 (2020-04-02)                  

  - reticulate now ensures SciPy csr_matrix objects are sorted before
    attempting to convert them to their R equivalent. (#738,
    @paulofelipe)

  - Fixed an issue where calling input() from Python with no prompt
    would fail. (#728)

  - Lines ending with a semi-colon are no longer auto-printed in the
    reticulate REPL. (#717, @jsfalk)

  - reticulate now searches for Conda binaries in /opt/anaconda and
    /opt/miniconda. (#713)

  - The conda executable used by reticulate can now be configured using
    an R option. Use options(reticulate.conda_binary = <...>) to force
    reticulate to use a particular conda executable.

  - reticulate::use_condaenv() better handles cases where no matching
    environment could be found. (#687)

  - reticulate gains the py_ellipsis() function, used to access the
    Python Ellipsis builtin. (#700, @skeydan)

  - reticulate::configure_environment() now only allows environment
    configuration within interactive R sessions, and ensures that the
    version of Python that has been initialized by Python is indeed
    associated with a virtual environment or Conda environment. Use
    reticulate::configure_environment(force = TRUE) to force environment
    configuration within non-interactive R sessions.

  - reticulate now automatically flushes output written to Python's
    stdout / stderr, as a top-level task added by addTaskCallback().
    This behavior is controlled with the options(reticulate.autoflush)
    option. (#685)

  - reticulate::install_miniconda() no longer attempts to modify the
    system PATH or registry when installing Miniconda. (#681)

  - reticulate::conda_install() gains the channel argument, allowing
    custom Conda channels to be used when installing Python packages.
    (#443)

  - reticulate::configure_environment() can now be used to configure a
    non-Miniconda Python environment. (#682; @skeydan)

  - Fixed an issue where matplotlib plots would be included using
    absolute paths, which fails in non-standalone documents rendered to
    HTML. (#669)

  - Fixed an issue where reticulate would attempt to flush a
    non-existent stdout / stderr stream. (#584)

                  Changes in version 1.14 (2019-12-17)                  

  - Fixed an issue where rmarkdown::render() could fail when including
    matplotlib plots when knit_root_dir is set. (#645)

  - reticulate now scans for Conda installations within the ~/opt
    folder, as per the updated installers distributed for macOS. (#661)

  - Python classes can now be defined directly from R using the
    PyClass() function. (#635; @dfalbel)

  - reticulate is now compatible with Python 3.9. (#630, @skeydan)

  - Pandas DataFrames with a large number of columns should now be
    converted to R data.frames more quickly. (#620, @skeydan)

  - Python loggers are now better behaved in the Python chunks of R
    Markdown documents. (#386)

  - reticulate will now attempt to bind to python3 rather than python,
    when no other version of Python has been explicitly requested by
    e.g. use_python().

  - reticulate now provides R hooks for Python's input() and raw_input()
    functions. It should now be possible to read user input from Python
    scripts loaded by reticulate. (#610)

  - reticulate now more consistently normalizes the paths reported by
    py_config(). (#609)

  - reticulate now provides a mechanism for allowing client packages to
    declare their Python package dependencies. Packages should declare
    the Python packages they require as part of the Config/reticulate
    field in their DESCRIPTION file. Currently, this only activated when
    using Miniconda; as the assumption is that users will otherwise
    prefer to manually manage their Python environments. Please see
    vignette("python_dependencies") for more details.

  - reticulate will now prompt the user to create and use a Miniconda
    environment when no other suitable Python environment has already
    been requested. This should help ease some of the trouble in setting
    up a Python environment on different platforms. The installer code
    was contributed by @hafen, from the rminiconda package.

  - Fixed an issue where virtualenv_create(..., python = "<python>")
    could fail to use the requested version of Python when venv is not
    installed. (#399)

  - Fixed an issue where iterable Python objects could not be iterated
    with iter_next() due to a missing class. (#603)

  - Fixed an issue where Conda environments could be mis-detected as
    virtual environments.

  - R functions wrapping Python functions now inherit the formal
    arguments as specified by Python, making autocompletion more
    reliable. (#573, @flying-sheep)

  - Fixed an issue where attempts to query Conda for environments could
    fail on Windows. (#576; #575; @dfalbel)

  - Properly check for NULL keyword arguments in call_r_function().
    (#562, @dfalbel)

                  Changes in version 1.13 (2019-07-24)                  

  - Fixed an issue where subsetting with [.python.builtin.object could
    fail when convert = TRUE is set on the associated Python object.
    (#554)

  - Fixed an issue where the wrong definition of
    [[.python.builtin.object was being exported. (#554)

  - py_install() now accepts python_version, and can be used if a
    particular version of Python is required for a Conda environment.
    (This argument is ignored for virtual environments.) (#549)

  - Fixed an issue where reticulate could segfault in some cases (e.g.
    when using the iterate() function). (#551)

  - It is now possible to compile reticulate with support for debug
    versions of Python by setting the RETICULATE_PYTHON_DEBUG
    preprocessor define during compilation. (#548)

  - reticulate now warns if it did not honor the user's request to load
    a particular version of Python, as through e.g.
    reticulate::use_python(). (#545)

  - py_save_object() and py_load_object() now accept ... arguments.
    (#542)

  - py_install() has been revamped, and now better detects available
    Python tooling (virtualenv vs. venv vs. Conda). (#544)

  - reticulate now flushes stdout / stderr after calls to py_run_file()
    and py_run_string().

  - Python tuples are now converted recursively, in the same way that
    Python lists are. This means that the sub-elements of the tuple will
    be converted to R objects when possible. (#525, @skeydan)

  - Python OrderedDict objects with non-string keys are now properly
    converted to R. (#516)

  - Fixed an issue where reticulate could crash after a failed attempt
    to load NumPy. (#497, @ecoughlan)

                  Changes in version 1.12 (2019-04-12)                  

  - Fixed an issue where Python objects within Python lists would not be
    converted to R objects as expected.

  - Fixed an issue where single-row data.frames with row names could not
    be converted. (#468)

  - Fixed an issue where reticulate could fail to query Anaconda
    environment names with Anaconda 3.7.

  - Fixed an issue where vectors of R Dates were not converted
    correctly. (#454)

  - Fixed an issue where R Dates could not be passed to Python
    functions. (#458)

                 Changes in version 1.11.1 (2019-03-06)                 

  - Fixed a failing virtual environment test on CRAN.

                  Changes in version 1.11 (2019-02-27)                  

  - Fixed an issue where attempts to activate virtual environments
    created with virtualenv 16.4.1 would fail. (#437)

  - Fixed an issue where conversion of Pandas Categorical variables to R
    objects would fail. (#389)

  - Textual output generated when adding items to a matplotlib plot
    object are now suppressed.

  - If the last statement in a Python chunk returns a matplotlib plot
    object, the plot will now be auto-shown as in other environments.

  - The reticulate function help handler now returns function arguments
    for Python builtin functions.

  - Top-level Python statements can now include leading indent when
    submitted with repl_python().

  - The current matplotlib figure is now cleared as each Python chunk in
    an R Markdown document is run.

  - The r helper object (used for evaluating R code from Python) now
    better handles conversion of R functions. (#383)

  - The use_virtualenv() function now understands how to bind to virtual
    environments created by the Python venv module.

  - Reticulate better handles conversions of R lists to Python, and
    similarly, Python lists to R. We now call r_to_py() on each
    sub-element of an R list, and similarly, py_to_r() on each
    sub-element of a Python list.

  - Reticulate now always converts R Date objects into Python datetime
    objects. Note that these conversions can be inefficient -- if you
    would prefer conversion to NumPy datetime64 objects / arrays, you
    should convert your date to POSIXct first.

  - Python chunks containing errors will cause execution to halt if
    'error=FALSE' during render, conforming with the default knitr
    behavior for R chunks.

  - The output of bare statements (e.g. 1 + 1) is now emitted as output
    when using the reticulate Python engine.

  - Remapping of Python output streams to be R can now be explicitly
    enabled by setting the environment variable
    RETICULATE_REMAP_OUTPUT_STREAMS to 1. (#335)

  - Allow syntax errors in Python chunks with 'eval = FALSE' (#343)

  - Avoid dropping blank lines in Python chunks (#328)

  - Use "agg" matplotlib backend when running under RStudio Desktop
    (avoids crashes when attempting to generate Python plots)

  - Add as.character() S3 method for Python bytes (defaults to
    converting using UTF-8 encoding)

  - Add py_main_thread_func() for providing R callbacks to Python
    libraries that may invoke the function on a Python background
    thread.

  - Add py_to_r S3 methods for Scipy sparse matrices: CSR to dgRMatrix,
    COO to dgTMatrix, and for all other sparse matrices, conversion via
    CSC/dgCMatrix.

                  Changes in version 1.10 (2018-08-05)                  

  - Output is now properly displayed when using the reticulate REPL with
    Windows + Python 2.7.

  - Address memory protection issues identified by rchk

  - Make variables defined using %as% operator in with() available after
    execution of the with block (same behavior as Python).

  - Check for presence of "module" property before reading in
    as_r_class()

  - Only update pip in virtualenv_install() when version is < 8.1

  - Support converting Python OrderedDict to R

  - Support for iterating all types of Python iterable

  - Add conda_python() and virtualenv_python() functions for finding the
    python binary associated with an environment.

                  Changes in version 1.9 (2018-07-06)                   

  - Detect python 3 in environments where there is no python 2 (e.g.
    Ubuntu 18.04)

  - Always call r_to_py S3 method when converting objects from Python to
    R

  - Handle NULL module name when determining R class for Python objects

  - Convert RAW vectors to Python bytearray; Convert Python bytearray to
    RAW

  - Use importlib for detecting modules (rather than imp) for Python
    >= 3.4

  - Close text connection used for reading Python configuration probe

                  Changes in version 1.8 (2018-06-08)                   

  - source_python() now flushes stdout and stderr after running the
    associated Python script, to ensure that print()-ed output is output
    to the console. (#284)

  - Fixed an issue where logical R matrices would not be converted
    correctly to their NumPy counterpart. (#280)

  - Fixed an issue where Python chunks containing multiple statements on
    the same line would be evaluated and printed multiple times.

  - Added py_get_item(), py_set_item(), and py_del_item() as lower-level
    APIs for directly accessing the items of e.g. a Python dictionary or
    a Pandas DataFrame.

  - Fix issue with Pandas column names that clash with built in methods
    (e.g. 'pop')

  - Improve default str() output for Python objects (print __dict__ if
    available)

                  Changes in version 1.7 (2018-04-28)                   

  - Improved filtering of non-numeric characters in Python / NumPy
    versions.

  - Added py_func() to wrap an R function in a Python function with the
    same signature as that of the original R function.

  - Added support for conversion between Matrix::dgCMatrix objects in R
    and Scipy CSC matrices in Python.

  - source_python() can now source a Python script from a URL into R
    environments.

  - Always run source_python() in the main Python module.

  - py_install() function for installing Python packages into
    virtualenvs and conda envs

  - Automatically create conda environment for conda_install()

  - Removed delay_load parameter from import_from_path()

                  Changes in version 1.6 (2018-03-21)                   

  - repl_python() function implementing a lightweight Python REPL in R.

  - Support for converting Pandas objects (Index, Series, DataFrame)

  - Support for converting Python datetime objects.

  - py_dict() function to enable creation of dictionaries based on lists
    of keys and values.

  - Provide default base directory (e.g. '~/.virtualenvs') for
    environments specified by name in use_virtualenv().

  - Fail when environment not found with use_condaenv(..., required =
    TRUE)

  - Ensure that use_* python version is satisfied when using
    eng_python()

  - Forward required argument from use_virtualenv() and use_condaenv()

  - Fix leak which occurred when assigning R objects into Python
    containers

  - Add support for Conda Forge (enabled by default) to conda_install()

  - Added functions for managing Python virtual environments
    (virtualenv)

                  Changes in version 1.5 (2018-02-14)                   

  - Remove implicit documentation extraction for Python classes

  - Add Library\bin to PATH on Windows to ensure Anaconda can find MKL

  - New source_python() function for sourcing Python scripts into R
    environments.

                  Changes in version 1.4 (2018-01-09)                   

  - Support for RETICULATE_DUMP_STACK_TRACE environment variable which
    can be set to the number of milliseconds in which to output into
    stderr the call stacks from all running threads.

  - Provide hook to change target module when delay loading

  - Scan for conda environments in system-level installations

  - Support for miniconda environments

  - Implement eval, echo, and include knitr chunk options for Python
    engine

                 Changes in version 1.3.1 (2017-11-24)                  

  - Bugfix: ensure single-line Python chunks that produce no output
    still have source code emitted.

                  Changes in version 1.3 (2017-11-16)                   

  - Use existing instance of Python when reticulate is loaded within an
    embedded Python environment (e.g. rpy2, rice, etc.)

  - Force use of Python specified in PYTHON_SESSION_INITIALIZED (defined
    by rpy2)

  - Define R_SESSION_INITIALIZED (used by rpy2)

  - Force use of Python when required = TRUE in use_python functions

  - Force use of Python specified by RETICULATE_PYTHON

  - dict: Don't scan parent frame for Python objects if a single unnamed
    list is passed.

  - Wait as long as required for scheduling generator calls on the main
    thread

  - Refine stripping of object addresses from output of py_str() method

  - Added py_id() function to get globally unique ids for Python objects

  - Added py_len() function and S3 length() method for Python lists
    (already had length() methods for dicts, tuples, and NumPy arrays).

  - Exported py object (reference to Python main module)

  - Added eng_python() (knitr engine for Python chunks)

  - Improved compatibility with strings containing high unicode
    characters when running under Python 2

  - Remove dim methods for NumPy arrays (semantics of NumPy reshaping
    are different from R reshaping)

  - Added array_reshape function for reshaping R arrays using NumPy
    (row-major) semantics.

  - Provide mechanism for custom R wrapper objects for Python objects

  - Added interface to pickle (py_save_object() and py_load_object())

  - Catch and print errors which occur in generator functions

  - Write using Rprintf when providing custom Python output streams
    (enables correct handling of terminal control characters)

  - Implement isatty when providing custom Python output streams

                  Changes in version 1.2 (2017-09-27)                   

  - Add np_array function for creating NumPy arrays and converting the
    data type, dimensions, and in-memory ordering of existing NumPy
    arrays.

  - Add dim and length functions for NumPy arrays

  - Add py_set_seed function for setting Python and NumPy random seeds.

  - Search in additional locations for Anaconda on Linux/Mac

  - Improved support for UTF-8 conversions (always use UTF-8 when
    converting from Python to R)

  - Ignore private ("_" prefixed) attributes of dictionaries for
    .DollarNames

  - Provide "`function`" rather than "function" in completions.

  - Fail gracefully if call to conda in conda_list results in an error

  - Add pip_ignore_installed option to conda_install function.

                  Changes in version 1.1 (2017-08-26)                   

  - Allow dict() function to accept keys with mixed alpha/numeric
    characters

  - Use conda_list() to discover conda environments on Windows (slower
    but much more reliable than scanning the filesystem)

  - Add interface for registering F1 help handlers for Python modules

  - Provide virtual/conda env hint mechanism for delay loaded imports

                  Changes in version 1.0 (2017-07-25)                   

  - Search WORKON_HOME (used by virtualenv_wrapper) for Python
    environments

  - Support priority field for delay loaded modules.

  - Use json output from conda_list (handle spaces in path of conda env)

  - Look for callable before iterable when converting Python objects to
    R

  - Correct propagation of errors in R functions called from Python

  - Support for generators (creating Python iterators from R functions)

  - Changed default completed value for iter_next() to NULL (was NA)

  - Support for converting 16-bit floats (NPY_HALF) to R

  - Don't throw error when probing Python <= 2.6

  - Copy Python dictionary before converting to R named list (fixes
    issue with dictionaries that are mutated during iteration, e.g.
    sys.modules)

  - Ensure that existing warning filters aren't reset by
    py_suppress_warnings

                  Changes in version 0.9 (2017-06-23)                   

  - Detect older versions of Anaconda during registry scanning.

  - Don't probe python versions on windows when no executable is found

  - Poll for interrupts every 500ms rather than 100ms

  - Provide sys.stdout and sys.stderr when they are None (e.g. in R GUI)

  - Add Scripts directory to PATH on Windows

  - Add iter_next function for element-by-element access to iterators

  - Eliminate special print method for iterators/generators

  - Added py_help() function for printing documentation on Python
    objects

  - Added conda_version() function.

  - Search dict() parent frames for symbols; only use symbols which
    inherit from python.builtin.object as keys.

                  Changes in version 0.8 (2017-05-22)                   

  - Add import_from_path() function for importing Python modules from
    the filesystem.

  - Add py_discover_config() function to determine which versions of
    Python will be discovered and which one will be used by reticulate.

  - Add py_function_docs() amd py_function_wrapper() utility functions
    for scaffolding R wrappers for Python functions.

  - Add py_last_error() function for retrieving last Python error.

  - Convert 0-dimension NumPy arrays (scalars) to single element R
    vectors

  - Convert "callable" Python objects to R functions

  - Automatically add Python bin directory to system PATH for consistent
    version usage in reticulate and calls to system

  - Added length() method for tuple objects

  - Enable specification of __name__ for R functions converted to Python
    functions.

  - Give priority to the first registered delay load module (previously
    the last registered module was given priority)

  - Add additional safety checks to detect use of NULL xptr objects
    (i.e. objects from a previous session). This should mean that S3
    methods no longer need to check whether they are handling an xptr.

  - Added py_eval() function for evaluating simple Python statements.

  - Add local option to py_run_string() and py_run_file(). Modify
    behavior to return local execution dictionary (rather than a
    reference to the main module).

  - Use PyImport_Import rather than PyImport_ImportModule for import()

  - Added ability to customize mapping of Python classes to R classes
    via the as argument to import() and the register_class_filter()
    function

  - Added separate on_load and on_error functions for delay_load

  - Scan customary root directories for virtualenv installations

  - Allow calling __getitem__ via [[ operator (zero-based to match
    Python style indexing)

  - Added conda_* family of functions for using conda utilities from
    within R.

  - Implement comparison operators (e.g. ==, >=, etc.) for Python
    objects

  - Implement names() generic for Python objects

  - Improve performance for marshalling of large Python dictionaries and
    iterators that return large numbers of items.

  - Implement str methods for Python List, Dict, and Tuple (to prevent
    printing of very large collections via default str method)

  - Use grepl() rather than endsWith() for compatibility with R <= 3.2

  - Use inspect.getmro rather than __bases__ for enumerating the base
    classes of Python objects.

  - Fix PROTECT/UNPROTECT issue detected by CRAN

  - Correct conversion of strings with Unicode characters on Windows

  - Fix incompatibility with system-wide Python installations on Windows

  - Fix issue with Python dictionary keys that shared names with
    primitive R functions (don't check environment inheritance chain
    when looking for dictionary key objects by name).

  - Propagate convert parameter for modules with delay_load

                  Changes in version 0.7 (2017-03-14)                   

  - Initial CRAN release
