API guidelines#

Rules#

• Deprecations are targeted at the next meso release (e.g. 3.Y)

• Deprecated API is generally removed (expired) two point-releases after introduction of the deprecation. Longer deprecations can be imposed by core developers on a case-by-case basis to give more time for the transition

• The old API must remain fully functional during the deprecation period

• If alternatives to the deprecated API exist, they should be available during the deprecation period

• If in doubt, decisions about API changes are finally made by the API consistency lead developer.

Introduce deprecation#

Deprecations are introduced to warn users that the API will change. The deprecation notice describes how the API will change. When alternatives to the deprecated API exist, they are also listed in the notice and decorators.

1. Create a deprecation notice

2. If possible, issue a MatplotlibDeprecationWarning when the deprecated API is used. There are a number of helper tools for this:

   • Use _api.warn_deprecated() for general deprecation warnings

   • Use the decorator @_api.deprecated to deprecate classes, functions, methods, or properties

   • Use @_api.deprecate_privatize_attribute to annotate deprecation of attributes while keeping the internal private version.

   • To warn on changes of the function signature, use the decorators @_api.delete_parameter, @_api.rename_parameter, and @_api.make_keyword_only

   All these helpers take a first parameter since, which should be set to the next point release, e.g. "3.x".

   You can use standard rst cross references in alternative.

3. Make appropriate changes to the type hints in the associated .pyi file. The general guideline is to match runtime reported behavior.

   • Items marked with @_api.deprecated or @_api.deprecate_privatize_attribute are generally kept during the expiry period, and thus no changes are needed on introduction.

   • Items decorated with @_api.rename_parameter or @_api.make_keyword_only report the new (post deprecation) signature at runtime, and thus should be updated on introduction.

   • Items decorated with @_api.delete_parameter should include a default value hint for the deleted parameter, even if it did not previously have one (e.g. param: <type> = ...).

Expire deprecation#

The API changes described in the introduction notice are only implemented after the introduction period has expired.

1. Create a deprecation announcement. For the content, you can usually copy the deprecation notice and adapt it slightly.

2. Change the code functionality and remove any related deprecation warnings.

3. Make appropriate changes to the type hints in the associated .pyi file.

   • Items marked with @_api.deprecated or @_api.deprecate_privatize_attribute are to be removed on expiry.

   • Items decorated with @_api.rename_parameter or @_api.make_keyword_only will have been updated at introduction, and require no change now.

   • Items decorated with @_api.delete_parameter will need to be updated to the final signature, in the same way as the .py file signature is updated.

   • Any entries in ci/mypy-stubtest-allowlist.txt which indicate a deprecation version should be double checked. In most cases this is not needed, though some items were never type hinted in the first place and were added to this file instead. For removed items that were not in the stub file, only deleting from the allowlist is required.

Pending deprecation#

A pending deprecation is an announcement that a deprecation will be introduced in the future. By default, pending deprecations do not raise a warning to the user; however, pending deprecations are rendered in the documentation and listed in the release notes. Pending notices are primarily intended to give downstream library and tool developers time to adapt their code so that it does not raise a deprecation warning. This is because their users cannot act on warnings triggered by how the tools and libraries use Matplotlib. It's also possible to run Python in dev mode to raise PendingDeprecationWarning.

To mark a deprecation as pending, set the following parameters on the appropriate deprecation decorator: * the pending parameter is set to True * the removal parameter is left blank

When converting a pending deprecation to an introduced deprecation, update the decorator such that: * pending is set to False * since is set to the next meso release (3.Y+1) * removal is set to at least 2 meso releases after (3.Y+3) introduction.

Pending deprecations are documented in the API change notes in the same manner as introduced and expired deprecations. The notice should include pending deprecation in the title.

Versioning directives#

When making a backward incompatible change, please add a versioning directive in the docstring. The directives should be placed at the end of a description block. For example:

class Foo:
    """
    This is the summary.

    Followed by a longer description block.

    Consisting of multiple lines and paragraphs.

    .. versionadded:: 3.5

    Parameters
    ----------
    a : int
        The first parameter.
    b: bool, default: False
        This was added later.

        .. versionadded:: 3.6
    """

    def set_b(b):
        """
        Set b.

        .. versionadded:: 3.6

        Parameters
        ----------
        b: bool

For classes and functions, the directive should be placed before the Parameters section. For parameters, the directive should be placed at the end of the parameter description. The micro release version is omitted and the directive should not be added to entire modules.

Release notes#

For both change notes and what's new, please avoid using cross-references in section titles as it causes links to be confusing in the table of contents. Instead, ensure that a cross-reference is included in the descriptive text.

Locators
~~~~~~~~
The unused `Locator.autoscale()` method is deprecated (pass the axis
limits to `Locator.view_limits()` instead).

Section title for feature
-------------------------

A description of the feature from the user perspective. This should include
what the feature allows users to do and how the feature is used. Technical
details should be left out when they do not impact usage, for example
implementation details.

The description may include a a short instructive example, if it helps to
understand the feature.