bump

Author: cnheider

.pre-commit-config.yaml

@@ -1,26 +1,26 @@
 fail_fast: true
 repos:
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.19.1
+    rev: v3.20.0
     hooks:
       - id: pyupgrade
         args:
           - --py38-plus
           - --keep-runtime-typing
 
   - repo: https://github.com/ambv/black
-    rev: 24.10.0
+    rev: 25.1.0
     hooks:
       - id: black
         language_version: python3.10
 
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.23
+    rev: v0.24.1
     hooks:
       - id: validate-pyproject
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.14.1
+    rev: v1.16.0
     hooks:
       - id: mypy
         verbose: true
@@ -29,7 +29,7 @@ repos:
         #args: [ --strict ]
 
   - repo: https://github.com/pycqa/flake8
-    rev: 7.1.1 # pick a git hash / tag to point to
+    rev: 7.2.0 # pick a git hash / tag to point to
     hooks:
       - id: flake8 # stop the build if there are Python syntax errors or undefined names
         additional_dependencies: [flake8-docstrings]
@@ -93,7 +93,7 @@ repos:
   #    - id: pydocstyle
 
   - repo: https://github.com/executablebooks/mdformat
-    rev: 0.7.21
+    rev: 0.7.22
     hooks:
       - id: mdformat
         additional_dependencies:

warg/__init__.py

@@ -4,7 +4,7 @@
 __project__ = "Warg"
 
 __author__ = "Christian Heider Lindbjerg"
-__version__ = "1.4.8"
+__version__ = "1.4.9"
 __doc__ = r"""
 Created on 27/04/2019
 

warg/data_structures/mappings.py

@@ -1,9 +1,19 @@
 #!/usr/bin/env python3
 import logging
 from typing import Callable, Dict, Hashable, Iterable, Mapping, MutableMapping
+from collections import defaultdict
+
 
 logger = logging.getLogger(__name__)
-__all__ = ["invert_mapping", "invert_dict", "AppendingDict", "pivot_dict_object", "pivot_dict", "to_dict"]
+__all__ = [
+    "invert_mapping",
+    "invert_dict",
+    "AppendingDict",
+    "pivot_dict_object",
+    "pivot_dict",
+    "to_dict",
+    "nested_dict",
+]
 
 
 def append_to_dict(d: Dict, key, value) -> Dict:
@@ -116,6 +126,8 @@ def to_dict(m: Mapping) -> dict:
     return o
 
 
+nested_dict = lambda: defaultdict(nested_dict)
+
 if __name__ == "__main__":
     logger.info(invert_mapping({"a": 1, "b": 2}))
 

warg/decorators/kw_passing.py

@@ -116,6 +116,7 @@ def passes_kws_to(
     a receiver function. No call graph checks if this actually enforces this yet. Also all receiver kwargs
     must be able to be received by receivers if multiple contracts are use
 
+    :param no_pass_filter:
     :param receiver_funcs:
     :param keep_from_var_kw:
     :return:"""

warg/map_itertools.py

@@ -9,52 +9,105 @@
 __all__ = [
     "map_value_product",
     "map_product",
+    "map_sorted",
     "map_permutations",
     "map_combinations",
     "map_combinations_with_replacement",
 ]
 
 import itertools
 import logging
-from typing import Any, Mapping, Tuple
+from typing import Any, Generator, Mapping, Optional, Tuple
 
 logger = logging.getLogger(__name__)
 
 
-def map_value_product(dicts: Mapping) -> Any:
-    """description"""
-    return (dict(zip(dicts, x)) for x in itertools.product(*dicts.values()))
+def map_value_product(mappings: Optional[Mapping]) -> Optional[Generator[dict, None, None]]:
+    """
+
+    :param mappings:
+    :return:
+    """
+    if mappings is None:
+        return None
+
+    return (dict(zip(mappings, x)) for x in itertools.product(*mappings.values()))
+
+
+def map_reversed(mapping: Optional[Mapping]) -> Optional[dict]:
+    """
+
+    :param mapping:
+    :return:
+    """
+    if mapping is None:
+        return None
+
+    return dict(reversed(list(mapping.items())))
+
+
+def map_sorted(mapping: Optional[Mapping], **kwargs) -> Optional[dict]:
+    """
 
+    :param mapping:
+    :param kwargs:
+    :return:
+    """
+    if mapping is None:
+        return None
 
