dependence 0.1.1__tar.gz → 0.2.0__tar.gz

{dependence-0.1.1 → dependence-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dependence
-Version: 0.1.1
+Version: 0.2.0
 Summary: Requirement (dependency) management for python projects
 Home-page: https://github.com/enorganic/dependence
 Author-email: david@belais.me
@@ -95,50 +95,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.1.1 → dependence-0.2.0}/README.md

@@ -78,50 +78,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.1.1 → dependence-0.2.0}/dependence/freeze.py

@@ -3,7 +3,7 @@ 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
 
@@ -76,6 +76,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 +96,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 +113,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] = unique_everseen(
+        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 +172,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 +193,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,
         )
 
+    distribution_names: MutableSet[str]
     requirements: Iterable[str] = unique_everseen(
-        chain(*map(get_required_distribution_names_, requirement_strings)),
+        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 +235,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 +257,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 +268,7 @@ def freeze(
                 no_version=no_version,
                 dependency_order=dependency_order,
                 reverse=reverse,
+                depth=depth,
             )
         )
     )
@@ -331,15 +352,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-0.1.1 → dependence-0.2.0}/dependence/utilities.py

@@ -636,6 +636,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 +653,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 +666,7 @@ def get_required_distribution_names(
             exclude=exclude,
             recursive=recursive,
             echo=echo,
+            depth=depth,
         )
     )
 
@@ -817,6 +821,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)
@@ -843,20 +848,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 +873,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
 

{dependence-0.1.1 → dependence-0.2.0}/dependence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dependence
-Version: 0.1.1
+Version: 0.2.0
 Summary: Requirement (dependency) management for python projects
 Home-page: https://github.com/enorganic/dependence
 Author-email: david@belais.me
@@ -95,50 +95,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.1.1 → dependence-0.2.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = dependence
-version = 0.1.1
+version = 0.2.0
 author_email = david@belais.me
 description = Requirement (dependency) management for python projects
 long_description = file: README.md