@scrypted/arlo 0.11.26 → 0.11.28

package/venv/lib/python3.10/site-packages/setuptools/_distutils/version.py

@@ -1,363 +0,0 @@
-#
-# distutils/version.py
-#
-# Implements multiple version numbering conventions for the
-# Python Module Distribution Utilities.
-#
-# $Id$
-#
-
-"""Provides classes to represent module version numbers (one class for
-each style of version numbering).  There are currently two such classes
-implemented: StrictVersion and LooseVersion.
-
-Every version number class implements the following interface:
-  * the 'parse' method takes a string and parses it to some internal
-    representation; if the string is an invalid version number,
-    'parse' raises a ValueError exception
-  * the class constructor takes an optional string argument which,
-    if supplied, is passed to 'parse'
-  * __str__ reconstructs the string that was passed to 'parse' (or
-    an equivalent string -- ie. one that will generate an equivalent
-    version number instance)
-  * __repr__ generates Python code to recreate the version number instance
-  * _cmp compares the current instance with either another instance
-    of the same class or a string (which will be parsed to an instance
-    of the same class, thus must follow the same rules)
-"""
-
-import re
-import warnings
-import contextlib
-
-
-@contextlib.contextmanager
-def suppress_known_deprecation():
-    with warnings.catch_warnings(record=True) as ctx:
-        warnings.filterwarnings(
-            action='default',
-            category=DeprecationWarning,
-            message="distutils Version classes are deprecated.",
-        )
-        yield ctx
-
-
-class Version:
-    """Abstract base class for version numbering classes.  Just provides
-    constructor (__init__) and reproducer (__repr__), because those
-    seem to be the same for all version numbering classes; and route
-    rich comparisons to _cmp.
-    """
-
-    def __init__ (self, vstring=None):
-        warnings.warn(
-            "distutils Version classes are deprecated. "
-            "Use packaging.version instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        if vstring:
-            self.parse(vstring)
-
-    def __repr__ (self):
-        return "%s ('%s')" % (self.__class__.__name__, str(self))
-
-    def __eq__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c == 0
-
-    def __lt__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c < 0
-
-    def __le__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c <= 0
-
-    def __gt__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c > 0
-
-    def __ge__(self, other):
-        c = self._cmp(other)
-        if c is NotImplemented:
-            return c
-        return c >= 0
-
-
-# Interface for version-number classes -- must be implemented
-# by the following classes (the concrete ones -- Version should
-# be treated as an abstract class).
-#    __init__ (string) - create and take same action as 'parse'
-#                        (string parameter is optional)
-#    parse (string)    - convert a string representation to whatever
-#                        internal representation is appropriate for
-#                        this style of version numbering
-#    __str__ (self)    - convert back to a string; should be very similar
-#                        (if not identical to) the string supplied to parse
-#    __repr__ (self)   - generate Python code to recreate
-#                        the instance
-#    _cmp (self, other) - compare two version numbers ('other' may
-#                        be an unparsed version string, or another
-#                        instance of your version class)
-
-
-class StrictVersion (Version):
-
-    """Version numbering for anal retentives and software idealists.
-    Implements the standard interface for version number classes as
-    described above.  A version number consists of two or three
-    dot-separated numeric components, with an optional "pre-release" tag
-    on the end.  The pre-release tag consists of the letter 'a' or 'b'
-    followed by a number.  If the numeric components of two version
-    numbers are equal, then one with a pre-release tag will always
-    be deemed earlier (lesser) than one without.
-
-    The following are valid version numbers (shown in the order that
-    would be obtained by sorting according to the supplied cmp function):
-
-        0.4       0.4.0  (these two are equivalent)
-        0.4.1
-        0.5a1
-        0.5b3
-        0.5
-        0.9.6
-        1.0
-        1.0.4a3
-        1.0.4b1
-        1.0.4
-
-    The following are examples of invalid version numbers:
-
-        1
-        2.7.2.2
-        1.3.a4
-        1.3pl1
-        1.3c4
-
-    The rationale for this version numbering system will be explained
-    in the distutils documentation.
-    """
-
-    version_re = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$',
-                            re.VERBOSE | re.ASCII)
-
-
-    def parse (self, vstring):
-        match = self.version_re.match(vstring)
-        if not match:
-            raise ValueError("invalid version number '%s'" % vstring)
-
-        (major, minor, patch, prerelease, prerelease_num) = \
-            match.group(1, 2, 4, 5, 6)
-
-        if patch:
-            self.version = tuple(map(int, [major, minor, patch]))
-        else:
-            self.version = tuple(map(int, [major, minor])) + (0,)
-
-        if prerelease:
-            self.prerelease = (prerelease[0], int(prerelease_num))
-        else:
-            self.prerelease = None
-
-
-    def __str__ (self):
-
-        if self.version[2] == 0:
-            vstring = '.'.join(map(str, self.version[0:2]))
-        else:
-            vstring = '.'.join(map(str, self.version))
-
-        if self.prerelease:
-            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])
-
-        return vstring
-
-
-    def _cmp (self, other):
-        if isinstance(other, str):
-            with suppress_known_deprecation():
-                other = StrictVersion(other)
-        elif not isinstance(other, StrictVersion):
-            return NotImplemented
-
-        if self.version != other.version:
-            # numeric versions don't match
-            # prerelease stuff doesn't matter
-            if self.version < other.version:
-                return -1
-            else:
-                return 1
-
-        # have to compare prerelease
-        # case 1: neither has prerelease; they're equal
-        # case 2: self has prerelease, other doesn't; other is greater
-        # case 3: self doesn't have prerelease, other does: self is greater
-        # case 4: both have prerelease: must compare them!
-
-        if (not self.prerelease and not other.prerelease):
-            return 0
-        elif (self.prerelease and not other.prerelease):
-            return -1
-        elif (not self.prerelease and other.prerelease):
-            return 1
-        elif (self.prerelease and other.prerelease):
-            if self.prerelease == other.prerelease:
-                return 0
-            elif self.prerelease < other.prerelease:
-                return -1
-            else:
-                return 1
-        else:
-            assert False, "never get here"
-
-# end class StrictVersion
-
-
-# The rules according to Greg Stein:
-# 1) a version number has 1 or more numbers separated by a period or by
-#    sequences of letters. If only periods, then these are compared
-#    left-to-right to determine an ordering.
-# 2) sequences of letters are part of the tuple for comparison and are
-#    compared lexicographically
-# 3) recognize the numeric components may have leading zeroes
-#
-# The LooseVersion class below implements these rules: a version number
-# string is split up into a tuple of integer and string components, and
-# comparison is a simple tuple comparison.  This means that version
-# numbers behave in a predictable and obvious way, but a way that might
-# not necessarily be how people *want* version numbers to behave.  There
-# wouldn't be a problem if people could stick to purely numeric version
-# numbers: just split on period and compare the numbers as tuples.
-# However, people insist on putting letters into their version numbers;
-# the most common purpose seems to be:
-#   - indicating a "pre-release" version
-#     ('alpha', 'beta', 'a', 'b', 'pre', 'p')
-#   - indicating a post-release patch ('p', 'pl', 'patch')
-# but of course this can't cover all version number schemes, and there's
-# no way to know what a programmer means without asking him.
-#
-# The problem is what to do with letters (and other non-numeric
-# characters) in a version number.  The current implementation does the
-# obvious and predictable thing: keep them as strings and compare
-# lexically within a tuple comparison.  This has the desired effect if
-# an appended letter sequence implies something "post-release":
-# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
-#
-# However, if letters in a version number imply a pre-release version,
-# the "obvious" thing isn't correct.  Eg. you would expect that
-# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
-# implemented here, this just isn't so.
-#
-# Two possible solutions come to mind.  The first is to tie the
-# comparison algorithm to a particular set of semantic rules, as has
-# been done in the StrictVersion class above.  This works great as long
-# as everyone can go along with bondage and discipline.  Hopefully a
-# (large) subset of Python module programmers will agree that the
-# particular flavour of bondage and discipline provided by StrictVersion
-# provides enough benefit to be worth using, and will submit their
-# version numbering scheme to its domination.  The free-thinking
-# anarchists in the lot will never give in, though, and something needs
-# to be done to accommodate them.
-#
-# Perhaps a "moderately strict" version class could be implemented that
-# lets almost anything slide (syntactically), and makes some heuristic
-# assumptions about non-digits in version number strings.  This could
-# sink into special-case-hell, though; if I was as talented and
-# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
-# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
-# just as happy dealing with things like "2g6" and "1.13++".  I don't
-# think I'm smart enough to do it right though.
-#
-# In any case, I've coded the test suite for this module (see
-# ../test/test_version.py) specifically to fail on things like comparing
-# "1.2a2" and "1.2".  That's not because the *code* is doing anything
-# wrong, it's because the simple, obvious design doesn't match my
-# complicated, hairy expectations for real-world version numbers.  It
-# would be a snap to fix the test suite to say, "Yep, LooseVersion does
-# the Right Thing" (ie. the code matches the conception).  But I'd rather
-# have a conception that matches common notions about version numbers.
-
-class LooseVersion (Version):
-
-    """Version numbering for anarchists and software realists.
-    Implements the standard interface for version number classes as
-    described above.  A version number consists of a series of numbers,
-    separated by either periods or strings of letters.  When comparing
-    version numbers, the numeric components will be compared
-    numerically, and the alphabetic components lexically.  The following
-    are all valid version numbers, in no particular order:
-
-        1.5.1
-        1.5.2b2
-        161
-        3.10a
-        8.02
-        3.4j
-        1996.07.12
-        3.2.pl0
-        3.1.1.6
-        2g6
-        11g
-        0.960923
-        2.2beta29
-        1.13++
-        5.5.kw
-        2.0b1pl0
-
-    In fact, there is no such thing as an invalid version number under
-    this scheme; the rules for comparison are simple and predictable,
-    but may not always give the results you want (for some definition
-    of "want").
-    """
-
-    component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
-
-    def parse (self, vstring):
-        # I've given up on thinking I can reconstruct the version string
-        # from the parsed tuple -- so I just store the string here for
-        # use by __str__
-        self.vstring = vstring
-        components = [x for x in self.component_re.split(vstring)
-                              if x and x != '.']
-        for i, obj in enumerate(components):
-            try:
-                components[i] = int(obj)
-            except ValueError:
-                pass
-
-        self.version = components
-
-
-    def __str__ (self):
-        return self.vstring
-
-
-    def __repr__ (self):
-        return "LooseVersion ('%s')" % str(self)
-
-
-    def _cmp (self, other):
-        if isinstance(other, str):
-            other = LooseVersion(other)
-        elif not isinstance(other, LooseVersion):
-            return NotImplemented
-
-        if self.version == other.version:
-            return 0
-        if self.version < other.version:
-            return -1
-        if self.version > other.version:
-            return 1
-
-
-# end class LooseVersion

