designkit 0.1.2__tar.gz → 0.2.0__tar.gz

{designkit-0.1.2 → designkit-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: designkit
-Version: 0.1.2
+Version: 0.2.0
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
@@ -16,12 +16,15 @@ Requires-Dist: designkit-utils>=0.6.1,<0.7
 Requires-Dist: validators>=0.35.0,<0.36
 Requires-Dist: pathlib>=1.0.1,<2.0
 Requires-Dist: rich>=15.0.0,<16.0
+Requires-Dist: python-dotenv>=1.2.3,<2.0
+Requires-Dist: httpx>=0.28.1,<0.29
+Requires-Dist: msgspec>=0.21.1,<0.22
 Requires-Dist: pytest>=9.1.1,<10.0 ; extra == 'dev'
 Requires-Dist: pytest-cov>=5.3.1,<6.0 ; extra == 'dev'
 Requires-Dist: mypy ; extra == 'dev'
 Provides-Extra: dev
 License-File: LICENSE
-Summary: A modern Python toolkit for software architecture, featuring all 23 GoF + 6 original design patterns, original architectural patterns, and powerful developer utilities.
+Summary: A modern Python toolkit for software architecture, featuring all 12 GoF + 18 original design patterns, original architectural patterns, and powerful developer utilities.
 Keywords: patterns,design,kit,utils,framework,rust,pyo3
 Author-email: Sheñey <sheneyby2010@gmail.com>
 Requires-Python: >=3.14

designkit-0.2.0/designkit/behavioral/cache/__init__.py

@@ -0,0 +1,5 @@
+
+from designkit.behavioral.cache.core import cached
+
+from .lru_cache import LRUCache
+from .fifo_cache import FIFOCache

{designkit-0.1.2 → designkit-0.2.0}/designkit/behavioral/cache/core.py

@@ -2,8 +2,8 @@
 from functools import wraps
 from typing import Callable, overload, Any
 
-from .models import _MISSING, AbstractCache
-from .lru_cache import LRUCache
+from designkit.behavioral.cache.models import _MISSING, AbstractCache
+from designkit.behavioral.cache.lru_cache import LRUCache
 
 
 @overload
@@ -17,7 +17,7 @@ def cached[F: Callable[..., R], R](
     *,
     capacity: int = 32,
     cache: type[AbstractCache[R]] = LRUCache,
-    skip_when: Callable[[tuple[Any], dict[str, Any]], bool] = lambda args, kwargs: False,
+    skip_when: Callable[[tuple[Any], dict[str, Any]], bool] = lambda *args, **kwargs: False,
 ) -> Callable[[F], F]: ...
 
 def cached[F: Callable[..., R], R](
@@ -26,7 +26,7 @@ def cached[F: Callable[..., R], R](
     *,
     capacity: int = 32,
     cache: type[AbstractCache[R]] = LRUCache,
-    skip_when: Callable[[tuple[Any], dict[str, Any]], bool] = lambda args, kwargs: False,
+    skip_when: Callable[[tuple[Any], dict[str, Any]], bool] = lambda *args, **kwargs: False,
 ) -> Callable[[F], F]:
     def decorator(func: F) -> F:
         @wraps(func)

designkit-0.2.0/designkit/behavioral/cache/fifo_cache.py

@@ -0,0 +1,80 @@
+
+from typing import Hashable
+from collections import deque
+
+from designkit.behavioral.cache.exceptions import ItemNotHashableError
+from designkit.behavioral.cache.models import _MISSING, AbstractCache
+
+
+class FIFOCache[T](AbstractCache[T]):
+    def __init__(self, capacity: int) -> None:
+        self.__capacity: int = capacity
+        self.__map: deque[tuple[Hashable, T]] = deque(maxlen=capacity)
+
+    def __str__(self) -> str:
+        return f'{self.__class__.__name__}( capacity={self.__capacity} )'
+
+    def __repr__(self) -> str:
+        fmt = lambda k, v: f'[{k}:{v}]'
+        return ''.join(fmt(k, v) for k, v in self.__map)
+
+    def __getitem__(self, key: Hashable) -> T:
+        return self.get(key, _MISSING)
+
+    def __setitem__(self, key: Hashable, value: T) -> None:
+        self.put(key, value)
+
+    def __contains__(self, key: Hashable) -> bool:
+        return any(k == key for k, _ in self.__map)
+
+    def __len__(self) -> int:
+        return len(self.__map)
+
+    def get(self, key: Hashable, default: T | object = _MISSING) -> T | object:
+        for k, v in self.__map:
+            if k == key:
+                return v
+        return default
+
+    def put(self, key: Hashable, value: T) -> None:
+        try:
+            for i, (k, _) in enumerate(self.__map):
+                if k == key:
+                    del self.__map[i]
+                    break
+            self.__map.append((key, value))
+        except TypeError:
+            raise ItemNotHashableError(self.__class__.__name__, key)
+
+    def dump(self, from_page: int = 0, to_page: int | None = None) -> list[tuple[Hashable, T]]:
+        PAGE_SIZE: int = 32
+        
+        if to_page is None:
+            to_page = len(self.__map)
+        
+        if from_page < 0 or to_page < 0 or from_page >= to_page:
+            raise ValueError(f'Invalid page range: from_page={from_page}, to_page={to_page}')
+        
+        start_index: int = from_page * PAGE_SIZE
+        end_index: int = min(to_page * PAGE_SIZE, len(self.__map))
+        return list(self.__map)[start_index:end_index]
+
+    def clear(self) -> None:
+        self.__map.clear()
+
+    def copy(self) -> FIFOCache[T]:
+        new_cache: FIFOCache[T] = FIFOCache(self.__capacity)
+        new_cache.__map = self.__map.copy()
+        return new_cache
+
+    @property
+    def capacity(self) -> int:
+        return self.__capacity
+
+    @property
+    def free_space(self) -> int:
+        return self.__capacity - len(self.__map)
+
+    @property
+    def is_full(self) -> bool:
+        return len(self.__map) >= self.__capacity

{designkit-0.1.2 → designkit-0.2.0}/designkit/behavioral/cache/lru_cache.py

@@ -4,6 +4,7 @@ from typing import Hashable
 from designkit.behavioral.cache.exceptions import ItemNotHashableError
 from designkit.behavioral.cache.models import _MISSING, AbstractCache
 
+
 class Node[T]:
     def __init__(self, key: Hashable, value: T) -> None:
         self.key: Hashable = key
@@ -20,6 +21,9 @@ class LRUCache[T](AbstractCache[T]):
         self.__head.next = self.__tail
         self.__tail.prev = self.__head
 
+    def __str__(self) -> str:
+        return f'{self.__class__.__name__}( capacity={self.__capacity}, map={self.__map} )'
+    
     def __repr__(self) -> str:
         nodes: list[str] = []
         current: Node[T] | None = self.__head.next
@@ -30,11 +34,8 @@ class LRUCache[T](AbstractCache[T]):
         
         return ' <-> '.join(nodes)
 
-    def __str__(self) -> str:
-        return f'{self.__class__.__name__}( capacity={self.__capacity}, map={self.__map} )'
-
     def __getitem__(self, key: Hashable) -> T:
-        return self.get(key)
+        return self.get(key, _MISSING)
 
     def __setitem__(self, key: Hashable, value: T) -> None:
         self.put(key, value)

designkit-0.2.0/designkit/behavioral/control/__init__.py

@@ -0,0 +1,21 @@
+
+from designkit.behavioral.control.promises import (
+    Pending, Resolved, Rejected,
+    Promise, Task,
+)
+from designkit.behavioral.control.result import (
+    Ok, Err,
+    Some, Nothing,
+    Result
+)
+from designkit.behavioral.control.http import (
+    Info, Success, Redirect, ClientFailure, ServerFailure,
+    HTTPResult, HTTPStatus
+)
+from designkit.behavioral.control.validation import (
+    Valid, Invalid,
+    Validation
+)
+from designkit.behavioral.control.mathematical import (
+    Left, Right, Either
+)

{designkit-0.1.2 → designkit-0.2.0}/designkit/behavioral/control/http.py

@@ -36,7 +36,7 @@ class HTTPResponse[T]:
             case s if 500 <= s < 600:
                 return ServerFailure(value=value, status=s)
             case _:
-                raise ValueError(f"Invalid HTTP status code: {s}")
+                raise ValueError(f'Invalid HTTP status code: {s}')
 
 
 
@@ -51,7 +51,7 @@ class Info[T](HTTPResponse[T]):
 
     def __post_init__(self) -> None:
         if not (100 <= self.status < 200):
-            raise ValueError("Status code for Info must be in the range [100, 199]")
+            raise ValueError('Status code for Info must be in the range [100, 199]')
 
 @dataclass(frozen=True)
 class Success[T](HTTPResponse[T]):
@@ -60,7 +60,7 @@ class Success[T](HTTPResponse[T]):
 
     def __post_init__(self) -> None:
         if not (200 <= self.status < 300):
-            raise ValueError("Status code for Success must be in the range [200, 299]")
+            raise ValueError('Status code for Success must be in the range [200, 299]')
 
 @dataclass(frozen=True)
 class Redirect[T](HTTPResponse[T]):
@@ -69,7 +69,7 @@ class Redirect[T](HTTPResponse[T]):
 
     def __post_init__(self) -> None:
         if not (300 <= self.status < 400):
-            raise ValueError("Status code for Redirect must be in the range [300, 399]")
+            raise ValueError('Status code for Redirect must be in the range [300, 399]')
 
 @dataclass(frozen=True)
 class ClientFailure[T](HTTPResponse[T]):
@@ -78,7 +78,7 @@ class ClientFailure[T](HTTPResponse[T]):
 
     def __post_init__(self) -> None:
         if not (400 <= self.status < 500):
-            raise ValueError("Status code for ClientFailure must be in the range [400, 499]")
+            raise ValueError('Status code for ClientFailure must be in the range [400, 499]')
     
 @dataclass(frozen=True)
 class ServerFailure[T](HTTPResponse[T]):
@@ -87,7 +87,7 @@ class ServerFailure[T](HTTPResponse[T]):
 
     def __post_init__(self) -> None:
         if not (500 <= self.status < 600):
-            raise ValueError("Status code for ServerFailure must be in the range [500, 599]")
+            raise ValueError('Status code for ServerFailure must be in the range [500, 599]')
 
 
 

{designkit-0.1.2 → designkit-0.2.0}/designkit/behavioral/control/promises.py

@@ -68,13 +68,13 @@ class Future[T, E]:
 class Promise[T, E](Future[T, E]):
     def resolve(self, value: T) -> None:
         if self.settled:
-            raise RuntimeError("Cannot resolve a Promise that is already settled.")
+            raise RuntimeError('Cannot resolve a Promise that is already settled.')
         
         self.state = Resolved(value)
         
     def reject(self, error: E) -> None:
         if self.settled:
-            raise RuntimeError("Cannot reject a Promise that is already settled.")
+            raise RuntimeError('Cannot reject a Promise that is already settled.')
         
         self.state = Rejected(error)
 
@@ -88,7 +88,7 @@ class Task[T, E](Future[T, E]):
         ) -> None:
 
         if self.settled:
-            raise RuntimeError("Cannot run a Task that is already settled.")
+            raise RuntimeError('Cannot run a Task that is already settled.')
         
         _normalized_processes: list[ProcessAsTuple[T, Any, Any]] = []
         for process in processes:
@@ -100,7 +100,7 @@ class Task[T, E](Future[T, E]):
             elif isinstance(process, tuple) and len(process) == 3:
                 _normalized_processes.append(process)
             else:
-                raise ValueError("Each process must be either a dict or a tuple of (func, args, kwargs).")
+                raise ValueError('Each process must be either a dict or a tuple of (func, args, kwargs).')
 
         workers: int = min(workers, mp.cpu_count())
         try:

{designkit-0.1.2 → designkit-0.2.0}/designkit/behavioral/control/validation.py

@@ -64,21 +64,3 @@ class Invalid[T](ValidatedResponse[Never, T]):
 
 type Validated[T] = Valid[T] | Invalid[T]
 
-
-# Example Usage:
-
-db: list[int] = [-3, 0, 5, 10, -62, 13, 2]
-
-def are_all_positive(n: list[int]) -> bool:
-    return all(x > 0 for x in n)
-
-def validate_db() -> Validated[list[int]]:
-    return Validation.validate(db, are_all_positive)
-
-results: Validated[list[int]] = validate_db()
-
-match results:
-    case Valid(value=numbers):
-        print(f"All numbers are valid: {numbers}")
-    case Invalid(value=numbers):
-        print(f"Few numbers are invalid: {numbers}")

designkit-0.2.0/designkit/behavioral/pub_sub/__init__.py

@@ -0,0 +1,4 @@
+
+from designkit.behavioral.pub_sub.core import Publisher, Suscription
+
+__all__ = ['Publisher', 'Suscription']

designkit-0.2.0/designkit/behavioral/pub_sub/core.py

@@ -0,0 +1,95 @@
+
+from typing import Callable, Self
+from enum import Enum
+from dataclasses import dataclass
+
+
+@dataclass
+class ReasonCallback[R: Enum, T]:
+    reason: R
+    callback: Callable[[T], None]
+
+
+class Publisher[R: Enum]:
+    def __init__(self, max_subscribers: int | None = None) -> None:
+        self.__subscribers: dict[tuple[Suscription, R], Callable] = {}
+        self.__max_subscribers = max_subscribers
+        self.__subs_count: int = 0
+
+    def __str__(self) -> str:
+        return f'{self.__class__.__name__}( subs={len(self.__subscribers)}, max_subs={self.__max_subscribers} )'
+
+    def __len__(self) -> int:
+        return self.__subs_count
+
+    def __contains__(self, subscriber: Suscription) -> bool:
+        return self.has_subscriber(subscriber)
+
+    def __getitem__(self, subscriber: Suscription) -> list[ReasonCallback[R]]:
+        return self.subscribers.get(subscriber, [])
+
+    def __setitem__(self, subscriber: Suscription, reason: R) -> None:
+        self.subscribe(subscriber, [reason])
+
+    def subscribe(self, subscriber: Suscription, reasons: list[R]) -> Self:
+        if self.__max_subscribers is not None and self.__subs_count >= self.__max_subscribers:
+            raise ValueError('Maximum number of subscribers reached')
+        
+        for reason in reasons:
+            expected_callback: str = f'on_{reason.name.lower()}'
+            callback: Callable | None = getattr(subscriber, expected_callback)
+
+            if not callable(callback):
+                raise ValueError(f'Subscriber must implement a callable method named "{expected_callback}" for reason "{reason.name}"')
+            self.__subscribers[(subscriber, reason)] = callback
+            self.__subs_count += 1
+        return self
+
+    def unsubscribe(self, subscriber: Suscription) -> Self:
+        keys_to_remove = [key for key in self.__subscribers if key[0] == subscriber]
+        for key in keys_to_remove:
+            del self.__subscribers[key]
+            self.__subs_count -= 1
+        return self
+
+    def unsubscribe_for_reason(self, subscriber: Suscription, reason: R) -> Self:
+        key: tuple[Suscription, R] = (subscriber, reason)
+        if key in self.__subscribers:
+            del self.__subscribers[key]
+            self.__subs_count -= 1
+        return self
+
+    def notify[T](self, reason: R, content: T) -> Self:
+        for (subs, r), callback in self.__subscribers.items():
+            if r == reason:
+                callback(content)
+        return self
+    
+    def is_subscribed(self, subscriber: Suscription, reason: R) -> bool:
+        return (subscriber, reason) in self.__subscribers
+
+    def has_subscriber(self, subscriber: Suscription) -> bool:
+        return any(subs == subscriber for (subs, _) in self.__subscribers.keys())
+
+    def has_subs_for_reason(self, reason: R) -> bool:
+        return any(r == reason for (_, r) in self.__subscribers.keys())
+
+    @property
+    def subscribers(self) -> dict[Suscription, list[ReasonCallback[R]]]:
+        result: dict[Suscription, list[ReasonCallback[R]]] = {}
+        for (subs, r), callback in self.__subscribers.items():
+            if subs not in result:
+                result[subs] = []
+            result[subs].append(ReasonCallback(reason=r, callback=callback))
+        return result
+
+    @subscribers.delete
+    def subscribers(self) -> None:
+        self.__subscribers.clear()
+
+    @property
+    def max_subscribers(self) -> int | None:
+        return self.__max_subscribers
+
+class Suscription:
+    ...

designkit-0.2.0/designkit/behavioral/typing/__init__.py

@@ -0,0 +1,6 @@
+
+from .core import (
+    Assertion,
+    classname,
+    structure, attributes, methods, fields
+)