nlbone 0.4.3__tar.gz → 0.6.0__tar.gz

{nlbone-0.4.3 → nlbone-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.4.3
+Version: 0.6.0
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT
@@ -11,6 +11,7 @@ Requires-Dist: dependency-injector>=4.48.1
 Requires-Dist: elasticsearch==8.14.0
 Requires-Dist: fastapi>=0.116
 Requires-Dist: httpx>=0.27
+Requires-Dist: makefun>=1.16.0
 Requires-Dist: psycopg>=3.2.9
 Requires-Dist: pydantic-settings>=2.0
 Requires-Dist: pydantic>=2.0

{nlbone-0.4.3 → nlbone-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.4.3"
+version = "0.6.0"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -26,7 +26,8 @@ dependencies = [
     "elasticsearch==8.14.0",
     "redis~=6.4.0",
     "python-dateutil~=2.9.0.post0",
-    "typer>=0.17.4"
+    "typer>=0.17.4",
+    "makefun>=1.16.0"
 ]
 
 [tool.ruff]

nlbone-0.6.0/src/nlbone/adapters/cache/async_redis.py

@@ -0,0 +1,180 @@
+import asyncio
+import json
+import os
+from typing import Optional, Iterable, Any, Mapping, Sequence, List
+
+from redis.asyncio import Redis
+from nlbone.core.ports.cache import AsyncCachePort
+
+
+def _nsver_key(ns: str) -> str: return f"nsver:{ns}"
+def _tag_key(tag: str) -> str: return f"tag:{tag}"
+
+class AsyncRedisCache(AsyncCachePort):
+    def __init__(self, url: str, *, invalidate_channel: str | None = None):
+        self._r = Redis.from_url(url, decode_responses=False)
+        self._ch = invalidate_channel or os.getenv("NLBONE_REDIS_INVALIDATE_CHANNEL", "cache:invalidate")
+
+    @property
+    def redis(self) -> Redis:
+        return self._r
+
+    async def _current_ver(self, ns: str) -> int:
+        v = await self._r.get(_nsver_key(ns))
+        return int(v) if v else 1
+
+    async def _full_key(self, key: str) -> str:
+        try:
+            ns, rest = key.split(":", 1)
+        except ValueError:
+            ns, rest = "app", key
+        ver = await self._current_ver(ns)
+        return f"{ns}:{ver}:{rest}"
+
+    # -------- basic --------
+    async def get(self, key: str) -> Optional[bytes]:
+        fk = await self._full_key(key)
+        return await self._r.get(fk)
+
+    async def set(self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
+        fk = await self._full_key(key)
+        if ttl is None:
+            await self._r.set(fk, value)
+        else:
+            await self._r.setex(fk, ttl, value)
+        if tags:
+            pipe = self._r.pipeline()
+            for t in tags:
+                pipe.sadd(_tag_key(t), fk)
+            await pipe.execute()
+
+    async def delete(self, key: str) -> None:
+        fk = await self._full_key(key)
+        await self._r.delete(fk)
+
+    async def exists(self, key: str) -> bool:
+        return (await self.get(key)) is not None
+
+    async def ttl(self, key: str) -> Optional[int]:
+        fk = await self._full_key(key)
+        t = await self._r.ttl(fk)
+        return None if t < 0 else int(t)
+
+        # -------- multi --------
+
+    async def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
+        fks = [await self._full_key(k) for k in keys]
+        return await self._r.mget(fks)
+
+    async def mset(self, items: Mapping[str, bytes], *, ttl: Optional[int] = None,
+                   tags: Optional[Iterable[str]] = None) -> None:
+        pipe = self._r.pipeline()
+        if ttl is None:
+            for k, v in items.items():
+                fk = await self._full_key(k)
+                pipe.set(fk, v)
+        else:
+            for k, v in items.items():
+                fk = await self._full_key(k)
+                pipe.setex(fk, ttl, v)
+        await pipe.execute()
+
+        if tags:
+            pipe = self._r.pipeline()
+            for t in tags:
+                for k in items.keys():
+                    fk = await self._full_key(k)
+                    pipe.sadd(_tag_key(t), fk)
+            await pipe.execute()
+
+        # -------- json --------
+
+    async def get_json(self, key: str) -> Optional[Any]:
+        b = await self.get(key)
+        return None if b is None else json.loads(b)
+
+    async def set_json(self, key: str, value: Any, *, ttl: Optional[int] = None,
+                       tags: Optional[Iterable[str]] = None) -> None:
+        await self.set(key, json.dumps(value).encode("utf-8"), ttl=ttl, tags=tags)
+
+        # -------- invalidation --------
+
+    async def invalidate_tags(self, tags: Iterable[str]) -> int:
+        removed = 0
+        pipe = self._r.pipeline()
+        key_sets: list[tuple[str, set[bytes]]] = []
+        for t in tags:
+            tk = _tag_key(t)
+            members = await self._r.smembers(tk)
+            if members:
+                pipe.delete(*members)
+            pipe.delete(tk)
+            key_sets.append((tk, members))
+            removed += len(members or [])
+        await pipe.execute()
+
+        # publish notification for other processes
+        try:
+            payload = json.dumps({"tags": list(tags)}).encode("utf-8")
+            await self._r.publish(self._ch, payload)
+        except Exception:
+            pass
+
+        return removed
+
+    async def bump_namespace(self, namespace: str) -> int:
+        v = await self._r.incr(_nsver_key(namespace))
+        # اطلاع‌رسانی اختیاری
+        try:
+            await self._r.publish(self._ch, json.dumps({"ns_bump": namespace}).encode("utf-8"))
+        except Exception:
+            pass
+        return int(v)
+
+    async def clear_namespace(self, namespace: str) -> int:
+        cnt = 0
+        cursor = 0
+        pattern = f"{namespace}:*"
+        while True:
+            cursor, keys = await self._r.scan(cursor=cursor, match=pattern, count=1000)
+            if keys:
+                await self._r.delete(*keys)
+                cnt += len(keys)
+            if cursor == 0:
+                break
+        try:
+            await self._r.publish(self._ch, json.dumps({"ns_clear": namespace}).encode("utf-8"))
+        except Exception:
+            pass
+        return cnt
+
+        # -------- dogpile-safe get_or_set --------
+
+    async def get_or_set(self, key: str, producer, *, ttl: int, tags=None) -> bytes:
+        fk = await self._full_key(key)
+        val = await self._r.get(fk)
+        if val is not None:
+            return val
+
+        lock_key = f"lock:{fk}"
+        got = await self._r.set(lock_key, b"1", ex=10, nx=True)
+        if got:
+            try:
+                produced = await producer() if asyncio.iscoroutinefunction(producer) else producer()
+                if isinstance(produced, str):
+                    produced = produced.encode("utf-8")
+                await self.set(key, produced, ttl=ttl, tags=tags)
+                return produced
+            finally:
+                await self._r.delete(lock_key)
+
+        await asyncio.sleep(0.05)
+        val2 = await self._r.get(fk)
+        if val2 is not None:
+            return val2
+        # fallback
+        produced = await producer() if asyncio.iscoroutinefunction(producer) else producer()
+        if isinstance(produced, str):
+            produced = produced.encode("utf-8")
+        await self.set(key, produced, ttl=ttl, tags=tags)
+        return produced

nlbone-0.6.0/src/nlbone/adapters/cache/memory.py

@@ -0,0 +1,104 @@
+import json, threading, time
+from typing import Optional, Iterable, Any, Mapping, Sequence, Dict, Set
+from nlbone.core.ports.cache import CachePort
+
+
+class InMemoryCache(CachePort):
+    def __init__(self):
+        self._data: Dict[str, tuple[bytes, Optional[float]]] = {}
+        self._tags: Dict[str, Set[str]] = {}
+        self._ns_ver: Dict[str, int] = {}
+        self._lock = threading.RLock()
+
+    def _expired(self, key: str) -> bool:
+        v = self._data.get(key)
+        if not v: return True
+        _, exp = v
+        return exp is not None and time.time() > exp
+
+    def _gc(self, key: str) -> None:
+        if self._expired(key):
+            self._data.pop(key, None)
+
+    def _attach_tags(self, key: str, tags: Optional[Iterable[str]]) -> None:
+        if not tags: return
+        for t in tags:
+            self._tags.setdefault(t, set()).add(key)
+
+    def get(self, key: str) -> Optional[bytes]:
+        with self._lock:
+            self._gc(key)
+            v = self._data.get(key)
+            return v[0] if v else None
+
+    def set(self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
+        with self._lock:
+            exp = None if ttl is None else time.time() + ttl
+            self._data[key] = (value, exp)
+            self._attach_tags(key, tags)
+
+    def delete(self, key: str) -> None:
+        with self._lock:
+            self._data.pop(key, None)
+            for s in self._tags.values():
+                s.discard(key)
+
+    def exists(self, key: str) -> bool:
+        return self.get(key) is not None
+
+    def ttl(self, key: str) -> Optional[int]:
+        with self._lock:
+            self._gc(key)
+            v = self._data.get(key)
+            if not v: return None
+            _, exp = v
+            if exp is None: return None
+            rem = int(exp - time.time())
+            return rem if rem >= 0 else 0
+
+    def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
+        return [self.get(k) for k in keys]
+
+    def mset(self, items: Mapping[str, bytes], *, ttl: Optional[int] = None,
+             tags: Optional[Iterable[str]] = None) -> None:
+        for k, v in items.items():
+            self.set(k, v, ttl=ttl, tags=tags)
+
+    def get_json(self, key: str) -> Optional[Any]:
+        b = self.get(key)
+        return None if b is None else json.loads(b)
+
+    def set_json(self, key: str, value: Any, *, ttl: Optional[int] = None,
+                 tags: Optional[Iterable[str]] = None) -> None:
+        self.set(key, json.dumps(value).encode("utf-8"), ttl=ttl, tags=tags)
+
+    def invalidate_tags(self, tags: Iterable[str]) -> int:
+        removed = 0
+        with self._lock:
+            for t in tags:
+                keys = self._tags.pop(t, set())
+                for k in keys:
+                    if k in self._data:
+                        self._data.pop(k, None)
+                        removed += 1
+        return removed
+
+    def bump_namespace(self, namespace: str) -> int:
+        with self._lock:
+            self._ns_ver[namespace] = self._ns_ver.get(namespace, 0) + 1
+            return self._ns_ver[namespace]
+
+    def clear_namespace(self, namespace: str) -> int:
+        with self._lock:
+            keys = [k for k in self._data.keys() if k.startswith(namespace + ":")]
+            for k in keys: self.delete(k)
+            return len(keys)
+
+    def get_or_set(self, key: str, producer, *, ttl: int, tags=None) -> bytes:
+        with self._lock:
+            b = self.get(key)
+            if b is not None:
+                return b
+        val: bytes = producer()
+        self.set(key, val, ttl=ttl, tags=tags)
+        return val

nlbone-0.6.0/src/nlbone/adapters/cache/pubsub_listener.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+import asyncio
+import json
+from typing import Awaitable, Callable, Optional
+from redis.asyncio import Redis
+
+async def run_cache_invalidation_listener(
+    redis: Redis,
+    channel: str = "cache:invalidate",
+    *,
+    on_tags: Optional[Callable[[list[str]], Awaitable[None]]] = None,
+    on_ns_bump: Optional[Callable[[str], Awaitable[None]]] = None,
+    on_ns_clear: Optional[Callable[[str], Awaitable[None]]] = None,
+    stop_event: Optional[asyncio.Event] = None,
+) -> None:
+    pubsub = redis.pubsub()
+    await pubsub.subscribe(channel)
+    try:
+        while True:
+            if stop_event and stop_event.is_set():
+                break
+            message = await pubsub.get_message(ignore_subscribe_messages=True, timeout=1.0)
+            if not message:
+                await asyncio.sleep(0.05)
+                continue
+            try:
+                data = json.loads(message["data"])
+            except Exception:
+                continue
+
+            if "tags" in data and on_tags:
+                tags = data.get("tags") or []
+                await on_tags(list(tags))
+            if "ns_bump" in data and on_ns_bump:
+                await on_ns_bump(str(data["ns_bump"]))
+            if "ns_clear" in data and on_ns_clear:
+                await on_ns_clear(str(data["ns_clear"]))
+    finally:
+        try:
+            await pubsub.unsubscribe(channel)
+        finally:
+            await pubsub.close()

nlbone-0.6.0/src/nlbone/adapters/cache/redis.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+import json, os, time
+from typing import Optional, Iterable, Any, Mapping, Sequence, List, Set
+import redis  # redis-py (sync)
+from nlbone.core.ports.cache import CachePort
+
+
+
+def _nsver_key(ns: str) -> str: return f"nsver:{ns}"
+def _tag_key(tag: str) -> str: return f"tag:{tag}"
+
+class RedisCache(CachePort):
+    def __init__(self, url: str):
+        self.r = redis.Redis.from_url(url, decode_responses=False)
+
+    def _current_ver(self, ns: str) -> int:
+        v = self.r.get(_nsver_key(ns))
+        return int(v) if v else 1
+
+    def _full_key(self, key: str) -> str:
+        try:
+            ns, rest = key.split(":", 1)
+        except ValueError:
+            ns, rest = "app", key
+        ver = self._current_ver(ns)
+        return f"{ns}:{ver}:{rest}"
+
+    def get(self, key: str) -> Optional[bytes]:
+        fk = self._full_key(key)
+        return self.r.get(fk)
+
+    def set(self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
+        fk = self._full_key(key)
+        if ttl is None:
+            self.r.set(fk, value)
+        else:
+            self.r.setex(fk, ttl, value)
+        if tags:
+            pipe = self.r.pipeline()
+            for t in tags:
+                pipe.sadd(_tag_key(t), fk)
+            pipe.execute()
+
+    def delete(self, key: str) -> None:
+        fk = self._full_key(key)
+        self.r.delete(fk)
+
+    def exists(self, key: str) -> bool:
+        return bool(self.get(key))
+
+    def ttl(self, key: str) -> Optional[int]:
+        fk = self._full_key(key)
+        t = self.r.ttl(fk)
+        return None if t < 0 else int(t)
+
+    def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
+        fks = [self._full_key(k) for k in keys]
+        return self.r.mget(fks)
+
+    def mset(self, items: Mapping[str, bytes], *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
+        pipe = self.r.pipeline()
+        if ttl is None:
+            for k, v in items.items():
+                pipe.set(self._full_key(k), v)
+        else:
+            for k, v in items.items():
+                pipe.setex(self._full_key(k), ttl, v)
+        pipe.execute()
+        if tags:
+            pipe = self.r.pipeline()
+            for t in tags:
+                for k in items.keys():
+                    pipe.sadd(_tag_key(t), self._full_key(k))
+            pipe.execute()
+
+    def get_json(self, key: str) -> Optional[Any]:
+        b = self.get(key)
+        return None if b is None else json.loads(b)
+
+    def set_json(self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
+        self.set(key, json.dumps(value).encode("utf-8"), ttl=ttl, tags=tags)
+
+    def invalidate_tags(self, tags: Iterable[str]) -> int:
+        removed = 0
+        pipe = self.r.pipeline()
+        for t in tags:
+            tk = _tag_key(t)
+            keys = self.r.smembers(tk)
+            if keys:
+                pipe.delete(*keys)
+            pipe.delete(tk)
+            removed += len(keys or [])
+        pipe.execute()
+        try:
+            ch = os.getenv("NLBONE_REDIS_INVALIDATE_CHANNEL", "cache:invalidate")
+            self.r.publish(ch, json.dumps({"tags": list(tags)}).encode("utf-8"))
+        except Exception:
+            pass
+        return removed
+
+    def bump_namespace(self, namespace: str) -> int:
+        v = self.r.incr(_nsver_key(namespace))
+        return int(v)
+
+    def clear_namespace(self, namespace: str) -> int:
+        cnt = 0
+        cursor = 0
+        pattern = f"{namespace}:*"
+        while True:
+            cursor, keys = self.r.scan(cursor=cursor, match=pattern, count=1000)
+            if keys:
+                self.r.delete(*keys); cnt += len(keys)
+            if cursor == 0: break
+        return cnt
+
+    def get_or_set(self, key: str, producer, *, ttl: int, tags=None) -> bytes:
+        fk = self._full_key(key)
+        val = self.r.get(fk)
+        if val is not None:
+            return val
+        lock_key = f"lock:{fk}"
+        got = self.r.set(lock_key, b"1", nx=True, ex=10)
+        if got:
+            try:
+                produced: bytes = producer()
+                self.set(key, produced, ttl=ttl, tags=tags)
+                return produced
+            finally:
+                self.r.delete(lock_key)
+        time.sleep(0.05)
+        val2 = self.r.get(fk)
+        if val2 is not None:
+            return val2
+        produced: bytes = producer()
+        self.set(key, produced, ttl=ttl, tags=tags)
+        return produced

nlbone-0.6.0/src/nlbone/adapters/http_clients/__init__.py

@@ -0,0 +1,2 @@
+from .uploadchi import UploadchiClient, UploadchiAsyncClient, UploadchiError
+from .pricing import PricingService, CalculatePriceIn, CalculatePriceOut

nlbone-0.6.0/src/nlbone/adapters/http_clients/pricing/__init__.py

@@ -0,0 +1 @@
+from .pricing_service import PricingService, CalculatePriceIn, CalculatePriceOut

nlbone-0.6.0/src/nlbone/adapters/http_clients/pricing/pricing_service.py

@@ -0,0 +1,96 @@
+from enum import Enum
+from typing import Optional, Literal, List
+
+import httpx
+import requests
+from pydantic import BaseModel, Field, NonNegativeInt, RootModel
+
+from nlbone.adapters.auth.token_provider import ClientTokenProvider
+from nlbone.config.settings import get_settings
+from nlbone.utils.http import normalize_https_base, auth_headers
+
+
+class PricingError(Exception):
+    pass
+
+
+class CalculatePriceIn(BaseModel):
+    params: dict[str, str]
+    product_id: NonNegativeInt | None = None
+    product_title: str | None = None
+
+
+class DiscountType(str, Enum):
+    percent = "percent"
+    amount = "amount"
+
+
+class Product(BaseModel):
+    id: Optional[int] = Field(None, description="Nullable product id")
+    service_product_id: NonNegativeInt
+    title: Optional[str] = None
+
+
+class Pricing(BaseModel):
+    source: Literal["formula", "static"]
+    price: float
+    discount: Optional[float] = None
+    discount_type: Optional[DiscountType] = None
+    params: dict
+
+
+class Formula(BaseModel):
+    id: int
+    title: str
+    key: str
+    status: str
+    description: str
+
+
+class PricingRule(BaseModel):
+    product: Product
+    segment_name: str | None
+    formula: Optional[Formula] = None
+    specificity: int
+    matched_fields: list
+    pricing: Pricing
+
+
+class CalculatePriceOut(RootModel[List[PricingRule]]):
+    pass
+
+
+class PricingService:
+    def __init__(
+            self,
+            token_provider: ClientTokenProvider,
+            base_url: Optional[str] = None,
+            timeout_seconds: Optional[float] = None,
+            client: httpx.Client | None = None,
+    ) -> None:
+        s = get_settings()
+        self._base_url = normalize_https_base(base_url or str(s.PRICING_SERVICE_URL), enforce_https=False)
+        self._timeout = timeout_seconds or float(s.HTTP_TIMEOUT_SECONDS)
+        self._client = client or requests.session()
+        self._token_provider = token_provider
+
+    def calculate(self, items: list[CalculatePriceIn]) -> CalculatePriceOut:
+        body = {
+            "items": [i.model_dump() for i in items]
+        }
+
+        r = self._client.post(
+            f"{self._base_url}/priced",
+            headers=auth_headers(self._token_provider.get_access_token()),
+            json=body,
+            timeout=self._timeout,
+            verify=False
+        )
+
+        if r.status_code not in (200, 204):
+            raise PricingError(r.status_code, r.text)
+
+        if r.status_code == 204 or not r.content:
+            return CalculatePriceOut.model_validate(root=[])
+
+        return CalculatePriceOut.model_validate(r.json())

nlbone-0.6.0/src/nlbone/adapters/http_clients/uploadchi/__init__.py

@@ -0,0 +1,2 @@
+from .uploadchi import UploadchiClient, UploadchiError
+from .uploadchi_async import UploadchiAsyncClient