omdev 0.0.0.dev7__py3-none-any.whl

omdev/versioning/specifiers.py

@@ -0,0 +1,531 @@
+# Copyright (c) Donald Stufft and individual contributors.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
+# following conditions are met:
+#
+#     1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
+#        following disclaimer.
+#
+#     2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
+#        following disclaimer in the documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. This file is dual licensed under the terms of the
+# Apache License, Version 2.0, and the BSD License. See the LICENSE file in the root of this repository for complete
+# details.
+# https://github.com/pypa/packaging/blob/2c885fe91a54559e2382902dce28428ad2887be5/src/packaging/specifiers.py
+# ruff: noqa: UP006 UP007
+import abc
+import itertools
+import re
+import typing as ta
+
+from .versions import Version
+from .versions import canonicalize_version
+
+
+UnparsedVersion = ta.Union['Version', str]
+UnparsedVersionVar = ta.TypeVar('UnparsedVersionVar', bound=UnparsedVersion)
+CallableVersionOperator = ta.Callable[['Version', str], bool]
+
+
+##
+
+
+def _coerce_version(version: UnparsedVersion) -> Version:
+    if not isinstance(version, Version):
+        version = Version(version)
+    return version
+
+
+class InvalidSpecifier(ValueError):  # noqa
+    pass
+
+
+class BaseSpecifier(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def __str__(self) -> str:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __hash__(self) -> int:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __eq__(self, other: object) -> bool:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def prereleases(self) -> ta.Optional[bool]:
+        raise NotImplementedError
+
+    @prereleases.setter
+    def prereleases(self, value: bool) -> None:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def contains(self, item: str, prereleases: ta.Optional[bool] = None) -> bool:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def filter(
+            self,
+            iterable: ta.Iterable[UnparsedVersionVar],
+            prereleases: ta.Optional[bool] = None,
+    ) -> ta.Iterator[UnparsedVersionVar]:
+        raise NotImplementedError
+
+
+class Specifier(BaseSpecifier):
+    _operator_regex_str = r"""
+        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
+        """
+
+    _version_regex_str = r"""
+        (?P<version>
+            (?:
+                (?<====)
+                \s*
+                [^\s;)]*
+            )
+            |
+            (?:
+                (?<===|!=)
+                \s*
+                v?
+                (?:[0-9]+!)?
+                [0-9]+(?:\.[0-9]+)*
+                (?:
+                    \.\*
+                    |
+                    (?:
+                        [-_\.]?
+                        (alpha|beta|preview|pre|a|b|c|rc)
+                        [-_\.]?
+                        [0-9]*
+                    )?
+                    (?:
+                        (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                    )?
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?
+                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)?
+                )?
+            )
+            |
+            (?:
+                (?<=~=)
+                \s*
+                v?
+                (?:[0-9]+!)?
+                [0-9]+(?:\.[0-9]+)+
+                (?:
+                    [-_\.]?
+                    (alpha|beta|preview|pre|a|b|c|rc)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?
+            )
+            |
+            (?:
+                (?<!==|!=|~=)
+                \s*
+                v?
+                (?:[0-9]+!)?
+                [0-9]+(?:\.[0-9]+)*
+                (?:
+                    [-_\.]?
+                    (alpha|beta|preview|pre|a|b|c|rc)
+                    [-_\.]?
+                    [0-9]*
+                )?
+                (?:
+                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                )?
+                (?:[-_\.]?dev[-_\.]?[0-9]*)?
+            )
+        )
+        """
+
+    _regex = re.compile(
+        r'^\s*' + _operator_regex_str + _version_regex_str + r'\s*$',
+        re.VERBOSE | re.IGNORECASE,
+    )
+
+    OPERATORS: ta.ClassVar[ta.Mapping[str, str]] = {
+        '~=': 'compatible',
+        '==': 'equal',
+        '!=': 'not_equal',
+        '<=': 'less_than_equal',
+        '>=': 'greater_than_equal',
+        '<': 'less_than',
+        '>': 'greater_than',
+        '===': 'arbitrary',
+    }
+
+    def __init__(
+            self,
+            spec: str = '',
+            prereleases: ta.Optional[bool] = None,
+    ) -> None:
+        match = self._regex.search(spec)
+        if not match:
+            raise InvalidSpecifier(f"Invalid specifier: '{spec}'")
+
+        self._spec: ta.Tuple[str, str] = (
+            match.group('operator').strip(),
+            match.group('version').strip(),
+        )
+
+        self._prereleases = prereleases
+
+    @property  # type: ignore
+    def prereleases(self) -> bool:
+        if self._prereleases is not None:
+            return self._prereleases
+
+        operator, version = self._spec
+        if operator in ['==', '>=', '<=', '~=', '===']:
+            if operator == '==' and version.endswith('.*'):
+                version = version[:-2]
+
+            if Version(version).is_prerelease:
+                return True
+
+        return False
+
+    @prereleases.setter
+    def prereleases(self, value: bool) -> None:
+        self._prereleases = value
+
+    @property
+    def operator(self) -> str:
+        return self._spec[0]
+
+    @property
+    def version(self) -> str:
+        return self._spec[1]
+
+    def __repr__(self) -> str:
+        pre = (
+            f', prereleases={self.prereleases!r}'
+            if self._prereleases is not None
+            else ''
+        )
+
+        return f'<{self.__class__.__name__}({str(self)!r}{pre})>'
+
+    def __str__(self) -> str:
+        return '{}{}'.format(*self._spec)
+
+    @property
+    def _canonical_spec(self) -> ta.Tuple[str, str]:
+        canonical_version = canonicalize_version(
+            self._spec[1],
+            strip_trailing_zero=(self._spec[0] != '~='),
+        )
+        return self._spec[0], canonical_version
+
+    def __hash__(self) -> int:
+        return hash(self._canonical_spec)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, str):
+            try:
+                other = self.__class__(str(other))
+            except InvalidSpecifier:
+                return NotImplemented
+        elif not isinstance(other, self.__class__):
+            return NotImplemented
+
+        return self._canonical_spec == other._canonical_spec
+
+    def _get_operator(self, op: str) -> CallableVersionOperator:
+        operator_callable: CallableVersionOperator = getattr(self, f'_compare_{self.OPERATORS[op]}')
+        return operator_callable
+
+    def _compare_compatible(self, prospective: Version, spec: str) -> bool:
+        prefix = _version_join(list(itertools.takewhile(_is_not_version_suffix, _version_split(spec)))[:-1])
+        prefix += '.*'
+        return self._get_operator('>=')(prospective, spec) and self._get_operator('==')(prospective, prefix)
+
+    def _compare_equal(self, prospective: Version, spec: str) -> bool:
+        if spec.endswith('.*'):
+            normalized_prospective = canonicalize_version(prospective.public, strip_trailing_zero=False)
+            normalized_spec = canonicalize_version(spec[:-2], strip_trailing_zero=False)
+            split_spec = _version_split(normalized_spec)
+
+            split_prospective = _version_split(normalized_prospective)
+            padded_prospective, _ = _pad_version(split_prospective, split_spec)
+            shortened_prospective = padded_prospective[: len(split_spec)]
+
+            return shortened_prospective == split_spec
+
+        else:
+            spec_version = Version(spec)
+            if not spec_version.local:
+                prospective = Version(prospective.public)
+            return prospective == spec_version
+
+    def _compare_not_equal(self, prospective: Version, spec: str) -> bool:
+        return not self._compare_equal(prospective, spec)
+
+    def _compare_less_than_equal(self, prospective: Version, spec: str) -> bool:
+        return Version(prospective.public) <= Version(spec)
+
+    def _compare_greater_than_equal(self, prospective: Version, spec: str) -> bool:
+        return Version(prospective.public) >= Version(spec)
+
+    def _compare_less_than(self, prospective: Version, spec_str: str) -> bool:
+        spec = Version(spec_str)
+
+        if not prospective < spec:
+            return False
+
+        if not spec.is_prerelease and prospective.is_prerelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        return True
+
+    def _compare_greater_than(self, prospective: Version, spec_str: str) -> bool:
+        spec = Version(spec_str)
+
+        if not prospective > spec:
+            return False
+
+        if not spec.is_postrelease and prospective.is_postrelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        if prospective.local is not None:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        return True
+
+    def _compare_arbitrary(self, prospective: Version, spec: str) -> bool:
+        return str(prospective).lower() == str(spec).lower()
+
+    def __contains__(self, item: ta.Union[str, Version]) -> bool:
+        return self.contains(item)
+
+    def contains(self, item: UnparsedVersion, prereleases: ta.Optional[bool] = None) -> bool:
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        normalized_item = _coerce_version(item)
+
+        if normalized_item.is_prerelease and not prereleases:
+            return False
+
+        operator_callable: CallableVersionOperator = self._get_operator(self.operator)
+        return operator_callable(normalized_item, self.version)
+
+    def filter(
+            self,
+            iterable: ta.Iterable[UnparsedVersionVar],
+            prereleases: ta.Optional[bool] = None,
+    ) -> ta.Iterator[UnparsedVersionVar]:
+        yielded = False
+        found_prereleases = []
+
+        kw = {'prereleases': prereleases if prereleases is not None else True}
+
+        for version in iterable:
+            parsed_version = _coerce_version(version)
+
+            if self.contains(parsed_version, **kw):
+                if parsed_version.is_prerelease and not (prereleases or self.prereleases):
+                    found_prereleases.append(version)
+                else:
+                    yielded = True
+                    yield version
+
+        if not yielded and found_prereleases:
+            for version in found_prereleases:
+                yield version
+
+
+_version_prefix_regex = re.compile(r'^([0-9]+)((?:a|b|c|rc)[0-9]+)$')
+
+
+def _version_split(version: str) -> ta.List[str]:
+    result: ta.List[str] = []
+
+    epoch, _, rest = version.rpartition('!')
+    result.append(epoch or '0')
+
+    for item in rest.split('.'):
+        match = _version_prefix_regex.search(item)
+        if match:
+            result.extend(match.groups())
+        else:
+            result.append(item)
+    return result
+
+
+def _version_join(components: ta.List[str]) -> str:
+    epoch, *rest = components
+    return f"{epoch}!{'.'.join(rest)}"
+
+
+def _is_not_version_suffix(segment: str) -> bool:
+    return not any(segment.startswith(prefix) for prefix in ('dev', 'a', 'b', 'rc', 'post'))
+
+
+def _pad_version(left: ta.List[str], right: ta.List[str]) -> ta.Tuple[ta.List[str], ta.List[str]]:
+    left_split, right_split = [], []
+
+    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
+    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
+
+    left_split.append(left[len(left_split[0]):])
+    right_split.append(right[len(right_split[0]):])
+
+    left_split.insert(1, ['0'] * max(0, len(right_split[0]) - len(left_split[0])))
+    right_split.insert(1, ['0'] * max(0, len(left_split[0]) - len(right_split[0])))
+
+    return (
+        list(itertools.chain.from_iterable(left_split)),
+        list(itertools.chain.from_iterable(right_split)),
+    )
+
+
+class SpecifierSet(BaseSpecifier):
+    def __init__(
+            self,
+            specifiers: str = '',
+            prereleases: ta.Optional[bool] = None,
+    ) -> None:
+        split_specifiers = [s.strip() for s in specifiers.split(',') if s.strip()]
+
+        self._specs = frozenset(map(Specifier, split_specifiers))
+        self._prereleases = prereleases
+
+    @property
+    def prereleases(self) -> ta.Optional[bool]:
+        if self._prereleases is not None:
+            return self._prereleases
+
+        if not self._specs:
+            return None
+
+        return any(s.prereleases for s in self._specs)
+
+    @prereleases.setter
+    def prereleases(self, value: bool) -> None:
+        self._prereleases = value
+
+    def __repr__(self) -> str:
+        pre = (
+            f', prereleases={self.prereleases!r}'
+            if self._prereleases is not None
+            else ''
+        )
+
+        return f'<SpecifierSet({str(self)!r}{pre})>'
+
+    def __str__(self) -> str:
+        return ','.join(sorted(str(s) for s in self._specs))
+
+    def __hash__(self) -> int:
+        return hash(self._specs)
+
+    def __and__(self, other: ta.Union['SpecifierSet', str]) -> 'SpecifierSet':
+        if isinstance(other, str):
+            other = SpecifierSet(other)
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented  # type: ignore
+
+        specifier = SpecifierSet()
+        specifier._specs = frozenset(self._specs | other._specs)
+
+        if self._prereleases is None and other._prereleases is not None:
+            specifier._prereleases = other._prereleases
+        elif self._prereleases is not None and other._prereleases is None:
+            specifier._prereleases = self._prereleases
+        elif self._prereleases == other._prereleases:
+            specifier._prereleases = self._prereleases
+        else:
+            raise ValueError('Cannot combine SpecifierSets with True and False prerelease overrides.')
+
+        return specifier
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, (str, Specifier)):
+            other = SpecifierSet(str(other))
+        elif not isinstance(other, SpecifierSet):
+            return NotImplemented
+
+        return self._specs == other._specs
+
+    def __len__(self) -> int:
+        return len(self._specs)
+
+    def __iter__(self) -> ta.Iterator[Specifier]:
+        return iter(self._specs)
+
+    def __contains__(self, item: UnparsedVersion) -> bool:
+        return self.contains(item)
+
+    def contains(
+        self,
+        item: UnparsedVersion,
+        prereleases: ta.Optional[bool] = None,
+        installed: ta.Optional[bool] = None,
+    ) -> bool:
+        if not isinstance(item, Version):
+            item = Version(item)
+
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        if not prereleases and item.is_prerelease:
+            return False
+
+        if installed and item.is_prerelease:
+            item = Version(item.base_version)
+
+        return all(s.contains(item, prereleases=prereleases) for s in self._specs)
+
+    def filter(
+            self,
+            iterable: ta.Iterable[UnparsedVersionVar],
+            prereleases: ta.Optional[bool] = None,
+    ) -> ta.Iterator[UnparsedVersionVar]:
+        if prereleases is None:
+            prereleases = self.prereleases
+
+        if self._specs:
+            for spec in self._specs:
+                iterable = spec.filter(iterable, prereleases=bool(prereleases))
+            return iter(iterable)
+
+        else:
+            filtered: ta.List[UnparsedVersionVar] = []
+            found_prereleases: ta.List[UnparsedVersionVar] = []
+
+            for item in iterable:
+                parsed_version = _coerce_version(item)
+
+                if parsed_version.is_prerelease and not prereleases:
+                    if not filtered:
+                        found_prereleases.append(item)
+                else:
+                    filtered.append(item)
+
+            if not filtered and found_prereleases and prereleases is None:
+                return iter(found_prereleases)
+
+            return iter(filtered)