develia-pytools 0.1.0__tar.gz

develia_pytools-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: develia-pytools
+Version: 0.1.0
+Summary: General utility library.
+Author: Antonio Gil Espinosa
+Author-email: antonio.gil.espinosa@gmail.com
+Requires-Python: >=3.6,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+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
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14

develia_pytools-0.1.0/pyproject.toml

@@ -0,0 +1,16 @@
+[tool.poetry]
+name = "develia-pytools"
+version = "0.1.0"
+description = "General utility library."
+authors = ["Antonio Gil Espinosa <antonio.gil.espinosa@gmail.com>"]
+#readme = "README.md"
+packages = [
+    { include = "pytools" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.6"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

develia_pytools-0.1.0/pytools/__init__.py

@@ -0,0 +1,7 @@
+# from ._multipledispatch import dispatch
+from ._lang import *
+from ._functions import *
+from ._lazy import Lazy
+from ._segment import Segment
+from ._range import Range
+from ._result import Result

develia_pytools-0.1.0/pytools/_functions.py

@@ -0,0 +1,172 @@
+import typing as _t
+
+_T = _t.TypeVar('_T')
+_R = _t.TypeVar("_R")
+
+
+def staticinitialization(cls: _t.Type):
+    """
+    Perform static initialization for a given class.
+
+    :param cls: The class to perform static initialization on.
+    :return: The modified class with static initialization.
+    :raises Exception: If `cls.__static_init__` is not callable.
+    """
+    if hasattr(cls, "__static_init__") and callable(cls.__static_init__):
+
+        cls.__static_init__()
+
+        def raise_exception(*args, **kwargs):
+            raise Exception("The static initializer cannot be called more than once.")
+
+        cls.__static_init__ = raise_exception
+
+    else:
+        raise Exception(f"Method \'{cls.__name__}__static_init__\' is not implemented")
+
+    return cls
+
+
+def new(cls: _t.Type[_T], *args, **kwargs) -> _T:
+    """
+    Create a new instance of a class.
+
+    :param cls: The class to create an instance of.
+    :param args: Positional arguments that will be passed to the class constructor.
+    :param kwargs: Keyword arguments that will be passed to the class constructor.
+    :return: The newly created instance of the class.
+    """
+    return cls.__new__(cls, *args, **kwargs)
+
+
+def clamp(x, min, max):
+    """
+    Clamp a value to a specified range.
+
+    :param x: The value to be clamped.
+    :param min: The minimum value of the range.
+    :param max: The maximum value of the range.
+    :return: The clamped value.
+    """
+    if x < min:
+        return min
+    if x > max:
+        return max
+    return x
+
+
+def compare(a: _t.Any, b: _t.Any) -> int:
+    """
+    :param a: The first value to compare.
+    :param b: The second value to compare.
+    :return: -1 if `a` is less than `b`, 1 if `a` is greater than `b`, 0 if `a` is equal to `b`.
+
+    """
+    if a < b:
+        return -1
+    elif a > b:
+        return 1
+    else:
+        return 0
+
+
+def unzip(iterable: _t.Iterable) -> _t.Iterable:
+    """
+    Unzips an iterable by transposing the elements of the nested iterables.
+
+    :param iterable: An iterable containing nested iterables.
+    :return: An iterable of tuples, each representing a column of the transposed elements.
+    """
+    return zip(*iterable)
+
+
+def try_resolve(obj: _t.Any, key: str, fallback=None):
+    """
+    Tries to resolve the value of a given key in an object and returns a Result.
+
+    :param obj: The object to resolve the key from.
+    :param key: The key to resolve in the object.
+    :param fallback: The fallback value to return if the key is not found. Default is None.
+    :return: A Result object containing a boolean indicating if the key was found,
+             and the value of the key if found or the fallback value if not found.
+    """
+    from pytools import Result
+
+    if hasattr(obj, key):
+        return Result(True, getattr(obj, key))
+
+    return Result(False, fallback)
+
+
+def debugging() -> bool:
+    """
+    Check if the Python interpreter is currently being run in a debugger.
+
+    :return: Returns True if the interpreter is being run in a debugger, False otherwise.
+    :rtype: bool
+    """
+    import sys
+    output = hasattr(sys, 'gettrace') and sys.gettrace() is not None
+    print(output)
+    return output
+
+
+def between(value, min, max, inclusive=True):
+    """
+    :param value: The value to check if it is between the minimum and maximum values.
+    :param min: The minimum value of the range.
+    :param max: The maximum value of the range.
+    :param inclusive: Optional parameter indicating if the minimum and maximum values should be inclusive (default is True).
+    :return: True if the value is between the minimum and maximum values (inclusive or exclusive based on the inclusive parameter), False otherwise.
+    """
+    if inclusive:
+        return min <= value <= max
+    else:
+        return min < value < max
+
+
+def evaluate(obj: _t.Union[_t.Callable[[], _T], _T]) -> _T:
+    """
+    :param obj: The object to be evaluated. It can either be a callable or a regular object.
+    :return: The result of evaluating the object. If the object is callable, the returned value is the result of calling the object.
+             If the object is not callable, the returned value is the object itself.
+
+    """
+    if callable(obj):
+        return obj()
+    return obj
+
+
+def tap(obj: _T, callable: _t.Callable[[_T], _t.Any]) -> _T:
+    """
+    Apply a Callable function to an object and return the object.
+
+    :param obj: The object to apply the callable function to.
+    :param callable: The Callable function that will be applied to the object.
+    :return: The object after applying the callable function.
+    """
+    callable(obj)
+    return obj
+
+
+def coalesce(arg1, arg2) -> _t.Optional[_T]:
+    return arg1 if arg1 is not None else arg2
+
+# def parse(target_type: _typing.Union[_typing.Type[int], _typing.Type[float]], string: str,
+#           decimal_separator: str = ".",
+#           thousands_separator: str = None,
+#           fallback: _typing.Any = None) -> _typing.Any:
+#     if thousands_separator is not None:
+#         string = string.replace(thousands_separator, "")
+#
+#     try:
+#         if target_type == float:
+#             if decimal_separator != ".":
+#                 string = string.replace(decimal_separator, ".")
+#             return float(string)
+#         elif target_type == int:
+#             return int(string)
+#
+#         return fallback() if callable(fallback) else fallback
+#     except ValueError:
+#         return fallback() if callable(fallback) else fallback

develia_pytools-0.1.0/pytools/_lang.py

@@ -0,0 +1,10 @@
+import typing as _t
+
+
+class segment:
+
+    def __new__(cls, start: _t.Optional[int] = None, count: _t.Optional[int] = None, step: _t.Optional[int] = None) -> slice:
+        return slice(start, (start + count) if (count is not None and start is not None) else start, step)
+
+    def __class_getitem__(cls, item: slice) -> slice:
+        return slice(item.start, (item.start + item.stop) if (item.stop is not None and item.start is not None) else item.start, item.step)

develia_pytools-0.1.0/pytools/_lazy.py

@@ -0,0 +1,32 @@
+import threading as _threading
+import typing as _t
+
+_T = _t.TypeVar("_T")
+
+
+class Lazy(_t.Generic[_T]):
+    def __init__(self, factory_method: _t.Callable[[], _T], lock=None):
+        self._factory_method = factory_method
+        self._value_created = False
+        self._value = None
+        self._lock = lock if lock is not None else _threading.RLock()
+
+    @property
+    def value_created(self) -> bool:
+        return self._value_created
+
+    @property
+    def value(self) -> _T:
+        with self._lock:
+            if not self._value_created:
+                self._value = self._factory_method()
+                self._value_created = True
+
+            return self._value
+
+    def __repr__(self):  # pragma: no cover
+        with self._lock:
+            if self._value_created:
+                return repr(self._value)
+
+            return "Value not created yet."

develia_pytools-0.1.0/pytools/_range.py

@@ -0,0 +1,69 @@
+import typing as _t
+
+_T = _t.TypeVar("_T")
+
+
+class Range(_t.Generic[_T]):
+    def __init__(self, start: _T, end: _T):
+        self.end = end
+        self.start = start
+
+    def contains(self, item: _T, start_inclusive: bool = True, end_inclusive: bool = True) -> bool:
+        if isinstance(item, Range):
+            return self.contains(item.start, start_inclusive, end_inclusive) and self.contains(item.end, start_inclusive, end_inclusive)
+        else:
+            return (((item >= self.start) if start_inclusive else (item > self.start)) and
+                    ((item <= self.end) if end_inclusive else (item < self.end)))
+
+    def overlaps(self, start: _T, end: _T, inclusive: bool = True) -> bool:
+        return self.overlaps_range(Range(start, end), inclusive)
+
+    def overlaps_range(self, range: "Range[_T]", inclusive: bool = True) -> bool:
+        return self.contains(range.start, inclusive) or self.contains(range.end, inclusive) or \
+            range.contains(self.start, inclusive) or range.contains(self.end, inclusive)
+
+    def split(self, size) -> _t.List[_T]:
+
+        output = []
+
+        interval = Range(self.start, min(self.start + size, self.end))
+
+        while self.contains(interval):
+            output.append(interval)
+            interval = Range(interval.start + size, min(interval.end + size, self.end))
+
+        return output
+
+    def __str__(self):
+        return str(self.start) + " - " + str(self.end)
+
+    def intersect(self, other: 'Range[_T]') -> _t.Optional['Range[_T]']:
+        # Lógica para la intersección de intervalos
+        start = max(self.start, other.start)
+        end = min(self.end, other.end)
+        if start < end:
+            return Range(start, end)
+        else:
+            return None
+
+    def subtract(self, other):
+        if self.start >= other.end or self.end <= other.start:
+            # No hay intersección
+            return [Range(self.start, self.start)]
+        elif other.start <= self.start and other.end >= self.end:
+            # B cubre completamente A
+            return []
+        else:
+            # Intersección parcial
+            result = []
+            if self.start < other.start:
+                result.append(Range(self.start, other.start))
+            if self.end > other.end:
+                result.append(Range(other.end, self.end))
+            return result
+
+    def __and__(self, other) -> _t.Optional['Range[_T]']:
+        return self.intersect(other)
+
+    def __sub__(self, other) -> _t.List["Range[_T]"]:
+        return self.subtract(other)

develia_pytools-0.1.0/pytools/_result.py

@@ -0,0 +1,16 @@
+import typing as _t
+
+_T = _t.TypeVar("_T")
+
+
+class Result(_t.Generic[_T]):
+    def __init__(self, success: bool, data: _T):
+        self._data: _T = data
+        self._success: bool = success
+
+    def __bool__(self):
+        return self._success
+
+    @property
+    def value(self):
+        return self._data

develia_pytools-0.1.0/pytools/_segment.py

@@ -0,0 +1,59 @@
+import typing
+from functools import wraps
+import typing as _t
+
+_sequenciable = _t.Union[_t.Sequence, 'Segment', typing.List, typing.Tuple]
+
+_T = typing.TypeVar('_T')
+
+
+class Segment(_t.Generic[_T]):
+
+    @property
+    def stop(self):
+        return self._stop
+
+    @property
+    def start(self):
+        return self._start
+
+    def __init__(self, sequence: _sequenciable, start: int, stop: int = None, count: int = None):
+
+        assert not (stop is not None and count is not None)
+
+        if count is not None:
+            self._stop = start + count
+            assert self._stop <= len(sequence)
+        elif stop is not None:
+            self._stop = stop
+        else:
+            self._stop = len(sequence)
+
+        self._start = start
+        self._sequence: _sequenciable = sequence
+
+    def __getitem__(self, item) -> _T:
+        # if isinstance(item, slice):
+        #     start = item.start + self._start
+        #     stop = start + item.stop
+        #     return self._sequence[start:stop: item.step]
+
+        return self._sequence[item]
+
+    def __setitem__(self, item: int, value: _T):
+        # if isinstance(item, slice):
+        #     start = item.start + self._start
+        #     stop = start + item.stop
+        #     self._sequence[start:stop: item.step] = value
+
+        self._sequence[item + self._start] = value
+
+    def __iter__(self) -> _t.Iterator[_T]:
+        for x in range(self._start, self._stop):
+            yield self._sequence[x]
+
+    def __len__(self):
+        return self._stop - self._start
+
+    # def __repr__(self):
+    #     return self._sequence[self._start:self._stop].__repr__()

develia_pytools-0.1.0/pytools/algorithms.py

@@ -0,0 +1,39 @@
+import typing as _t
+
+
+def binary_search(start_idx: int, end_idx: int, getter: _t.Callable[[int], int]) -> int:
+    """
+    Perform binary search to find a target element within a given range.
+
+    :param start_idx: The starting index of the range to search within (inclusive).
+    :param end_idx: The ending index of the range to search within (inclusive).
+    :param getter: A function that takes an index and returns the corresponding element for comparison.
+
+    :return: The index of the target element within the range, or the index where the target element should be inserted if not found.
+
+    Example usage:
+    ```
+    def getter(index):
+        # Assume array is a sorted list of integers
+        return array[index]
+
+    target_index = binary_search(0, len(array) - 1, getter)
+    ```
+    """
+    start = start_idx
+    end = end_idx
+
+    while start != end:
+
+        mid = int((start + end) / 2)
+        comparison = getter(mid)
+
+        if comparison == 0:
+            return mid
+
+        if comparison < 0:
+            end = mid - 1
+        else:
+            start = mid + 1
+
+    return start

develia_pytools-0.1.0/pytools/asynctools.py

@@ -0,0 +1,52 @@
+import asyncio as _asyncio
+import typing as _t
+from concurrent.futures import Future as _Future
+from enum import Enum as _Enum
+from multiprocessing import Process as _Process
+from threading import Thread as _Thread
+
+_T = _t.TypeVar('_T')
+
+
+class AsyncType(_Enum):
+    THREADING = "threading"
+    MULTIPROCESSING = "multiprocessing"
+    ASYNCIO = "asyncio"
+
+
+def wait_all(tasks: _t.Optional[_t.Iterable] = None):
+    tasks = [] if tasks is None else tasks
+    for task in tasks:
+        if isinstance(task, _Thread) or isinstance(task, _Process):
+            task.join()
+        elif isinstance(task, _asyncio.Task):
+            _asyncio.get_running_loop().run_until_complete(task)
+
+
+class EndSignal:
+    def __new__(cls, *args, **kwargs):
+        return cls
+
+
+def run(func: _t.Callable[[], _T],
+        async_type: _t.Optional[_t.Union[AsyncType, str]] = AsyncType.THREADING,
+        *args,
+        **kwarg) -> _Future[_T]:
+    future = _Future()
+
+    def job():
+        try:
+            future.set_result(func())
+        except Exception as ex:
+            future.set_exception(ex)
+
+    if async_type == AsyncType.THREADING or async_type == AsyncType.THREADING.value:
+        thread = _Thread(target=job, *args, **kwarg)
+        thread.start()
+        return future
+    elif async_type == AsyncType.MULTIPROCESSING or async_type == AsyncType.MULTIPROCESSING.value:
+        process = _Process(target=job, *args, **kwarg)
+        process.start()
+        return future
+
+    raise ValueError("async_type")

develia_pytools-0.1.0/pytools/collections/__init__.py

@@ -0,0 +1,2 @@
+from ._lazy_sequence import LazySequence
+from ._stream import Stream

develia_pytools-0.1.0/pytools/collections/_lazy_sequence.py

@@ -0,0 +1,38 @@
+import typing as _t
+
+_T = _t.TypeVar('_T')
+
+
+class LazySequence(_t.Sequence[_T]):
+    def __init__(self, iterable: _t.Iterable[_T]):
+        self._iterator = iter(iterable)
+        self._cache = []
+
+    @property
+    def cache(self):
+        return self._cache
+
+    def __iter__(self) -> _t.Iterator[_T]:
+        for item in self._cache:
+            yield item
+
+        for item in self._iterator:
+            self._cache.append(item)
+            yield item
+
+    def __len__(self) -> int:
+        return len(self)
+
+    def __getitem__(self, index: int) -> _T:
+        i = 0
+        for item in self:
+            if i == index:
+                return item
+            i += 1
+        raise IndexError()
+
+    def __contains__(self, item: object) -> bool:
+        for x in self:
+            if x == item:
+                return True
+        return False