dependence 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

dependence/_utilities.py

@@ -2,11 +2,23 @@ import sys
 from functools import lru_cache
 from itertools import chain
 from traceback import format_exception
-from typing import Any, Dict, Iterable, List
+from typing import Any, Dict, Hashable, Iterable, List, Set
 
 import tomli
 
 
+def iter_distinct(items: Iterable[Hashable]) -> Iterable:
+    """
+    Yield distinct elements, preserving order
+    """
+    visited: Set[Hashable] = set()
+    item: Hashable
+    for item in items:
+        if item not in visited:
+            visited.add(item)
+            yield item
+
+
 @lru_cache()
 def pyproject_toml_defines_project(pyproject_toml_path: str) -> bool:
     pyproject: Dict[str, Any]

dependence/freeze.py

@@ -3,11 +3,9 @@ from fnmatch import fnmatch
 from importlib.metadata import Distribution
 from importlib.metadata import distribution as _get_distribution
 from itertools import chain
-from typing import Dict, Iterable, MutableSet, Tuple, cast
+from typing import Dict, Iterable, MutableSet, Optional, Tuple, cast
 
-from more_itertools import unique_everseen
-
-from ._utilities import iter_parse_delimited_values
+from ._utilities import iter_distinct, iter_parse_delimited_values
 from .utilities import (
     get_distribution,
     get_required_distribution_names,
@@ -76,6 +74,7 @@ def get_frozen_requirements(
     no_version: Iterable[str] = (),
     dependency_order: bool = False,
     reverse: bool = False,
+    depth: Optional[int] = None,
 ) -> Tuple[str, ...]:
     """
     Get the (frozen) requirements for one or more specified distributions or
@@ -95,6 +94,7 @@ def get_frozen_requirements(
       (only return distribution names)
     - dependency_order (bool) = False: Sort requirements so that dependents
       precede dependencies
+    - depth (int|None) = None: Depth of recursive requirement discovery
     """
     # Separate requirement strings from requirement files
     if isinstance(requirements, str):
@@ -111,37 +111,42 @@ def get_frozen_requirements(
     requirement_strings: MutableSet[str] = cast(
         MutableSet[str], requirements - requirement_files
     )
-    frozen_requirements: Iterable[str] = _iter_frozen_requirements(
-        unique_everseen(
-            chain(
-                requirement_strings,
-                *map(
-                    iter_configuration_file_requirement_strings,
-                    requirement_files,
-                ),
-            )
-        ),
-        exclude=set(
-            chain(
-                # Exclude requirement strings which are *not*
-                # distribution names (such as editable package paths),
-                # as in these cases we are typically looking for this
-                # package's dependencies
-                (
-                    set(
-                        map(
-                            get_requirement_string_distribution_name,
-                            requirement_strings,
-                        )
-                    )
-                    - set(map(normalize_name, requirement_strings))
-                ),
-                map(normalize_name, exclude),
-            )
-        ),
-        exclude_recursive=set(map(normalize_name, exclude_recursive)),
-        no_version=no_version,
+    frozen_requirements: Iterable[str] = iter_distinct(
+        chain(
+            requirement_strings,
+            *map(
+                iter_configuration_file_requirement_strings,
+                requirement_files,
+            ),
+        )
     )
+    if depth is not None:
+        depth -= 1
+    if (depth is None) or depth >= 0:
+        frozen_requirements = _iter_frozen_requirements(
+            frozen_requirements,
+            exclude=set(
+                chain(
+                    # Exclude requirement strings which are *not*
+                    # distribution names (such as editable package paths),
+                    # as in these cases we are typically looking for this
+                    # package's dependencies
+                    (
+                        set(
+                            map(
+                                get_requirement_string_distribution_name,
+                                requirement_strings,
+                            )
+                        )
+                        - set(map(normalize_name, requirement_strings))
+                    ),
+                    map(normalize_name, exclude),
+                )
+            ),
+            exclude_recursive=set(map(normalize_name, exclude_recursive)),
+            no_version=no_version,
+            depth=depth,
+        )
     if dependency_order:
         frozen_requirements = tuple(
             _iter_sort_dependents_last(frozen_requirements)
@@ -165,6 +170,7 @@ def _iter_frozen_requirements(
     exclude: MutableSet[str],
     exclude_recursive: MutableSet[str],
     no_version: Iterable[str] = (),
+    depth: Optional[int] = None,
 ) -> Iterable[str]:
     def get_requirement_string(distribution_name: str) -> str:
         def distribution_name_matches_pattern(pattern: str) -> bool:
@@ -185,25 +191,35 @@ def _iter_frozen_requirements(
 
     def get_required_distribution_names_(
         requirement_string: str,
+        depth_: Optional[int] = None,
     ) -> MutableSet[str]:
         name: str = get_requirement_string_distribution_name(
             requirement_string
         )
         if name in exclude_recursive:
             return set()
+        distribution_names: MutableSet[str] = {name}
+        if (depth_ is None) or depth_:
+            distribution_names |= get_required_distribution_names(
+                requirement_string,
+                exclude=exclude_recursive,
+                depth=None if (depth_ is None) else depth_ - 1,
+            )
         return cast(
             MutableSet[str],
-            (
-                set((name,))
-                | get_required_distribution_names(
-                    requirement_string, exclude=exclude_recursive
-                )
-            )
-            - exclude,
+            distribution_names - exclude,
         )
 
-    requirements: Iterable[str] = unique_everseen(
-        chain(*map(get_required_distribution_names_, requirement_strings)),
+    distribution_names: MutableSet[str]
+    requirements: Iterable[str] = iter_distinct(
+        chain(
+            *map(
+                lambda distribution_names: get_required_distribution_names_(
+                    distribution_names, None if (depth is None) else depth - 1
+                ),
+                requirement_strings,
+            )
+        ),
     )
 
     requirements = map(get_requirement_string, requirements)
@@ -217,6 +233,7 @@ def freeze(
     no_version: Iterable[str] = (),
     dependency_order: bool = False,
     reverse: bool = False,
+    depth: Optional[int] = None,
 ) -> None:
     """
     Print the (frozen) requirements for one or more specified requirements or
@@ -238,6 +255,7 @@ def freeze(
       patterns
     - dependency_order (bool) = False: Sort requirements so that dependents
       precede dependencies
+    - depth (int|None) = None: Depth of recursive requirement discovery
     """
     print(
         "\n".join(
@@ -248,6 +266,7 @@ def freeze(
                 no_version=no_version,
                 dependency_order=dependency_order,
                 reverse=reverse,
+                depth=depth,
             )
         )
     )
@@ -331,15 +350,23 @@ def main() -> None:
         action="store_true",
         help="Print requirements in reverse order",
     )
-    arguments: argparse.Namespace = parser.parse_args()
+    parser.add_argument(
+        "-d",
+        "--depth",
+        default=None,
+        type=int,
+        help="Depth of recursive requirement discovery",
+    )
+    namespace: argparse.Namespace = parser.parse_args()
     freeze(
-        requirements=arguments.requirement,
-        exclude=tuple(iter_parse_delimited_values(arguments.exclude)),
+        requirements=namespace.requirement,
+        exclude=tuple(iter_parse_delimited_values(namespace.exclude)),
         exclude_recursive=tuple(
-            iter_parse_delimited_values(arguments.exclude_recursive)
+            iter_parse_delimited_values(namespace.exclude_recursive)
         ),
-        no_version=arguments.no_version,
-        dependency_order=arguments.dependency_order,
+        no_version=namespace.no_version,
+        dependency_order=namespace.dependency_order,
+        depth=namespace.depth,
     )
 
 

dependence/update.py

@@ -21,13 +21,12 @@ from typing import (
 
 import tomli
 import tomli_w
-from more_itertools import unique_everseen
 from packaging.requirements import Requirement
 from packaging.specifiers import Specifier, SpecifierSet
 from packaging.version import Version
 from packaging.version import parse as parse_version
 
-from ._utilities import iter_parse_delimited_values
+from ._utilities import iter_distinct, iter_parse_delimited_values
 from .utilities import (
     get_installed_distributions,
     is_requirement_string,
@@ -230,7 +229,7 @@ def get_updated_setup_cfg(
             # We pre-pend an empty requirement string in order to]
             # force new-line creation at the beginning of the extra
             extras_require[all_extra_name] = "\n".join(
-                unique_everseen([""] + all_extra_requirements)
+                iter_distinct([""] + all_extra_requirements)
             )
     # Return as a string
     setup_cfg: str
@@ -369,7 +368,7 @@ def get_updated_pyproject_toml(
             project_optional_dependencies[extra_name] = extra_requirements
         if all_extra_name:
             project_optional_dependencies[all_extra_name] = list(
-                unique_everseen(all_extra_requirements)
+                iter_distinct(all_extra_requirements)
             )
     if (
         build_system_requires

dependence/utilities.py

@@ -32,11 +32,14 @@ from typing import (
 from warnings import warn
 
 import tomli
-from more_itertools import unique_everseen
 from packaging.requirements import InvalidRequirement, Requirement
 from packaging.utils import canonicalize_name
 
-from ._utilities import append_exception_text, get_exception_text
+from ._utilities import (
+    append_exception_text,
+    get_exception_text,
+    iter_distinct,
+)
 
 _BUILTIN_DISTRIBUTION_NAMES: Tuple[str] = ("distribute",)
 
@@ -330,7 +333,7 @@ def _iter_setup_cfg_requirement_strings(path: str) -> Iterable[str]:
                     extra_requirements_string.split("\n"),
                 ),
             )
-    return unique_everseen(requirement_strings)
+    return iter_distinct(requirement_strings)
 
 
 def _iter_tox_ini_requirement_strings(path: str) -> Iterable[str]:
@@ -358,7 +361,7 @@ def _iter_tox_ini_requirement_strings(path: str) -> Iterable[str]:
             )
         return requirements
 
-    return unique_everseen(
+    return iter_distinct(
         chain(("tox",), *map(get_section_requirements, parser.sections()))
     )
 
@@ -636,6 +639,7 @@ def get_required_distribution_names(
     exclude: Iterable[str] = (),
     recursive: bool = True,
     echo: bool = False,
+    depth: Optional[int] = None,
 ) -> MutableSet[str]:
     """
     Return a `tuple` of all distribution names which are required by the
@@ -652,6 +656,8 @@ def get_required_distribution_names(
       be obtained recursively.
     - echo (bool) = False: If `True`, commands and responses executed in
       subprocesses will be printed to `sys.stdout`
+    - depth (int|None) = None: The maximum depth of recursion to follow
+      requirements. If `None` (the default), recursion is not restricted.
     """
     if isinstance(exclude, str):
         exclude = set((normalize_name(exclude),))
@@ -663,6 +669,7 @@ def get_required_distribution_names(
             exclude=exclude,
             recursive=recursive,
             echo=echo,
+            depth=depth,
         )
     )
 
@@ -817,6 +824,7 @@ def _iter_requirement_names(
     exclude: MutableSet[str],
     recursive: bool = True,
     echo: bool = False,
+    depth: Optional[int] = None,
 ) -> Iterable[str]:
     name: str = normalize_name(requirement.name)
     extras: Tuple[str, ...] = tuple(requirement.extras)
@@ -831,7 +839,7 @@ def _iter_requirement_names(
     if distribution is None:
         return ()
     requirements: Tuple[Requirement, ...] = tuple(
-        unique_everseen(
+        iter_distinct(
             _iter_distribution_requirements(
                 distribution,
                 extras=extras,
@@ -843,20 +851,23 @@ def _iter_requirement_names(
 
     def iter_requirement_names_(
         requirement_: Requirement,
+        depth_: Optional[int] = None,
     ) -> Iterable[str]:
-        return _iter_requirement_names(
-            requirement_,
-            exclude=cast(
-                MutableSet[str],
-                exclude
-                | (
-                    lateral_exclude
-                    - set((_get_requirement_name(requirement_),))
+        if (depth_ is None) or depth_ >= 0:
+            yield from _iter_requirement_names(
+                requirement_,
+                exclude=cast(
+                    MutableSet[str],
+                    exclude
+                    | (
+                        lateral_exclude
+                        - set((_get_requirement_name(requirement_),))
+                    ),
                 ),
-            ),
-            recursive=recursive,
-            echo=echo,
-        )
+                recursive=recursive,
+                echo=echo,
+                depth=None if (depth_ is None) else depth_ - 1,
+            )
 
     def not_excluded(name: str) -> bool:
         if name not in exclude:
@@ -865,10 +876,19 @@ def _iter_requirement_names(
             return True
         return False
 
+    requirement_names: Iterable[str] = filter(
+        not_excluded, map(_get_requirement_name, requirements)
+    )
     if recursive:
+        requirement_: Requirement
         requirement_names = chain(
-            filter(not_excluded, map(_get_requirement_name, requirements)),
-            *map(iter_requirement_names_, requirements),
+            requirement_names,
+            *map(
+                lambda requirement_: iter_requirement_names_(
+                    requirement_, None if (depth is None) else depth - 1
+                ),
+                requirements,
+            ),
         )
     return requirement_names
 
@@ -901,7 +921,7 @@ def _iter_requirement_strings_required_distribution_names(
                 pass
         return set()
 
-    return unique_everseen(
+    return iter_distinct(
         chain(*map(get_required_distribution_names_, requirement_strings)),
     )
 
@@ -934,7 +954,7 @@ def get_requirements_required_distribution_names(
     name: str
     return set(
         _iter_requirement_strings_required_distribution_names(
-            unique_everseen(
+            iter_distinct(
                 chain(
                     requirement_strings,
                     *map(

{dependence-0.1.1.dist-info → dependence-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dependence
-Version: 0.1.1
+Version: 0.3.0
 Summary: Requirement (dependency) management for python projects
 Home-page: https://github.com/enorganic/dependence
 Author-email: david@belais.me
@@ -12,7 +12,6 @@ Requires-Dist: packaging
 Requires-Dist: pip
 Requires-Dist: tomli ~=2.0
 Requires-Dist: tomli-w ~=1.0
-Requires-Dist: more-itertools >7
 Requires-Dist: setuptools >63
 
 # dependence
@@ -95,50 +94,43 @@ dependence update -aen all setup.cfg pyproject.toml tox.ini
 
 ```console
 $ dependence freeze -h
-usage: dependence freeze [-h] [-e EXCLUDE] [-er EXCLUDE_RECURSIVE]
-                         [-nv NO_VERSION] [-do] [--reverse]
+usage: dependence freeze [-h] [-e EXCLUDE] [-er EXCLUDE_RECURSIVE] [-nv NO_VERSION]
+                         [-do] [--reverse] [-d DEPTH]
                          requirement [requirement ...]
 
-This command prints dependencies inferred from an installed
-distribution or project, in a similar format to the output of `pip
-freeze`, except that all generated requirements are specified in the
-format "distribution-name==0.0.0" (including for editable
-installations). Using this command instead of `pip freeze` to generate
-requirement files ensures that you don't bloat your requirements files
-with superfluous distributions. The default sorting starts with
-directly specified requirements, followed by recursively discovered
-requirements, in the order of discovery.
+This command prints dependencies inferred from an installed distribution or project, in
+a similar format to the output of `pip freeze`, except that all generated requirements
+are specified in the format "distribution-name==0.0.0" (including for editable
+installations). Using this command instead of `pip freeze` to generate requirement
+files ensures that you don't bloat your requirements files with superfluous
+distributions.
 
 positional arguments:
-  requirement           One or more requirement specifiers (for
-                        example: "requirement-name", "requirement-
-                        name[extra-a,extra-b]", ".[extra-a, extra-b]"
-                        or "../other-editable-package-
-                        directory[extra-a, extra-b]) and/or paths to a
-                        setup.py, setup.cfg, pyproject.toml, tox.ini or
-                        requirements.txt file
+  requirement           One or more requirement specifiers (for example: "requirement-
+                        name", "requirement-name[extra-a,extra-b]", ".[extra-a,
+                        extra-b]" or "../other-editable-package-directory[extra-a,
+                        extra-b]) and/or paths to a setup.py, setup.cfg,
+                        pyproject.toml, tox.ini or requirements.txt file
 
 optional arguments:
   -h, --help            show this help message and exit
   -e EXCLUDE, --exclude EXCLUDE
-                        A distribution (or comma-separated list of
-                        distributions) to exclude from the output
+                        A distribution (or comma-separated list of distributions) to
+                        exclude from the output
   -er EXCLUDE_RECURSIVE, --exclude-recursive EXCLUDE_RECURSIVE
-                        A distribution (or comma-separated list of
-                        distributions) to exclude from the output.
-                        Unlike -e / --exclude, this argument also
-                        precludes recursive requirement discovery for
-                        the specified packages, thereby excluding all
-                        of the excluded package's requirements which
-                        are not required by another (non-excluded)
-                        distribution.
+                        A distribution (or comma-separated list of distributions) to
+                        exclude from the output. Unlike -e / --exclude, this argument
+                        also precludes recursive requirement discovery for the
+                        specified packages, thereby excluding all of the excluded
+                        package's requirements which are not required by another (non-
+                        excluded) distribution.
   -nv NO_VERSION, --no-version NO_VERSION
-                        Don't include versions (only output
-                        distribution names) for packages matching
-                        this/these glob pattern(s) (note: the value
+                        Don't include versions (only output distribution names) for
+                        packages matching this/these glob pattern(s) (note: the value
                         must be single-quoted if it contains wildcards)
   -do, --dependency-order
-                        Sort requirements so that dependents precede
-                        dependencies
+                        Sort requirements so that dependents precede dependencies
   --reverse             Print requirements in reverse order
+  -d DEPTH, --depth DEPTH
+                        Depth of recursive requirement discovery
 ```

dependence-0.3.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+dependence/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dependence/__main__.py,sha256=myBIBZdez2jC3_dkVSE-mOLo39yKi2cF_0NuVXcXF1E,1528
+dependence/_utilities.py,sha256=txNRK5Y7Dd7w8-qG7wGmS6mrAcGvy73DIjAHswW4glA,2684
+dependence/freeze.py,sha256=kGT1Kjr7QeKMqXEO03cg4CD4s_rOc3khjJla_822gOk,13299
+dependence/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dependence/update.py,sha256=FRl0FsdAIfjWacw1cVS8Fh024ZN7hK3ZHJiQpsRinfQ,16571
+dependence/utilities.py,sha256=8QdX2_O-Qdc-dh-qpi76KuykEROpvKZrApNOzOTaO8I,31816
+dependence-0.3.0.dist-info/METADATA,sha256=Yzr2gGfOu3qEQ9pCgIaAUFqWvB6cU0N8GHzG8JmEIac,5597
+dependence-0.3.0.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+dependence-0.3.0.dist-info/entry_points.txt,sha256=NStO_B0D81ObVYr9zDs6LCy0whm0a8KCiiFHMmTwOVE,56
+dependence-0.3.0.dist-info/top_level.txt,sha256=5rooMYWKlAUelE8hjGegbf4uuAIqNuRlhlpA7oc7Qro,11
+dependence-0.3.0.dist-info/RECORD,,

{dependence-0.1.1.dist-info → dependence-0.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

dependence-0.1.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-dependence/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dependence/__main__.py,sha256=myBIBZdez2jC3_dkVSE-mOLo39yKi2cF_0NuVXcXF1E,1528
-dependence/_utilities.py,sha256=pGK9JAMOAVGvamo4Espmk0NUftosW7UxZnwWXbNM47w,2385
-dependence/freeze.py,sha256=K_6YeL9MWc4-ct9Niv3Sco9CvRcZ4ueMSrL9gy6Ahlc,12229
-dependence/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dependence/update.py,sha256=9TIU4JC1M-RHZfXYxeAmtbXS_lAFy_Z9sy8Ce1PTz4g,16603
-dependence/utilities.py,sha256=btrlAFPx8TaPvm_Qw6stLbUWdKqkLJ1l6-P9lR675pI,31133
-dependence-0.1.1.dist-info/METADATA,sha256=S0ZMUaDmIqqQzLcll0lINfy-OPi2uJBMdlGffZ06BJQ,5813
-dependence-0.1.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-dependence-0.1.1.dist-info/entry_points.txt,sha256=NStO_B0D81ObVYr9zDs6LCy0whm0a8KCiiFHMmTwOVE,56
-dependence-0.1.1.dist-info/top_level.txt,sha256=5rooMYWKlAUelE8hjGegbf4uuAIqNuRlhlpA7oc7Qro,11
-dependence-0.1.1.dist-info/RECORD,,