nlbone 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

nlbone/adapters/http_clients/__init__.py

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

nlbone/adapters/http_clients/pricing/__init__.py

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

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/adapters/http_clients/uploadchi/__init__.py

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

nlbone/adapters/http_clients/{uploadchi.py → 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/adapters/http_clients/{uploadchi_async.py → 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/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/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/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))

{nlbone-0.5.0.dist-info → nlbone-0.6.0.dist-info}/METADATA

@@ -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.dist-info → nlbone-0.6.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 nlbone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/container.py,sha256=gbO8D23HOCHe2lpZpHCvpb5zPMSJnShK9AOna1UQFWg,3169
+nlbone/container.py,sha256=hOkc8F6Zx4fP5HxRp_uBYQyxhi6QYRAIqUPFEYd18aQ,3361
 nlbone/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/auth/__init__.py,sha256=hkDHvsFhw_UiOHG9ZSMqjiAhK4wumEforitveSZswVw,42
@@ -21,10 +21,12 @@ nlbone/adapters/db/postgres/schema.py,sha256=NlE7Rr8uXypsw4oWkdZhZwcIBHQEPIpoHLx
 nlbone/adapters/db/postgres/uow.py,sha256=nRxNpY-WoWHpym-XeZ8VHm0MYvtB9wuopOeNdV_ebk8,2088
 nlbone/adapters/db/redis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/db/redis/client.py,sha256=XAKcmU0lpPvWPMS0fChVQ3iSJfHV1g4bMOCgJaj2bCI,512
-nlbone/adapters/http_clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/adapters/http_clients/email_gateway.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/adapters/http_clients/uploadchi.py,sha256=-goyqa3DNnDdkiIvrJRMlk5KVCaRNy34pPYklLHV04w,5556
-nlbone/adapters/http_clients/uploadchi_async.py,sha256=9QxunVxPEyf6LxcGaQ9I2JFtVB6s-JtR9f7RtND8pIk,4695
+nlbone/adapters/http_clients/__init__.py,sha256=Ed75OHxkJ401XNHpfx3pz20e7Z_YFSAoKUct8o-SI9k,150
+nlbone/adapters/http_clients/pricing/__init__.py,sha256=RLSnG9mgaw1Qwt5Qsc4SwRCjNiqWeyDpvFY79PlhkFE,81
+nlbone/adapters/http_clients/pricing/pricing_service.py,sha256=cdYEF_ZY01QbhSXoifotELdp2n8GyzdKIC_nWHP696E,2568
+nlbone/adapters/http_clients/uploadchi/__init__.py,sha256=VjLtgOPvNufoQvNCrwPLwlzJicdfJCZUqBK4VEXNQ3o,104
+nlbone/adapters/http_clients/uploadchi/uploadchi.py,sha256=_D6Gv5nj4TJXcEq_YJWut92vEu69LflLTw6m2dlD7C0,4864
+nlbone/adapters/http_clients/uploadchi/uploadchi_async.py,sha256=EGFI1ZhfMxotHkORyU1cJVGG4tsFAbnITZViIc3J7vI,4766
 nlbone/adapters/messaging/__init__.py,sha256=UDAwu3s-JQmOZjWz2Nu0SgHhnkbeOhKDH_zLD75oWMY,40
 nlbone/adapters/messaging/event_bus.py,sha256=w-NPwDiPMLFPU_enRQCtfQXOALsXfg31u57R8sG_-1U,781
 nlbone/adapters/messaging/redis.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -32,7 +34,7 @@ nlbone/adapters/percolation/__init__.py,sha256=viq5WZqcSLlRBF5JwuyTD_IZaNWfpKzGJ
 nlbone/adapters/percolation/connection.py,sha256=xZ-OtQVbyQYH83TUizS0UWI85Iic-AhUjiuyzO0e46s,331
 nlbone/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/config/logging.py,sha256=rGQz9W5ZgUFXBK74TFmTuwx_WMJhD8zPN39zfKVxwnI,4115
-nlbone/config/settings.py,sha256=-FcCbS30yDK-ZXlC_336T4yea7sVjnzNak22wSptOXI,3596
+nlbone/config/settings.py,sha256=W3NHZP6yjIyyKiGWNkjlUt_RYFKkcIfMBoKih_z_0Bs,3911
 nlbone/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/application/base_worker.py,sha256=uHqglsd33jXl_0kmkFlB4KQ5NdI1wArcOeQmdcifPQc,1192
@@ -79,10 +81,11 @@ nlbone/utils/cache.py,sha256=3sKtWoGBlrEvkg74r4C-Sx8u41OTup_G4s-Q57IaOXg,5921
 nlbone/utils/cache_keys.py,sha256=a1yRMUuyRJ2-CswjtgVkLcJAeT2QmThLQ5kQWvpOKL4,1069
 nlbone/utils/cache_registry.py,sha256=0csax1-GmKBcsZmQYWI4Bs0X9_BMo6Jdoac-e9Zusv8,819
 nlbone/utils/context.py,sha256=MmclJ24BG2uvSTg1IK7J-Da9BhVFDQ5ag4Ggs2FF1_w,1600
+nlbone/utils/http.py,sha256=krNfMoD9kTFE_E5yX-0DzgH97H-UgAiKRMXmATlwgIM,876
 nlbone/utils/redactor.py,sha256=JbbPs2Qtnz0zHN85BGPYQNWwBigXMSzmMEmmZZOTs_U,1277
 nlbone/utils/time.py,sha256=6e0A4_hG1rYDCrWoOklEGVJstBf8j9XSSTT7VNV2K9Y,1272
-nlbone-0.5.0.dist-info/METADATA,sha256=4EzJYpbkzQZ1LsKAYpY94NrDARztMctvov_bf1vjmfI,2194
-nlbone-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nlbone-0.5.0.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
-nlbone-0.5.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone-0.5.0.dist-info/RECORD,,
+nlbone-0.6.0.dist-info/METADATA,sha256=402hd-duWpvMKlnSwcgbbYLJQ0OQFgwKtWd9zlfkdB8,2194
+nlbone-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nlbone-0.6.0.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
+nlbone-0.6.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone-0.6.0.dist-info/RECORD,,