nlbone 0.5.0__tar.gz → 0.6.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.5.0
+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

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

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

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

{nlbone-0.5.0/src/nlbone/adapters/http_clients → nlbone-0.6.0/src/nlbone/adapters/http_clients/uploadchi}/uploadchi.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-import json
 from typing import Any, Optional
-from urllib.parse import urlparse, urlunparse
 
 import httpx
 import requests
@@ -10,6 +8,7 @@ import requests
 from nlbone.adapters.auth.token_provider import ClientTokenProvider
 from nlbone.config.settings import get_settings
 from nlbone.core.ports.files import FileServicePort
+from nlbone.utils.http import auth_headers, build_list_query, normalize_https_base
 
 
 class UploadchiError(RuntimeError):
@@ -26,21 +25,6 @@ def _resolve_token(explicit: str | None) -> str | None:
     return s.UPLOADCHI_TOKEN.get_secret_value() if s.UPLOADCHI_TOKEN else None
 
 
-def _auth_headers(token: str | None) -> dict[str, str]:
-    return {"Authorization": f"Bearer {token}"} if token else {}
-
-
-def _build_list_query(
-        limit: int, offset: int, filters: dict[str, Any] | None, sort: list[tuple[str, str]] | None
-) -> dict[str, Any]:
-    q: dict[str, Any] = {"limit": limit, "offset": offset}
-    if filters:
-        q["filters"] = json.dumps(filters)
-    if sort:
-        q["sort"] = ",".join([f"{f}:{o}" for f, o in sort])
-    return q
-
-
 def _filename_from_cd(cd: str | None, fallback: str) -> str:
     if not cd:
         return fallback
@@ -49,14 +33,6 @@ def _filename_from_cd(cd: str | None, fallback: str) -> str:
     return fallback
 
 
-def _normalize_https_base(url: str) -> str:
-    p = urlparse(url.strip())
-    p = p._replace(scheme="https")  # enforce https
-    if p.path.endswith("/"):
-        p = p._replace(path=p.path.rstrip("/"))
-    return str(urlunparse(p))
-
-
 class UploadchiClient(FileServicePort):
     def __init__(
             self,
@@ -66,7 +42,7 @@ class UploadchiClient(FileServicePort):
             client: httpx.Client | None = None,
     ) -> None:
         s = get_settings()
-        self._base_url = _normalize_https_base(base_url or str(s.UPLOADCHI_BASE_URL))
+        self._base_url = normalize_https_base(base_url or str(s.UPLOADCHI_BASE_URL))
         self._timeout = timeout_seconds or float(s.HTTP_TIMEOUT_SECONDS)
         self._client = client or requests.session()
         self._token_provider = token_provider
@@ -80,7 +56,7 @@ class UploadchiClient(FileServicePort):
         tok = _resolve_token(token)
         files = {"file": (filename, file_bytes)}
         data = (params or {}).copy()
-        r = self._client.post(self._base_url, files=files, data=data, headers=_auth_headers(tok))
+        r = self._client.post(self._base_url, files=files, data=data, headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         return r.json()
@@ -91,7 +67,7 @@ class UploadchiClient(FileServicePort):
         tok = _resolve_token(token)
         r = self._client.post(
             f"{self._base_url}/{file_id}/commit",
-            headers=_auth_headers(tok or self._token_provider.get_access_token()),
+            headers=auth_headers(tok or self._token_provider.get_access_token()),
         )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, r.text)
@@ -102,7 +78,7 @@ class UploadchiClient(FileServicePort):
         tok = _resolve_token(token)
         r = self._client.post(
             f"{self._base_url}/{file_id}/rollback",
-            headers=_auth_headers(tok or self._token_provider.get_access_token()),
+            headers=auth_headers(tok or self._token_provider.get_access_token()),
         )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, r.text)
@@ -116,22 +92,22 @@ class UploadchiClient(FileServicePort):
             token: str | None = None,
     ) -> dict:
         tok = _resolve_token(token)
