more verbose

Author: cnheider

devpack/batch_tools.py

@@ -10,8 +10,9 @@
 __all__ = ["auto_add_readme", "recursive_add_readmes", "TouchModeEnum"]
 
 from enum import Enum
+from functools import wraps
 from pathlib import Path
-from typing import Callable, Iterable, Optional
+from typing import Callable, Iterable, Optional, MutableMapping, Sequence
 
 from sorcery import assigned_names
 
@@ -62,6 +63,9 @@ def auto_add_readme(
             readme_file.write_text(prefix + str(readme_file.parent.name))
         else:
             raise ValueError(f"Unknown touch mode {touch_mode}")
+    else:
+        if verbose:
+            print(f"{readme_name} already exists at {path}")
 
 
 def is_python_module(path: Path) -> bool:
@@ -80,9 +84,23 @@ def is_python_package(path: Path) -> bool:
 
 def negate(f: Callable) -> Callable:
     """
-    Negate a function
+    Negate a function return
     """
-    return lambda *args, **kwargs: not f(*args, **kwargs)
+
+    @wraps(f)
+    def wrapper(*args: Sequence, **kwargs: MutableMapping):
+        """
+
+        :param args:
+        :type args:
+        :param kwargs:
+        :type kwargs:
+        :return:
+        :rtype:
+        """
+        return not f(*args, **kwargs)
+
+    return wrapper
 
 
 def recursive_add_readmes(
@@ -111,8 +129,10 @@ def recursive_add_readmes(
     )
 
     for child in path.iterdir():
-        if exclusion_filter is None or not any(flt(child) for flt in exclusion_filter):
-            if child.is_dir():
+        if child.is_dir():
+            if exclusion_filter is None or not any(
+                flt(child) for flt in exclusion_filter
+            ):
                 recursive_add_readmes(
                     child,
                     exclusion_filter,
@@ -121,8 +141,13 @@ def recursive_add_readmes(
                     root_path=root_path,
                     verbose=verbose,
                 )
-            elif child.is_file():
-                pass
+            else:
+                if verbose:
+                    print(
+                        f"{child} was excluded, filters:\n{[(flt.__name__, flt(child)) for flt in exclusion_filter]}"
+                    )
+        elif child.is_file():
+            pass
 
 
 if __name__ == "__main__":

devpack/entry_points/batch.py

@@ -11,7 +11,6 @@
 
 import argparse
 from pathlib import Path
-from tabnanny import verbose
 
 from devpack.batch_tools import TouchModeEnum, recursive_add_readmes
 

devpack/entry_points/cli.py

@@ -7,10 +7,8 @@
 
 import argparse
 
-from devpack.devpack.development import pip_uninstall_package
-
-
-from .development import pip_install_development_package
+from devpack.development import pip_uninstall_package
+from devpack.development import pip_install_development_package
 
 
 def install_develop():

setup.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-from typing import List, Union
+from typing import List, Union, TextIO, Sequence
 
 
 def python_version_check(major=3, minor=6):
@@ -15,10 +15,56 @@ def python_version_check(major=3, minor=6):
 
 
 python_version_check()
-
 import pathlib
 import re
 
+
+def read_reqs(file: str, path: pathlib.Path) -> List[str]:
+    """description"""
+
+    def readlines_ignore_comments(f: TextIO):
+        """description"""
+        return [a_ for a_ in f.readlines() if "#" not in a_ and a_]
+
+    def recursive_flatten_ignore_str(seq: Sequence) -> Sequence:
+        """description"""
+        if not seq:  # is empty Sequence
+            return seq
+        if isinstance(seq[0], str):
+            return seq
+        if isinstance(seq[0], Sequence):
+            return (
+                *recursive_flatten_ignore_str(seq[0]),
+                *recursive_flatten_ignore_str(seq[1:]),
+            )
+        return (*seq[:1], *recursive_flatten_ignore_str(seq[1:]))
+
+    def unroll_nested_reqs(req_str: str, base_path: pathlib.Path):
+        """description"""
+        if req_str.startswith("-r"):
+            with open(base_path / req_str.strip("-r").strip()) as f:
+                return [
+                    unroll_nested_reqs(req.strip(), base_path)
+                    for req in readlines_ignore_comments(f)
+                ]
+        else:
+            return (req_str,)
+
+    requirements_group = []
+    with open(str(path / file)) as f:
+        requirements = readlines_ignore_comments(f)
+        for requirement in requirements:
+            requirements_group.extend(
+                recursive_flatten_ignore_str(
+                    unroll_nested_reqs(requirement.strip(), path)
+                )
+            )
+
+    req_set = set(requirements_group)
+    req_set.discard("")
+    return list(req_set)
+
+
 from setuptools import find_packages, setup
 
 with open(
@@ -44,33 +90,16 @@ class DevPackPackage:
 
     @property
     def test_dependencies(self) -> list:
-        """
-        The test dependencies
-        """
-        path = pathlib.Path(__file__).parent
-        requirements_tests = []
-        with open(path / "requirements_tests.txt") as f:
-            requirements = f.readlines()
-
-            for requirement in requirements:
-                requirements_tests.append(requirement.strip())
-
-        return requirements_tests
+        return read_reqs(
+            "requirements_tests.txt", pathlib.Path(__file__).parent / "requirements"
+        )
 
     @property
     def setup_dependencies(self) -> list:
-        """
-        Get the setup dependencies
-        """
-        path = pathlib.Path(__file__).parent
-        requirements_setup = []
-        with open(path / "requirements_setup.txt") as f:
-            requirements = f.readlines()
-
-            for requirement in requirements:
-                requirements_setup.append(requirement.strip())
-
-        return requirements_setup
+        """description"""
+        return read_reqs(
+            "requirements_setup.txt", pathlib.Path(__file__).parent / "requirements"
+        )
 
     @property
     def package_name(self) -> str:
@@ -164,43 +193,29 @@ def entry_points(self) -> dict:
 
     @property
     def extras(self) -> dict:
-        """
-        Extra requirements
-        """
-        path = pathlib.Path(__file__).parent
-        requirements_xx = []
-        with open(path / "requirements_dev.txt") as f:
-            requirements = f.readlines()
-
-            for requirement in requirements:
-                requirements_xx.append(requirement.strip())
-
+        """description"""
         these_extras = {
-            # 'ExtraGroupName':['package-name; platform_system == "System(Linux,Windows)"'
-            # "xx": requirements_xx
+            # 'ExtraName':['package-name; platform_system == "System(Linux,Windows)"'
         }
 
-        all_dependencies = []
+        path: pathlib.Path = pathlib.Path(__file__).parent / "requirements"
 
+        for file in path.iterdir():
+            if file.name.startswith("requirements_"):
+                group_name_ = "_".join(file.name.strip(".txt").split("_")[1:])
+                these_extras[group_name_] = read_reqs(file.name, path)
+
+        all_dependencies = []
         for group_name in these_extras:
             all_dependencies += these_extras[group_name]
-        these_extras["all"] = all_dependencies
+        these_extras["all"] = list(set(all_dependencies))
 
         return these_extras
 
     @property
     def requirements(self) -> list:
-        """
-        Requirements for the package
-        """
-        requirements_out = []
-        with open("requirements.txt") as f:
-            requirements = f.readlines()
-
-            for requirement in requirements:
-                requirements_out.append(requirement.strip())
-
-        return requirements_out
+        """description"""
+        return read_reqs("requirements.txt", pathlib.Path(__file__).parent)
 
     @property
     def description(self) -> str: