Source code for binaryninja.deprecation

# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import re
import collections
import functools
import textwrap
import warnings

from datetime import date

__version__ = "2.0.7"

# This is mostly here so automodule docs are ordered more ideally.
__all__ = ["deprecated", "message_location", "fail_if_not_removed",
           "DeprecatedWarning", "UnsupportedWarning"]

#: Location where the details are added to a deprecated docstring
#: When set to ``"bottom"``, the details are appended to the end.
#: When set to ``"top"``, the details are inserted between the
#: summary line and docstring contents.
message_location = "bottom"

# This is a patch applied to this library to allow specifying a deprecation version
def parse_version(version: str) -> tuple:
    match = re.match(r"^(?P<major>\d+)\.(?P<minor>\d+)(\.(?P<patch>\d+))?", version)
    if match is None:
        return (0,0,0)
    groups = match.groupdict()
    return (int(groups['major']), int(groups['minor']), int(groups['patch'] or '0'))

[docs]class DeprecatedWarning(DeprecationWarning): """A warning class for deprecated methods This is a specialization of the built-in :class:`DeprecationWarning`, adding parameters that allow us to get information into the __str__ that ends up being sent through the :mod:`warnings` system. The attributes aren't able to be retrieved after the warning gets raised and passed through the system as only the class--not the instance--and message are what gets preserved. :param function: The function being deprecated. :param deprecated_in: The version that ``function`` is deprecated in :param removed_in: The version or :class:`` specifying when ``function`` gets removed. :param details: Optional details about the deprecation. Most often this will include directions on what to use instead of the now deprecated code. """ def __init__(self, function, deprecated_in, removed_in, details=""): # NOTE: The docstring only works for this class if it appears up # near the class name, not here inside __init__. I think it has # to do with being an exception class. self.function = function self.deprecated_in = deprecated_in self.removed_in = removed_in self.details = details super(DeprecatedWarning, self).__init__(function, deprecated_in, removed_in, details) def __str__(self): # Use a defaultdict to give us the empty string # when a part isn't included. parts = collections.defaultdict(str) parts["function"] = self.function if self.deprecated_in: parts["deprecated"] = " as of %s" % self.deprecated_in if self.removed_in: parts["removed"] = " and will be removed {} {}".format("on" if isinstance(self.removed_in, date) else "in", self.removed_in) if any([self.deprecated_in, self.removed_in, self.details]): parts["period"] = "." if self.details: parts["details"] = " %s" % self.details return ("%(function)s is deprecated%(deprecated)s%(removed)s" "%(period)s%(details)s" % (parts))
[docs]class UnsupportedWarning(DeprecatedWarning): """A warning class for methods to be removed This is a subclass of :class:`~deprecation.DeprecatedWarning` and is used to output a proper message about a function being unsupported. Additionally, the :func:`~deprecation.fail_if_not_removed` decorator will handle this warning and cause any tests to fail if the system under test uses code that raises this warning. """ def __str__(self): parts = collections.defaultdict(str) parts["function"] = self.function parts["removed"] = self.removed_in if self.details: parts["details"] = " %s" % self.details return ("%(function)s is unsupported as of %(removed)s." "%(details)s" % (parts))
[docs]def deprecated(deprecated_in: str, removed_in=None, current_version=None, details=""): """Decorate a function to signify its deprecation This function wraps a method that will soon be removed and does two things: * The docstring of the method will be modified to include a notice about deprecation, e.g., "Deprecated since 0.9.11. Use foo instead." * Raises a :class:`~deprecation.DeprecatedWarning` via the :mod:`warnings` module, which is a subclass of the built-in :class:`DeprecationWarning`. Note that built-in :class:`DeprecationWarning` are ignored by default, so for users to be informed of said warnings they will need to enable them--see the :mod:`warnings` module documentation for more details. :param deprecated_in: The version at which the decorated method is considered deprecated. This will usually be the next version to be released when the decorator is added. :param removed_in: The version or :class:`` when the decorated method will be removed. The default is **None**, specifying that the function is not currently planned to be removed. :param current_version: The source of version information for the currently running code. This will usually be a `__version__` attribute on your library. The default is `None`. When `current_version=None` the automation to determine if the wrapped function is actually in a period of deprecation or time for removal does not work, causing a :class:`~deprecation.DeprecatedWarning` to be raised in all cases. :param details: Extra details to be added to the method docstring and warning. For example, the details may point users to a replacement method, such as "Use the foo_bar method instead". By default there are no details. """ # You can't just jump to removal. It's weird, unfair, and also makes # building up the docstring weird. if deprecated_in is None and removed_in is not None: raise TypeError("Cannot set removed_in to a value " "without also setting deprecated_in") # Only warn when it's appropriate. There may be cases when it makes sense # to add this decorator before a formal deprecation period begins. # In CPython, PendingDeprecatedWarning gets used in that period, # so perhaps mimick that at some point. is_deprecated = False is_unsupported = False # StrictVersion won't take a None or a "", so make whatever goes to it # is at least *something*. Compare versions only if removed_in is not # of type if isinstance(removed_in, date): if >= removed_in: is_unsupported = True else: is_deprecated = True elif current_version: current_version = parse_version(current_version) if (removed_in and current_version >= parse_version(removed_in)): is_unsupported = True elif (deprecated_in and current_version >= parse_version(deprecated_in)): is_deprecated = True else: # If we can't actually calculate that we're in a period of # deprecation...well, they used the decorator, so it's deprecated. # This will cover the case of someone just using # @deprecated("1.0") without the other advantages. is_deprecated = True should_warn = any([is_deprecated, is_unsupported]) def _function_wrapper(function): if should_warn: # Everything *should* have a docstring, but just in case... existing_docstring = function.__doc__ or "" # The various parts of this decorator being optional makes for # a number of ways the deprecation notice could go. The following # makes for a nicely constructed sentence with or without any # of the parts. # If removed_in is a date, use "removed on" # If removed_in is a version, use "removed in" parts = { "deprecated_in": " %s" % deprecated_in if deprecated_in else "<unknown>", "removed_in": "\n This will be removed {} {}.".format("on" if isinstance(removed_in, date) else "in", removed_in) if removed_in else "", "details": " %s" % details if details else ""} deprecation_note = (".. deprecated::{deprecated_in}" "{removed_in}{details}".format(**parts)) # default location for insertion of deprecation note loc = 1 # split docstring at first occurrence of newline string_list = existing_docstring.split("\n", 1) if len(string_list) > 1: # With a multi-line docstring, when we modify # existing_docstring to add our deprecation_note, # if we're not careful we'll interfere with the # indentation levels of the contents below the # first line, or as PEP 257 calls it, the summary # line. Since the summary line can start on the # same line as the """, dedenting the whole thing # won't help. Split the summary and contents up, # dedent the contents independently, then join # summary, dedent'ed contents, and our # deprecation_note. # in-place dedent docstring content string_list[1] = textwrap.dedent(string_list[1]) # we need another newline string_list.insert(loc, "\n") # change the message_location if we add to end of docstring # do this always if not "top" if message_location != "top": loc = 3 # insert deprecation note and dual newline string_list.insert(loc, deprecation_note) string_list.insert(loc, "\n\n") function.__doc__ = "".join(string_list) @functools.wraps(function) def _inner(*args, **kwargs): if should_warn: if is_unsupported: cls = UnsupportedWarning else: cls = DeprecatedWarning the_warning = cls(function.__name__, deprecated_in, removed_in, details) warnings.warn(the_warning, category=DeprecationWarning, stacklevel=2) return function(*args, **kwargs) return _inner return _function_wrapper
[docs]def fail_if_not_removed(method): """Decorate a test method to track removal of deprecated code This decorator catches :class:`~deprecation.UnsupportedWarning` warnings that occur during testing and causes unittests to fail, making it easier to keep track of when code should be removed. :raises: :class:`AssertionError` if an :class:`~deprecation.UnsupportedWarning` is raised while running the test method. """ # NOTE(briancurtin): Unless this is named test_inner, nose won't work # properly. See Issue #32. @functools.wraps(method) def test_inner(*args, **kwargs): with warnings.catch_warnings(record=True) as caught_warnings: warnings.simplefilter("always") rv = method(*args, **kwargs) for warning in caught_warnings: if warning.category == UnsupportedWarning: raise AssertionError( ("%s uses a function that should be removed: %s" % (method, str(warning.message)))) return rv return test_inner