package/venv/lib/python3.10/site-packages/setuptools/_distutils/versionpredicate.py

@@ -1,169 +0,0 @@
-"""Module for parsing and testing package version predicate strings.
-"""
-import re
-import distutils.version
-import operator
-
-
-re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)",
-    re.ASCII)
-# (package) (rest)
-
-re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses
-re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
-# (comp) (version)
-
-
-def splitUp(pred):
-    """Parse a single version comparison.
-
-    Return (comparison string, StrictVersion)
-    """
-    res = re_splitComparison.match(pred)
-    if not res:
-        raise ValueError("bad package restriction syntax: %r" % pred)
-    comp, verStr = res.groups()
-    with distutils.version.suppress_known_deprecation():
-        other = distutils.version.StrictVersion(verStr)
-    return (comp, other)
-
-compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq,
-           ">": operator.gt, ">=": operator.ge, "!=": operator.ne}
-
-class VersionPredicate:
-    """Parse and test package version predicates.
-
-    >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')
-
-    The `name` attribute provides the full dotted name that is given::
-
-    >>> v.name
-    'pyepat.abc'
-
-    The str() of a `VersionPredicate` provides a normalized
-    human-readable version of the expression::
-
-    >>> print(v)
-    pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)
-
-    The `satisfied_by()` method can be used to determine with a given
-    version number is included in the set described by the version
-    restrictions::
-
-    >>> v.satisfied_by('1.1')
-    True
-    >>> v.satisfied_by('1.4')
-    True
-    >>> v.satisfied_by('1.0')
-    False
-    >>> v.satisfied_by('4444.4')
-    False
-    >>> v.satisfied_by('1555.1b3')
-    False
-
-    `VersionPredicate` is flexible in accepting extra whitespace::
-
-    >>> v = VersionPredicate(' pat( ==  0.1  )  ')
-    >>> v.name
-    'pat'
-    >>> v.satisfied_by('0.1')
-    True
-    >>> v.satisfied_by('0.2')
-    False
-
-    If any version numbers passed in do not conform to the
-    restrictions of `StrictVersion`, a `ValueError` is raised::
-
-    >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
-    Traceback (most recent call last):
-      ...
-    ValueError: invalid version number '1.2zb3'
-
-    It the module or package name given does not conform to what's
-    allowed as a legal module or package name, `ValueError` is
-    raised::
-
-    >>> v = VersionPredicate('foo-bar')
-    Traceback (most recent call last):
-      ...
-    ValueError: expected parenthesized list: '-bar'
-
-    >>> v = VersionPredicate('foo bar (12.21)')
-    Traceback (most recent call last):
-      ...
-    ValueError: expected parenthesized list: 'bar (12.21)'
-
-    """
-
-    def __init__(self, versionPredicateStr):
-        """Parse a version predicate string.
-        """
-        # Fields:
-        #    name:  package name
-        #    pred:  list of (comparison string, StrictVersion)
-
-        versionPredicateStr = versionPredicateStr.strip()
-        if not versionPredicateStr:
-            raise ValueError("empty package restriction")
-        match = re_validPackage.match(versionPredicateStr)
-        if not match:
-            raise ValueError("bad package name in %r" % versionPredicateStr)
-        self.name, paren = match.groups()
-        paren = paren.strip()
-        if paren:
-            match = re_paren.match(paren)
-            if not match:
-                raise ValueError("expected parenthesized list: %r" % paren)
-            str = match.groups()[0]
-            self.pred = [splitUp(aPred) for aPred in str.split(",")]
-            if not self.pred:
-                raise ValueError("empty parenthesized list in %r"
-                                 % versionPredicateStr)
-        else:
-            self.pred = []
-
-    def __str__(self):
-        if self.pred:
-            seq = [cond + " " + str(ver) for cond, ver in self.pred]
-            return self.name + " (" + ", ".join(seq) + ")"
-        else:
-            return self.name
-
-    def satisfied_by(self, version):
-        """True if version is compatible with all the predicates in self.
-        The parameter version must be acceptable to the StrictVersion
-        constructor.  It may be either a string or StrictVersion.
-        """
-        for cond, ver in self.pred:
-            if not compmap[cond](version, ver):
-                return False
-        return True
-
-
-_provision_rx = None
-
-def split_provision(value):
-    """Return the name and optional version number of a provision.
-
-    The version number, if given, will be returned as a `StrictVersion`
-    instance, otherwise it will be `None`.
-
-    >>> split_provision('mypkg')
-    ('mypkg', None)
-    >>> split_provision(' mypkg( 1.2 ) ')
-    ('mypkg', StrictVersion ('1.2'))
-    """
-    global _provision_rx
-    if _provision_rx is None:
-        _provision_rx = re.compile(
-            r"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$",
-            re.ASCII)
-    value = value.strip()
-    m = _provision_rx.match(value)
-    if not m:
-        raise ValueError("illegal provides specification: %r" % value)
-    ver = m.group(2) or None
-    if ver:
-        with distutils.version.suppress_known_deprecation():
-            ver = distutils.version.StrictVersion(ver)
-    return m.group(1), ver

