cobrala 1.0.0__py3-none-any.whl

cobrala/__init__.py

@@ -0,0 +1,18 @@
+"""
+cobrala: the Python SDK of the Access API of Cobrala.
+
+    from cobrala import Cobrala
+
+    cobrala = Cobrala(api_key="sk_...", base_url="https://access-api.cobrala.com.py")
+    verdict = cobrala.verify("USR-42", "invoices")
+    if verdict["allowed"]:
+        cobrala.consume("USR-42", "invoices", idempotency_key="factura-1")
+
+It keeps no answers: what the API says has to be right every time. Only the
+standard library is needed. ``AsyncCobrala`` has the same methods, to
+``await``.
+"""
+from .client import AsyncCobrala, Cobrala, CobralaError, entitlement_rows
+from .webhooks import verify_webhook
+
+__all__ = ["AsyncCobrala", "Cobrala", "CobralaError", "entitlement_rows", "verify_webhook"]

cobrala/client.py

@@ -0,0 +1,321 @@
+"""
+cobrala/client.py
+
+One method per route of the Access API. A rejection raises ``CobralaError``
+with its stable ``code``; a 429 waits what the API says and tries twice more.
+"""
+from __future__ import annotations
+
+import asyncio
+import functools
+import json
+import secrets
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from typing import Any, AsyncIterator, Callable, Dict, Iterator, Optional
+
+DEFAULT_TIMEOUT = 10.0
+RETRIES = 2
+RATE_LIMITED = 429
+UNREACHABLE = "unreachable"    # the status is 0: nobody answered
+
+
+class CobralaError(Exception):
+    def __init__(self, status: int, code: str, message: str, data: Optional[Dict[str, Any]] = None) -> None:
+        super().__init__(f"{code}: {message}")
+        self.status = status
+        self.code = code
+        self.message = message
+        self.data = data or {}
+
+
+@dataclass(frozen=True)
+class EntitlementRow:
+    """One row of the synchronization: the same in the API and in the event ``entitlements.changed``."""
+    included: bool
+    limit: Optional[int]
+    resets_at: Optional[str]
+    ends_at: Optional[str]
+
+
+def entitlement_rows(state: Dict[str, Any]) -> Dict[str, EntitlementRow]:
+    """The rows of a client, with their names, from ``sync_entitlements`` or a webhook."""
+    return {code: EntitlementRow(*row) for code, row in state["rows"].items()}
+
+
+def _without_empty(values: Dict[str, Any]) -> Dict[str, Any]:
+    return {name: value for name, value in values.items() if value is not None}
+
+
+class Cobrala:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str,
+        *,
+        timeout: float = DEFAULT_TIMEOUT,
+        sleep: Callable[[float], None] = time.sleep,
+    ) -> None:
+        self._key = api_key
+        self._base = f"{base_url.rstrip('/')}/v1"
+        self._timeout = timeout
+        self._sleep = sleep
+
+    # ---- The catalog ----
+
+    def plans(self, cursor: Optional[str] = None, limit: Optional[int] = None) -> Dict[str, Any]:
+        return self._get("/plans", cursor=cursor, limit=limit)
+
+    def plan(self, plan_id: int) -> Dict[str, Any]:
+        return self._get(f"/plans/{plan_id}")
+
+    def products(self, cursor: Optional[str] = None, limit: Optional[int] = None) -> Dict[str, Any]:
+        return self._get("/products", cursor=cursor, limit=limit)
+
+    def product(self, product_id: int) -> Dict[str, Any]:
+        return self._get(f"/products/{product_id}")
+
+    def features(self, cursor: Optional[str] = None, limit: Optional[int] = None) -> Dict[str, Any]:
+        return self._get("/features", cursor=cursor, limit=limit)
+
+    def feature(self, code: str) -> Dict[str, Any]:
+        return self._get(f"/features/{_part(code)}")
+
+    # ---- Clients ----
+
+    def clients(
+        self,
+        email: Optional[str] = None,
+        updated_since: Optional[str] = None,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        return self._get("/clients", email=email, updated_since=updated_since, cursor=cursor, limit=limit)
+
+    def client(self, code: str) -> Dict[str, Any]:
+        return self._get(f"/clients/{_part(code)}")
+
+    def create_client(self, legal_name: str, code: Optional[str] = None, **fields: Any) -> Dict[str, Any]:
+        return self._post("/clients", _without_empty({"legal_name": legal_name, "code": code, **fields}))
+
+    def update_client(self, client_code: str, **changes: Any) -> Dict[str, Any]:
+        """``code=`` among the changes gives the client another code."""
+        return self._request("PATCH", f"/clients/{_part(client_code)}", body=changes)
+
+    def portal_link(self, code: str) -> str:
+        return self._post(f"/clients/{_part(code)}/portal-link")["url"]
+
+    # ---- Entitlements ----
+
+    def verify(self, client_code: str, feature_code: str) -> Dict[str, Any]:
+        return self._post("/entitlements/verify", {"client_code": client_code, "feature_code": feature_code})
+
+    def consume(
+        self, client_code: str, feature_code: str, amount: int = 1, idempotency_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        return self._post("/entitlements/consume", _without_empty({
+            "client_code": client_code, "feature_code": feature_code, "amount": amount,
+            "idempotency_key": idempotency_key,
+        }))
+
+    def set_usage(self, client_code: str, feature_code: str, value: int) -> Dict[str, Any]:
+        return self._post("/entitlements/set", {"client_code": client_code, "feature_code": feature_code, "value": value})
+
+    def sync_entitlements(
+        self,
+        client_code: Optional[str] = None,
+        since: Optional[str] = None,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        return self._get("/entitlements/sync", client_code=client_code, since=since, cursor=cursor, limit=limit)
+
+    # ---- Subscriptions ----
+
+    def subscriptions(
+        self,
+        client_code: Optional[str] = None,
+        status: Optional[str] = None,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        return self._get("/subscriptions", client_code=client_code, status=status, cursor=cursor, limit=limit)
+
+    def subscription(self, subscription_id: int) -> Dict[str, Any]:
+        return self._get(f"/subscriptions/{subscription_id}")
+
+    def cancel_subscription(self, subscription_id: int, when: str) -> Dict[str, Any]:
+        """``when``: ``now`` or ``period_end``."""
+        return self._post(f"/subscriptions/{subscription_id}/cancel", {"when": when})
+
+    def revert_cancellation(self, subscription_id: int) -> Dict[str, Any]:
+        return self._post(f"/subscriptions/{subscription_id}/cancel/revert")
+
+    def change_plan(
+        self,
+        subscription_id: int,
+        price_id: int,
+        actor: str,
+        *,
+        when: str = "now",
+        paid: bool = False,
+        return_url: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """``actor``: ``operator`` (it applies at once) or ``customer`` (it pays first)."""
+        return self._post(
+            f"/subscriptions/{subscription_id}/change-plan", _change(price_id, actor, when, paid, return_url),
+        )
+
+    def preview_change_plan(self, subscription_id: int, price_id: int, actor: str, *, when: str = "now") -> Dict[str, Any]:
+        return self._post(
+            f"/subscriptions/{subscription_id}/change-plan/preview", _change(price_id, actor, when, False, None),
+        )
+
+    def cancel_plan_change(self, subscription_id: int) -> Dict[str, Any]:
+        return self._post(f"/subscriptions/{subscription_id}/change-plan/cancel")
+
+    # ---- Charges and documents ----
+
+    def payments(
+        self,
+        client_code: Optional[str] = None,
+        subscription_id: Optional[int] = None,
+        status: Optional[str] = None,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        return self._get(
+            "/payments", client_code=client_code, subscription_id=subscription_id, status=status,
+            cursor=cursor, limit=limit,
+        )
+
+    def payment(self, payment_id: int) -> Dict[str, Any]:
+        return self._get(f"/payments/{payment_id}")
+
+    def pay_link(self, payment_id: int, return_url: Optional[str] = None) -> str:
+        return self._post(f"/payments/{payment_id}/pay-link", _without_empty({"return_url": return_url}))["url"]
+
+    def upload_receipt(
+        self, payment_id: int, content: bytes, filename: str, content_type: str, note: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        boundary = f"cobrala{secrets.token_hex(12)}"
+        parts = []
+        if note is not None:
+            parts.append(f'--{boundary}\r\nContent-Disposition: form-data; name="note"\r\n\r\n{note}\r\n'.encode())
+        parts.append(
+            f'--{boundary}\r\nContent-Disposition: form-data; name="file"; filename="{_header_safe(filename)}"\r\n'
+            f"Content-Type: {content_type}\r\n\r\n".encode()
+        )
+        data = b"".join(parts) + content + f"\r\n--{boundary}--\r\n".encode()
+        return self._send("POST", f"/payments/{payment_id}/receipt", data, f"multipart/form-data; boundary={boundary}")
+
+    def documents(
+        self,
+        client_code: Optional[str] = None,
+        payment_id: Optional[int] = None,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        return self._get("/documents", client_code=client_code, payment_id=payment_id, cursor=cursor, limit=limit)
+
+    # ---- Checkout ----
+
+    def checkout_subscription(self, price_id: int, **client: Any) -> Dict[str, Any]:
+        """``client``: client_code, or else legal_name and email; ruc and return_url are optional."""
+        return self._post("/checkout/subscription", _without_empty({"price_id": price_id, **client}))
+
+    def checkout_product(self, price_id: int, **client: Any) -> Dict[str, Any]:
+        return self._post("/checkout/product", _without_empty({"price_id": price_id, **client}))
+
+    # ---- Pages ----
+
+    def every(self, method: Callable[..., Dict[str, Any]], **filters: Any) -> Iterator[Dict[str, Any]]:
+        """Every item of a list, page by page: ``for plan in cobrala.every(cobrala.plans): ...``."""
+        cursor = None
+        while True:
+            page = method(cursor=cursor, **filters)
+            yield from page["data"]
+            if not page["pagination"]["has_more"]:
+                return
+            cursor = page["pagination"]["next_cursor"]
+
+    # ---- The request ----
+
+    def _get(self, path: str, **query: Any) -> Dict[str, Any]:
+        wanted = _without_empty(query)
+        return self._request("GET", f"{path}?{urllib.parse.urlencode(wanted)}" if wanted else path)
+
+    def _post(self, path: str, body: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        return self._request("POST", path, body=body if body is not None else {})
+
+    def _request(self, method: str, path: str, body: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        return self._send(method, path, None if body is None else json.dumps(body).encode(), "application/json")
+
+    def _send(self, method: str, path: str, data: Optional[bytes], content_type: str) -> Dict[str, Any]:
+        request = urllib.request.Request(
+            f"{self._base}{path}", data=data, method=method,
+            headers={"X-API-Key": self._key, "Content-Type": content_type, "Accept": "application/json"},
+        )
+        for attempt in range(RETRIES + 1):
+            try:
+                with urllib.request.urlopen(request, timeout=self._timeout) as answer:
+                    return json.loads(answer.read() or b"null")
+            except urllib.error.HTTPError as failure:
+                if failure.code == RATE_LIMITED and attempt < RETRIES:
+                    self._sleep(float(failure.headers.get("Retry-After") or 1))
+                    continue
+                raise _error_of(failure) from failure
+            except OSError as failure:    # no answer: refused, cut or timed out
+                raise CobralaError(0, UNREACHABLE, str(failure)) from failure
+        raise AssertionError("every attempt returns or raises")
+
+
+def _change(price_id: int, actor: str, when: str, paid: bool, return_url: Optional[str]) -> Dict[str, Any]:
+    return _without_empty({"price_id": price_id, "as": actor, "when": when, "paid": paid, "return_url": return_url})
+
+
+def _part(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+def _header_safe(value: str) -> str:
+    return value.replace('"', "'").replace("\r", " ").replace("\n", " ")
+
+
+def _error_of(failure: urllib.error.HTTPError) -> CobralaError:
+    raw = failure.read().decode(errors="replace")
+    try:
+        body = json.loads(raw)
+    except ValueError:
+        body = {}
+    return CobralaError(failure.code, body.get("code", "http_error"), body.get("message", raw), body.get("data"))
+
+
+class AsyncCobrala:
+    """The same methods as ``Cobrala``, to ``await``: each one runs in a thread."""
+
+    def __init__(self, api_key: str, base_url: str, **options: Any) -> None:
+        self._client = Cobrala(api_key, base_url, **options)
+
+    async def every(self, method: Callable[..., Any], **filters: Any) -> AsyncIterator[Dict[str, Any]]:
+        """Every item of a list, page by page: ``async for plan in cobrala.every(cobrala.plans): ...``."""
+        cursor = None
+        while True:
+            page = await method(cursor=cursor, **filters)
+            for item in page["data"]:
+                yield item
+            if not page["pagination"]["has_more"]:
+                return
+            cursor = page["pagination"]["next_cursor"]
+
+    def __getattr__(self, name: str) -> Callable[..., Any]:
+        method = getattr(self._client, name)
+
+        @functools.wraps(method)
+        async def call(*args: Any, **kwargs: Any) -> Any:
+            return await asyncio.to_thread(method, *args, **kwargs)
+
+        return call

cobrala/webhooks.py

@@ -0,0 +1,37 @@
+"""
+cobrala/webhooks.py
+
+The signature of a webhook: the HMAC SHA-256 of ``"{timestamp}.{body}"``
+with the secret of the endpoint, over the exact bytes that arrived, in
+``X-Webhook-Signature: sha256=<hex>``, with its moment in ``X-Webhook-Timestamp``.
+"""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import time
+from typing import Optional, Union
+
+PREFIX = "sha256="
+TOLERANCE_SECONDS = 300
+
+
+def verify_webhook(
+    secret: str,
+    body: Union[bytes, str],
+    timestamp: str,
+    signature: str,
+    *,
+    tolerance: int = TOLERANCE_SECONDS,
+    now: Optional[float] = None,
+) -> bool:
+    """Whether the webhook is of Cobrala and recent. ``body`` is the raw body, before parsing it."""
+    raw = body.encode() if isinstance(body, str) else body
+    try:
+        moment = int(timestamp)
+    except (TypeError, ValueError):
+        return False
+    if abs((time.time() if now is None else now) - moment) > tolerance:
+        return False
+    expected = hmac.new(secret.encode(), f"{moment}.".encode() + raw, hashlib.sha256).hexdigest()
+    return hmac.compare_digest(f"{PREFIX}{expected}", signature or "")

cobrala-1.0.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.5
+Name: cobrala
+Version: 1.0.0
+Summary: Python SDK for the Access API of Cobrala: plans, entitlements, usage and checkout
+Project-URL: Homepage, https://cobrala.com.py/
+Project-URL: Documentación de la API, https://access-api.cobrala.com.py/docs
+Author: Araitek
+License-Expression: MIT
+License-File: LICENSE
+Keywords: checkout,cobrala,cobros,entitlements,paraguay,suscripciones
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: Spanish
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# cobrala (Python)
+
+SDK de la Access API de Cobrala, para Python 3.9 o más y sin dependencias. Envuelve cada ruta de la API, que además publica su OpenAPI en `/docs`, y se autentica con `X-API-Key: sk_...`. La versión para TypeScript y JavaScript tiene las mismas funciones: `npm install cobrala`.
+
+```bash
+pip install cobrala
+```
+
+```python
+from cobrala import Cobrala, CobralaError, verify_webhook
+
+cobrala = Cobrala(api_key="sk_...", base_url="https://access-api.cobrala.com.py")
+
+# Mostrar los planes en tu sitio
+for plan in cobrala.every(cobrala.plans):
+    print(plan["name"], plan["intervals"][0]["prices"][0]["price"])
+
+# Vender: abrí la url que vuelve
+sale = cobrala.checkout_subscription(
+    price_id=17, client_code="USR-42", legal_name="Ana", email="ana@example.com",
+    return_url="https://example.com/gracias",
+)
+
+# Verificar y consumir
+if cobrala.verify("USR-42", "facturas")["allowed"]:
+    cobrala.consume("USR-42", "facturas", idempotency_key="factura-9921")
+
+# Un rechazo tiene su código
+try:
+    cobrala.change_plan(sale["subscription_id"], price_id=18, actor="customer")
+except CobralaError as error:
+    if error.code == "grace_pay_first":
+        ...
+
+# Un webhook, sobre el cuerpo crudo
+valid = verify_webhook(secret, raw_body, headers["X-Webhook-Timestamp"], headers["X-Webhook-Signature"])
+```
+
+`AsyncCobrala` tiene los mismos métodos, para `await`. El SDK no guarda respuestas: lo que dice la API tiene que estar bien siempre.
+
+## Lo que resolvés en tu sistema
+
+**La clave va solo en tu servidor.** Nunca en el navegador ni en una app móvil: quien la tenga hace todo lo que sus permisos dejan. Cada clave es de un servicio.
+
+**Qué campo es el `client_code`.** Elegí un dato que tu sistema ya tenga, único y que no cambie: el id de tu usuario, por ejemplo `USR-42`. Es lo que une a tu usuario con su cliente en Cobrala.
+- Si tu usuario ya existe, mandalo en el checkout. Si el cliente no existe en Cobrala, se crea en la misma llamada con el nombre y el correo que mandes.
+- Si todavía no tiene cuenta (la página de precios abierta), no mandes código: Cobrala crea un cliente con un código generado (`CLI-8F3A21BC`) y lo devuelve junto con la dirección. Guardalo al abrirle la cuenta, o cambialo por el tuyo con `PATCH /v1/clients/{code}`.
+- Cobrala nunca une clientes por correo: el mismo correo con otro código es otro cliente, porque dos personas pueden compartirlo. Para unir a uno que ya estaba cargado, buscalo con `GET /v1/clients?email=` y cambiale el código.
+
+**Verificar en vivo o con una copia.** Las dos cosas son válidas:
+- En vivo, `POST /v1/entitlements/verify` en cada acción sensible: siempre dice lo correcto, y cuenta contra el límite de 50 pedidos por segundo de tu clave.
+- Con copia, `GET /v1/entitlements/sync` para armar menús y pantallas sin un pedido por feature. Cada fila trae `resets_at` y el vencimiento más cercano: un reinicio o un vencimiento no es un cambio y no te llega como tal, así que tu copia tiene que mirar esas fechas.
+
+**Cada cuánto sincronizar.** Lo normal: el webhook `entitlements.changed` en el momento y, por las dudas, una sincronización cada 15 minutos con `since` igual al `as_of` de la anterior. Sin webhooks, sincronizá más seguido y al entrar cada usuario.
+
+**Qué hacer si Cobrala no contesta.** Lo decidís vos según tu negocio. Con copia local, seguí con lo último que sabés. Sin copia, elegí entre dejar pasar (mejor para el usuario) o cortar (mejor para una feature cara), y dejalo escrito en tu código. El SDK reintenta solo los `429`, dos veces, esperando lo que dice `Retry-After`; si Cobrala no contesta, da un error con el código `unreachable`.
+
+**Registrar consumo sin contar dos veces.** Mandá `idempotency_key` en cada consumo, con un valor propio del evento (`factura-9921`). Si reintentás con la misma clave, la API contesta lo que contestó y no suma.
+
+**Vender.** Tu servidor pide el checkout con el `price_id` y abre la `url` que vuelve: es la página de Cobrala, donde el cliente paga. El resultado nunca lo dice la vuelta del navegador: confirmalo por webhook o verificando. El `return_url` es solo el botón "Volver a" de esa página.
+
+**Cambiar de plan.** Con `operator` rige en el acto o se programa, y la diferencia sigue el flujo normal. Con `customer`, subir primero se paga por la `url` que devuelve y bajar se programa. `POST /v1/subscriptions/{id}/change-plan/preview` dice qué va a pasar antes de confirmar.
+
+**Webhooks.** Verificá la firma sobre el cuerpo crudo, antes de parsearlo; el SDK trae la función. Las filas de `entitlements.changed` y de la sincronización tienen la misma forma, `[incluida, límite, resets_at, vencimiento]`, y el SDK trae otra función que les pone nombre.
+
+## Lo que necesita cada función
+
+| Qué hace | Ruta | Permiso |
+|---|---|---|
+| Planes, productos, features | `GET /v1/plans`, `/v1/products`, `/v1/features` | `plans`, `products`, `features` |
+| Clientes | `GET /v1/clients`, `/v1/clients/{code}` | `clients` |
+| Crear y editar clientes | `POST /v1/clients`, `PATCH /v1/clients/{code}` | `clients_write` |
+| Verificar y sincronizar | `POST /v1/entitlements/verify`, `GET /v1/entitlements/sync` | `entitlements` |
+| Consumir o fijar el consumo | `POST /v1/entitlements/consume`, `/set` | `entitlements_write` |
+| Ver suscripciones y preview del cambio | `GET /v1/subscriptions`, `POST .../change-plan/preview` | `subscriptions` |
+| Bajas y cambios de plan | `POST .../cancel`, `.../cancel/revert`, `.../change-plan`, `.../change-plan/cancel` | `subscriptions_write` |
+| Ver cobros y pedir su link | `GET /v1/payments`, `POST /v1/payments/{id}/pay-link` | `payments` |
+| Subir un comprobante | `POST /v1/payments/{id}/receipt` | `payments_receipt` |
+| Documentos y su PDF | `GET /v1/documents` | `documents` |
+| Vender | `POST /v1/checkout/subscription`, `/product` | `checkout` |
+| Abrir el portal ya autenticado | `POST /v1/clients/{code}/portal-link` | `portal` |
+
+Los rechazos son siempre `{"code": ..., "message": ..., "data": {...}}`, y el `code` es estable. Con la cuenta congelada, la clave lee pero no escribe (`account_frozen`); sin la API en el plan, contesta `plan_without_api`.
+
+## Licencia
+
+MIT. Ver [`LICENSE`](LICENSE).

cobrala-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+cobrala/__init__.py,sha256=02JKztYuRCiPlD1rICJqV-kNJTIJ7xySR5bavbi8HQ8,697
+cobrala/client.py,sha256=_EXftB-ogpx1GTtloJM9-tZ7GK4wHMnnPVbFBqFr69w,12981
+cobrala/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cobrala/webhooks.py,sha256=9r1_WXy89W6dDLUNW2Mybl4qsiGVZzuPJP1wzGkgq0A,1129
+cobrala-1.0.0.dist-info/METADATA,sha256=-uErAwUt9I5bSEAG2FjIEszvyJUXUBi40B9OntjvOmM,7302
+cobrala-1.0.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+cobrala-1.0.0.dist-info/licenses/LICENSE,sha256=QJFlN3ydmoLYPPLdVj5Jgbqa5TkywLD3oxT3OCp3CZg,1064
+cobrala-1.0.0.dist-info/RECORD,,

cobrala-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cobrala-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Araitek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.