danielutils 1.0.1__tar.gz → 1.0.3__tar.gz

{danielutils-1.0.1/danielutils.egg-info → danielutils-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 1.0.1
+Version: 1.0.3
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License

{danielutils-1.0.1 → danielutils-1.0.3}/danielutils/__init__.py

@@ -45,3 +45,4 @@ from .testing import *
 from .retry_executor import *
 from .java import *
 from .random_ import *
+from .lombok import *

{danielutils-1.0.1 → danielutils-1.0.3}/danielutils/context_managers/temporary_file.py

@@ -44,6 +44,12 @@ class TemporaryFile(ContextManager):
         with open(self.path, 'r') as f:
             return f.read()
 
+    def readbinary(self) -> bytes:
+        if not file_exists(self.path):
+            return b""
+        with open(self.path, 'rb') as f:
+            return f.read()
+
     def readlines(self) -> List[str]:
         if not file_exists(self.path):
             return []
@@ -54,6 +60,10 @@ class TemporaryFile(ContextManager):
         with open(self.path, 'a') as f:
             f.write(s)
 
+    def writebinary(self, s: bytes) -> None:
+        with open(self.path, 'ab') as f:
+            f.write(s)
+
     def writelines(self, lines: List[str]) -> None:
         with open(self.path, 'a') as f:
             f.writelines(lines)

{danielutils-1.0.1/danielutils/Functions → danielutils-1.0.3/danielutils/functions}/isoftype.py

@@ -431,8 +431,4 @@ def isoftype(V: Any, T: Any, /, strict: bool = True) -> bool:
 
 __all__ = [
     "isoftype"
-]
-
-__all__ = [
-    "isoftype"
-]
+]

danielutils-1.0.3/danielutils/java/interfaces/comparable.py

@@ -0,0 +1,31 @@
+# from abc import abstractmethod
+# from typing import TypeVar, Generic
+#
+# from ..java_interface import JavaInterface
+#
+# T = TypeVar('T')
+#
+#
+# class Comparable(JavaInterface, Generic[T]):
+#     @abstractmethod
+#     def __lt__(self, other: T) -> bool: ...
+#
+#     @abstractmethod
+#     def __gt__(self, other: T) -> bool: ...
+#
+#     @abstractmethod
+#     def __eq__(self, other: T) -> bool: ...
+#
+#     @abstractmethod
+#     def __le__(self, other: T) -> bool: ...
+#
+#     @abstractmethod
+#     def __ge__(self, other: T) -> bool: ...
+#
+#     @abstractmethod
+#     def __ne__(self, other: T) -> bool: ...
+#
+#
+# __all__ = [
+#     "Comparable",
+# ]

danielutils-1.0.3/danielutils/java/java_interface.py

@@ -0,0 +1,41 @@
+
+from abc import abstractmethod, ABC
+from typing import Protocol, runtime_checkable, Any, Callable, ParamSpec, Generic
+from ..reflection import ClassInfo
+
+
+class InterfaceError(Exception):
+    ...
+
+
+# @runtime_checkable
+class JavaInterface(ABC):
+    InterfaceError = InterfaceError
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs) -> None:
+        info = ClassInfo(cls)
+        for base in info.bases:
+            if base.name == JavaInterface.__name__:
+                setattr(cls, "__is_interface__", True)
+                break
+        else:
+            setattr(cls, "__is_interface__", False)
+            info = ClassInfo(cls)
+            print(set(info.functions))
+            print(set(info.inherited_methods))
+            actual_func_names = set(f.name for f in info.functions)
+            for to_remove in {"__class_getitem__", "__init_subclass__"}:
+                if getattr(cls, to_remove, None) is getattr(JavaInterface, to_remove, None):
+                    actual_func_names.remove(to_remove)
+            for interface in (base for base in cls.__mro__ if getattr(base, "__is_interface__", False)):
+                expected_func_names = set(f.name for f in ClassInfo(interface).abstract_methods)
+                if subtraction := expected_func_names.difference(actual_func_names):
+                    raise InterfaceError(
+                        f"class '{cls.__name__}' does not implement required methods {subtraction}")
+        super().__init_subclass__(**kwargs)
+
+
+__all__ = [
+    "JavaInterface",
+]

danielutils-1.0.3/danielutils/logging_/__init__.py

@@ -0,0 +1,4 @@
+from .builtin_impls import *
+from .log_level import *
+from .logger import *
+from .logger_strategy_impl_base import *

danielutils-1.0.3/danielutils/logging_/builtin_impls/__init__.py

