requirements-detector 1.3.1__tar.gz → 1.4.0__tar.gz

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/PKG-INFO

@@ -1,29 +1,29 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: requirements-detector
-Version: 1.3.1
+Version: 1.4.0
 Summary: Python tool to find and list requirements of a Python project
-Home-page: https://github.com/landscapeio/requirements-detector
 License: MIT
 Keywords: python,requirements detector
 Author: Landscape.io
 Author-email: code@landscape.io
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Dist: astroid (>=3.0,<4.0)
 Requires-Dist: packaging (>=21.3)
 Requires-Dist: semver (>=3.0.0,<4.0.0)
-Requires-Dist: toml (>=0.10.2,<0.11.0)
+Requires-Dist: tomli (>=2.2.1,<3.0.0) ; python_version < "3.11"
+Project-URL: Homepage, https://github.com/landscapeio/requirements-detector
 Description-Content-Type: text/markdown
 
 # Requirements Detector
@@ -45,7 +45,7 @@ When run from the root of a Python project, it will try to ascertain which libra
 It uses the following methods in order, in the root of the project:
 
 1. Parse `setup.py` (if this is successful, the remaining steps are skipped)
-2. Parse `pyproject.yoml` (if a `tool.poetry.dependencies` section is found, the remaining steps are skipped)
+2. Parse `pyproject.toml` (if a `tool.poetry.dependencies` section is found, the remaining steps are skipped)
 3. Parse `requirements.txt` or `requirements.pip`
 4. Parse all `*.txt` and `*.pip` files inside a folder called `requirements`
 5. Parse all files in the root folder matching `*requirements*.txt` or `reqs.txt` (so for example, `pip_requirements.txt` would match, as would `requirements_common.txt`)

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/README.md

@@ -17,7 +17,7 @@ When run from the root of a Python project, it will try to ascertain which libra
 It uses the following methods in order, in the root of the project:
 
 1. Parse `setup.py` (if this is successful, the remaining steps are skipped)
-2. Parse `pyproject.yoml` (if a `tool.poetry.dependencies` section is found, the remaining steps are skipped)
+2. Parse `pyproject.toml` (if a `tool.poetry.dependencies` section is found, the remaining steps are skipped)
 3. Parse `requirements.txt` or `requirements.pip`
 4. Parse all `*.txt` and `*.pip` files inside a folder called `requirements`
 5. Parse all files in the root folder matching `*requirements*.txt` or `reqs.txt` (so for example, `pip_requirements.txt` would match, as would `requirements_common.txt`)

requirements_detector-1.4.0/pyproject.toml

@@ -0,0 +1,52 @@
+[build-system]
+build-backend = "poetry.core.masonry.api"
+requires = [ "poetry-core>=1" ]
+
+[tool.poetry]
+name = "requirements-detector"
+version = "1.4.0"
+authors = [ "Landscape.io <code@landscape.io>" ]
+classifiers = [
+  'Development Status :: 5 - Production/Stable',
+  'Environment :: Console',
+  'Intended Audience :: Developers',
+  'Operating System :: Unix',
+  'Topic :: Software Development :: Quality Assurance',
+  'Programming Language :: Python :: 3.9',
+  'Programming Language :: Python :: 3.10',
+  'Programming Language :: Python :: 3.11',
+  'Programming Language :: Python :: 3.12',
+  'Programming Language :: Python :: 3.13',
+  'License :: OSI Approved :: MIT License',
+]
+license = "MIT"
+keywords = [ "python", "requirements detector" ]
+description = "Python tool to find and list requirements of a Python project"
+readme = "README.md"
+homepage = "https://github.com/landscapeio/requirements-detector"
+packages = [
+  { include = "requirements_detector/" },
+]
+include = [
+  "c2cgeoform/py.typed",
+]
+
+[tool.poetry.scripts]
+detect-requirements = 'requirements_detector.run:run'
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+astroid = "^3.0"
+packaging = ">=21.3"
+tomli = { version = "^2.2.1", python = "<3.11" }
+semver = "^3.0.0"
+
+[tool.poetry.dev-dependencies]
+tox = "^3.24.5"
+pre-commit = "^4.2.0"
+pytest = "^6.2.4"
+twine = "^6.1.0"
+coverage = "^5.5"
+pytest-benchmark = "^3.4.1"
+pytest-cov = "^2.12.1"
+types-toml = "^0.10.4"

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/requirements_detector/__init__.py

@@ -8,3 +8,14 @@ from requirements_detector.detect import (  # from_setup_py,
     from_requirements_txt,
     from_setup_py,
 )
+
+__all__ = [
+    "CouldNotParseRequirements",
+    "RequirementsNotFound",
+    "find_requirements",
+    "from_pyproject_toml",
+    "from_requirements_blob",
+    "from_requirements_dir",
+    "from_requirements_txt",
+    "from_setup_py",
+]

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/requirements_detector/detect.py

