requirements-detector 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

requirements_detector/detect.py

@@ -1,14 +1,22 @@
 import re
+import sys
 from pathlib import Path
-from typing import List, Union
+from typing import List, Optional, Union
 
 import toml
 
 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
 
+_USE_TOMLLIB = sys.version_info.major > 3 or sys.version_info.minor >= 11
+if _USE_TOMLLIB:
+    import tomllib
+else:
+    import toml
+
 __all__ = [
     "find_requirements",
     "from_requirements_txt",
@@ -102,13 +110,36 @@ 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)
+    if _USE_TOMLLIB:
+        with open(toml_file, "rb") as toml_file_open:
+            parsed = tomllib.load(toml_file_open)
+    else:
+        parsed = toml.load(toml_file)
     poetry_section = parsed.get("tool", {}).get("poetry", {})
     dependencies = poetry_section.get("dependencies", {})
     dependencies.update(poetry_section.get("dev-dependencies", {}))
@@ -116,15 +147,15 @@ 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))
+
+        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}"
 

requirements_detector/poetry_semver/__init__.py

@@ -16,7 +16,7 @@ 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()
 
@@ -47,7 +47,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()

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,7 +167,7 @@ class Version(VersionRange):
         return self._increment_major()
 
     @property
-    def first_prerelease(self):  # type: () -> Version
+    def first_prerelease(self) -> "Version":
         return Version.parse("{}.{}.{}-alpha.0".format(self.major, self.minor, self.patch))
 
     @property
@@ -191,7 +191,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 +221,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 +264,25 @@ 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
+    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
+    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 +307,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 +319,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 +389,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 +422,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/poetry_semver/version_constraint.py

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

requirements_detector/poetry_semver/version_range.py

@@ -58,7 +58,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 +75,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 +92,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():
@@ -109,7 +109,7 @@ class VersionRange(VersionConstraint):
 
         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():
@@ -162,7 +162,7 @@ class VersionRange(VersionConstraint):
         # If we got here, there is an actual range.
         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):
@@ -210,7 +210,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():
@@ -265,7 +265,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 +296,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 +311,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 +326,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,10 +338,10 @@ 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
 