@@ -0,0 +1,2 @@
+from .print_logger import *
+from .file_logger import *

danielutils-1.0.3/danielutils/logging_/builtin_impls/file_logger.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+
+from danielutils import delete_file, directory_exists, create_directory
+
+from ..logger_strategy_impl_base import LoggerStrategyImplBase
+
+
+class FIleLogger(LoggerStrategyImplBase):
+    def __init__(self, output_path: str, logger_id: str, delete_if_already_exists: bool = True, channel: str = "all"):
+        if delete_if_already_exists:
+            delete_file(output_path)
+        if not directory_exists(parent := str(Path(output_path).parent.absolute().resolve())):
+            create_directory(parent)
+        self.output_path: str = str(Path(output_path).absolute().resolve())
+
+        def foo(s: str):
+            with open(self.output_path, "a+") as f:
+                f.write(s)
+
+        super().__init__(foo, logger_id, channel)
+
+
+__all__ = [
+    "FIleLogger"
+]

danielutils-1.0.3/danielutils/logging_/builtin_impls/print_logger.py

@@ -0,0 +1,11 @@
+from ..logger_strategy_impl_base import LoggerStrategyImplBase
+
+
+class PrintLogger(LoggerStrategyImplBase):
+    def __init__(self, logger_id: str, channel: str = "all"):
+        super().__init__(lambda s: print(s, end=""), logger_id, channel)
+
+
+__all__ = [
+    "PrintLogger"
+]

danielutils-1.0.3/danielutils/logging_/log_level.py

@@ -0,0 +1,13 @@
+from enum import IntEnum
+
+
+class LogLevel(IntEnum):
+    DEBUG = 0
+    INFO = 1
+    WARNING = 2
+    ERROR = 3
+
+
+__all__ = [
+    "LogLevel"
+]

danielutils-1.0.3/danielutils/logging_/logger.py

@@ -0,0 +1,99 @@
+import json
+from datetime import datetime
+from typing import Type, Optional, Dict, List
+
+from .log_level import LogLevel
+from .logger_strategy_impl_base import LoggerStrategyImplBase
+
+
+class _LoggerImpl:
+    def __init__(self, origin: Type):
+        self.origin = origin
+
+    @classmethod
+    def parse_message(
+            cls,
+            origin: Type,
+            logger_id: Optional,
+            channel: str,
+            level: LogLevel,
+            message: str,
+            module: Optional[str] = None,
+            cls_name: Optional[str] = None,
+            metadata: Optional[Dict] = None
+    ) -> str:
+        d = dict(
+            timestamp=str(datetime.now()),
+            origin=origin.__qualname__,
+            logger_id=logger_id,
+            channel=channel,
+            level=level.name,
+            message=message
+        )
+        if module:
+            d.update({'module': module})
+
+        if cls_name:
+            d.update({'cls': cls_name})
+
+        if metadata:
+            d.update({'metadata': metadata})
+        s = json.dumps(d)
+        return f"{s}\n"
+
+    def _log(self, level: LogLevel, message: str, channel: str, **metadata):
+        message = str(message)
+        for logger in LoggerStrategyImplBase._loggers[channel]:
+            logger(self.parse_message(
+                self.origin,
+                logger.logger_id,
+                channel,
+                level,
+                message,
+                metadata.get("cls", {}).get("__module__", None),
+                metadata.pop("cls", {}).get("__qualname__", None),
+                metadata
+            ))
+
+    def debug(self, message: str, channel: str = "all", **metadata):
+        self._log(LogLevel.DEBUG, message, channel, **metadata)
+
+    def info(self, message: str, channel: str = "all", **metadata):
+        self._log(LogLevel.INFO, message, channel, **metadata)
+
+    def warning(self, message: str, channel: str = "all", **metadata):
+        self._log(LogLevel.WARNING, message, channel, **metadata)
+
+    def error(self, message: str, channel: str = "all", **metadata):
+        self._log(LogLevel.ERROR, message, channel, **metadata)
+
+
+class Logger:
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        cls._logger = _LoggerImpl(cls)
+        cls._registered_loggers: List[LoggerStrategyImplBase] = []
+        cls.init_subscribers()
+
+    @classmethod
+    @property
+    def logger(cls) -> _LoggerImpl:
+        return cls._logger
+
+    @classmethod
+    def init_subscribers(cls):
+        pass
+
+    @classmethod
+    def register_logger(cls, logger: LoggerStrategyImplBase) -> None:
+        cls._registered_loggers.append(logger)
+
+
+class GlobalLogger(Logger):
+    pass
+
+
+__all__ = [
+    "Logger",
+    "GlobalLogger"
+]