-def map_product(dicts: Mapping, repeat: int = 2) -> Any:
+    return dict(sorted(mapping.items(), **kwargs))
+
+
+def map_product(mapping: Mapping, repeat: int = 2) -> Any:
     """description"""
     yield from zip(
-        itertools.product(dicts.keys(), repeat=repeat),
-        itertools.product(dicts.values(), repeat=repeat),
+        itertools.product(mapping.keys(), repeat=repeat),
+        itertools.product(mapping.values(), repeat=repeat),
     )
 
 
-def map_permutations(dicts: Mapping, repeat: int = 2) -> Tuple:
-    """description"""
+def map_permutations(mapping: Mapping, repeat: int = 2) -> Generator[Tuple[Any, ...], None, None]:
+    """
+
+    :param mapping:
+    :param repeat:
+    :return:
+    """
     yield from zip(
-        itertools.permutations(dicts.keys(), repeat),
-        itertools.permutations(dicts.values(), repeat),
+        itertools.permutations(mapping.keys(), repeat),
+        itertools.permutations(mapping.values(), repeat),
     )
 
 
-def map_combinations(dicts: Mapping, repeat: int = 2) -> Tuple:
-    """description"""
+def map_combinations(mapping: Mapping, repeat: int = 2) -> Generator[Tuple[Any, ...], None, None]:
+    """
+
+    :param mapping:
+    :param repeat:
+    :return:
+    """
     yield from zip(
-        itertools.combinations(dicts.keys(), repeat),
-        itertools.combinations(dicts.values(), repeat),
+        itertools.combinations(mapping.keys(), repeat),
+        itertools.combinations(mapping.values(), repeat),
     )
 
 
-def map_combinations_with_replacement(dicts: Mapping, repeat: int = 2) -> Tuple:
-    """description"""
+def map_combinations_with_replacement(
+    mappings: Mapping, repeat: int = 2
+) -> Generator[Tuple[Any, ...], None, None]:
+    """
+
+    :param mappings:
+    :param repeat:
+    :return:
+    """
+    if mappings is None:
+        return None
+
     yield from zip(
-        itertools.combinations_with_replacement(dicts.keys(), repeat),
-        itertools.combinations_with_replacement(dicts.values(), repeat),
+        itertools.combinations_with_replacement(mappings.keys(), repeat),
+        itertools.combinations_with_replacement(mappings.values(), repeat),
     )
 
 

warg/modules.py

@@ -3,15 +3,15 @@
 import pkgutil
 from pathlib import Path
 from types import ModuleType
-from typing import Sequence
+from typing import Any, Generator, Sequence
 
 logger = logging.getLogger(__name__)
 
 
 __all__ = ["iter_import_module", "get_submodules", "get_submodules_by_path"]
 
 
-def iter_import_module(module_name: str, module_paths: Sequence[str]) -> ModuleType:
+def iter_import_module(module_name: str, module_paths: Sequence[str]) -> Generator[ModuleType, Any, None]:
     logger.info(f"Found {module_name} in {module_paths}")
 
     yield from (
@@ -20,13 +20,13 @@ def iter_import_module(module_name: str, module_paths: Sequence[str]) -> ModuleT
     )
 
 
-def get_submodules(module: ModuleType) -> ModuleType:
+def get_submodules(module: ModuleType) -> Generator[ModuleType, Any, None]:
     logger.info(f"Found {module.__path__} {module.__name__}")
 
     yield from iter_import_module(module.__name__, module.__path__)
 
 
-def get_submodules_by_path(module_path: Path) -> ModuleType:
+def get_submodules_by_path(module_path: Path) -> Generator[ModuleType, Any, None]:
     assert module_path.exists(), f"{module_path} does not exist"
 
     yield from iter_import_module(module_path.stem, [str(module_path)])

warg/packages/versioning.py

@@ -90,7 +90,10 @@ def get_version(version: str, append_time: bool = False, verbose: bool = False,
 
     except:
         if append_time:
-            now = datetime.datetime.utcnow()
+            try:
+                now = datetime.datetime.now(datetime.UTC)
+            except:
+                now = datetime.datetime.utcnow()
             date_version = now.strftime("%Y%m%d%H%M%S")
             # date_version = time.time()