dependence 0.3.6__py3-none-any.whl → 1.0.0__py3-none-any.whl

dependence/freeze.py

@@ -1,18 +1,20 @@
 import argparse
 from fnmatch import fnmatch
+from functools import partial
 from importlib.metadata import Distribution
 from importlib.metadata import distribution as _get_distribution
 from itertools import chain
 from typing import Dict, Iterable, MutableSet, Optional, Tuple, cast
 
-from ._utilities import iter_distinct, iter_parse_delimited_values
-from .utilities import (
+from ._utilities import (
     get_distribution,
     get_required_distribution_names,
     get_requirement_string_distribution_name,
     install_requirement,
     is_configuration_file,
     iter_configuration_file_requirement_strings,
+    iter_distinct,
+    iter_parse_delimited_values,
     normalize_name,
 )
 
@@ -40,12 +42,15 @@ def _iter_sort_dependents_last(requirements: Iterable[str]) -> Iterable[str]:
         dependent: str
         dependencies: MutableSet[str]
         item: Tuple[str, MutableSet[str]]
-        for dependent, dependencies in sorted(
+        for dependent, dependencies in sorted(  # noqa: C414
             tuple(dependent_dependencies.items()),
             key=lambda item: item[0].lower(),
         ):
 
-            def is_non_circular_requirement(dependency: str) -> bool:
+            def is_non_circular_requirement(
+                dependency: str,
+                dependent: str,
+            ) -> bool:
                 """
                 Return `True` if the dependency is still among the unaccounted
                 for requirements, and is not a circular reference
@@ -53,13 +58,12 @@ def _iter_sort_dependents_last(requirements: Iterable[str]) -> Iterable[str]:
                 return (dependency in dependent_dependencies) and (
                     # Exclude interdependent distributions
                     # (circular references)
-                    dependent
-                    not in dependent_dependencies[dependency]
+                    dependent not in dependent_dependencies[dependency]
                 )
 
             if (not dependencies) or not any(
                 map(
-                    is_non_circular_requirement,
+                    partial(is_non_circular_requirement, dependent=dependent),
                     dependencies,
                 )
             ):
@@ -75,30 +79,35 @@ def get_frozen_requirements(
     dependency_order: bool = False,
     reverse: bool = False,
     depth: Optional[int] = None,
+    include_pointers: Tuple[str, ...] = (),
+    exclude_pointers: Tuple[str, ...] = (),
 ) -> Tuple[str, ...]:
     """
     Get the (frozen) requirements for one or more specified distributions or
     configuration files.
 
     Parameters:
-
-    - requirements ([str]): One or more requirement specifiers (for example:
-      "requirement-name[extra-a,extra-b]" or ".[extra-a, extra-b]) and/or paths
-      to a setup.cfg, pyproject.toml, tox.ini or requirements.txt file
-    - exclude ([str]): One or more distributions to exclude/ignore
-    - exclude_recursive ([str]): One or more distributions to exclude/ignore.
-      Note: Excluding a distribution here excludes all requirements which would
-      be identified through recursively.
-      those requirements occur elsewhere.
-    - no_version ([str]) = (): Exclude version numbers from the output
-      (only return distribution names)
-    - dependency_order (bool) = False: Sort requirements so that dependents
-      precede dependencies
-    - depth (int|None) = None: Depth of recursive requirement discovery
+        requirements: One or more requirement specifiers (for example:
+            "requirement-name[extra-a,extra-b]" or ".[extra-a, extra-b]) and/or
+            paths to a setup.cfg, pyproject.toml, tox.ini or requirements.txt
+            file
+        exclude: One or more distributions to exclude/ignore
+        exclude_recursive: One or more distributions to exclude/ignore.
+            Note: Excluding a distribution here excludes all requirements which
+            would be identified through recursion.
+        no_version: Exclude version numbers from the output
+            (only return distribution names)
+        dependency_order: Sort requirements so that dependents
+            precede dependencies
+        depth: Depth of recursive requirement discovery
+        include_pointers: A tuple of JSON pointers indicating elements to
+            include (defaults to all elements). Only applies to TOML files.
+        exclude_pointers: A tuple of JSON pointers indicating elements to
+            exclude (defaults to no exclusions). Only applies to TOML files.
     """
     # Separate requirement strings from requirement files
     if isinstance(requirements, str):
-        requirements = set((requirements,))
+        requirements = {requirements}
     else:
         requirements = set(requirements)
     if isinstance(no_version, str):
@@ -115,7 +124,11 @@ def get_frozen_requirements(
         chain(
             requirement_strings,
             *map(
-                iter_configuration_file_requirement_strings,
+                partial(
+                    iter_configuration_file_requirement_strings,
+                    include_pointers=include_pointers,
+                    exclude_pointers=exclude_pointers,
+                ),
                 requirement_files,
             ),
         )
@@ -210,14 +223,14 @@ def _iter_frozen_requirements(
             distribution_names - exclude,
         )
 
-    distribution_names: MutableSet[str]
+    requirement_string: 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,
+            *(
+                get_required_distribution_names_(
+                    requirement_string, None if (depth is None) else depth - 1
+                )
+                for requirement_string in requirement_strings
             )
         ),
     )
@@ -233,28 +246,32 @@ def freeze(
     dependency_order: bool = False,
     reverse: bool = False,
     depth: Optional[int] = None,
+    include_pointers: Tuple[str, ...] = (),
+    exclude_pointers: Tuple[str, ...] = (),
 ) -> None:
     """
     Print the (frozen) requirements for one or more specified requirements or
     configuration files.
 
     Parameters:
-
-    - requirements ([str]): One or more requirement specifiers (for example:
-      "requirement-name[extra-a,extra-b]" or ".[extra-a, extra-b]) and/or paths
-      to a setup.py, setup.cfg, pyproject.toml, tox.ini or requirements.txt
-      file
-    - exclude ([str]): One or more distributions to exclude/ignore
-    - exclude_recursive ([str]): One or more distributions to exclude/ignore.
-      Note: Excluding a distribution here excludes all requirements which would
-      be identified through recursively.
-      those requirements occur elsewhere.
-    - no_version ([str]) = (): Exclude version numbers from the output
-      (only print distribution names) for package names matching any of these
-      patterns
-    - dependency_order (bool) = False: Sort requirements so that dependents
-      precede dependencies
-    - depth (int|None) = None: Depth of recursive requirement discovery
+        requirements: One or more requirement specifiers (for example:
+            "requirement-name[extra-a,extra-b]" or ".[extra-a, extra-b]) and/or
+            paths to a setup.py, setup.cfg, pyproject.toml, tox.ini or
+            requirements.txt file
+        exclude: One or more distributions to exclude/ignore
+        exclude_recursive: One or more distributions to exclude/ignore.
+            Note: Excluding a distribution here halts recursive
+            discovery of requirements.
+        no_version: Exclude version numbers from the output
+            (only print distribution names) for package names matching any of
+            these patterns
+        dependency_order: Sort requirements so that dependents
+            precede dependencies
+        depth: Depth of recursive requirement discovery
+        include_pointers: If this not empty, *only* these TOML tables will
+            inspected (for pyproject.toml files)
+        exclude_pointers: If not empty, these TOML tables will *not* be
+            inspected (for pyproject.toml files)
     """
     print(
         "\n".join(
@@ -266,6 +283,8 @@ def freeze(
                 dependency_order=dependency_order,
                 reverse=reverse,
                 depth=depth,
+                include_pointers=include_pointers,
+                exclude_pointers=exclude_pointers,
             )
         )
     )
@@ -356,6 +375,26 @@ def main() -> None:
         type=int,
         help="Depth of recursive requirement discovery",
     )
+    parser.add_argument(
+        "--include-pointer",
+        default=[],
+        type=str,
+        action="append",
+        help=(
+            "One or more JSON pointers of elements to *include* "
+            "(applies to TOML files only)"
+        ),
+    )
+    parser.add_argument(
+        "--exclude-pointer",
+        default=[],
+        type=str,
+        action="append",
+        help=(
+            "One or more JSON pointers of elements to *exclude* "
+            "(applies to TOML files only)"
+        ),
+    )
     namespace: argparse.Namespace = parser.parse_args()
     freeze(
         requirements=namespace.requirement,
@@ -366,6 +405,8 @@ def main() -> None:
         no_version=namespace.no_version,
         dependency_order=namespace.dependency_order,
         depth=namespace.depth,
+        include_pointers=tuple(namespace.include_pointer),
+        exclude_pointers=tuple(namespace.exclude_pointer),
     )
 
 

dependence/update.py

@@ -1,11 +1,12 @@
 import argparse
-import os
 import re
 from collections import deque
 from configparser import ConfigParser, SectionProxy
+from copy import deepcopy
 from dataclasses import dataclass
 from importlib.metadata import Distribution
 from io import StringIO
+from itertools import chain
 from typing import (
     IO,
     Any,
@@ -26,10 +27,14 @@ from packaging.specifiers import Specifier, SpecifierSet
 from packaging.version import Version
 from packaging.version import parse as parse_version
 
-from ._utilities import iter_distinct, iter_parse_delimited_values
-from .utilities import (
+from ._utilities import (
+    ConfigurationFileType,
+    get_configuration_file_type,
     get_installed_distributions,
     is_requirement_string,
+    iter_distinct,
+    iter_find_requirements_lists,
+    iter_parse_delimited_values,
     normalize_name,
 )
 
@@ -299,103 +304,173 @@ def get_updated_tox_ini(data: str, ignore: Iterable[str] = ()) -> str:
         return f"{tox_ini}\n"
 
 
-def get_updated_pyproject_toml(
-    data: str, ignore: Iterable[str] = (), all_extra_name: str = ""
+def _update_document_requirements(
+    document: Dict[str, Any],
+    ignore: Iterable[str] = (),
+    include_pointers: Tuple[str, ...] = (),
+    exclude_pointers: Tuple[str, ...] = (),
+) -> None:
+    ignore_set: Set[str] = _normalize_ignore_argument(ignore)
+
+    def get_updated_requirement_string(requirement: str) -> str:
+        return _get_updated_requirement_string(requirement, ignore=ignore_set)
+
+    # Find and update requirements
+    requirements_list: List[str]
+    for requirements_list in iter_find_requirements_lists(
+        document,
+        include_pointers=include_pointers,
+        exclude_pointers=exclude_pointers,
+    ):
+        requirements_list[:] = list(
+            map(
+                get_updated_requirement_string,
+                requirements_list,
+            )
+        )
+
+
+def _get_updated_pyproject_toml(
+    data: str,
+    ignore: Iterable[str] = (),
+    all_extra_name: str = "",
+    include_pointers: Tuple[str, ...] = (),
+    exclude_pointers: Tuple[str, ...] = (),
 ) -> str:
     """
-    Return the contents of a *setup.cfg* file, updated to reflect the
+    Return the contents of a *pyproject.toml* file, updated to reflect the
     currently installed project versions, excluding those specified in
     `ignore`.
 
     Parameters:
-
-    - data (str): The contents of a *setup.cfg* file
-    - ignore ([str]): One or more project names to leave as-is
-    - all_extra_name (str): An (optional) extra name which will
-      consolidate requirements from all other extras
+        data: The contents of a *pyproject.toml* file
+        ignore: One or more project names to leave as-is
+        all_extra_name: An (optional) extra name which will
+            consolidate requirements from all other extras
+        include_pointers: A tuple of JSON pointers indicating elements to
+            include (defaults to all elements).
+        exclude_pointers: A tuple of JSON pointers indicating elements to
+            exclude (defaults to no exclusions).
 
     Returns:
-
-    The contents of the update pyproject.toml file.
+        The contents of the updated pyproject.toml file.
     """
-    ignore_set: Set[str] = _normalize_ignore_argument(ignore)
-
-    def get_updated_requirement_string(requirement: str) -> str:
-        return _get_updated_requirement_string(requirement, ignore=ignore_set)
-
     # Parse pyproject.toml
-    pyproject: Dict[str, Any] = tomli.loads(data)
-    build_system_requires: List[str] = pyproject.get("build-system", {}).get(
-        "requires", []
+    original_pyproject: Dict[str, Any] = tomli.loads(data)
+    updated_pyproject: Dict[str, Any] = deepcopy(original_pyproject)
+    # Find and update requirements
+    _update_document_requirements(
+        updated_pyproject,
+        ignore=ignore,
+        include_pointers=include_pointers,
+        exclude_pointers=exclude_pointers,
     )
-    if build_system_requires:
-        # Update build dependency versions
-        pyproject["build-system"]["requires"] = list(
-            map(
-                get_updated_requirement_string,
-                build_system_requires,
-            )
-        )
-    project: Dict[str, Any] = pyproject.get("project", {})
-    project_dependencies: List[str] = project.get("dependencies", [])
-    if project_dependencies:
-        # Update project dependency versions
-        pyproject["project"]["dependencies"] = list(
-            map(
-                get_updated_requirement_string,
-                project_dependencies,
+    # Update consolidated optional requirements
+    project_optional_dependencies: Dict[str, List[str]] = (
+        updated_pyproject.get("project", {}).get("optional-dependencies", {})
+    )
+    # Update an extra indicated to encompass all other extras
+    if project_optional_dependencies and all_extra_name:
+        key: str
+        dependencies: List[str]
+        project_optional_dependencies[all_extra_name] = list(
+            iter_distinct(
+                chain(
+                    *(
+                        dependencies
+                        for key, dependencies in (
+                            project_optional_dependencies.items()
+                        )
+                        if key != all_extra_name
+                    )
+                )
             )
         )
-    project_optional_dependencies: Dict[str, List[str]] = project.get(
-        "optional-dependencies", {}
+    # Only dump the data if something was updated
+    if original_pyproject != updated_pyproject:
+        return tomli_w.dumps(updated_pyproject)
+    return data
+
+
+def _get_updated_toml(
+    data: str,
+    ignore: Iterable[str] = (),
+    include_pointers: Tuple[str, ...] = (),
+    exclude_pointers: Tuple[str, ...] = (),
+) -> str:
+    """
+    Return the contents of a TOML file, updated to reflect the
+    currently installed project versions, excluding those specified in
+    `ignore`.
+
+    Note: This functions identically to `get_updated_pyproject_toml`, but
+    does not consolidate optional dependencies.
+
+    Parameters:
+        data: The contents of a TOML file
+        ignore: One or more package names to leave as-is
+        include_pointers: A tuple of JSON pointers indicating elements to
+            include (defaults to all elements).
+        exclude_pointers: A tuple of JSON pointers indicating elements to
+            exclude (defaults to no exclusions).
+
+    Returns:
+        The contents of the updated TOML file.
+    """
+    # Parse pyproject.toml
+    original_pyproject: Dict[str, Any] = tomli.loads(data)
+    updated_pyproject: Dict[str, Any] = deepcopy(original_pyproject)
+    # Find and update requirements
+    _update_document_requirements(
+        updated_pyproject,
+        ignore=ignore,
+        include_pointers=include_pointers,
+        exclude_pointers=exclude_pointers,
     )
-    if project_optional_dependencies:
-        # Update optional dependency versions
-        all_extra_requirements: List[str] = []
-        extra_name: str
-        extra_requirements: List[str]
-        for (
-            extra_name,
-            extra_requirements,
-        ) in project_optional_dependencies.items():
-            if extra_name == all_extra_name:
-                continue
-            extra_requirements = list(
-                map(get_updated_requirement_string, extra_requirements)
-            )
-            if all_extra_name:
-                all_extra_requirements += extra_requirements
-            project_optional_dependencies[extra_name] = extra_requirements
-        if all_extra_name:
-            project_optional_dependencies[all_extra_name] = list(
-                iter_distinct(all_extra_requirements)
-            )
-    if (
-        build_system_requires
-        or project_dependencies
-        or project_optional_dependencies
-    ):
-        return tomli_w.dumps(pyproject)
+    # Only dump the data if something was updated
+    if original_pyproject != updated_pyproject:
+        return tomli_w.dumps(updated_pyproject)
     return data
 
 
 def _update(
-    path: str, ignore: Iterable[str] = (), all_extra_name: str = ""
+    path: str,
+    ignore: Iterable[str] = (),
+    all_extra_name: str = "",
+    include_pointers: Tuple[str, ...] = (),
+    exclude_pointers: Tuple[str, ...] = (),
 ) -> None:
     data: str
     update_function: Callable[[str], str]
     kwargs: Dict[str, Union[str, Iterable[str]]] = {}
-    base_file_name: str = os.path.basename(path).lower()
-    if base_file_name == "setup.cfg":
+    configuration_file_type: ConfigurationFileType = (
+        get_configuration_file_type(path)
+    )
+    if configuration_file_type == ConfigurationFileType.SETUP_CFG:
         update_function = get_updated_setup_cfg
         if all_extra_name:
             kwargs["all_extra_name"] = all_extra_name
-    elif base_file_name == "pyproject.toml":
-        update_function = get_updated_pyproject_toml
-    elif base_file_name == "tox.ini":
+    elif configuration_file_type == ConfigurationFileType.PYPROJECT_TOML:
+        update_function = _get_updated_pyproject_toml
+        kwargs.update(
+            all_extra_name=all_extra_name,
+            include_pointers=include_pointers,
+            exclude_pointers=exclude_pointers,
+        )
+    elif configuration_file_type == ConfigurationFileType.TOML:
+        update_function = _get_updated_toml
+        kwargs.update(
+            include_pointers=include_pointers,
+            exclude_pointers=exclude_pointers,
+        )
+    elif configuration_file_type == ConfigurationFileType.TOX_INI:
         update_function = get_updated_tox_ini
-    else:
+    elif configuration_file_type == ConfigurationFileType.REQUIREMENTS_TXT:
         update_function = get_updated_requirements_txt
+    else:
+        raise NotImplementedError(
+            f"Updating requirements for {path} is not supported"
+        )
     kwargs["ignore"] = ignore
     file_io: IO[str]
     with open(path) as file_io:
@@ -413,25 +488,36 @@ def update(
     paths: Iterable[str],
     ignore: Iterable[str] = (),
     all_extra_name: str = "",
+    include_pointers: Tuple[str, ...] = (),
+    exclude_pointers: Tuple[str, ...] = (),
 ) -> None:
     """
     Update requirement versions in the specified files.
 
     Parameters:
-
-    - path (str|[str}): One or more local paths to a setup.cfg,
-      setup.cfg, and/or requirements.txt files
-    - ignore ([str]): One or more project names to ignore (leave as-is)
-    - all_extra_name (str): If provided, an extra which consolidates
-      the requirements for all other extras will be added/updated to
-      setup.cfg or setup.cfg (this argument is ignored for
-      requirements.txt files)
+        path: One or more local paths to a setup.cfg,
+            setup.cfg, and/or requirements.txt files
+        ignore: One or more project names to ignore (leave as-is)
+        all_extra_name: If provided, an extra which consolidates
+            the requirements for all other extras will be added/updated to
+            setup.cfg or setup.cfg (this argument is ignored for
+            requirements.txt files)
+        include_pointers: A tuple of JSON pointers indicating elements to
+            include (defaults to all elements).
+        exclude_pointers: A tuple of JSON pointers indicating elements to
+            exclude (defaults to no exclusions).
     """
     if isinstance(paths, str):
         paths = (paths,)
 
     def update_(path: str) -> None:
-        _update(path, ignore=ignore, all_extra_name=all_extra_name)
+        _update(
+            path,
+            ignore=ignore,
+            all_extra_name=all_extra_name,
+            include_pointers=include_pointers,
+            exclude_pointers=exclude_pointers,
+        )
 
     deque(map(update_, paths), maxlen=0)
 
@@ -467,6 +553,26 @@ def main() -> None:
             "requirements.txt files)"
         ),
     )
+    parser.add_argument(
+        "--include-pointer",
+        default=[],
+        type=str,
+        action="append",
+        help=(
+            "One or more JSON pointers of elements to *include* "
+            "(applies to TOML files only)"
+        ),
+    )
+    parser.add_argument(
+        "--exclude-pointer",
+        default=[],
+        type=str,
+        action="append",
+        help=(
+            "One or more JSON pointers of elements to *exclude* "
+            "(applies to TOML files only)"
+        ),
+    )
     parser.add_argument(
         "path",
         nargs="+",
@@ -476,11 +582,13 @@ def main() -> None:
             "and/or requirements.txt file"
         ),
     )
-    arguments: argparse.Namespace = parser.parse_args()
+    namespace: argparse.Namespace = parser.parse_args()
     update(
-        paths=arguments.path,
-        ignore=tuple(iter_parse_delimited_values(arguments.ignore)),
-        all_extra_name=arguments.all_extra_name,
+        paths=namespace.path,
+        ignore=tuple(iter_parse_delimited_values(namespace.ignore)),
+        all_extra_name=namespace.all_extra_name,
+        include_pointers=tuple(namespace.include_pointer),
+        exclude_pointers=tuple(namespace.exclude_pointer),
     )