@@ -1,14 +1,21 @@
 import re
+import sys
 from pathlib import Path
-from typing import List, Union
-
-import toml
+from typing import List, Optional, Union
 
 from .exceptions import CouldNotParseRequirements, RequirementsNotFound
 from .handle_setup import from_setup_py
 from .poetry_semver import parse_constraint
+from .poetry_semver.version_constraint import VersionConstraint
 from .requirement import DetectedRequirement
 
+try:
+    # added in Python 3.11: https://docs.python.org/3/library/tomllib.html
+    import tomllib
+except ImportError:
+    # for Python <= 3.10:
+    import tomli as tomllib
+
 __all__ = [
     "find_requirements",
     "from_requirements_txt",
@@ -81,7 +88,7 @@ def find_requirements(path: P) -> List[DetectedRequirement]:
         if reqfile.exists and reqfile.is_file():
             try:
                 requirements += from_requirements_txt(reqfile)
-            except CouldNotParseRequirements as e:
+            except CouldNotParseRequirements:
                 pass
 
     requirements_dir = path / "requirements"
@@ -102,13 +109,34 @@ def find_requirements(path: P) -> List[DetectedRequirement]:
     raise RequirementsNotFound
 
 
+def _version_from_spec(spec: Union[list, dict, str]) -> Optional[VersionConstraint]:
+    if isinstance(spec, list):
+        constraint = None
+        for new_constraint in [_version_from_spec(s) for s in spec]:
+            if constraint is None:
+                constraint = new_constraint
+            elif new_constraint is not None:
+                constraint = constraint.union(new_constraint)
+        return constraint
+
+    if isinstance(spec, dict):
+        if "version" in spec:
+            spec = spec["version"]
+        else:
+            return None
+
+    return parse_constraint(spec)
+
+
 def from_pyproject_toml(toml_file: P) -> List[DetectedRequirement]:
     requirements = []
 
     if isinstance(toml_file, str):
         toml_file = Path(toml_file)
 
-    parsed = toml.load(toml_file)
+    with open(toml_file, "rb") as toml_file_open:
+        parsed = tomllib.load(toml_file_open)
+
     poetry_section = parsed.get("tool", {}).get("poetry", {})
     dependencies = poetry_section.get("dependencies", {})
     dependencies.update(poetry_section.get("dev-dependencies", {}))
@@ -116,16 +144,21 @@ def from_pyproject_toml(toml_file: P) -> List[DetectedRequirement]:
     for name, spec in dependencies.items():
         if name.lower() == "python":
             continue
-        if isinstance(spec, dict):
-            if "version" in spec:
-                spec = spec["version"]
-            else:
-                req = DetectedRequirement.parse(f"{name}", toml_file)
-                if req is not None:
-                    requirements.append(req)
-                    continue
-        parsed_spec = str(parse_constraint(spec))
-        if "," not in parsed_spec and "<" not in parsed_spec and ">" not in parsed_spec and "=" not in parsed_spec:
+
+        parsed_spec_obj = _version_from_spec(spec)
+        if parsed_spec_obj is None and isinstance(spec, dict) and "version" not in spec:
+            req = DetectedRequirement.parse(f"{name}", toml_file)
+            if req is not None:
+                requirements.append(req)
+                continue
+        assert parsed_spec_obj is not None
+        parsed_spec = str(parsed_spec_obj)
+        if (
+            "," not in parsed_spec
+            and "<" not in parsed_spec
+            and ">" not in parsed_spec
+            and "=" not in parsed_spec
+        ):
             parsed_spec = f"=={parsed_spec}"
 
         req = DetectedRequirement.parse(f"{name}{parsed_spec}", toml_file)

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/requirements_detector/poetry_semver/__init__.py

@@ -1,6 +1,5 @@
 import re
 
-from .empty_constraint import EmptyConstraint
 from .patterns import (
     BASIC_CONSTRAINT,
     CARET_CONSTRAINT,
@@ -16,14 +15,16 @@ from .version_union import VersionUnion
 __version__ = "0.1.0"
 
 
-def parse_constraint(constraints):  # type: (str) -> VersionConstraint
+def parse_constraint(constraints: str) -> VersionConstraint:
     if constraints == "*":
         return VersionRange()
 
     or_constraints = re.split(r"\s*\|\|?\s*", constraints.strip())
     or_groups = []
     for constraints in or_constraints:
-        and_constraints = re.split("(?<!^)(?<![=>< ,]) *(?<!-)[, ](?!-) *(?!,|$)", constraints)
+        and_constraints = re.split(
+            "(?<!^)(?<![=>< ,]) *(?<!-)[, ](?!-) *(?!,|$)", constraints
+        )
         constraint_objects = []
 
         if len(and_constraints) > 1:
@@ -47,7 +48,7 @@ def parse_constraint(constraints):  # type: (str) -> VersionConstraint
         return VersionUnion.of(*or_groups)
 
 
-def parse_single_constraint(constraint):  # type: (str) -> VersionConstraint
+def parse_single_constraint(constraint: str) -> VersionConstraint:
     m = re.match(r"(?i)^v?[xX*](\.[xX*])*$", constraint)
     if m:
         return VersionRange()
@@ -61,7 +62,9 @@ def parse_single_constraint(constraint):  # type: (str) -> VersionConstraint
         if len(m.group(1).split(".")) == 1:
             high = version.stable.next_major
 
-        return VersionRange(version, high, include_min=True, always_include_max_prerelease=True)
+        return VersionRange(
+            version, high, include_min=True, always_include_max_prerelease=True
+        )
 
     # PEP 440 Tilde range (~=)
     m = TILDE_PEP440_CONSTRAINT.match(constraint)
@@ -82,7 +85,9 @@ def parse_single_constraint(constraint):  # type: (str) -> VersionConstraint
             low = Version(version.major, version.minor, version.patch)
             high = version.stable.next_minor
 
-        return VersionRange(low, high, include_min=True, always_include_max_prerelease=True)
+        return VersionRange(
+            low, high, include_min=True, always_include_max_prerelease=True
+        )
 
     # Caret range
     m = CARET_CONSTRAINT.match(constraint)
@@ -142,7 +147,9 @@ def parse_single_constraint(constraint):  # type: (str) -> VersionConstraint
         try:
             version = Version.parse(version)
         except ValueError:
-            raise ValueError("Could not parse version constraint: {}".format(constraint))
+            raise ValueError(
+                "Could not parse version constraint: {}".format(constraint)
+            )
 
         if op == "<":
             return VersionRange(max=version)

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/requirements_detector/poetry_semver/patterns.py

@@ -6,7 +6,9 @@ MODIFIERS = (
     r"([+-]?([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?"
 )
 
-_COMPLETE_VERSION = r"v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.(\d+))?{}(?:\+[^\s]+)?".format(MODIFIERS)
+_COMPLETE_VERSION = (
+    r"v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.(\d+))?{}(?:\+[^\s]+)?".format(MODIFIERS)
+)
 
 COMPLETE_VERSION = re.compile("(?i)" + _COMPLETE_VERSION)
 
@@ -14,4 +16,6 @@ CARET_CONSTRAINT = re.compile(r"(?i)^\^({})$".format(_COMPLETE_VERSION))
 TILDE_CONSTRAINT = re.compile("(?i)^~(?!=)({})$".format(_COMPLETE_VERSION))
 TILDE_PEP440_CONSTRAINT = re.compile("(?i)^~=({})$".format(_COMPLETE_VERSION))
 X_CONSTRAINT = re.compile(r"^(!=|==)?\s*v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.[xX*])+$")
-BASIC_CONSTRAINT = re.compile(r"(?i)^(<>|!=|>=?|<=?|==?)?\s*({}|dev)".format(_COMPLETE_VERSION))
+BASIC_CONSTRAINT = re.compile(
+    r"(?i)^(<>|!=|>=?|<=?|==?)?\s*({}|dev)".format(_COMPLETE_VERSION)
+)

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/requirements_detector/poetry_semver/version.py

@@ -16,15 +16,15 @@ class Version(VersionRange):
 
     def __init__(
         self,
-        major,  # type: int
-        minor=None,  # type: Optional[int]
-        patch=None,  # type: Optional[int]
-        rest=None,  # type: Optional[int]
-        pre=None,  # type: Optional[str]
-        build=None,  # type: Optional[str]
-        text=None,  # type: Optional[str]
-        precision=None,  # type: Optional[int]
-    ):  # type: (...) -> None
+        major: int,
+        minor: Optional[int] = None,
+        patch: Optional[int] = None,
+        rest: Optional[int] = None,
+        pre: Optional[str] = None,
+        build: Optional[str] = None,
+        text: Optional[str] = None,
+        precision: Optional[int] = None,
+    ) -> None:
         self._major = int(major)
         self._precision = None
         if precision is None:
@@ -92,27 +92,27 @@ class Version(VersionRange):
             self._build = self._split_parts(build)
 
     @property
-    def major(self):  # type: () -> int
+    def major(self) -> int:
         return self._major
 
     @property
-    def minor(self):  # type: () -> int
+    def minor(self) -> int:
         return self._minor
 
     @property
-    def patch(self):  # type: () -> int
+    def patch(self) -> int:
         return self._patch
 
     @property
-    def rest(self):  # type: () -> int
+    def rest(self) -> int:
         return self._rest
 
     @property
-    def prerelease(self):  # type: () -> List[str]
+    def prerelease(self) -> List[str]:
         return self._prerelease
 
     @property
-    def build(self):  # type: () -> List[str]
+    def build(self) -> List[str]:
         return self._build
 
     @property
@@ -120,7 +120,7 @@ class Version(VersionRange):
         return self._text
 
     @property
-    def precision(self):  # type: () -> int
+    def precision(self) -> int:
         return self._precision
 
     @property
@@ -131,28 +131,28 @@ class Version(VersionRange):
         return self.next_patch
 
     @property
-    def next_major(self):  # type: () -> Version
+    def next_major(self) -> "Version":
         if self.is_prerelease() and self.minor == 0 and self.patch == 0:
             return Version(self.major, self.minor, self.patch)
 
         return self._increment_major()
 
     @property
-    def next_minor(self):  # type: () -> Version
+    def next_minor(self) -> "Version":
         if self.is_prerelease() and self.patch == 0:
             return Version(self.major, self.minor, self.patch)
 
         return self._increment_minor()
 
     @property
-    def next_patch(self):  # type: () -> Version
+    def next_patch(self) -> "Version":
         if self.is_prerelease():
             return Version(self.major, self.minor, self.patch)
 
         return self._increment_patch()
 
     @property
-    def next_breaking(self):  # type: () -> Version
+    def next_breaking(self) -> "Version":
         if self.major == 0:
             if self.minor != 0:
                 return self._increment_minor()
@@ -167,8 +167,10 @@ class Version(VersionRange):
         return self._increment_major()
 
     @property
-    def first_prerelease(self):  # type: () -> Version
-        return Version.parse("{}.{}.{}-alpha.0".format(self.major, self.minor, self.patch))
+    def first_prerelease(self) -> "Version":
+        return Version.parse(
+            "{}.{}.{}-alpha.0".format(self.major, self.minor, self.patch)
+        )
 
     @property
     def min(self):
@@ -191,7 +193,7 @@ class Version(VersionRange):
         return True
 
     @classmethod
-    def parse(cls, text):  # type: (str) -> Version
+    def parse(cls, text: str) -> "Version":
         try:
             match = COMPLETE_VERSION.match(text)
         except TypeError:
@@ -221,25 +223,25 @@ class Version(VersionRange):
     def is_empty(self):
         return False
 
-    def is_prerelease(self):  # type: () -> bool
+    def is_prerelease(self) -> bool:
         return len(self._prerelease) > 0
 
-    def allows(self, version):  # type: (Version) -> bool
+    def allows(self, version: "Version") -> bool:
         return self == version
 
-    def allows_all(self, other):  # type: (VersionConstraint) -> bool
+    def allows_all(self, other: VersionConstraint) -> bool:
         return other.is_empty() or other == self
 
-    def allows_any(self, other):  # type: (VersionConstraint) -> bool
+    def allows_any(self, other: VersionConstraint) -> bool:
         return other.allows(self)
 
-    def intersect(self, other):  # type: (VersionConstraint) -> VersionConstraint
+    def intersect(self, other: VersionConstraint) -> VersionConstraint:
         if other.allows(self):
             return self
 
         return EmptyConstraint()
 
-    def union(self, other):  # type: (VersionConstraint) -> VersionConstraint
+    def union(self, other: VersionConstraint) -> VersionConstraint:
         from .version_range import VersionRange
 
         if other.allows(self):
@@ -264,25 +266,31 @@ class Version(VersionRange):
 
         return VersionUnion.of(self, other)
 
-    def difference(self, other):  # type: (VersionConstraint) -> VersionConstraint
+    def difference(self, other: VersionConstraint) -> VersionConstraint:
         if other.allows(self):
             return EmptyConstraint()
 
         return self
 
-    def equals_without_prerelease(self, other):  # type: (Version) -> bool
-        return self.major == other.major and self.minor == other.minor and self.patch == other.patch
+    def equals_without_prerelease(self, other: "Version") -> bool:
+        return (
+            self.major == other.major
+            and self.minor == other.minor
+            and self.patch == other.patch
+        )
 
-    def _increment_major(self):  # type: () -> Version
+    def _increment_major(self) -> "Version":
         return Version(self.major + 1, 0, 0, precision=self._precision)
 
-    def _increment_minor(self):  # type: () -> Version
+    def _increment_minor(self) -> "Version":
         return Version(self.major, self.minor + 1, 0, precision=self._precision)
 
-    def _increment_patch(self):  # type: () -> Version
-        return Version(self.major, self.minor, self.patch + 1, precision=self._precision)
+    def _increment_patch(self) -> "Version":
+        return Version(
+            self.major, self.minor, self.patch + 1, precision=self._precision
+        )
 
-    def _normalize_prerelease(self, pre):  # type: (str) -> str
+    def _normalize_prerelease(self, pre: str) -> str:
         if not pre:
             return
 
@@ -307,7 +315,7 @@ class Version(VersionRange):
 
         return "{}.{}".format(modifier, number)
 
-    def _normalize_build(self, build):  # type: (str) -> str
+    def _normalize_build(self, build: str) -> str:
         if not build:
             return
 
@@ -319,7 +327,7 @@ class Version(VersionRange):
 
         return build
 
-    def _split_parts(self, text):  # type: (str) -> List[Union[str, int]]
+    def _split_parts(self, text: str) -> List[Union[str, int]]:
         parts = text.split(".")
 
         for i, part in enumerate(parts):
@@ -389,7 +397,7 @@ class Version(VersionRange):
 
         return 0
 
-    def _cmp_lists(self, a, b):  # type: (List, List) -> int
+    def _cmp_lists(self, a: List, b: List) -> int:
         for i in range(max(len(a), len(b))):
             a_part = None
             if i < len(a):
@@ -422,7 +430,7 @@ class Version(VersionRange):
 
         return 0
 
-    def __eq__(self, other):  # type: (Version) -> bool
+    def __eq__(self, other: "Version") -> bool:
         if not isinstance(other, Version):
             return NotImplemented
 

requirements_detector-1.4.0/requirements_detector/poetry_semver/version_constraint.py

@@ -0,0 +1,27 @@
+import semver
+
+
+class VersionConstraint:
+    def is_empty(self) -> bool:
+        raise NotImplementedError()
+
+    def is_any(self) -> bool:
+        raise NotImplementedError()
+
+    def allows(self, version: semver.Version) -> bool:
+        raise NotImplementedError()
+
+    def allows_all(self, other: "VersionConstraint") -> bool:
+        raise NotImplementedError()
+
+    def allows_any(self, other: "VersionConstraint") -> bool:
+        raise NotImplementedError()
+
+    def intersect(self, other: "VersionConstraint") -> "VersionConstraint":
+        raise NotImplementedError()
+
+    def union(self, other: "VersionConstraint") -> "VersionConstraint":
+        raise NotImplementedError()
+
+    def difference(self, other: "VersionConstraint") -> "VersionConstraint":
+        raise NotImplementedError()

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/requirements_detector/poetry_semver/version_range.py

@@ -22,7 +22,11 @@ class VersionRange(VersionConstraint):
             and not include_max
             and not full_max.is_prerelease()
             and not full_max.build
-            and (min is None or not min.is_prerelease() or not min.equals_without_prerelease(full_max))
+            and (
+                min is None
+                or not min.is_prerelease()
+                or not min.equals_without_prerelease(full_max)
+            )
         ):
             full_max = full_max.first_prerelease
 