-        q = _build_list_query(limit, offset, filters, sort)
-        r = self._client.get(self._base_url, params=q, headers=_auth_headers(tok))
+        q = build_list_query(limit, offset, filters, sort)
+        r = self._client.get(self._base_url, params=q, headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         return r.json()
 
     def get_file(self, file_id: str, token: str | None = None) -> dict:
         tok = _resolve_token(token)
-        r = self._client.get(f"{self._base_url}/{file_id}", headers=_auth_headers(tok))
+        r = self._client.get(f"{self._base_url}/{file_id}", headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         return r.json()
 
     def download_file(self, file_id: str, token: str | None = None) -> tuple[bytes, str, str]:
         tok = _resolve_token(token)
-        r = self._client.get(f"{self._base_url}/{file_id}/download", headers=_auth_headers(tok))
+        r = self._client.get(f"{self._base_url}/{file_id}/download", headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         filename = _filename_from_cd(r.headers.get("content-disposition"), fallback=f"file-{file_id}")
@@ -140,6 +116,6 @@ class UploadchiClient(FileServicePort):
 
     def delete_file(self, file_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
-        r = self._client.delete(f"{self._base_url}/{file_id}", headers=_auth_headers(tok))
+        r = self._client.delete(f"{self._base_url}/{file_id}", headers=auth_headers(tok))
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, r.text)

{nlbone-0.5.0/src/nlbone/adapters/http_clients → nlbone-0.6.0/src/nlbone/adapters/http_clients/uploadchi}/uploadchi_async.py

@@ -7,8 +7,9 @@ import httpx
 from nlbone.config.settings import get_settings
 from nlbone.core.ports.files import AsyncFileServicePort
 
-from .uploadchi import UploadchiError, _auth_headers, _build_list_query, _filename_from_cd, _resolve_token
-from ..auth.token_provider import ClientTokenProvider
+from nlbone.adapters.http_clients.uploadchi.uploadchi import UploadchiError, _filename_from_cd, _resolve_token
+from nlbone.adapters.auth.token_provider import ClientTokenProvider
+from nlbone.utils.http import auth_headers, build_list_query
 
 
 class UploadchiAsyncClient(AsyncFileServicePort):
@@ -36,7 +37,7 @@ class UploadchiAsyncClient(AsyncFileServicePort):
         tok = _resolve_token(token)
         files = {"file": (filename, file_bytes)}
         data = (params or {}).copy()
-        r = await self._client.post("", files=files, data=data, headers=_auth_headers(tok))
+        r = await self._client.post("", files=files, data=data, headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, await r.aread())
         return r.json()
@@ -46,7 +47,7 @@ class UploadchiAsyncClient(AsyncFileServicePort):
             raise UploadchiError(detail="token_provider is not provided", status=400)
         tok = _resolve_token(token)
         r = await self._client.post(
-            f"/{file_id}/commit", headers=_auth_headers(tok or self._token_provider.get_access_token())
+            f"/{file_id}/commit", headers=auth_headers(tok or self._token_provider.get_access_token())
         )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, await r.aread())
@@ -56,7 +57,7 @@ class UploadchiAsyncClient(AsyncFileServicePort):
             raise UploadchiError(detail="token_provider is not provided", status=400)
         tok = _resolve_token(token)
         r = await self._client.post(
-            f"/{file_id}/rollback", headers=_auth_headers(tok or self._token_provider.get_access_token())
+            f"/{file_id}/rollback", headers=auth_headers(tok or self._token_provider.get_access_token())
         )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, await r.aread())
@@ -70,22 +71,22 @@ class UploadchiAsyncClient(AsyncFileServicePort):
             token: str | None = None,
     ) -> dict:
         tok = _resolve_token(token)
-        q = _build_list_query(limit, offset, filters, sort)
-        r = await self._client.get("", params=q, headers=_auth_headers(tok))
+        q = build_list_query(limit, offset, filters, sort)
+        r = await self._client.get("", params=q, headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, await r.aread())
         return r.json()
 
     async def get_file(self, file_id: str, token: str | None = None) -> dict:
         tok = _resolve_token(token)
-        r = await self._client.get(f"/{file_id}", headers=_auth_headers(tok))
+        r = await self._client.get(f"/{file_id}", headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, await r.aread())
         return r.json()
 
     async def download_file(self, file_id: str, token: str | None = None) -> tuple[AsyncIterator[bytes], str, str]:
         tok = _resolve_token(token)
-        r = await self._client.get(f"/{file_id}/download", headers=_auth_headers(tok), stream=True)
+        r = await self._client.get(f"/{file_id}/download", headers=auth_headers(tok), stream=True)
         if r.status_code >= 400:
             body = await r.aread()
             raise UploadchiError(r.status_code, body.decode(errors="ignore"))
