convertaja 0.1.0__py3-none-any.whl

convertaja/__init__.py

@@ -0,0 +1,23 @@
+"""SDK oficial da API do Convertajá (https://convertaja.com.br/api).
+
+>>> import convertaja
+>>> client = convertaja.Convertaja(api_key="cj_live_...")
+>>> client.lookups.cnpj("11.222.333/0001-81")["razaoSocial"]
+"""
+from . import webhooks
+from .client import DEFAULT_BASE_URL, BinaryFile, Convertaja, LastResponse, __version__
+from .errors import ConvertajaError, ConvertajaSignatureError
+
+Client = Convertaja
+
+__all__ = [
+    "Convertaja",
+    "Client",
+    "ConvertajaError",
+    "ConvertajaSignatureError",
+    "BinaryFile",
+    "LastResponse",
+    "webhooks",
+    "DEFAULT_BASE_URL",
+    "__version__",
+]

convertaja/client.py

@@ -0,0 +1,658 @@
+"""Cliente da API do Convertajá (só biblioteca padrão: urllib)."""
+from __future__ import annotations
+
+import base64
+import http.client
+import json
+import mimetypes
+import os
+import random
+import re
+import socket
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple, Union
+
+from . import webhooks as _webhooks
+from .errors import ConvertajaError, parse_retry_after
+
+__version__ = "0.1.0"
+DEFAULT_BASE_URL = "https://convertaja.com.br"
+MAX_RETRY_AFTER = 60.0
+MAX_BACKOFF = 8.0
+# 429 que não adianta repetir em seguida (cota diária de teste, lembrete repetido)
+NON_RETRYABLE_429 = {"test_limit", "reminder_too_soon"}
+
+JSON = Dict[str, Any]
+# Arquivo: caminho (str/PathLike), bytes, objeto com .read(), {"path"}, {"data", "name"}, {"url"} ou {"base64", "name"}
+FileInput = Any
+
+
+@dataclass
+class BinaryFile:
+    """Arquivo baixado da API."""
+
+    data: bytes
+    filename: Optional[str] = None
+    content_type: Optional[str] = None
+
+    @property
+    def size(self) -> int:
+        return len(self.data)
+
+    def save(self, path: Union[str, "os.PathLike[str]"]) -> str:
+        """Grava o arquivo no caminho indicado e devolve o caminho."""
+        with open(path, "wb") as fh:
+            fh.write(self.data)
+        return os.fspath(path)
+
+
+@dataclass
+class LastResponse:
+    status: int
+    request_id: Optional[str]
+    replayed: bool
+    idempotency_key: Optional[str]
+    attempts: int
+    headers: Dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class _Upload:
+    local: bool
+    name: str = "arquivo"
+    data: bytes = b""
+    value: Optional[JSON] = None
+
+
+def _normalize_base_url(url: Optional[str]) -> str:
+    s = (url or DEFAULT_BASE_URL).strip().rstrip("/")
+    if s.endswith("/v1"):
+        s = s[:-3]
+    return s
+
+
+def _query_string(query: Optional[Mapping[str, Any]]) -> str:
+    if not query:
+        return ""
+    pairs: List[Tuple[str, str]] = []
+    for k, v in query.items():
+        if v is None or v == "":
+            continue
+        if isinstance(v, bool):
+            v = "true" if v else "false"
+        elif isinstance(v, (list, tuple)):
+            v = ",".join(str(x) for x in v)
+        elif hasattr(v, "isoformat"):
+            v = v.isoformat()
+        pairs.append((k, str(v)))
+    return ("?" + urllib.parse.urlencode(pairs)) if pairs else ""
+
+
+def _seg(v: Any) -> str:
+    return urllib.parse.quote(str(v), safe="")
+
+
+def _filename_from(cd: Optional[str]) -> Optional[str]:
+    if not cd:
+        return None
+    m = re.search(r"filename\*\s*=\s*(?:UTF-8|utf-8)''([^;]+)", cd)
+    if m:
+        try:
+            return urllib.parse.unquote(m.group(1).strip().strip('"'), encoding="utf-8", errors="strict")
+        except UnicodeDecodeError:
+            pass
+    m = re.search(r'filename\s*=\s*"?([^";]+)"?', cd, re.IGNORECASE)
+    return m.group(1).strip() if m else None
+
+
+def _as_list(v: Any) -> List[Any]:
+    if v is None:
+        return []
+    if isinstance(v, (list, tuple)):
+        return list(v)
+    return [v]
+
+
+def _to_upload(item: FileInput, index: int, fallback: str = "arquivo") -> _Upload:
+    if item is None:
+        raise TypeError(f"Arquivo {index + 1} vazio.")
+    if isinstance(item, (str, os.PathLike)):
+        p = os.fspath(item)
+        with open(p, "rb") as fh:
+            return _Upload(True, os.path.basename(p), fh.read())
+    if isinstance(item, (bytes, bytearray, memoryview)):
+        return _Upload(True, fallback, bytes(item))
+    if isinstance(item, Mapping):
+        if isinstance(item.get("url"), str):
+            v: JSON = {"url": item["url"]}
+            if item.get("name"):
+                v["name"] = item["name"]
+            return _Upload(False, value=v)
+        if isinstance(item.get("base64"), str):
+            return _Upload(False, value={"base64": item["base64"], "name": item.get("name") or fallback})
+        if item.get("path") is not None:
+            p = os.fspath(item["path"])
+            with open(p, "rb") as fh:
+                return _Upload(True, item.get("name") or os.path.basename(p), fh.read())
+        if item.get("data") is not None:
+            d = item["data"]
+            if hasattr(d, "read"):
+                d = d.read()
+            if isinstance(d, str):
+                d = d.encode("utf-8")
+            return _Upload(True, item.get("name") or fallback, bytes(d))
+    if hasattr(item, "read"):
+        data = item.read()
+        if isinstance(data, str):
+            data = data.encode("utf-8")
+        name = os.path.basename(str(getattr(item, "name", "") or "")) or fallback
+        return _Upload(True, name, bytes(data))
+    raise TypeError(f"Arquivo {index + 1}: use um caminho, bytes, arquivo aberto, {{'data', 'name'}}, {{'url'}} ou {{'base64', 'name'}}.")
+
+
+def _to_json_file(u: _Upload) -> JSON:
+    if not u.local:
+        return dict(u.value or {})
+    return {"base64": base64.b64encode(u.data).decode("ascii"), "name": u.name}
+
+
+def _quote_name(s: str) -> str:
+    return s.replace("\\", "\\\\").replace('"', "%22").replace("\r", " ").replace("\n", " ")
+
+
+def _encode_multipart(fields: Sequence[Tuple[str, str]], files: Sequence[Tuple[str, _Upload]]) -> Tuple[bytes, str]:
+    boundary = "----convertaja" + uuid.uuid4().hex
+    out: List[bytes] = []
+    for name, value in fields:
+        out.append(f'--{boundary}\r\nContent-Disposition: form-data; name="{_quote_name(name)}"\r\n\r\n'.encode("utf-8"))
+        out.append(str(value).encode("utf-8"))
+        out.append(b"\r\n")
+    for name, up in files:
+        ctype = mimetypes.guess_type(up.name)[0] or "application/octet-stream"
+        fname = _quote_name(up.name)
+        disp = f'form-data; name="{_quote_name(name)}"; filename="{fname}"'
+        if not up.name.isascii():
+            disp += "; filename*=UTF-8''" + urllib.parse.quote(up.name, safe="")
+        out.append(f"--{boundary}\r\nContent-Disposition: {disp}\r\nContent-Type: {ctype}\r\n\r\n".encode("utf-8"))
+        out.append(up.data)
+        out.append(b"\r\n")
+    out.append(f"--{boundary}--\r\n".encode("utf-8"))
+    return b"".join(out), f"multipart/form-data; boundary={boundary}"
+
+
+def _wait_param(w: Union[bool, int, float, None]) -> Optional[str]:
+    if w is True:
+        return "true"
+    if isinstance(w, (int, float)) and not isinstance(w, bool) and w > 0:
+        return str(min(60, int(-(-w // 1))))
+    return None
+
+
+class Convertaja:
+    """Cliente da API do Convertajá.
+
+    >>> client = Convertaja(api_key="cj_live_...")
+    >>> job = client.tools.run("comprimir-pdf", files=["contrato.pdf"], options={"level": "high"}, wait=True)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: Optional[str] = None,
+        max_retries: int = 2,
+        timeout: float = 120.0,
+        retry_delay: float = 0.5,
+        user_agent: Optional[str] = None,
+    ) -> None:
+        key = api_key or os.environ.get("CONVERTAJA_API_KEY")
+        if not key:
+            raise ConvertajaError(
+                'Informe a chave da API: Convertaja(api_key="cj_live_...") ou a variável CONVERTAJA_API_KEY.',
+                code="missing_api_key",
+            )
+        self.api_key = str(key)
+        self.base_url = _normalize_base_url(base_url)
+        self.max_retries = max_retries if isinstance(max_retries, int) and max_retries >= 0 else 2
+        self.timeout = float(timeout) if timeout and timeout > 0 else 120.0
+        self.retry_delay = float(retry_delay) if retry_delay is not None and retry_delay >= 0 else 0.5
+        self.user_agent = f"{user_agent} convertaja-python/{__version__}" if user_agent else f"convertaja-python/{__version__}"
+        self._sleep: Callable[[float], None] = time.sleep
+        self._opener = urllib.request.build_opener()
+
+        #: Último X-Credits-Remaining recebido (ou None)
+        self.last_credits_remaining: Optional[int] = None
+        #: X-RateLimit-* da última resposta: {"limit", "remaining", "reset"}
+        self.last_rate_limit: Optional[Dict[str, int]] = None
+        self.last_request_id: Optional[str] = None
+        self.last_response: Optional[LastResponse] = None
+
+        self.tools = Tools(self)
+        self.jobs = Jobs(self)
+        self.lookups = Lookups(self)
+        self.boleto = Boleto(self)
+        self.pix = Pix(self)
+        self.esign = Esign(self)
+        self.expedicao = Expedicao(self)
+        self.webhooks = WebhooksResource(self)
+
+    @property
+    def credits_remaining(self) -> Optional[int]:
+        """Créditos restantes informados pela última resposta."""
+        return self.last_credits_remaining
+
+    # ---------- Conta e dados ----------
+    def me(self, **opts: Any) -> JSON:
+        return self._request("GET", "/v1/me", **opts)
+
+    def usage(self, from_: Optional[str] = None, to: Optional[str] = None, **opts: Any) -> JSON:
+        return self._request("GET", "/v1/usage", query={"from": from_, "to": to}, **opts)
+
+    def validate(self, value: Optional[str] = None, *, type: Optional[str] = None, values: Optional[Sequence[str]] = None, **opts: Any) -> JSON:  # noqa: A002
+        body: JSON = {}
+        if type is not None:
+            body["type"] = type
+        if values is not None:
+            body["values"] = list(values)
+        if value is not None:
+            body["value"] = value
+        return self._request("POST", "/v1/validate", json_body=body, **opts)
+
+    def qrcode(self, text: str, idempotency_key: Optional[str] = None, **params: Any) -> JSON:
+        return self._request("POST", "/v1/qrcode", json_body={"text": text, **params}, idempotency_key=idempotency_key)
+
+    def barcode(self, type: str, value: str, idempotency_key: Optional[str] = None, **params: Any) -> JSON:  # noqa: A002
+        return self._request("POST", "/v1/barcode", json_body={"type": type, "value": value, **params}, idempotency_key=idempotency_key)
+
+    # ---------- HTTP ----------
+    def _backoff(self, attempt: int, retry_after: Optional[float]) -> float:
+        if retry_after is not None:
+            return min(MAX_RETRY_AFTER, max(0.0, retry_after))
+        return min(MAX_BACKOFF, self.retry_delay * (2 ** attempt) + random.random() * self.retry_delay * 0.25)
+
+    def _capture(self, status: int, headers: Dict[str, str], key: Optional[str], attempts: int) -> None:
+        cr = headers.get("x-credits-remaining")
+        if cr is not None and cr.strip().lstrip("-").isdigit():
+            self.last_credits_remaining = int(cr)
+        lim = headers.get("x-ratelimit-limit")
+        if lim is not None:
+            def _int(v: Optional[str]) -> int:
+                try:
+                    return int(v or 0)
+                except ValueError:
+                    return 0
+            self.last_rate_limit = {"limit": _int(lim), "remaining": _int(headers.get("x-ratelimit-remaining")), "reset": _int(headers.get("x-ratelimit-reset"))}
+        self.last_request_id = headers.get("x-request-id")
+        self.last_response = LastResponse(status, self.last_request_id, headers.get("idempotent-replayed") == "true", key, attempts, headers)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Mapping[str, Any]] = None,
+        json_body: Any = None,
+        multipart: Optional[Tuple[Sequence[Tuple[str, str]], Sequence[Tuple[str, _Upload]]]] = None,
+        binary: bool = False,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+        max_retries: Optional[int] = None,
+    ) -> Any:
+        """Requisição com novas tentativas (rede, 429, 5xx, 409 idempotency_in_progress).
+
+        Todo POST leva uma Idempotency-Key gerada uma vez por chamada e repetida em todas as
+        tentativas, para que uma nova tentativa nunca cobre duas vezes.
+        """
+        url = f"{self.base_url}{path}{_query_string(query)}"
+        retries = max_retries if isinstance(max_retries, int) and max_retries >= 0 else self.max_retries
+        key = str(idempotency_key or uuid.uuid4()) if method == "POST" else None
+        tmo = float(timeout) if timeout and timeout > 0 else self.timeout
+
+        body: Optional[bytes] = None
+        content_type: Optional[str] = None
+        if multipart is not None:
+            body, content_type = _encode_multipart(*multipart)
+        elif json_body is not None:
+            body = json.dumps(json_body, ensure_ascii=False).encode("utf-8")
+            content_type = "application/json"
+        elif method == "POST":
+            body = b""
+
+        attempt = 0
+        while True:
+            headers = {"Authorization": f"Bearer {self.api_key}", "Accept": "application/json", "User-Agent": self.user_agent}
+            if key:
+                headers["Idempotency-Key"] = key
+            if content_type:
+                headers["Content-Type"] = content_type
+            req = urllib.request.Request(url, data=body, method=method, headers=headers)
+            status: int
+            raw: bytes
+            try:
+                with self._opener.open(req, timeout=tmo) as resp:
+                    status = resp.status
+                    resp_headers = {k.lower(): v for k, v in resp.headers.items()}
+                    raw = resp.read()
+            except urllib.error.HTTPError as e:
+                status = e.code
+                resp_headers = {k.lower(): v for k, v in (e.headers or {}).items()}
+                try:
+                    raw = e.read()
+                except Exception:  # noqa: BLE001
+                    raw = b""
+                finally:
+                    e.close()
+            except (urllib.error.URLError, socket.timeout, TimeoutError, ConnectionError, http.client.HTTPException, OSError) as e:
+                reason = getattr(e, "reason", e)
+                timed_out = isinstance(e, (socket.timeout, TimeoutError)) or isinstance(reason, (socket.timeout, TimeoutError))
+                if attempt < retries:
+                    self._sleep(self._backoff(attempt, None))
+                    attempt += 1
+                    continue
+                if timed_out:
+                    raise ConvertajaError(f"Tempo esgotado após {tmo:g} s ({method} {path}).", code="timeout") from e
+                raise ConvertajaError(f"Falha de rede em {method} {path}: {reason}", code="network_error") from e
+
+            self._capture(status, resp_headers, key, attempt + 1)
+            if 200 <= status < 300:
+                if binary:
+                    return BinaryFile(raw, _filename_from(resp_headers.get("content-disposition")), resp_headers.get("content-type"))
+                if not raw:
+                    return None
+                text = raw.decode("utf-8", errors="replace")
+                try:
+                    return json.loads(text)
+                except ValueError:
+                    return text
+            text = raw.decode("utf-8", errors="replace")
+            parsed: Any
+            try:
+                parsed = json.loads(text) if text else None
+            except ValueError:
+                parsed = text
+            error = ConvertajaError.from_response(status, parsed, resp_headers)
+            retryable = (
+                status >= 500
+                or status == 408
+                or (status == 429 and error.code not in NON_RETRYABLE_429)
+                or (status == 409 and error.code == "idempotency_in_progress")
+            )
+            if retryable and attempt < retries:
+                self._sleep(self._backoff(attempt, parse_retry_after(resp_headers.get("retry-after"))))
+                attempt += 1
+                continue
+            raise error
+
+    def _poll(self, getter: Callable[[], JSON], interval: float, timeout: float) -> JSON:
+        deadline = time.monotonic() + timeout
+        while True:
+            cur = getter()
+            if isinstance(cur, dict) and cur.get("status") in ("done", "error"):
+                return cur
+            if time.monotonic() + interval > deadline:
+                status = cur.get("status") if isinstance(cur, dict) else None
+                raise ConvertajaError(f"O recurso não terminou em {timeout:g} s (situação: {status}).", code="wait_timeout", details=cur)
+            time.sleep(interval)
+
+
+def _opts(idempotency_key: Optional[str] = None, timeout: Optional[float] = None, max_retries: Optional[int] = None) -> Dict[str, Any]:
+    out: Dict[str, Any] = {}
+    if idempotency_key is not None:
+        out["idempotency_key"] = idempotency_key
+    if timeout is not None:
+        out["timeout"] = timeout
+    if max_retries is not None:
+        out["max_retries"] = max_retries
+    return out
+
+
+class _Resource:
+    def __init__(self, client: Convertaja) -> None:
+        self._client = client
+
+
+class Tools(_Resource):
+    def list(self, **opts: Any) -> JSON:
+        return self._client._request("GET", "/v1/tools", **opts)
+
+    def get(self, tool_id: str, **opts: Any) -> JSON:
+        return self._client._request("GET", f"/v1/tools/{_seg(tool_id)}", **opts)
+
+    def run(
+        self,
+        tool_id: str,
+        files: Union[FileInput, Sequence[FileInput], None] = None,
+        *,
+        options: Optional[Mapping[str, Any]] = None,
+        webhook_url: Optional[str] = None,
+        wait: Union[bool, int, float, None] = None,
+        extra_files: Optional[Mapping[str, FileInput]] = None,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+        max_retries: Optional[int] = None,
+    ) -> JSON:
+        """Cria uma tarefa.
+
+        Arquivos locais vão em multipart/form-data; se houver algum ``{"url"}`` ou ``{"base64"}``,
+        tudo vai em JSON (os locais são convertidos para base64).
+        """
+        ups = [_to_upload(f, i) for i, f in enumerate(_as_list(files))]
+        extras = {k: _to_upload(v, 0, k) for k, v in (extra_files or {}).items() if v is not None}
+        everything = ups + list(extras.values())
+        w = _wait_param(wait)
+        if timeout is None and w:
+            timeout = 90.0  # ?wait segura a resposta até 60 s
+        common = dict(query={"wait": w}, **_opts(idempotency_key, timeout, max_retries))
+        path = f"/v1/tools/{_seg(tool_id)}"
+        if everything and all(u.local for u in everything):
+            fields: List[Tuple[str, str]] = []
+            if options:
+                fields.append(("options", json.dumps(dict(options), ensure_ascii=False)))
+            if webhook_url:
+                fields.append(("webhook_url", webhook_url))
+            parts = [("files", u) for u in ups] + [(k, u) for k, u in extras.items()]
+            return self._client._request("POST", path, multipart=(fields, parts), **common)
+        body: JSON = {"files": [_to_json_file(u) for u in ups]}
+        if extras:
+            body["extra_files"] = {k: _to_json_file(u) for k, u in extras.items()}
+        if options is not None:
+            body["options"] = dict(options)
+        if webhook_url:
+            body["webhook_url"] = webhook_url
+        return self._client._request("POST", path, json_body=body, **common)
+
+
+class Jobs(_Resource):
+    def list(
+        self,
+        *,
+        limit: Optional[int] = None,
+        starting_after: Optional[str] = None,
+        status: Union[str, Sequence[str], None] = None,
+        tool: Optional[str] = None,
+        created_after: Any = None,
+        created_before: Any = None,
+        **opts: Any,
+    ) -> JSON:
+        q = {"limit": limit, "starting_after": starting_after, "status": status, "tool": tool, "created_after": created_after, "created_before": created_before}
+        return self._client._request("GET", "/v1/jobs", query=q, **opts)
+
+    def list_all(self, **params: Any) -> Iterator[JSON]:
+        """Percorre todas as páginas."""
+        cursor = params.pop("starting_after", None)
+        while True:
+            page = self.list(starting_after=cursor, **params)
+            for j in page.get("data") or []:
+                yield j
+            if not page.get("has_more") or not page.get("next_cursor"):
+                return
+            cursor = page["next_cursor"]
+
+    def get(self, job_id: str, **opts: Any) -> JSON:
+        return self._client._request("GET", f"/v1/jobs/{_seg(job_id)}", **opts)
+
+    def delete(self, job_id: str, **opts: Any) -> JSON:
+        return self._client._request("POST", f"/v1/jobs/{_seg(job_id)}/delete", **opts)
+
+    def wait(self, job_id: str, *, interval: float = 2.0, timeout: float = 300.0) -> JSON:
+        """Consulta a tarefa até ``status`` ser ``done`` ou ``error``."""
+        return self._client._poll(lambda: self.get(job_id), interval, timeout)
+
+    def download_file(self, job_id: str, index: int = 0, **opts: Any) -> BinaryFile:
+        return self._client._request("GET", f"/v1/jobs/{_seg(job_id)}/files/{_seg(index)}", binary=True, **opts)
+
+    def download(self, job_id: str, **opts: Any) -> BinaryFile:
+        return self._client._request("GET", f"/v1/jobs/{_seg(job_id)}/download", binary=True, **opts)
+
+
+class Lookups(_Resource):
+    def cnpj(self, cnpj: str, **opts: Any) -> JSON:
+        clean = re.sub(r"[.\-/\s]", "", str(cnpj))
+        return self._client._request("GET", f"/v1/cnpj/{_seg(clean)}", **opts)
+
+    def cep(self, cep: str, **opts: Any) -> JSON:
+        return self._client._request("GET", f"/v1/cep/{_seg(re.sub(r'[^0-9]', '', str(cep)))}", **opts)
+
+
+class Boleto(_Resource):
+    def parse(self, code: str, **opts: Any) -> JSON:
+        return self._client._request("POST", "/v1/boleto/parse", json_body={"code": str(code)}, **opts)
+
+
+class Pix(_Resource):
+    def brcode(self, key: str, name: str, city: str, idempotency_key: Optional[str] = None, **params: Any) -> JSON:
+        """Gera o Pix copia e cola. Parâmetros extras: amount, txid, description, format, module_size, margin, color, background."""
+        return self._client._request("POST", "/v1/pix/brcode", json_body={"key": key, "name": name, "city": city, **params}, idempotency_key=idempotency_key)
+
+
+class Envelopes(_Resource):
+    def create(
+        self,
+        file: FileInput,
+        signers: Sequence[Mapping[str, Any]],
+        *,
+        fields: Optional[Sequence[Mapping[str, Any]]] = None,
+        name: Optional[str] = None,
+        message: Optional[str] = None,
+        expires_at: Optional[str] = None,
+        sequential: Optional[bool] = None,
+        send: Optional[bool] = None,
+        return_links: Optional[bool] = None,
+        webhook_url: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+        max_retries: Optional[int] = None,
+    ) -> JSON:
+        """Cria um envelope de assinatura (PDF local em multipart, ou {"url"}/{"base64"} em JSON)."""
+        up = _to_upload(file, 0, "documento.pdf")
+        data: JSON = {"signers": [dict(s) for s in signers]}
+        for k, v in (("fields", fields), ("name", name), ("message", message), ("expires_at", expires_at), ("sequential", sequential), ("send", send), ("return_links", return_links), ("webhook_url", webhook_url)):
+            if v is not None:
+                data[k] = [dict(x) for x in v] if k == "fields" else v
+        o = _opts(idempotency_key, timeout, max_retries)
+        if up.local:
+            return self._client._request("POST", "/v1/esign/envelopes", multipart=([("data", json.dumps(data, ensure_ascii=False))], [("file", up)]), **o)
+        return self._client._request("POST", "/v1/esign/envelopes", json_body={"file": up.value, **data}, **o)
+
+    def list(self, *, limit: Optional[int] = None, cursor: Optional[str] = None, offset: Optional[int] = None, status: Optional[str] = None, **opts: Any) -> JSON:
+        return self._client._request("GET", "/v1/esign/envelopes", query={"limit": limit, "cursor": cursor, "offset": offset, "status": status}, **opts)
+
+    def list_all(self, **params: Any) -> Iterator[JSON]:
+        cursor = params.pop("cursor", None)
+        while True:
+            page = self.list(cursor=cursor, **params)
+            for e in page.get("data") or []:
+                yield e
+            if not page.get("has_more") or not page.get("next_cursor"):
+                return
+            cursor = page["next_cursor"]
+
+    def get(self, envelope_id: str, *, events: bool = False, links: bool = False, **opts: Any) -> JSON:
+        q = {"events": "true" if events else None, "links": "true" if links else None}
+        return self._client._request("GET", f"/v1/esign/envelopes/{_seg(envelope_id)}", query=q, **opts)
+
+    def send(self, envelope_id: str, *, return_links: Optional[bool] = None, **opts: Any) -> JSON:
+        body = None if return_links is None else {"return_links": bool(return_links)}
+        return self._client._request("POST", f"/v1/esign/envelopes/{_seg(envelope_id)}/send", json_body=body, **opts)
+
+    def remind(self, envelope_id: str, **opts: Any) -> JSON:
+        return self._client._request("POST", f"/v1/esign/envelopes/{_seg(envelope_id)}/remind", **opts)
+
+    def cancel(self, envelope_id: str, **opts: Any) -> JSON:
+        return self._client._request("POST", f"/v1/esign/envelopes/{_seg(envelope_id)}/cancel", **opts)
+
+    def delete(self, envelope_id: str, **opts: Any) -> JSON:
+        return self._client._request("POST", f"/v1/esign/envelopes/{_seg(envelope_id)}/delete", **opts)
+
+    def download_final(self, envelope_id: str, **opts: Any) -> BinaryFile:
+        return self._client._request("GET", f"/v1/esign/envelopes/{_seg(envelope_id)}/files/final", binary=True, **opts)
+
+    def download_audit(self, envelope_id: str, **opts: Any) -> BinaryFile:
+        return self._client._request("GET", f"/v1/esign/envelopes/{_seg(envelope_id)}/files/audit", binary=True, **opts)
+
+
+class Esign(_Resource):
+    def __init__(self, client: Convertaja) -> None:
+        super().__init__(client)
+        self.envelopes = Envelopes(client)
+
+
+class Lotes(_Resource):
+    def create(
+        self,
+        labels: Union[FileInput, Sequence[FileInput]],
+        xmls: Union[FileInput, Sequence[FileInput], None] = None,
+        *,
+        intercalar: Optional[bool] = None,
+        wait: Union[bool, int, float, None] = None,
+        idempotency_key: Optional[str] = None,
+        timeout: Optional[float] = None,
+        max_retries: Optional[int] = None,
+    ) -> JSON:
+        """Cria um lote da Central de Expedição: labels (PDFs das etiquetas) e xmls (XMLs ou ZIP das NF-e)."""
+        lab = [_to_upload(f, i, f"etiquetas-{i + 1}.pdf") for i, f in enumerate(_as_list(labels))]
+        xm = [_to_upload(f, i, f"notas-{i + 1}.xml") for i, f in enumerate(_as_list(xmls))]
+        if not lab:
+            raise TypeError('Informe pelo menos um PDF de etiquetas em "labels".')
+        if any(not u.local for u in lab + xm):
+            raise TypeError("A Central de Expedição aceita só arquivos locais (multipart).")
+        fields: List[Tuple[str, str]] = []
+        if intercalar is not None:
+            fields.append(("intercalar", "true" if intercalar else "false"))
+        w = _wait_param(wait)
+        if timeout is None and w:
+            timeout = 90.0
+        parts = [("labels", u) for u in lab] + [("xmls", u) for u in xm]
+        return self._client._request("POST", "/v1/expedicao/lotes", query={"wait": w}, multipart=(fields, parts), **_opts(idempotency_key, timeout, max_retries))
+
+    def get(self, lote_id: str, **opts: Any) -> JSON:
+        return self._client._request("GET", f"/v1/expedicao/lotes/{_seg(lote_id)}", **opts)
+
+    def wait(self, lote_id: str, *, interval: float = 2.0, timeout: float = 300.0) -> JSON:
+        return self._client._poll(lambda: self.get(lote_id), interval, timeout)
+
+    def download_file(self, lote_id: str, name: str, **opts: Any) -> BinaryFile:
+        return self._client._request("GET", f"/v1/expedicao/lotes/{_seg(lote_id)}/files/{_seg(name)}", binary=True, **opts)
+
+    def download(self, lote_id: str, **opts: Any) -> BinaryFile:
+        return self._client._request("GET", f"/v1/expedicao/lotes/{_seg(lote_id)}/download", binary=True, **opts)
+
+
+class Expedicao(_Resource):
+    def __init__(self, client: Convertaja) -> None:
+        super().__init__(client)
+        self.lotes = Lotes(client)
+
+
+class WebhooksResource(_Resource):
+    verify = staticmethod(_webhooks.verify)
+    construct_event = staticmethod(_webhooks.construct_event)
+
+    def test(self, url: str, **opts: Any) -> JSON:
+        """Envia um evento webhook.test assinado para a URL e devolve o que o receptor respondeu."""
+        return self._client._request("POST", "/v1/webhooks/test", json_body={"url": url}, **opts)

convertaja/errors.py

@@ -0,0 +1,74 @@
+"""Erros do SDK do Convertajá."""
+from __future__ import annotations
+
+import email.utils
+import time
+from typing import Any, Mapping, Optional
+
+
+class ConvertajaError(Exception):
+    """Erro de uma chamada à API (HTTP 4xx/5xx), de rede, de tempo esgotado ou de webhook.
+
+    A API responde ``{"error": {"code", "message", "request_id"}}``; ``code`` é estável
+    e ``message`` vem em português.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: Optional[int] = None,
+        code: str = "unknown_error",
+        request_id: Optional[str] = None,
+        details: Any = None,
+        headers: Optional[Mapping[str, str]] = None,
+        retry_after: Optional[float] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.request_id = request_id
+        self.details = details
+        self.headers = dict(headers) if headers else None
+        self.retry_after = retry_after
+
+    def __repr__(self) -> str:
+        return f"ConvertajaError(status={self.status!r}, code={self.code!r}, message={self.message!r}, request_id={self.request_id!r})"
+
+    @classmethod
+    def from_response(cls, status: int, body: Any, headers: Mapping[str, str]) -> "ConvertajaError":
+        err = body.get("error") if isinstance(body, dict) and isinstance(body.get("error"), dict) else {}
+        message = err.get("message") or (body[:300] if isinstance(body, str) and body else f"HTTP {status}")
+        return cls(
+            message,
+            status=status,
+            code=err.get("code") or f"http_{status}",
+            request_id=err.get("request_id") or headers.get("x-request-id"),
+            details=err or body or None,
+            headers=headers,
+            retry_after=parse_retry_after(headers.get("retry-after")),
+        )
+
+
+class ConvertajaSignatureError(ConvertajaError):
+    """Assinatura de webhook ausente, malformada, vencida ou que não confere."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message, code="invalid_signature")
+
+
+def parse_retry_after(value: Optional[str]) -> Optional[float]:
+    """Retry-After em segundos (aceita número ou data HTTP)."""
+    if value is None or str(value).strip() == "":
+        return None
+    s = str(value).strip()
+    try:
+        return max(0.0, float(s))
+    except ValueError:
+        pass
+    try:
+        dt = email.utils.parsedate_to_datetime(s)
+        return max(0.0, dt.timestamp() - time.time())
+    except (TypeError, ValueError, IndexError):
+        return None

convertaja/webhooks.py

@@ -0,0 +1,93 @@
+"""Verificação dos webhooks do Convertajá.
+
+Cabeçalho ``X-Convertaja-Signature: t=<unix>,v1=<hex(HMAC_SHA256(segredo, f"{t}.{corpo_bruto}"))>``.
+Use SEMPRE o corpo bruto (os bytes exatos recebidos), nunca o JSON reserializado.
+"""
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from .errors import ConvertajaSignatureError
+
+DEFAULT_TOLERANCE_SEC = 300
+
+RawBody = Union[str, bytes, bytearray, memoryview]
+
+
+def _to_bytes(raw_body: RawBody) -> bytes:
+    if isinstance(raw_body, str):
+        return raw_body.encode("utf-8")
+    if isinstance(raw_body, (bytes, bytearray, memoryview)):
+        return bytes(raw_body)
+    raise TypeError("raw_body deve ser str ou bytes (o corpo bruto da requisição).")
+
+
+def _parse_header(header: str) -> Tuple[Optional[str], List[str]]:
+    t: Optional[str] = None
+    sigs: List[str] = []
+    for part in str(header or "").split(","):
+        if "=" not in part:
+            continue
+        k, v = part.split("=", 1)
+        k, v = k.strip(), v.strip()
+        if k == "t":
+            t = v
+        elif k == "v1" and v:
+            sigs.append(v)
+    return t, sigs
+
+
+def sign(secret: str, raw_body: RawBody, timestamp: Optional[int] = None) -> str:
+    """Gera o cabeçalho de assinatura (útil para testar o seu receptor)."""
+    ts = int(time.time()) if timestamp is None else int(timestamp)
+    mac = hmac.new(str(secret).encode("utf-8"), f"{ts}.".encode("utf-8") + _to_bytes(raw_body), hashlib.sha256).hexdigest()
+    return f"t={ts},v1={mac}"
+
+
+def _check(raw_body: RawBody, header: Optional[str], secret: str, tolerance_sec: Optional[float]) -> Optional[str]:
+    if not secret:
+        return "Segredo do webhook ausente."
+    if not header:
+        return "Cabeçalho X-Convertaja-Signature ausente."
+    t, sigs = _parse_header(header)
+    if not t or not (t.isascii() and t.isdigit()) or not sigs:
+        return "Cabeçalho X-Convertaja-Signature malformado."
+    if tolerance_sec and tolerance_sec > 0 and abs(time.time() - int(t)) > tolerance_sec:
+        return "Assinatura fora da janela de tolerância (possível repetição)."
+    expected = hmac.new(str(secret).encode("utf-8"), f"{t}.".encode("utf-8") + _to_bytes(raw_body), hashlib.sha256).hexdigest()
+    if any(hmac.compare_digest(expected.encode("ascii"), s.encode("utf-8", "replace")) for s in sigs):
+        return None
+    return "Assinatura não confere."
+
+
+def verify(raw_body: RawBody, header: Optional[str], secret: str, tolerance_sec: float = DEFAULT_TOLERANCE_SEC) -> bool:
+    """True se a assinatura confere e está dentro da tolerância (padrão 300 s)."""
+    try:
+        return _check(raw_body, header, secret, tolerance_sec) is None
+    except (TypeError, ValueError):
+        return False
+
+
+def construct_event(raw_body: RawBody, header: Optional[str], secret: str, tolerance_sec: float = DEFAULT_TOLERANCE_SEC) -> Dict[str, Any]:
+    """Confere a assinatura e devolve o evento ``{id, type, created_at, data}``.
+
+    Lança :class:`ConvertajaSignatureError` se não conferir.
+    """
+    problem = _check(raw_body, header, secret, tolerance_sec)
+    if problem:
+        raise ConvertajaSignatureError(problem)
+    try:
+        event = json.loads(_to_bytes(raw_body).decode("utf-8"))
+    except (ValueError, UnicodeDecodeError):
+        raise ConvertajaSignatureError("Corpo do webhook não é JSON válido.") from None
+    if not isinstance(event, dict):
+        raise ConvertajaSignatureError("Corpo do webhook não é um objeto JSON.")
+    return event
+
+
+# Alias no estilo do SDK Node
+constructEvent = construct_event

convertaja-0.1.0.dist-info/METADATA

@@ -0,0 +1,234 @@
+Metadata-Version: 2.4
+Name: convertaja
+Version: 0.1.0
+Summary: SDK oficial da API do Convertajá: PDF, DANFE, etiquetas ZPL, assinatura eletrônica, CNPJ, CEP, boleto e Pix.
+Author-email: Convertajá <contato@convertaja.com.br>
+License: MIT
+Project-URL: Homepage, https://convertaja.com.br/api
+Project-URL: Documentation, https://convertaja.com.br/api/docs
+Keywords: convertaja,pdf,danfe,nfe,zpl,cnpj,cep,boleto,pix,assinatura eletronica,api,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: Portuguese (Brazilian)
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# convertaja (Python)
+
+SDK oficial da [API do Convertajá](https://convertaja.com.br/api) para Python: comprimir e converter PDF, gerar DANFE a partir do XML da NF-e, converter etiquetas ZPL, assinatura eletrônica, Central de Expedição e consultas de CNPJ, CEP, boleto e Pix.
+
+- Só biblioteca padrão (`urllib`), sem `requests`. Python 3.9 ou mais novo, com type hints (`py.typed`).
+- Repete sozinho em falha de rede, 429 (respeitando `Retry-After`) e 5xx, **sem cobrar duas vezes** (Idempotency-Key automática).
+
+> **Ainda não publicado no PyPI.** Até a publicação, instale pelo caminho local ou pelo repositório git (veja abaixo).
+
+## Instalação
+
+```bash
+# caminho local
+pip install ./caminho/para/integrations/sdk-python
+
+# ou direto do git (quando o repositório estiver disponível)
+pip install "git+https://github.com/convertaja/sdk-python.git"
+
+# depois da publicação
+pip install convertaja
+```
+
+## Primeiros passos
+
+Crie a chave em **Minha conta → API** (`/conta/api`). Use `cj_test_…` para testar (não consome créditos, até 20 chamadas por dia) e `cj_live_…` em produção.
+
+```python
+import os
+from convertaja import Convertaja
+
+cj = Convertaja(api_key=os.environ["CONVERTAJA_API_KEY"])  # ou só Convertaja() lendo CONVERTAJA_API_KEY
+
+me = cj.me()
+print(me["plan"]["label"], me["credits"]["remaining"])
+print("Créditos depois da última chamada:", cj.credits_remaining)
+```
+
+Opções: `base_url` (padrão `https://convertaja.com.br`), `max_retries` (padrão 2), `timeout` em segundos (padrão 120), `retry_delay` (padrão 0,5 s).
+
+### Comprimir um PDF
+
+```python
+# wait=True segura a resposta até 60 s; se ainda não terminou, use jobs.wait
+job = cj.tools.run(
+    "comprimir-pdf",
+    files=["contrato.pdf"],          # caminho, bytes, arquivo aberto, {"data", "name"}, {"url"} ou {"base64", "name"}
+    options={"level": "high"},       # low | medium | high
+    wait=True,
+)
+if job["status"] not in ("done", "error"):
+    job = cj.jobs.wait(job["id"])
+if job["status"] == "error":
+    raise RuntimeError(job["error"]["message"])
+
+arquivo = cj.jobs.download(job["id"])  # um arquivo, ou ZIP se houver vários
+arquivo.save(arquivo.filename or "comprimido.pdf")
+```
+
+### Consultar CNPJ e CEP (grátis)
+
+```python
+empresa = cj.lookups.cnpj("11.222.333/0001-81")  # aceita o CNPJ alfanumérico
+print(empresa["razaoSocial"], empresa["situacao"])
+
+endereco = cj.lookups.cep("01310-100")
+print(endereco["logradouro"], endereco["cidade"], endereco["uf"])
+```
+
+### DANFE a partir do XML da NF-e
+
+```python
+job = cj.tools.run(
+    "xml-nfe-para-pdf",
+    files=["nota.xml"],              # vários XMLs ou um ZIP
+    options={"layout": "a4"},        # a4 | simplificado (10×15, etiqueta)
+    wait=True,
+)
+cj.jobs.download(job["id"]).save("danfe.pdf")
+```
+
+### ZPL para PDF
+
+```python
+# código ZPL direto nas opções (sem arquivo)...
+job = cj.tools.run(
+    "zpl-para-pdf",
+    options={"zpl": "^XA^FO50,50^A0N,40,40^FDOlá^FS^XZ", "width_mm": 100, "height_mm": 150, "dpmm": "8"},
+    wait=True,
+)
+# ...ou arquivos .zpl/.txt
+job = cj.tools.run("zpl-para-pdf", files=["etiquetas.zpl"], wait=True)
+cj.jobs.download(job["id"]).save("etiquetas.pdf")
+```
+
+Liste as ferramentas, extensões aceitas e opções (JSON Schema) com `cj.tools.list()` ou `cj.tools.get("comprimir-pdf")`.
+
+### Assinatura eletrônica (envelope)
+
+```python
+envelope = cj.esign.envelopes.create(
+    "contrato.pdf",                  # ou {"url": "https://…/contrato.pdf"}
+    signers=[
+        {"name": "Ana Souza", "email": "ana@cliente.com.br", "role": "sign"},
+        {"name": "Bruno Lima", "email": "bruno@empresa.com.br", "role": "witness"},
+    ],
+    fields=[
+        {"signer": 0, "type": "signature", "page": 0, "x": 0.1, "y": 0.75, "w": 0.3, "h": 0.07},
+        {"signer": 1, "type": "signature", "page": 0, "x": 0.55, "y": 0.75, "w": 0.3, "h": 0.07},
+    ],
+    name="Contrato de prestação de serviços",
+    message="Olá! Segue o contrato para assinatura.",
+    webhook_url="https://seusite.com.br/webhooks/convertaja",
+)
+print(envelope["id"], envelope["status"])  # K7QD-9WZ2-M4HT-R8PA pending
+
+# depois que todos assinarem:
+cj.esign.envelopes.download_final(envelope["id"]).save("contrato-assinado.pdf")
+```
+
+Também há `list`, `list_all`, `get(id, events=True, links=True)`, `send` (rascunhos criados com `send=False`), `remind`, `cancel`, `delete` e `download_audit`.
+
+### Outros recursos
+
+```python
+cj.validate("12.ABC.345/01DE-35", type="cnpj")
+cj.validate(values=["123.456.789-09", "11.222.333/0001-81"])  # lote: 1 crédito a cada 50
+cj.boleto.parse("23793.38128 86000.782713 36950.000632 1 10000000012345")
+cj.pix.brcode("contato@empresa.com.br", "Empresa", "SAO PAULO", amount=10.5, format="png")
+cj.qrcode("https://convertaja.com.br", format="svg")
+cj.barcode("ean13", "789123456789", format="png")
+
+# Tarefas
+page = cj.jobs.list(status="done", limit=20)  # page["next_cursor"] → starting_after
+for job in cj.jobs.list_all(tool="comprimir-pdf"):
+    print(job["id"])
+cj.jobs.download_file(job_id, 0).save("saida.pdf")
+cj.jobs.delete(job_id)  # apaga os arquivos antes de 1 hora (LGPD)
+
+# Central de Expedição: etiquetas + XMLs das notas
+lote = cj.expedicao.lotes.create(["etiquetas.pdf"], ["notas.zip"], intercalar=True, wait=True)
+lote = cj.expedicao.lotes.wait(lote["id"])
+cj.expedicao.lotes.download(lote["id"]).save("expedicao.zip")
+
+# Webhook de teste (envia um evento assinado para a sua URL)
+cj.webhooks.test("https://seusite.com.br/webhooks/convertaja")
+```
+
+## Webhooks: verificação da assinatura
+
+Cada aviso chega com `X-Convertaja-Signature: t=<unix>,v1=<hex>`, onde `v1 = HMAC-SHA256(segredo, "<t>.<corpo bruto>")`. O segredo (`whsec_…`) fica em **Minha conta → API**. Verifique sempre com o **corpo bruto** e recuse assinaturas com mais de 300 s.
+
+```python
+import os
+from flask import Flask, request, abort
+from convertaja import webhooks, ConvertajaSignatureError
+
+app = Flask(__name__)
+
+@app.post("/webhooks/convertaja")
+def convertaja_webhook():
+    try:
+        event = webhooks.construct_event(
+            request.get_data(),  # bytes exatos recebidos
+            request.headers.get("X-Convertaja-Signature"),
+            os.environ["CONVERTAJA_WEBHOOK_SECRET"],
+        )
+    except ConvertajaSignatureError:
+        abort(400)
+    if event["type"] == "job.completed":
+        tarefa = event["data"]  # id, outputs, download_url…
+    elif event["type"] == "esign.envelope.completed":
+        envelope = event["data"]
+    return "", 200  # responda 2xx rápido; o Convertajá tenta até 3 vezes
+```
+
+`webhooks.verify(raw_body, header, secret, tolerance_sec=300)` devolve `True`/`False` se você preferir tratar sozinho. Use o cabeçalho `X-Convertaja-Delivery` para descartar entregas repetidas.
+
+## Erros
+
+Toda falha vira `ConvertajaError`:
+
+```python
+from convertaja import ConvertajaError
+
+try:
+    cj.tools.run("comprimir-pdf", files=["grande.pdf"])
+except ConvertajaError as e:
+    print(e.status)      # 402
+    print(e.code)        # "insufficient_credits" (estável, para tratar no código)
+    print(e.message)     # mensagem em português
+    print(e.request_id)  # informe ao suporte
+    print(e.details)     # corpo de erro completo (ex.: credits_required)
+```
+
+Códigos do SDK, além dos da API: `network_error`, `timeout`, `wait_timeout` (em `jobs.wait`), `missing_api_key`, `invalid_signature`. Lista completa em [/api/docs](https://convertaja.com.br/api/docs).
+
+## Novas tentativas e idempotência
+
+- Repete até `max_retries` vezes (padrão 2) em falha de rede, tempo esgotado, 408, 429 (exceto `test_limit` e `reminder_too_soon`), 5xx e 409 `idempotency_in_progress`.
+- Em 429 espera o `Retry-After` da API (até 60 s); nos outros casos usa recuo exponencial (0,5 s, 1 s, 2 s… até 8 s).
+- Todo POST leva uma `Idempotency-Key` (UUID) gerada **uma vez por chamada** e repetida em todas as tentativas: se a primeira chegou a ser processada, a repetição devolve a mesma resposta, sem novo débito.
+- Para repetir com segurança entre processos, passe a sua chave: `cj.tools.run("comprimir-pdf", files=[...], idempotency_key=f"pedido-{pedido.id}")`. A mesma chave com outro conteúdo em 24 h dá 409 `idempotency_key_reused`.
+- Depois de cada chamada: `cj.credits_remaining`, `cj.last_rate_limit`, `cj.last_request_id` e `cj.last_response` (`status`, `attempts`, `idempotency_key`, `replayed`).
+- `timeout` vale por operação de rede (conexão e cada leitura), como no `urllib`.
+
+## Testes
+
+```bash
+python3 -I -m unittest discover -s tests -v   # servidor HTTP local numa thread; nenhuma chamada sai da máquina
+```
+
+## Licença
+
+MIT

convertaja-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+convertaja/__init__.py,sha256=ZtENTlADN9yaN6pViUS73k8c5OXZbv5b7fWR2nvJCOA,609
+convertaja/client.py,sha256=7jzho4KdzokJhOw8IpRtf_5vt24kiDhRZXzJ7imDVcw,28530
+convertaja/errors.py,sha256=rBsN_sqbh8MLPdC3lYSiiIwhOd3l2_TPBn8FIo7iDEo,2597
+convertaja/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+convertaja/webhooks.py,sha256=V1ltcTFRWgjr2zy-VfZDe3gG6Gzh0IPgkqcRRhPQN4k,3653
+convertaja-0.1.0.dist-info/licenses/LICENSE,sha256=aCKsdh-kR8Wu6X8bRA7XISy1uRCwRqIYijwbj9LqaAg,1068
+convertaja-0.1.0.dist-info/METADATA,sha256=Z7u0fXK2D_814R4MI7zXD_ZP8ipMMQ8HjBRNUOkeuug,9451
+convertaja-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+convertaja-0.1.0.dist-info/top_level.txt,sha256=tJArvu72ligFn4-YZ4wQNOCjcu0B_732SRcYuEAjOLw,11
+convertaja-0.1.0.dist-info/RECORD,,

convertaja-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

convertaja-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Convertajá
+
+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.

convertaja-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+convertaja