@@ -58,7 +62,7 @@ class VersionRange(VersionConstraint):
     def is_any(self):
         return self._min is None and self._max is None
 
-    def allows(self, other):  # type: (semver.Version) -> bool
+    def allows(self, other: semver.Version) -> bool:
         if self._min is not None:
             if other < self._min:
                 return False
@@ -75,7 +79,7 @@ class VersionRange(VersionConstraint):
 
         return True
 
-    def allows_all(self, other):  # type: (VersionConstraint) -> bool
+    def allows_all(self, other: VersionConstraint) -> bool:
         from .version import Version
 
         if other.is_empty():
@@ -92,7 +96,7 @@ class VersionRange(VersionConstraint):
 
         raise ValueError("Unknown VersionConstraint type {}.".format(other))
 
-    def allows_any(self, other):  # type: (VersionConstraint) -> bool
+    def allows_any(self, other: VersionConstraint) -> bool:
         from .version import Version
 
         if other.is_empty():
@@ -105,11 +109,13 @@ class VersionRange(VersionConstraint):
             return any([self.allows_any(constraint) for constraint in other.ranges])
 
         if isinstance(other, VersionRange):
-            return not other.is_strictly_lower(self) and not other.is_strictly_higher(self)
+            return not other.is_strictly_lower(self) and not other.is_strictly_higher(
+                self
+            )
 
         raise ValueError("Unknown VersionConstraint type {}.".format(other))
 