@@ -370,7 +370,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 +388,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/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):
     """
@@ -73,10 +76,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 +94,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 +112,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 +133,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 +216,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 +230,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.dist-info → requirements_detector-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: requirements-detector
-Version: 1.3.1
+Version: 1.3.2
 Summary: Python tool to find and list requirements of a Python project
 Home-page: https://github.com/landscapeio/requirements-detector
 License: MIT
@@ -23,7 +23,7 @@ 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: toml (>=0.10.2,<0.11.0) ; python_version < "3.11"
 Description-Content-Type: text/markdown
 
 # Requirements Detector

{requirements_detector-1.3.1.dist-info → requirements_detector-1.3.2.dist-info}/RECORD

@@ -1,22 +1,23 @@
 requirements_detector/__init__.py,sha256=XbBRnMPYhG2Eq2IhZQAzOA9d-9OTYMXJwRiaZhLFAEY,269
 requirements_detector/__main__.py,sha256=U6nHQrMwd11auXYgQsT0wqqqKyyGKXxHZ_SDaaOi878,59
-requirements_detector/detect.py,sha256=2RP-kNQe6hEXfLSknWuHP2BOo7nwe9Bhpb8QSmaLH48,5880
+requirements_detector/detect.py,sha256=E9jvDPxifmbf0VWhuzVZVkpx990ogrYmIqXLmBtDPxw,6867
 requirements_detector/exceptions.py,sha256=bTy7-ZvAXt-nucXKnaYIBxa5FngtFpD95FXswejc7Wk,103
 requirements_detector/formatters.py,sha256=zcxR2n2Tp8z3DHkpokbjHorNqei5LZ9hprWZK0ZBVik,340
 requirements_detector/handle_setup.py,sha256=K-tnZP9ioKO-zgVsDRaI9aBBZpMtQKLPkXyFWotohEk,3947
 requirements_detector/poetry_semver/README.md,sha256=lU6DxV4Qk1qv_KIgOW1uEahx6PWDNhnIziF2izA49-k,261
-requirements_detector/poetry_semver/__init__.py,sha256=3rarQkEpLB-X5nbqsIrCXspaUL1Y9DGQTKA2gvBritA,4681
+requirements_detector/poetry_semver/__init__.py,sha256=nSyskyy880xTIhbvvwBuUg0Jmu6DepC27kTWFJO49Hk,4661
 requirements_detector/poetry_semver/empty_constraint.py,sha256=U_a8Obi0shKP4KoLDbXTGWzwha3J4HKwqEKWTNiLfuo,562
 requirements_detector/poetry_semver/exceptions.py,sha256=M16rxsgcZfZUUiys8fKBPicD0AqCdP3kLlekm3_WkmA,46
 requirements_detector/poetry_semver/patterns.py,sha256=ejPriORCt-gB5MoUh8aNo5bcBV5ZTM8joWXJ5WUwlEQ,741
-requirements_detector/poetry_semver/version.py,sha256=ErVXM8tgotWJ74G7kmh5TzJcVQHYG7oaVJrbPXEGbQ4,12192
-requirements_detector/poetry_semver/version_constraint.py,sha256=VNpYqS7JhEW1P_QiJVJ0Os4oK2M9z4kpGRwaHWW4wOw,870
-requirements_detector/poetry_semver/version_range.py,sha256=dm7mgZL5H0Xn0vKG2YuM8ScBn2qARTBeHaJUYNk2kEo,13179
-requirements_detector/poetry_semver/version_union.py,sha256=MmYBSED7hyb2H5sxuL0i6feWTc6x1tYVrVvGraon1g0,7931
+requirements_detector/poetry_semver/version.py,sha256=DzSr4OqxSPY0TgKR2PqNCjQRt_vdg0VtkYnuSuBSXyQ,11829
+requirements_detector/poetry_semver/version_constraint.py,sha256=Vp5KW27IuXroKwcgBT7PZYxLaohoeCY3XMG4h0xvmK0,802
+requirements_detector/poetry_semver/version_range.py,sha256=FN05z4gituRsah1AxDogx2w-KRQPkRV03jIXTSqCpmI,13055
+requirements_detector/poetry_semver/version_union.py,sha256=qBqU0ocnHkLVKxKYZXz_MwODVzyRbuIcD2nN1LFUqL4,7922
+requirements_detector/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 requirements_detector/requirement.py,sha256=XuKspLsLY_sZOVKupXSjGFMxV1u3NHaTgjb-kRXbzFg,5548
 requirements_detector/run.py,sha256=8AjUalMAmCgK4HAsswSoxVG4N_uhYrvGMhZnfQUf8X8,861
-requirements_detector-1.3.1.dist-info/LICENSE,sha256=548oOCrCNqQty8Fsqqry522lXdxnBTqLyzqr38ct-cw,1040
-requirements_detector-1.3.1.dist-info/METADATA,sha256=Rf7ImjEZeg5meDZvvkBmHWOBcn10WEM4anJxoLZQhTk,3687
-requirements_detector-1.3.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-requirements_detector-1.3.1.dist-info/entry_points.txt,sha256=c1Pyo5EK49kT1g7Wac3vwl0bVs0QBZeQ8Zia1WVL1do,69
-requirements_detector-1.3.1.dist-info/RECORD,,
+requirements_detector-1.3.2.dist-info/LICENSE,sha256=548oOCrCNqQty8Fsqqry522lXdxnBTqLyzqr38ct-cw,1040
+requirements_detector-1.3.2.dist-info/METADATA,sha256=5QbwMaMSgTDIzgIHcS3afg2Twqam64KiokLHopbOhu4,3713
+requirements_detector-1.3.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+requirements_detector-1.3.2.dist-info/entry_points.txt,sha256=c1Pyo5EK49kT1g7Wac3vwl0bVs0QBZeQ8Zia1WVL1do,69
+requirements_detector-1.3.2.dist-info/RECORD,,