danielutils-1.0.3/danielutils/logging_/logger_strategy_impl_base.py

@@ -0,0 +1,29 @@
+from collections import defaultdict
+from typing import Dict, List, Callable
+
+
+class LoggerStrategyImplBase:
+    _loggers: Dict[str, List['LoggerStrategyImplBase']] = defaultdict(list)
+
+    def __init__(self, output_func: Callable[[str], None], logger_id: str, channel: str = "all"):
+        self.output_func: Callable[[str], None] = output_func
+        self.channel: str = channel
+        self.logger_id: str = logger_id
+        LoggerStrategyImplBase._loggers[channel].append(self)
+
+    def __call__(self, s: str) -> None:
+        self.output_func(s)
+
+    def delete(self) -> None:
+        LoggerStrategyImplBase._loggers[self.channel].remove(self)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.delete()
+
+
+__all__ = [
+    "LoggerStrategyImplBase"
+]

danielutils-1.0.3/danielutils/lombok/__init__.py

@@ -0,0 +1 @@
+from .builder import *

danielutils-1.0.3/danielutils/lombok/builder.py

@@ -0,0 +1,49 @@
+from typing import Type, Generic, TypeVar
+
+T = TypeVar("T", bound=Type)
+
+
+class Builder(Generic[T]):
+    PREFIX: str = "foo"
+
+    def __init__(self, dcls: T):
+        setattr(self, f"{Builder.PREFIX}_dcls", dcls)
+        setattr(self, f"{Builder.PREFIX}_kwargs", {})
+
+    def __getattribute__(self, item: str):
+        if item.startswith(Builder.PREFIX) or item == "build":
+            return super().__getattribute__(item)
+        cls = super().__getattribute__(f"{Builder.PREFIX}_dcls")
+        if item not in cls.__dataclass_fields__:
+            raise AttributeError(f"'{cls.__qualname__}' object has no attribute '{item}'")
+
+        def inner(o) -> Builder:
+            getattr(self, f"{Builder.PREFIX}_kwargs")[item] = o
+            return self
+
+        return inner
+
+    def build(self) -> T:
+        dcls = getattr(self, f"{Builder.PREFIX}_dcls")
+        kwargs = getattr(self, f"{Builder.PREFIX}_kwargs")
+        return dcls(**kwargs)
+
+
+def builder(dcls: T):
+    if not hasattr(dcls, "__dataclass_fields__"):
+        raise RuntimeError("Can only create builders out of @dataclass classes")
+    for name in dcls.__dataclass_fields__.keys():
+        if name.startswith("build"):
+            raise AttributeError(f"@builder reserves attributes that has 'build' prefix. Invalid attribute: '{name}'")
+
+    @classmethod  # type: ignore
+    def builder_impl(cls) -> Builder[T]:
+        return Builder[T](cls)
+
+    setattr(dcls, "builder", builder_impl)
+    return dcls
+
+
+__all__ = [
+    "builder"
+]

{danielutils-1.0.1/danielutils/Reflection → danielutils-1.0.3/danielutils/reflection}/class_info.py

@@ -1,9 +1,20 @@
 import inspect
 import re
-from typing import Optional, List, Iterable, Type
+from typing import Optional, List, Iterable, Type, TypeVar, Generic, get_origin
 from .function_info import FunctionInfo
 from .decoration_info import DecorationInfo
 from .argument_info import ArgumentInfo
+from danielutils.functions import isoftype
+
+T = TypeVar("T")
+
+
+class _A(Generic[T]): ...
+
+
+_GenericAlias = type(_A[int])
+
+del T, _A
 
 
 class ClassInfo:
@@ -13,6 +24,8 @@ class ClassInfo:
     # r"(?P<decorations>[\s\S]*)?^class (?P<name>\w[\w\d]*)(?:\((?P<bases>.*)\))?:(?P<body>[\s\S]+)"
 
     def __init__(self, cls: Type) -> None:
+        if isoftype(cls, _GenericAlias):  # type:ignore
+            cls = get_origin(cls)  # type:ignore
         if not inspect.isclass(cls):
             raise TypeError(f"'{cls.__name__}' is not a class")
         self._cls = cls
@@ -40,14 +53,15 @@ class ClassInfo:
     def _parse_body(self) -> None:
         for attr in dir(self._cls):
             obj = getattr(self._cls, attr, None)