-    def intersect(self, other):  # type: (VersionConstraint) -> VersionConstraint
+    def intersect(self, other: VersionConstraint) -> VersionConstraint:
         from .version import Version
 
         if other.is_empty():
@@ -160,9 +166,11 @@ class VersionRange(VersionConstraint):
             return intersect_min
 
         # If we got here, there is an actual range.
-        return VersionRange(intersect_min, intersect_max, intersect_include_min, intersect_include_max)
+        return VersionRange(
+            intersect_min, intersect_max, intersect_include_min, intersect_include_max
+        )
 
-    def union(self, other):  # type: (VersionConstraint) -> VersionConstraint
+    def union(self, other: VersionConstraint) -> VersionConstraint:
         from .version import Version
 
         if isinstance(other, Version):
@@ -170,19 +178,23 @@ class VersionRange(VersionConstraint):
                 return self
 
             if other == self.min:
-                return VersionRange(self.min, self.max, include_min=True, include_max=self.include_max)
+                return VersionRange(
+                    self.min, self.max, include_min=True, include_max=self.include_max
+                )
 
             if other == self.max:
-                return VersionRange(self.min, self.max, include_min=self.include_min, include_max=True)
+                return VersionRange(
+                    self.min, self.max, include_min=self.include_min, include_max=True
+                )
 
             return VersionUnion.of(self, other)
 
         if isinstance(other, VersionRange):
             # If the two ranges don't overlap, we won't be able to create a single
             # VersionRange for both of them.
