nlbone 0.7.2__tar.gz → 0.7.3__tar.gz

{nlbone-0.7.2 → nlbone-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.7.2
+Version: 0.7.3
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT

{nlbone-0.7.2 → nlbone-0.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.7.2"
+version = "0.7.3"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"

nlbone-0.7.3/src/nlbone/adapters/auth/auth_service.py

@@ -0,0 +1,25 @@
+import requests
+
+from nlbone.config.settings import get_settings
+from nlbone.core.ports.auth import AuthService as BaseAuthService
+from nlbone.utils.http import normalize_https_base
+
+
+class AuthService(BaseAuthService):
+    def __init__(self):
+        s = get_settings()
+        self._base_url = normalize_https_base(s.AUTH_SERVICE_URL.unicode_string())
+        self._timeout = float(s.HTTP_TIMEOUT_SECONDS)
+        self._client =  requests.session()
+
+    def has_access(self, token: str, permissions: list[str]) -> bool: ...
+    def verify_token(self, token: str) -> dict | None:
+        url = f"{self._base_url}/introspect"
+        result = self._client.post(url, data={
+            "token": token
+        })
+        return result.json()
+    def get_client_token(self) -> dict | None: ...
+    def is_client_token(self, token: str, allowed_clients: set[str] | None = None) -> bool: ...
+    def client_has_access(self, token: str, perms: list[str], allowed_clients: set[str] | None = None) -> bool: ...
+    def get_permissions(self, token: str) -> list[str]: ...

nlbone-0.7.3/src/nlbone/adapters/db/postgres/types.py

@@ -0,0 +1,21 @@
+from sqlalchemy.types import TypeDecorator, BigInteger
+
+class BaseIntegerIdType(TypeDecorator):
+    """Maps BaseId subclasses <-> BIGINT transparently (Infrastructure-only)."""
+    impl = BigInteger
+    cache_ok = True
+
+    def __init__(self, id_cls):
+        super().__init__()
+        self.id_cls = id_cls
+
+    def process_bind_param(self, value, dialect):
+        # Python -> DB
+        if value is None:
+            return None
+        return int(value)
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return None
+        return self.id_cls(int(value))

nlbone-0.7.3/src/nlbone/adapters/snowflake.py

@@ -0,0 +1,70 @@
+import threading
+import time
+from datetime import datetime, timezone
+
+from nlbone.config.settings import get_settings
+
+
+class Snowflake:
+    WORKER_ID_BITS = 5
+    DATACENTER_ID_BITS = 5
+    SEQUENCE_BITS = 12
+
+    MAX_WORKER_ID = (1 << WORKER_ID_BITS) - 1      # 31
+    MAX_DATACENTER_ID = (1 << DATACENTER_ID_BITS) - 1  # 31
+    SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1       # 4095
+
+    WORKER_ID_SHIFT = SEQUENCE_BITS
+    DATACENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS
+    TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS
+
+    EPOCH = int(datetime(2020, 1, 1, tzinfo=timezone.utc).timestamp() * 1000)
+
+    def __init__(self, datacenter_id: int, worker_id: int):
+        if not (0 <= worker_id <= self.MAX_WORKER_ID):
+            raise ValueError(f"worker_id must be 0..{self.MAX_WORKER_ID}")
+        if not (0 <= datacenter_id <= self.MAX_DATACENTER_ID):
+            raise ValueError(f"datacenter_id must be 0..{self.MAX_DATACENTER_ID}")
+
+        self.datacenter_id = datacenter_id
+        self.worker_id = worker_id
+        self.sequence = 0
+        self.last_ts = -1
+        self._lock = threading.Lock()
+
+    @staticmethod
+    def _timestamp_ms() -> int:
+        return int(time.time() * 1000)
+
+    def _wait_next_ms(self, last_ts: int) -> int:
+        ts = self._timestamp_ms()
+        while ts <= last_ts:
+            ts = self._timestamp_ms()
+        return ts
+
+    def next_id(self) -> int:
+        with self._lock:
+            ts = self._timestamp_ms()
+
+            if ts < self.last_ts:
+                ts = self._wait_next_ms(self.last_ts)
+
+            if ts == self.last_ts:
+                self.sequence = (self.sequence + 1) & self.SEQUENCE_MASK
+                if self.sequence == 0:
+                    ts = self._wait_next_ms(self.last_ts)
+            else:
+                self.sequence = 0
+
+            self.last_ts = ts
+
+            id64 = ((ts - self.EPOCH) << self.TIMESTAMP_SHIFT) | \
+                   (self.datacenter_id << self.DATACENTER_ID_SHIFT) | \
+                   (self.worker_id << self.WORKER_ID_SHIFT) | \
+                   self.sequence
+            return id64
+
+setting = get_settings()
+_DC_ID = int(setting.SNOWFLAKE_DATACENTER_ID)
+_WORKER_ID = int(setting.SNOWFLAKE_WORKER_ID)
+SNOWFLAKE = Snowflake(datacenter_id=_DC_ID, worker_id=_WORKER_ID)

{nlbone-0.7.2 → nlbone-0.7.3}/src/nlbone/config/settings.py

@@ -43,6 +43,9 @@ class Settings(BaseSettings):
     LOG_LEVEL: Literal["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"] = Field(default="INFO")
     LOG_JSON: bool = Field(default=True)
 
+    SNOWFLAKE_WORKER_ID : int = Field(default=1)
+    SNOWFLAKE_DATACENTER_ID: int = Field(default=1)
+
     AUDIT_DEFAULT_ENABLE: bool = False
 
     # ---------------------------
@@ -58,6 +61,8 @@ class Settings(BaseSettings):
     KEYCLOAK_CLIENT_ID: str = Field(default="nlbone")
     KEYCLOAK_CLIENT_SECRET: SecretStr = Field(default=SecretStr("dev-secret"))
 
+    AUTH_SERVICE_URL:  AnyHttpUrl = Field(default="https://auth.numberland.ir")
+
     # ---------------------------
     # Database
     # ---------------------------

{nlbone-0.7.2 → nlbone-0.7.3}/src/nlbone/core/domain/base.py

@@ -3,11 +3,13 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Generic, List, TypeVar
+from typing import Any, Generic, List, TypeVar, Callable, ClassVar
 from uuid import uuid4
 
 from pydantic import BaseModel
 
+from nlbone.adapters.snowflake import SNOWFLAKE
+
 TId = TypeVar("TId")
 
 
@@ -70,3 +72,37 @@ class AggregateRoot(Entity[TId]):
 
 class BaseEnum(Enum):
     pass
+
+
+
+ID = TypeVar("ID", bound="BaseId")
+
+@dataclass(frozen=True)
+class BaseId(ValueObject):
+    value: int
+
+    _generator: ClassVar[Callable[[], int]] = lambda: SNOWFLAKE.next_id()
+
+    def __post_init__(self):
+        if not isinstance(self.value, int):
+            raise TypeError("BaseId.value must be int")
+        if self.value <= 0:
+            raise ValueError("BaseId must be a positive integer")
+
+    def __int__(self) -> int:
+        return self.value
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def set_generator(cls, gen: Callable[[], int]) -> None:
+        cls._generator = gen
+
+    @classmethod
+    def new(cls: type[ID]) -> ID:
+        return cls(cls._generator())
+
+    @classmethod
+    def from_int(cls: type[ID], v: int) -> ID:
+        return cls(v)

nlbone-0.7.3/src/nlbone/interfaces/api/middleware/authentication.py

@@ -0,0 +1,80 @@
+from typing import Callable, Optional, Union
+
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from nlbone.adapters.auth.auth_service import AuthService
+
+try:
+    from dependency_injector import providers
+
+    ProviderType = providers.Provider  # type: ignore
+except Exception:
+    ProviderType = object
+
+from nlbone.core.ports.auth import AuthService as BaseAuthService
+
+
+def _to_factory(auth: Union[BaseAuthService, Callable[[], BaseAuthService], ProviderType]):
+    try:
+        from dependency_injector import providers as _p  # type: ignore
+
+        if isinstance(auth, _p.Provider):
+            return auth
+    except Exception:
+        pass
+    if callable(auth) and not hasattr(auth, "verify_token"):
+        return auth
+    return lambda: auth
+
+
+def authenticate_admin_user(request, auth_service):
+    token: Optional[str] = None
+    authz = request.headers.get("Authorization")
+    if authz:
+        try:
+            scheme, token = authz.split(" ", 1)
+            if scheme.lower() != "bearer":
+                token = None
+        except ValueError:
+            token = None
+
+    if token:
+        request.state.token = token
+        try:
+            service: BaseAuthService = auth_service()
+            data = service.verify_token(token)
+            if data:
+                request.state.user_id = data.get("user_id")
+        except Exception:
+            pass
+
+def authenticate_user(request):
+    token = request.cookies.get("access_token") or request.cookies.get("j_token")
+
+    if token:
+        request.state.token = token
+        try:
+            service: BaseAuthService = AuthService()
+            data = service.verify_token(token)
+            if data:
+                request.state.user_id = data.get("sub")
+        except Exception:
+            pass
+
+
+class AuthenticationMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, auth: Union[BaseAuthService, Callable[[], BaseAuthService], ProviderType]):
+        super().__init__(app)
+        self._get_auth = _to_factory(auth)
+
+    async def dispatch(self, request: Request, call_next):
+        request.state.client_id = request.headers.get("X-Client-Id")
+        request.state.user_id = None
+        request.state.token = None
+        if request.cookies.get("access_token"):
+            authenticate_user(request)
+        elif request.headers.get("Authorization"):
+            authenticate_admin_user(request, auth_service=self._get_auth)
+
+        return await call_next(request)

nlbone-0.7.2/src/nlbone/interfaces/api/middleware/authentication.py

@@ -1,59 +0,0 @@
-from typing import Callable, Optional, Union
-
-from fastapi import Request
-from starlette.middleware.base import BaseHTTPMiddleware
-
-try:
-    from dependency_injector import providers
-
-    ProviderType = providers.Provider  # type: ignore
-except Exception:
-    ProviderType = object
-
-from nlbone.core.ports.auth import AuthService
-
-
-def _to_factory(auth: Union[AuthService, Callable[[], AuthService], ProviderType]):
-    try:
-        from dependency_injector import providers as _p  # type: ignore
-
-        if isinstance(auth, _p.Provider):
-            return auth
-    except Exception:
-        pass
-    if callable(auth) and not hasattr(auth, "verify_token"):
-        return auth
-    return lambda: auth
-
-
-class AuthenticationMiddleware(BaseHTTPMiddleware):
-    def __init__(self, app, auth: Union[AuthService, Callable[[], AuthService], ProviderType]):
-        super().__init__(app)
-        self._get_auth = _to_factory(auth)
-
-    async def dispatch(self, request: Request, call_next):
-        request.state.client_id = request.headers.get("X-Client-Id")
-        request.state.user_id = None
-        request.state.token = None
-
-        token: Optional[str] = None
-        authz = request.headers.get("Authorization")
-        if authz:
-            try:
-                scheme, token = authz.split(" ", 1)
-                if scheme.lower() != "bearer":
-                    token = None
-            except ValueError:
-                token = None
-
-        if token:
-            request.state.token = token
-            try:
-                service: AuthService = self._get_auth()
-                data = service.verify_token(token)
-                if data:
-                    request.state.user_id = data.get("user_id")
-            except Exception:
-                pass
-
-        return await call_next(request)