package/venv/lib/python3.10/site-packages/setuptools/_imp.py

@@ -1,82 +0,0 @@
-"""
-Re-implementation of find_module and get_frozen_object
-from the deprecated imp module.
-"""
-
-import os
-import importlib.util
-import importlib.machinery
-
-from .py34compat import module_from_spec
-
-
-PY_SOURCE = 1
-PY_COMPILED = 2
-C_EXTENSION = 3
-C_BUILTIN = 6
-PY_FROZEN = 7
-
-
-def find_spec(module, paths):
-    finder = (
-        importlib.machinery.PathFinder().find_spec
-        if isinstance(paths, list) else
-        importlib.util.find_spec
-    )
-    return finder(module, paths)
-
-
-def find_module(module, paths=None):
-    """Just like 'imp.find_module()', but with package support"""
-    spec = find_spec(module, paths)
-    if spec is None:
-        raise ImportError("Can't find %s" % module)
-    if not spec.has_location and hasattr(spec, 'submodule_search_locations'):
-        spec = importlib.util.spec_from_loader('__init__.py', spec.loader)
-
-    kind = -1
-    file = None
-    static = isinstance(spec.loader, type)
-    if spec.origin == 'frozen' or static and issubclass(
-            spec.loader, importlib.machinery.FrozenImporter):
-        kind = PY_FROZEN
-        path = None  # imp compabilty
-        suffix = mode = ''  # imp compatibility
-    elif spec.origin == 'built-in' or static and issubclass(
-            spec.loader, importlib.machinery.BuiltinImporter):
-        kind = C_BUILTIN
-        path = None  # imp compabilty
-        suffix = mode = ''  # imp compatibility
-    elif spec.has_location:
-        path = spec.origin
-        suffix = os.path.splitext(path)[1]
-        mode = 'r' if suffix in importlib.machinery.SOURCE_SUFFIXES else 'rb'
-
-        if suffix in importlib.machinery.SOURCE_SUFFIXES:
-            kind = PY_SOURCE
-        elif suffix in importlib.machinery.BYTECODE_SUFFIXES:
-            kind = PY_COMPILED
-        elif suffix in importlib.machinery.EXTENSION_SUFFIXES:
-            kind = C_EXTENSION
-
-        if kind in {PY_SOURCE, PY_COMPILED}:
-            file = open(path, mode)
-    else:
-        path = None
-        suffix = mode = ''
-
-    return file, path, (suffix, mode, kind)
-
-
-def get_frozen_object(module, paths=None):
-    spec = find_spec(module, paths)
-    if not spec:
-        raise ImportError("Can't find %s" % module)
-    return spec.loader.get_code(module)
-
-
-def get_module(module, paths, info):
-    spec = find_spec(module, paths)
-    if not spec:
-        raise ImportError("Can't find %s" % module)
-    return module_from_spec(spec)

package/venv/lib/python3.10/site-packages/setuptools/_vendor/more_itertools/__init__.py

@@ -1,4 +0,0 @@
-from .more import *  # noqa
-from .recipes import *  # noqa
-
-__version__ = '8.8.0'