-            edges_touch = (self.max == other.min and (self.include_max or other.include_min)) or (
-                self.min == other.max and (self.include_min or other.include_max)
-            )
+            edges_touch = (
+                self.max == other.min and (self.include_max or other.include_min)
+            ) or (self.min == other.max and (self.include_min or other.include_max))
 
             if not edges_touch and not self.allows_any(other):
                 return VersionUnion.of(self, other)
@@ -210,7 +222,7 @@ class VersionRange(VersionConstraint):
 
         return VersionUnion.of(self, other)
 
-    def difference(self, other):  # type: (VersionConstraint) -> VersionConstraint
+    def difference(self, other: VersionConstraint) -> VersionConstraint:
         from .version import Version
 
         if other.is_empty():
@@ -245,14 +257,18 @@ class VersionRange(VersionConstraint):
             elif self.min == other.min:
                 before = self.min
             else:
-                before = VersionRange(self.min, other.min, self.include_min, not other.include_min)
+                before = VersionRange(
+                    self.min, other.min, self.include_min, not other.include_min
+                )
 
             if not self.allows_higher(other):
                 after = None
             elif self.max == other.max:
                 after = self.max
             else:
-                after = VersionRange(other.max, self.max, not other.include_max, self.include_max)
+                after = VersionRange(
+                    other.max, self.max, not other.include_max, self.include_max
+                )
 
             if before is None and after is None:
                 return EmptyConstraint()