-            if inspect.isbuiltin(obj): continue
+            if inspect.isbuiltin(obj):
+                continue
             try:
                 if inspect.isroutine(obj):
                     inspect.getsource(obj)
                 elif inspect.isdatadescriptor(obj):
                     inspect.getsource(obj.fget)  # type:ignore
                 else:
-                    raise 1
+                    raise Exception()
             except:
                 continue
             self._functions.append(FunctionInfo(obj, self._cls))
@@ -82,6 +96,14 @@ class ClassInfo:
     def instance_methods(self) -> Iterable[FunctionInfo]:
         return sorted(filter(lambda f: f.is_instance_method, self._functions), key=lambda f: f.name)
 
+    @property
+    def inherited_methods(self)->Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_inherited, self._functions), key=lambda f: f.name)
+
+    @property
+    def abstract_methods(self) -> Iterable[FunctionInfo]:
+        return sorted(filter(lambda f: f.is_abstract, self._functions), key=lambda f: f.name)
+
     @property
     def functions(self) -> List[FunctionInfo]:
         return self._functions

{danielutils-1.0.1/danielutils/Reflection → danielutils-1.0.3/danielutils/reflection}/decoration_info.py

@@ -6,7 +6,7 @@ from .argument_info import ArgumentInfo
 
 
 class DecorationInfo:
-    DECORATOR_INFO_REGEX: re.Pattern = re.compile(r"^@?(?P<name>\w[\w\d]*)(?P<arguments>\(.*\))?")
+    DECORATOR_INFO_REGEX: re.Pattern = re.compile(r"^@?(?P<name>\w[\w\d]*)(?:\((?P<arguments>.*)\))?")
 
     def __init__(self, name: str, arguments: List[ArgumentInfo]):
         self._name = name

{danielutils-1.0.1/danielutils/Reflection → danielutils-1.0.3/danielutils/reflection}/function_info.py

@@ -13,7 +13,7 @@ class FunctionInfo:
     def __init__(self, func: Callable, owner: Type) -> None:
         try:
             if inspect.isdatadescriptor(func):
-                inspect.getsource(func.fget)
+                inspect.getsource(func.fget)  # type: ignore
                 self._is_property = True
             else:
                 inspect.getsource(func)
@@ -53,7 +53,7 @@ class FunctionInfo:
 
     @property
     def is_inherited(self) -> bool:
-        return self._func in self._owner.__dict__
+        return self._func in set(self._owner.__dict__.keys())
 
     @property
     def is_class_method(self) -> bool:

danielutils-1.0.3/danielutils/testing/unittest_/always_teardown_testcase.py

@@ -0,0 +1,67 @@
+import functools
+import unittest
+from _collections_abc import Coroutine
+from typing import Optional, Callable, Type
+from unittest import TestResult
+
+
+class AlwaysTeardownTestCase(unittest.TestCase):
+    """
+    SafeTestCase makes sure that tearDown / cleanup methods are always run when
+    They should be.
+    """
+
+    def run(self, result=None) -> Optional[TestResult]:
+        test_method = getattr(self, self._testMethodName)
+        wrapped_test = self._cleanup_wrapper(test_method, KeyboardInterrupt)
+        setattr(self, self._testMethodName, wrapped_test)
+
+        self.setUp = self._cleanup_wrapper(self.setUp, BaseException)
+
+        return super().run(result)
+
+    def _cleanup_wrapper(self, method: Callable, exception: Type[BaseException]) -> Callable:
+        @functools.wraps(method)
+        def wrapper(*args, **kwargs):
+            try:
+                return method(*args, **kwargs)
+            except exception:
+                self.tearDown()
+                self.doCleanups()
+                raise
+
+        return wrapper
+
+
+class AsyncAlwaysTeardownTestCase(unittest.IsolatedAsyncioTestCase):
+    """
+    SafeTestCase makes sure that tearDown / cleanup methods are always run when
+    They should be.
+    """
+
+    def run(self, result=None) -> Optional[TestResult]:
+        test_method = getattr(self, self._testMethodName)
+        wrapped_test = self._cleanup_wrapper(test_method, KeyboardInterrupt)
+        setattr(self, self._testMethodName, wrapped_test)
+
+        self.asyncSetUp = self._cleanup_wrapper(self.asyncSetUp, BaseException)
+
+        return super().run(result)
+
+    def _cleanup_wrapper(self, method: Coroutine, exception: Type[BaseException]) -> Callable:
+        @functools.wraps(method)
+        async def wrapper(*args, **kwargs):
+            try:
+                return await method(*args, **kwargs)
+            except exception:
+                self.tearDown()
+                self.doCleanups()
+                raise
+
+        return wrapper
+
+
+__all__ = [
+    "AlwaysTeardownTestCase",
+    "AsyncAlwaysTeardownTestCase",
+]

