ddutils 0.0.1__tar.gz

ddutils-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Artem Davydov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ddutils-0.0.1/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: ddutils
+Version: 0.0.1
+Summary: Domain Driven Utils Library
+Home-page: https://github.com/davyddd/ddutils
+License: MIT
+Keywords: python,ddutils
+Author: davyddd
+Requires-Python: >=3.8,<3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Project-URL: Repository, https://github.com/davyddd/ddutils
+Description-Content-Type: text/markdown
+
+# DDUtils
+
+[![pypi](https://img.shields.io/pypi/v/ddutils.svg)](https://pypi.python.org/pypi/ddutils)
+[![downloads](https://static.pepy.tech/badge/ddutils/month)](https://pepy.tech/project/ddutils)
+[![versions](https://img.shields.io/pypi/pyversions/ddutils.svg)](https://github.com/davyddd/ddutils)
+[![codecov](https://codecov.io/gh/davyddd/ddutils/branch/main/graph/badge.svg)](https://app.codecov.io/github/davyddd/ddutils)
+[![license](https://img.shields.io/github/license/davyddd/ddutils.svg)](https://github.com/davyddd/ddutils/blob/main/LICENSE)
+
+## Installation
+
+Install the library using pip:
+```bash
+pip install ddutils
+```
+

ddutils-0.0.1/README.md

@@ -0,0 +1,14 @@
+# DDUtils
+
+[![pypi](https://img.shields.io/pypi/v/ddutils.svg)](https://pypi.python.org/pypi/ddutils)
+[![downloads](https://static.pepy.tech/badge/ddutils/month)](https://pepy.tech/project/ddutils)
+[![versions](https://img.shields.io/pypi/pyversions/ddutils.svg)](https://github.com/davyddd/ddutils)
+[![codecov](https://codecov.io/gh/davyddd/ddutils/branch/main/graph/badge.svg)](https://app.codecov.io/github/davyddd/ddutils)
+[![license](https://img.shields.io/github/license/davyddd/ddutils.svg)](https://github.com/davyddd/ddutils/blob/main/LICENSE)
+
+## Installation
+
+Install the library using pip:
+```bash
+pip install ddutils
+```

ddutils-0.0.1/ddutils/__init__.py

@@ -0,0 +1,11 @@
+__all__ = (
+    'convertors',
+    'class_helpers',
+    'function_exceptions_extractor',
+    'module_getter',
+    'sequence_helpers',
+    'annotation_helpers',
+    'function_helpers',
+    'safe_decorators',
+    'sequence_helpers',
+)

ddutils-0.0.1/ddutils/annotation_helpers.py

@@ -0,0 +1,85 @@
+import inspect
+import sys
+from typing import Any, Sequence, Tuple, Union, get_args
+
+if sys.version_info >= (3, 10):
+    from types import UnionType
+else:
+
+    class UnionType:
+        ...
+
+
+NON_COMPLEX_SEQUENCE_TYPES = (str, bytes, bytearray)
+
+
+def get_annotation_origin(annotation: Any) -> Any:
+    if annotation is None:
+        return annotation
+    elif hasattr(annotation, '__origin__'):
+        # This is a generic type from the typing module
+        # Generic types like List[int], Dict[str, int] have an '__origin__' attribute
+        return get_annotation_origin(annotation.__origin__)
+    elif hasattr(annotation, '__supertype__'):
+        # This is a type created with NewType
+        return get_annotation_origin(annotation.__supertype__)
+    elif annotation is Union or isinstance(annotation, UnionType):
+        # This also includes Optional types, since Optional[T] is Union[T, None]
+        raise TypeError('Union types are not supported')
+    elif not isinstance(annotation, type):
+        raise TypeError('Annotation must be instance of type')
+
+    return annotation
+
+
+def is_subclass(annotation: Any, *base_types: Any) -> bool:
+    annotation_origin = get_annotation_origin(annotation)
+    return inspect.isclass(annotation_origin) and issubclass(
+        annotation_origin, tuple(get_annotation_origin(base_type) for base_type in base_types)
+    )
+
+
+def is_complex_sequence(annotation: Any) -> bool:
+    annotation_origin = get_annotation_origin(annotation)
+    return annotation_origin not in NON_COMPLEX_SEQUENCE_TYPES and is_subclass(annotation_origin, Sequence)
+
+
+def get_complex_sequence_element_annotation(annotation: Any) -> Any:
+    if hasattr(annotation, '__supertype__'):
+        return get_complex_sequence_element_annotation(annotation.__supertype__)
+    elif not is_complex_sequence(annotation):
+        raise ValueError('Annotation must be a complex sequence')
+
+    element_annotation = next(iter(get_args(annotation)), None)
+    if element_annotation is None:
+        raise ValueError('Annotation must have subtype')
+
+    return element_annotation
+
+
+def get_dict_items_annotation(annotation: Any) -> Tuple[Any, Any]:
+    if hasattr(annotation, '__supertype__'):
+        return get_dict_items_annotation(annotation.__supertype__)
+    elif not is_subclass(annotation, dict):
+        raise TypeError('`annotation` must be a dict')
+
+    annotation_args = get_args(annotation)
+    if len(annotation_args) != 2:  # noqa: PLR2004
+        raise ValueError('Dict annotation must have two arguments')
+
+    key_annotation, value_annotation = annotation_args
+
+    return key_annotation, value_annotation
+
+
+def get_annotation_without_optional(annotation: Any) -> Any:
+    try:
+        get_annotation_origin(annotation)
+        return annotation
+    except TypeError:
+        annotation_args = tuple(arg for arg in get_args(annotation) if arg is not type(None))
+
+        if len(annotation_args) != 1:  # noqa: PLR2004
+            raise TypeError('Union types are not supported') from None
+
+        return annotation_args[0]

ddutils-0.0.1/ddutils/class_helpers.py

@@ -0,0 +1,8 @@
+import inspect
+from typing import Any
+
+
+def get_origin_class_of_method(cls: Any, method_name: str):
+    for base in inspect.getmro(cls):
+        if method_name in base.__dict__:
+            return base

ddutils-0.0.1/ddutils/convertors.py

@@ -0,0 +1,2 @@
+def convert_camel_case_to_snake_case(string: str) -> str:
+    return ''.join(f'_{char.lower()}' if char.isupper() else char for char in string).lstrip('_')

ddutils-0.0.1/ddutils/function_exceptions_extractor.py

@@ -0,0 +1,110 @@
+import ast
+import builtins
+import inspect
+import textwrap
+from importlib import import_module
+from typing import Any, Callable, Dict, Generator, NamedTuple, Optional, Tuple, Type
+
+from ddutils.module_getter import get_module
+
+UNDEFINED_VALUE = object()
+
+
+class Annotation(NamedTuple):
+    argument: str
+    default_value: Any
+
+    def is_empty(self) -> bool:
+        return self.default_value is inspect._empty
+
+
+class ExceptionInfo:
+    exception_class: Type[Exception]
+    args: Tuple[Any, ...]
+    kwargs: Dict[str, Any]
+
+    def __init__(self, exception_class: Type[Exception], args: Tuple[Any, ...], kwargs: Dict[str, Any]):
+        self.exception_class = exception_class
+        self.args = tuple(_v.value if isinstance(_v, ast.Constant) else UNDEFINED_VALUE for _v in args)
+        self.kwargs = {_k: _v.value if isinstance(_v, ast.Constant) else UNDEFINED_VALUE for _k, _v in kwargs.items()}
+
+    def get_kwargs(self) -> Dict[str, Any]:
+        annotations = tuple(
+            Annotation(argument, argument_info.default)
+            for argument, argument_info in inspect.signature(self.exception_class.__init__).parameters.items()
+            if argument not in {'self', 'args', 'kwargs'}
+        )
+        kwargs = {
+            **{annotation.argument: self.args[item] for item, annotation in enumerate(annotations[: len(self.args)])},
+            **self.kwargs,
+        }
+        for annotation in annotations:
+            if annotation.argument not in kwargs:
+                if not annotation.is_empty():
+                    kwargs[annotation.argument] = annotation.default_value
+                elif hasattr(self.exception_class, annotation.argument):
+                    kwargs[annotation.argument] = getattr(self.exception_class, annotation.argument)
+                else:
+                    kwargs[annotation.argument] = UNDEFINED_VALUE
+
+        del annotations
+
+        return kwargs
+
+    def get_exception_instance(self, dry_run: bool = True) -> Optional[Exception]:
+        kwargs = {k: f'<{k}>' if v is UNDEFINED_VALUE else v for k, v in self.get_kwargs().items()}
+        try:
+            # There might be issues with strict typing because UNDEFINED_VALUE is always replaced with a string
+            return self.exception_class(**kwargs)
+        except Exception as err:  # noqa: BLE001
+            if dry_run:
+                return None
+            else:
+                raise err
+
+
+def _get_node_name(node: ast.AST) -> str:
+    if isinstance(node, ast.Name):
+        return node.id
+    elif isinstance(node, ast.Attribute):
+        return f'{_get_node_name(node.value)}.{node.attr}'
+    elif isinstance(node, ast.Call):
+        return _get_node_name(node.func)
+    else:
+        raise TypeError(f'Unsupported node type: {type(node)}')
+
+
+def extract_function_exceptions(func: Callable) -> Generator[ExceptionInfo, None, None]:
+    source = textwrap.dedent(inspect.getsource(func))
+    tree = ast.parse(source)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Raise):
+            if node.exc is None:
+                continue
+
+            try:
+                exception_name: str = _get_node_name(node.exc)
+                exception_args: Tuple[Any, ...] = ()
+                exception_kwargs: Dict[str, Any] = {}
+            except TypeError:
+                continue
+
+            if isinstance(node.exc, ast.Call):
+                exception_args = tuple(node.exc.args)
+                exception_kwargs = {kw.arg: kw.value for kw in node.exc.keywords if isinstance(kw.arg, str)}
+
+            exception_name_slices = exception_name.split('.')
+            class_name = exception_name_slices[-1]
+            sub_modules = exception_name_slices[:-1]
+
+            exception_module = get_module(import_module(func.__module__), sub_modules)
+
+            exception_class: Optional[Type[Exception]] = getattr(exception_module, class_name, None)
+            if exception_class is None and hasattr(builtins, exception_name):
+                exception_class = getattr(builtins, exception_name)
+
+            if exception_class is None:
+                continue
+
+            yield ExceptionInfo(exception_class=exception_class, args=exception_args, kwargs=exception_kwargs)

ddutils-0.0.1/ddutils/function_helpers.py

@@ -0,0 +1,57 @@
+import sys
+from types import CellType, CodeType, FunctionType
+from typing import Callable, Optional
+
+
+def create_new_function(base_func: Callable, new_name: Optional[str] = None) -> Callable:
+    base_code = base_func.__code__
+    func_name = new_name or base_code.co_name
+
+    if sys.version_info >= (3, 11):
+        # for python 3.11 and newer
+        new_code = CodeType(
+            base_code.co_argcount,
+            base_code.co_posonlyargcount,
+            base_code.co_kwonlyargcount,
+            base_code.co_nlocals,
+            base_code.co_stacksize,
+            base_code.co_flags,
+            base_code.co_code,
+            base_code.co_consts,
+            base_code.co_names,
+            base_code.co_varnames,
+            base_code.co_filename,
+            func_name,
+            func_name,
+            base_code.co_firstlineno,
+            base_code.co_lnotab,
+            base_code.co_exceptiontable,
+            base_code.co_freevars,
+            base_code.co_cellvars,
+        )
+    else:
+        # for python 3.10 and older
+        new_code = CodeType(
+            base_code.co_argcount,
+            base_code.co_posonlyargcount,
+            base_code.co_kwonlyargcount,
+            base_code.co_nlocals,
+            base_code.co_stacksize,
+            base_code.co_flags,
+            base_code.co_code,
+            base_code.co_consts,
+            base_code.co_names,
+            base_code.co_varnames,
+            base_code.co_filename,
+            func_name,
+            base_code.co_firstlineno,
+            base_code.co_lnotab,
+            base_code.co_freevars,
+            base_code.co_cellvars,
+        )
+
+    closure = base_func.__closure__
+    if closure:
+        closure = tuple(CellType(cell.cell_contents) for cell in closure)
+
+    return FunctionType(new_code, base_func.__globals__, func_name, base_func.__defaults__, closure)

ddutils-0.0.1/ddutils/module_getter.py

@@ -0,0 +1,20 @@
+from types import ModuleType
+from typing import List
+
+
+def get_module(module: ModuleType, sub_modules: List[str]) -> ModuleType:
+    if not module:
+        raise ValueError('Argument `module` is required')
+    elif not isinstance(sub_modules, list):
+        raise ValueError('Argument `sub_modules` must be a list of strings')
+
+    if len(sub_modules) == 0:
+        return module
+
+    sub_module = sub_modules.pop(0)
+
+    if hasattr(module, sub_module):
+        module = getattr(module, sub_module)
+        return get_module(module, sub_modules)
+    else:
+        raise ValueError(f'Module {sub_module} not found in {module.__name__}')

ddutils-0.0.1/ddutils/safe_decorators.py

@@ -0,0 +1,50 @@
+import logging
+from functools import wraps
+from typing import Any, Callable, Optional, Tuple, Type
+
+logger = logging.getLogger(__name__)
+
+
+def safe_call(
+    func: Optional[Callable] = None,
+    capture_exception: bool = True,
+    default_result: Optional[Any] = None,
+    exceptions: Tuple[Type[Exception], ...] = (Exception,),
+) -> Callable:
+    if func is None:
+        return lambda _func: safe_call(
+            func=_func, capture_exception=capture_exception, default_result=default_result, exceptions=exceptions
+        )
+
+    @wraps(func)
+    def wrapped_func(*args, **kwargs):
+        try:
+            result = func(*args, **kwargs)
+        except exceptions as error:
+            if capture_exception:
+                logger.exception(error)
+
+            result = default_result
+
+        return result
+
+    return wrapped_func
+
+
+def retry_once_after_exception(
+    func: Optional[Callable] = None, capture_exception: bool = True, exceptions: Tuple[Type[Exception], ...] = (Exception,)
+) -> Callable:
+    if func is None:
+        return lambda _func: retry_once_after_exception(func=_func, capture_exception=capture_exception, exceptions=exceptions)
+
+    @wraps(func)
+    def wrapped_func(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except exceptions as error:
+            if capture_exception:
+                logger.exception(error)
+
+            return func(*args, **kwargs)
+
+    return wrapped_func

ddutils-0.0.1/ddutils/sequence_helpers.py

@@ -0,0 +1,8 @@
+from typing import Any, Sequence
+
+
+def get_safe_element(seq: Sequence[Any], index: int) -> Any:
+    try:
+        return seq[index]
+    except IndexError:
+        return None

ddutils-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[tool.poetry]
+name = "ddutils"
+description = "Domain Driven Utils Library"
+version = "0.0.1"
+authors = ["davyddd"]
+license = "MIT"
+repository = "https://github.com/davyddd/ddutils"
+readme = "README.md"
+keywords = ["python", "ddutils"]
+packages = [{include = "ddutils"}]
+
+[tool.poetry.dependencies]
+python = ">=3.8,<3.13"
+
+[tool.poetry.group.dev.dependencies]
+ipdb = "0.13.9"
+ipython = "8.12.3"
+
+[tool.poetry.group.test.dependencies]
+pytest = "8.1.1"
+pytest-cov = "5.0.0"
+parameterized = "0.9.0"
+typing-extensions = "^4.12.2"
+
+[tool.poetry.group.linter.dependencies]
+mypy = "1.1.1"
+ruff = "0.1.7"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"