@@ -265,7 +281,7 @@ class VersionRange(VersionConstraint):
 
             return VersionUnion.of(before, after)
         elif isinstance(other, VersionUnion):
-            ranges = []  # type: List[VersionRange]
+            ranges: List[VersionRange] = []
             current = self
 
             for range in other.ranges:
@@ -296,7 +312,7 @@ class VersionRange(VersionConstraint):
 
         raise ValueError("Unknown VersionConstraint type {}.".format(other))
 
-    def allows_lower(self, other):  # type: (VersionRange) -> bool
+    def allows_lower(self, other: "VersionRange") -> bool:
         if self.min is None:
             return other.min is not None
 
@@ -311,7 +327,7 @@ class VersionRange(VersionConstraint):
 
         return self.include_min and not other.include_min
 
-    def allows_higher(self, other):  # type: (VersionRange) -> bool
+    def allows_higher(self, other: "VersionRange") -> bool:
         if self.max is None:
             return other.max is not None
 
@@ -326,7 +342,7 @@ class VersionRange(VersionConstraint):
 
         return self.include_max and not other.include_max
 
-    def is_strictly_lower(self, other):  # type: (VersionRange) -> bool
+    def is_strictly_lower(self, other: "VersionRange") -> bool:
         if self.max is None or other.min is None:
             return False
 
@@ -338,14 +354,19 @@ class VersionRange(VersionConstraint):
 
         return not self.include_max or not other.include_min
 
-    def is_strictly_higher(self, other):  # type: (VersionRange) -> bool
+    def is_strictly_higher(self, other: "VersionRange") -> bool:
         return other.is_strictly_lower(self)
 
-    def is_adjacent_to(self, other):  # type: (VersionRange) -> bool
+    def is_adjacent_to(self, other: "VersionRange") -> bool:
         if self.max != other.min:
             return False
 
-        return self.include_max and not other.include_min or not self.include_max and other.include_min
+        return (
+            self.include_max
+            and not other.include_min
+            or not self.include_max
+            and other.include_min
+        )
 
     def __eq__(self, other):
         if not isinstance(other, VersionRange):
@@ -370,7 +391,7 @@ class VersionRange(VersionConstraint):
     def __ge__(self, other):
         return self._cmp(other) >= 0
 