@@ -103,7 +104,7 @@ class UploadchiAsyncClient(AsyncFileServicePort):
 
     async def delete_file(self, file_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
-        r = await self._client.delete(f"/{file_id}", headers=_auth_headers(tok))
+        r = await self._client.delete(f"/{file_id}", headers=auth_headers(tok))
         if r.status_code not in (204, 200):
             body = await r.aread()
             raise UploadchiError(r.status_code, body.decode(errors="ignore"))

{nlbone-0.5.0 → nlbone-0.6.0}/src/nlbone/config/settings.py

@@ -8,19 +8,22 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 def _guess_env_file() -> str | None:
-    explicit = os.getenv("NLBONE_ENV_FILE")
-    if explicit:
-        return explicit
+    try:
+        explicit = os.getenv("NLBONE_ENV_FILE")
+        if explicit:
+            return explicit
 
-    cwd_env = Path.cwd() / ".env"
-    if cwd_env.exists():
-        return str(cwd_env)
+        cwd_env = Path.cwd() / ".env"
+        if cwd_env.exists():
+            return str(cwd_env)
 
-    for i in range(0, 8):
-        p = Path.cwd().resolve().parents[i]
-        f = p / ".env"
-        if f.exists():
-            return str(f)
+        for i in range(0, 8):
+            p = Path.cwd().resolve().parents[i]
+            f = p / ".env"
+            if f.exists():
+                return str(f)
+    except Exception as e:
+        raise Exception("Failed to guess env file path!") from e
 
 
 def is_production_env() -> bool:
@@ -82,10 +85,15 @@ class Settings(BaseSettings):
     # ---------------------------
     # PERCOLATE
     # ---------------------------
-    ELASTIC_PERCOLATE_URL: str =  Field(default="http://localhost:9200")
+    ELASTIC_PERCOLATE_URL: str = Field(default="http://localhost:9200")
     ELASTIC_PERCOLATE_USER: str = Field(default="")
     ELASTIC_PERCOLATE_PASS: SecretStr = Field(default="")
 
+    # ---------------------------
+    # Pricing
+    # ---------------------------
+    PRICING_SERVICE_URL: AnyHttpUrl = Field(default="https://pricing.numberland.ir/v1")
+
     model_config = SettingsConfigDict(
         env_prefix="",
         env_file=None,

{nlbone-0.5.0 → nlbone-0.6.0}/src/nlbone/container.py

@@ -11,8 +11,9 @@ from nlbone.adapters.cache.memory import InMemoryCache
 from nlbone.adapters.cache.redis import RedisCache
 from nlbone.adapters.db.postgres import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork
 from nlbone.adapters.db.postgres.engine import get_async_session_factory, get_sync_session_factory
+from nlbone.adapters.http_clients import PricingService
 from nlbone.adapters.http_clients.uploadchi import UploadchiClient
-from nlbone.adapters.http_clients.uploadchi_async import UploadchiAsyncClient
+from nlbone.adapters.http_clients.uploadchi.uploadchi_async import UploadchiAsyncClient
 from nlbone.adapters.messaging import InMemoryEventBus
 from nlbone.core.ports import EventBusPort
 from nlbone.core.ports.cache import CachePort, AsyncCachePort
@@ -39,6 +40,7 @@ class Container(containers.DeclarativeContainer):
                                                                              token_provider=token_provider)
     afiles_service: providers.Singleton[AsyncFileServicePort] = providers.Singleton(UploadchiAsyncClient,
                                                                                     token_provider=token_provider)
+    pricing_service: providers.Singleton[PricingService] = providers.Singleton(PricingService, token_provider=token_provider)
 
     cache: providers.Singleton[CachePort] = providers.Selector(
         config.CACHE_BACKEND,

nlbone-0.6.0/src/nlbone/utils/http.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+from urllib.parse import urlparse, urlunparse
+
+
+def auth_headers(token: str | None) -> dict[str, str]:
+    return {"Authorization": f"Bearer {token}"} if token else {}
+
+
+def build_list_query(
+        limit: int, offset: int, filters: dict[str, Any] | None, sort: list[tuple[str, str]] | None
+) -> dict[str, Any]:
+    q: dict[str, Any] = {"limit": limit, "offset": offset}
+    if filters:
+        q["filters"] = json.dumps(filters)
+    if sort:
+        q["sort"] = ",".join([f"{f}:{o}" for f, o in sort])
+    return q
+
+
+def normalize_https_base(url: str, enforce_https: bool = True) -> str:
+    p = urlparse(url.strip())
+    if enforce_https:
+        p = p._replace(scheme="https")  # enforce https
+    if p.path.endswith("/"):
+        p = p._replace(path=p.path.rstrip("/"))
+    return str(urlunparse(p))