danielutils-1.0.3/danielutils/testing/unittest_/auto_cwd_testcase.py

@@ -0,0 +1,92 @@
+import asyncio
+import functools
+import os
+import unittest
+import inspect
+from inspect import iscoroutine, iscoroutinefunction
+from typing import Callable, Type, Coroutine, Union, Any
+
+from danielutils import create_directory, get_current_working_directory, set_current_working_directory, delete_directory
+
+
+def dispatch_function(func: Union[Callable, Coroutine], *args, **kwargs) -> Any:
+    if asyncio.iscoroutinefunction(func):
+        return asyncio.run(func(*args, **kwargs))
+    elif asyncio.iscoroutine(func):
+        return asyncio.run(func)
+    else:
+        return func(*args, **kwargs)
+
+
+def improved_setup(func: Callable) -> Callable:
+    @functools.wraps(func)
+    def wrapper(self):
+        self.cwd = f"./{self.__class__.__name__}_test_folder"
+        create_directory(self.cwd)
+        self.prev_cwd = get_current_working_directory()
+        set_current_working_directory(os.path.join(self.prev_cwd, self.cwd))
+        if func is not None:
+            func(self)
+
+    @functools.wraps(func)
+    async def async_wrapper(self):
+        self.cwd = f"./{self.__class__.__name__}_test_folder"
+        create_directory(self.cwd)
+        self.prev_cwd = get_current_working_directory()
+        set_current_working_directory(os.path.join(self.prev_cwd, self.cwd))
+        if func is not None:
+            await func(self)
+
+    return async_wrapper if iscoroutinefunction(func) else wrapper
+
+
+def improved_teardown(func: Callable) -> Callable:
+    @functools.wraps(func)
+    def wrapper(self):
+        if func is not None:
+            func(self)
+        set_current_working_directory(self.prev_cwd)
+        delete_directory(self.cwd)
+
+    @functools.wraps(func)
+    async def async_wrapper(self):
+        if func is not None:
+            await func(self)
+        set_current_working_directory(self.prev_cwd)
+        delete_directory(self.cwd)
+
+    return async_wrapper if iscoroutinefunction(func) else wrapper
+
+
+class AutoCWDTestCase(unittest.TestCase):
+    @staticmethod
+    def _dummy(*args, **kwargs) -> None:
+        pass
+
+    @classmethod
+    def __init_subclass__(cls: Type, **kwargs) -> None:
+        dct = dict(cls.__dict__)
+        impl_setUp = dct.get("setUp", cls._dummy)
+        impl_tearDown = dct.get("tearDown", cls._dummy)
+        setattr(cls, "setUp", improved_setup(impl_setUp))
+        setattr(cls, "tearDown", improved_teardown(impl_tearDown))
+
+
+class AsyncAutoCWDTestCase(unittest.IsolatedAsyncioTestCase):
+    @staticmethod
+    async def _async_dummy(*args, **kwargs) -> None:
+        pass
+
+    @classmethod
+    def __init_subclass__(cls: Type, **kwargs) -> None:
+        dct = dict(cls.__dict__)
+        async_impl_setUp = dct.get("asyncSetUp", cls._async_dummy)
+        async_impl_tearDown = dct.get("asyncTearDown", cls._async_dummy)
+        setattr(cls, "asyncSetUp", improved_setup(async_impl_setUp))
+        setattr(cls, "asyncTearDown", improved_teardown(async_impl_tearDown))
+
+
+__all__ = [
+    'AutoCWDTestCase',
+    "AsyncAutoCWDTestCase"
+]

{danielutils-1.0.1 → danielutils-1.0.3}/danielutils/versioned_imports.py

@@ -1,10 +1,12 @@
+from typing import Tuple
+
 try:
     from typing import ParamSpec
 except ImportError:
     from .reflection import get_python_version
 
     if get_python_version() >= (3, 9):
-        ParamSpec = lambda name: [...]
+        ParamSpec = lambda name: [Any]
     else:
         from typing import Any
 

{danielutils-1.0.1 → danielutils-1.0.3/danielutils.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: danielutils
-Version: 1.0.1
+Version: 1.0.3
 Summary: A python utils library for things I find useful
 Author-email: danielnachumdev <danielnachumdev@gmail.com>
 License: MIT License