-    def _cmp(self, other):  # type: (VersionRange) -> int
+    def _cmp(self, other: "VersionRange") -> int:
         if self.min is None:
             if other.min is None:
                 return self._compare_max(other)
@@ -388,7 +409,7 @@ class VersionRange(VersionConstraint):
 
         return self._compare_max(other)
 
-    def _compare_max(self, other):  # type: (VersionRange) -> int
+    def _compare_max(self, other: "VersionRange") -> int:
         if self.max is None:
             if other.max is None:
                 return 0

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/requirements_detector/poetry_semver/version_union.py

@@ -1,10 +1,13 @@
-from typing import List
+from typing import TYPE_CHECKING, List
 
 import semver
 
 from .empty_constraint import EmptyConstraint
 from .version_constraint import VersionConstraint
 
+if TYPE_CHECKING:
+    from .version_range import VersionRange
+
 
 class VersionUnion(VersionConstraint):
     """
@@ -57,7 +60,10 @@ class VersionUnion(VersionConstraint):
         merged = []
         for constraint in flattened:
             # Merge this constraint with the previous one, but only if they touch.
-            if not merged or (not merged[-1].allows_any(constraint) and not merged[-1].is_adjacent_to(constraint)):
+            if not merged or (
+                not merged[-1].allows_any(constraint)
+                and not merged[-1].is_adjacent_to(constraint)
+            ):
                 merged.append(constraint)
             else:
                 merged[-1] = merged[-1].union(constraint)
@@ -73,10 +79,10 @@ class VersionUnion(VersionConstraint):
     def is_any(self):
         return False
 
-    def allows(self, version):  # type: (semver.Version) -> bool
+    def allows(self, version: semver.Version) -> bool:
         return any([constraint.allows(version) for constraint in self._ranges])
 
-    def allows_all(self, other):  # type: (VersionConstraint) -> bool
+    def allows_all(self, other: VersionConstraint) -> bool:
         our_ranges = iter(self._ranges)
         their_ranges = iter(self._ranges_for(other))
 
@@ -91,7 +97,7 @@ class VersionUnion(VersionConstraint):
 
         return their_current_range is None
 
-    def allows_any(self, other):  # type: (VersionConstraint) -> bool
+    def allows_any(self, other: VersionConstraint) -> bool:
         our_ranges = iter(self._ranges)
         their_ranges = iter(self._ranges_for(other))
 
@@ -109,7 +115,7 @@ class VersionUnion(VersionConstraint):
 
         return False
 
-    def intersect(self, other):  # type: (VersionConstraint) -> VersionConstraint
+    def intersect(self, other: VersionConstraint) -> VersionConstraint:
         our_ranges = iter(self._ranges)
         their_ranges = iter(self._ranges_for(other))
         new_ranges = []
@@ -130,10 +136,10 @@ class VersionUnion(VersionConstraint):
 
         return VersionUnion.of(*new_ranges)
 
-    def union(self, other):  # type: (VersionConstraint) -> VersionConstraint
+    def union(self, other: VersionConstraint) -> VersionConstraint:
         return VersionUnion.of(self, other)
 
-    def difference(self, other):  # type: (VersionConstraint) -> VersionConstraint
+    def difference(self, other: VersionConstraint) -> VersionConstraint:
         our_ranges = iter(self._ranges)
         their_ranges = iter(self._ranges_for(other))
         new_ranges = []
@@ -213,7 +219,7 @@ class VersionUnion(VersionConstraint):
 
         return VersionUnion.of(*new_ranges)
 
-    def _ranges_for(self, constraint):  # type: (VersionConstraint) -> List[semver.VersionRange]
+    def _ranges_for(self, constraint: VersionConstraint) -> List["VersionRange"]:
         from .version_range import VersionRange
 
         if constraint.is_empty():
@@ -227,7 +233,7 @@ class VersionUnion(VersionConstraint):
 
         raise ValueError("Unknown VersionConstraint type {}".format(constraint))
 
-    def _excludes_single_version(self):  # type: () -> bool
+    def _excludes_single_version(self) -> bool:
         from .version import Version
         from .version_range import VersionRange
 

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/requirements_detector/requirement.py

@@ -8,6 +8,7 @@ we don't expect relative file paths to exist, for example. Note that the parsing
 is also intentionally more lenient - it is not our job to validate the requirements
 list.
 """
+
 import os
 import re
 from pathlib import Path
@@ -51,12 +52,18 @@ def _strip_fragment(urlparts):
 
 class DetectedRequirement:
     def __init__(
-        self, name: str = None, url: str = None, requirement: Requirement = None, location_defined: Path = None
+        self,
+        name: str = None,
+        url: str = None,
+        requirement: Requirement = None,
+        location_defined: Path = None,
     ):
         if requirement is not None:
             self.name = requirement.name
             self.requirement = requirement
