id card

1 files changed, 0 insertions, 290 deletions

diff --git a/env/lib/python3.10/site-packages/deprecation.py b/env/lib/python3.10/site-packages/deprecation.py
deleted file mode 100644
index 0217b58..0000000
--- a/env/lib/python3.10/site-packages/deprecation.py
+++ /dev/null
@@ -1,290 +0,0 @@
-# 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
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# 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 collections
-import functools
-import textwrap
-import warnings
-
-from packaging import version
-from datetime import date
-
-__version__ = "2.1.0"
-
-# 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"
-
-
-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:`datetime.date` 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))
-
-
-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))
-
-
-def deprecated(deprecated_in=None, 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`s 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. The default is **None**, which effectively
-                          means immediate deprecation. If this is not
-                          specified, then the `removed_in` and
-                          `current_version` arguments are ignored.
-    :param removed_in: The version or :class:`datetime.date` when the decorated
-                       method will be removed. The default is **None**,
-                       specifying that the function is not currently planned
-                       to be removed.
-                       Note: This parameter cannot be set to a value if
-                       `deprecated_in=None`.
-    :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 datetime.date
-    if isinstance(removed_in, date):
-        if date.today() >= removed_in:
-            is_unsupported = True
-        else:
-            is_deprecated = True
-    elif current_version:
-        current_version = version.parse(current_version)
-
-        if (removed_in
-                and current_version >= version.parse(removed_in)):
-            is_unsupported = True
-        elif (deprecated_in
-              and current_version >= version.parse(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 "",
-                "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
-
-
-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