-            self.version_specs = [(s.operator, s.version) for s in requirement.specifier]
+            self.version_specs = [
+                (s.operator, s.version) for s in requirement.specifier
+            ]
             self.url = None
         else:
             self.name = name
@@ -66,7 +73,9 @@ class DetectedRequirement:
         self.location_defined = location_defined
 
     def _format_specs(self) -> str:
-        return ",".join(["%s%s" % (comp, version) for comp, version in self.version_specs])
+        return ",".join(
+            ["%s%s" % (comp, version) for comp, version in self.version_specs]
+        )
 
     def pip_format(self) -> str:
         if self.url:
@@ -95,7 +104,11 @@ class DetectedRequirement:
         return "<DetectedRequirement:%s>" % str(self)
 
     def __eq__(self, other):
-        return self.name == other.name and self.url == other.url and self.version_specs == other.version_specs
+        return (
+            self.name == other.name
+            and self.url == other.url
+            and self.version_specs == other.version_specs
+        )
 
     def __gt__(self, other):
         return (self.name or "") > (other.name or "")
@@ -149,7 +162,9 @@ class DetectedRequirement:
                 # this happens if the line is invalid
                 return None
             else:
-                return DetectedRequirement(requirement=req, location_defined=location_defined)
+                return DetectedRequirement(
+                    requirement=req, location_defined=location_defined
+                )
 
         # otherwise, this is some kind of URL
         name = _parse_egg_name(url.fragment)
@@ -158,4 +173,6 @@ class DetectedRequirement:
         if vcs_scheme:
             url = "%s://%s" % (vcs_scheme, url)
 
-        return DetectedRequirement(name=name, url=url, location_defined=location_defined)
+        return DetectedRequirement(
+            name=name, url=url, location_defined=location_defined
+        )

{requirements_detector-1.3.1 → requirements_detector-1.4.0}/requirements_detector/run.py

@@ -1,4 +1,3 @@
-import os
 import sys
 from pathlib import Path
 from typing import NoReturn

requirements_detector-1.3.1/pyproject.toml

@@ -1,49 +0,0 @@
-[tool.poetry]
-name = "requirements-detector"
-version = "1.3.1"
-authors = ["Landscape.io <code@landscape.io>"]
-classifiers = [
-    'Development Status :: 5 - Production/Stable',
-    'Environment :: Console',
-    'Intended Audience :: Developers',
-    'Operating System :: Unix',
-    'Topic :: Software Development :: Quality Assurance',
-    'Programming Language :: Python :: 3.8',
-    'Programming Language :: Python :: 3.9',
-    'Programming Language :: Python :: 3.10',
-    'Programming Language :: Python :: 3.11',
-    'Programming Language :: Python :: 3.12',
-    'License :: OSI Approved :: MIT License',
-]
-license = "MIT"
-keywords = ["python","requirements detector"]
-description = "Python tool to find and list requirements of a Python project"
-readme = "README.md"
-homepage = "https://github.com/landscapeio/requirements-detector"
-packages = [
-  { include = "requirements_detector/"}
-]
-
-[tool.poetry.scripts]
-detect-requirements = 'requirements_detector.run:run'
-
-[tool.poetry.dependencies]
-python = ">=3.8,<4.0"
-astroid = "^3.0"
-packaging = ">=21.3"
-toml = "^0.10.2"
-semver = "^3.0.0"
-
-[tool.poetry.dev-dependencies]
-tox = "^3.24.5"
-pre-commit = "^2.17.0"
-pytest = "^6.2.4"
-coverage = "^5.5"
-twine = "^3.8.0"
-pytest-benchmark = "^3.4.1"
-pytest-cov = "^2.12.1"
-types-toml = "^0.10.4"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

requirements_detector-1.3.1/requirements_detector/poetry_semver/version_constraint.py

@@ -1,27 +0,0 @@
-import semver
-
-
-class VersionConstraint:
-    def is_empty(self):  # type: () -> bool
-        raise NotImplementedError()
-
-    def is_any(self):  # type: () -> bool
-        raise NotImplementedError()
-
-    def allows(self, version):  # type: (semver.Version) -> bool
-        raise NotImplementedError()
-
-    def allows_all(self, other):  # type: (VersionConstraint) -> bool
-        raise NotImplementedError()
-
-    def allows_any(self, other):  # type: (VersionConstraint) -> bool
-        raise NotImplementedError()
-
-    def intersect(self, other):  # type: (VersionConstraint) -> VersionConstraint
-        raise NotImplementedError()
-
-    def union(self, other):  # type: (VersionConstraint) -> VersionConstraint
-        raise NotImplementedError()
-
-    def difference(self, other):  # type: (VersionConstraint) -> VersionConstraint
-        raise NotImplementedError()