bytesmap 0.1.1__py3-none-any.whl

bytesmap/_limits.json

@@ -0,0 +1,9 @@
+{
+  "max_batch_bytes": 1048576,
+  "max_batch_events": 1000,
+  "max_data_bytes": 65536,
+  "max_depth": 16,
+  "max_dimensions": 64,
+  "dimension_pattern": "^[A-Za-z_][A-Za-z0-9_]{0,63}$",
+  "label_pattern": "^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$"
+}

bytesmap/_transport.py

@@ -0,0 +1,120 @@
+"""Standard-library transport with verified TLS and no redirect replay."""
+
+from __future__ import annotations
+
+import ipaddress
+import math
+import ssl
+from collections.abc import Mapping
+from dataclasses import dataclass
+from http.client import HTTPException
+from typing import Protocol
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlsplit
+from urllib.request import HTTPRedirectHandler, HTTPSHandler, Request, build_opener
+
+
+@dataclass(frozen=True)
+class Response:
+    status: int
+    headers: Mapping[str, str]
+    body: bytes
+
+
+class Transport(Protocol):
+    def request(
+        self,
+        method: str,
+        url: str,
+        headers: Mapping[str, str],
+        body: bytes | None,
+        timeout: float,
+    ) -> Response: ...
+    def close(self) -> None: ...
+
+
+class TransportError(Exception):
+    """Network delivery could not be confirmed; credentials are never included."""
+
+
+def validate_origin(value: str) -> tuple[str, bool]:
+    if not isinstance(value, str) or any(
+        ord(char) < 33 or ord(char) == 127 for char in value
+    ):
+        raise ValueError("Endpoint must be an HTTPS origin or HTTP loopback")
+    try:
+        parsed = urlsplit(value)
+        port = parsed.port
+        host = parsed.hostname
+        if not host or port is not None and not 1 <= port <= 65535:
+            raise ValueError()
+        try:
+            loopback = ipaddress.ip_address(host).is_loopback
+        except ValueError:
+            loopback = host.lower() == "localhost"
+        if (
+            parsed.scheme != "https"
+            and not (parsed.scheme == "http" and loopback)
+            or parsed.username is not None
+            or parsed.password is not None
+            or parsed.path not in ("", "/")
+            or parsed.query
+            or parsed.fragment
+        ):
+            raise ValueError()
+    except ValueError:
+        raise ValueError(
+            "Endpoint must be an HTTPS origin or HTTP loopback without credentials, path, query or fragment"
+        ) from None
+    return value.rstrip("/"), parsed.scheme == "http"
+
+
+def validate_timeout(value: float) -> None:
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(value)
+        or value <= 0
+    ):
+        raise ValueError("Timeout must be a finite positive number")
+
+
+class _NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+class UrllibTransport:
+    def __init__(self) -> None:
+        self._opener = build_opener(
+            _NoRedirect(), HTTPSHandler(context=ssl.create_default_context())
+        )
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        headers: Mapping[str, str],
+        body: bytes | None,
+        timeout: float,
+    ) -> Response:
+        request = Request(url, data=body, headers=dict(headers), method=method)
+        try:
+            try:
+                response = self._opener.open(request, timeout=timeout)
+            except HTTPError as error:
+                response = error
+            with response:
+                payload = response.read(64 * 1024 * 1024 + 1)
+                if len(payload) > 64 * 1024 * 1024:
+                    raise TransportError("Response exceeded the SDK size limit")
+                return Response(
+                    response.status,
+                    {key.lower(): value for key, value in response.headers.items()},
+                    payload,
+                )
+        except (URLError, OSError, ValueError, HTTPException):
+            raise TransportError("BytesMap connection failed") from None
+
+    def close(self) -> None:
+        self._opener.close()

bytesmap/client.py

@@ -0,0 +1,214 @@
+"""Workspace-scoped operations generated from BytesMap's shared catalogue."""
+
+from __future__ import annotations
+
+import base64
+import json
+import re
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from importlib.resources import files
+from typing import Any, Self
+from urllib.parse import quote, urlencode
+
+from ._generated import GeneratedClient
+from ._transport import Transport, UrllibTransport, validate_origin, validate_timeout
+
+_CATALOG = json.loads(files(__package__).joinpath("_catalog.json").read_text("utf-8"))
+
+
+class BytesMapError(Exception):
+    def __init__(
+        self, code: str, params: Mapping[str, Any] | None = None, status: int = 0
+    ) -> None:
+        super().__init__(code)
+        self.code, self.params, self.status = code, dict(params or {}), status
+
+
+@dataclass(frozen=True)
+class CallOptions:
+    project_id: str | None = None
+
+
+def _json(value: Any) -> bytes:
+    return json.dumps(
+        value, ensure_ascii=False, allow_nan=False, separators=(",", ":")
+    ).encode("utf-8")
+
+
+def _header(value: str) -> str:
+    if not isinstance(value, str) or any(
+        ord(char) < 32 or ord(char) == 127 for char in value
+    ):
+        raise ValueError("Invalid authentication or scope header")
+    return value
+
+
+class BytesMapClient(GeneratedClient):
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        token: str | Callable[[], str | None] | None = None,
+        organization_id: str | None = None,
+        project_id: str | Callable[[], str | None] | None = None,
+        timeout: float = 30,
+        transport: Transport | None = None,
+    ) -> None:
+        self._base_url, _ = validate_origin(base_url)
+        validate_timeout(timeout)
+        self._token, self._organization_id, self._project_id = (
+            token,
+            organization_id,
+            project_id,
+        )
+        self._timeout = timeout
+        self._transport = transport or UrllibTransport()
+        self._owns_transport = transport is None
+        self._closed = False
+        self._owner: BytesMapClient | None = None
+        self._initialize_modules()
+
+    def scope(self, organization_id: str) -> BytesMapClient:
+        self._check_open()
+        if not organization_id:
+            raise ValueError("Workspace ID is required")
+        scoped = BytesMapClient(
+            self._base_url,
+            token=self._token,
+            organization_id=_header(organization_id),
+            project_id=self._project_id,
+            timeout=self._timeout,
+            transport=self._transport,
+        )
+        scoped._owner = self._owner or self
+        return scoped
+
+    def invoke(
+        self,
+        operation: str,
+        input: Mapping[str, Any] | None = None,
+        *,
+        call_options: CallOptions | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        self._check_open()
+        if operation not in _CATALOG:
+            raise ValueError("Unknown BytesMap operation")
+        spec = _CATALOG[operation]
+        if input is not None and not isinstance(input, Mapping):
+            raise TypeError("Operation input must be a mapping")
+        values = dict(input or {})
+        for key, value in kwargs.items():
+            wire_key = spec["aliases"].get(key, key)
+            if wire_key in values:
+                raise ValueError("Duplicate operation input field")
+            values[wire_key] = value
+        values = json.loads(_json(values))
+        # Resolve project selection before a token callback can change application state.
+        project = (
+            call_options.project_id
+            if call_options and call_options.project_id is not None
+            else (
+                self._project_id() if callable(self._project_id) else self._project_id
+            )
+        )
+
+        def segment(match):
+            key = match.group(1)
+            if (
+                key not in values
+                or values[key] is None
+                or isinstance(values[key], (dict, list))
+            ):
+                raise ValueError("Missing or invalid path parameter")
+            value = values.pop(key)
+            text = value if isinstance(value, str) else _json(value).decode("utf-8")
+            if not text or text in (".", ".."):
+                raise ValueError("Invalid path parameter")
+            return quote(text, safe="")
+
+        path = re.sub(r":([A-Za-z0-9_]+)", segment, spec["path"])
+        url = self._base_url + path
+        headers = {"accept": "application/json"}
+        token = self._token() if callable(self._token) else self._token
+        if token:
+            headers["authorization"] = "Bearer " + _header(token)
+        if self._organization_id:
+            headers["x-organization-id"] = _header(self._organization_id)
+        if project:
+            headers["x-bytesmap-project"] = _header(project)
+        body = None
+        if spec["method"] == "GET":
+            if values:
+                query = {
+                    key: value
+                    if isinstance(value, str)
+                    else _json(value).decode("utf-8")
+                    for key, value in values.items()
+                }
+                url += "?" + urlencode(query)
+        else:
+            body = _json(values)
+            headers["content-type"] = "application/json"
+        response = self._transport.request(
+            spec["method"], url, headers, body, self._timeout
+        )
+        if not 200 <= response.status < 300:
+            try:
+                error = json.loads(response.body)
+            except (ValueError, UnicodeError):
+                error = {}
+            if not isinstance(error, dict):
+                error = {}
+            raise BytesMapError(
+                error.get("code")
+                if isinstance(error.get("code"), str)
+                else f"http.{response.status}",
+                error.get("params") if isinstance(error.get("params"), dict) else {},
+                response.status,
+            )
+        if spec["response"] == "file":
+            headers = {key.lower(): value for key, value in response.headers.items()}
+            disposition = headers.get("content-disposition", "")
+            from urllib.parse import unquote
+
+            filename = re.search(
+                r"filename\*=UTF-8''([^;]+)", disposition, re.IGNORECASE
+            )
+            plain = re.search(r'filename="?([^";]+)', disposition, re.IGNORECASE)
+            return {
+                "filename": unquote(filename.group(1))
+                if filename
+                else plain.group(1)
+                if plain
+                else "report",
+                "contentType": headers.get("content-type", "application/octet-stream"),
+                "contentBase64": base64.b64encode(response.body).decode("ascii"),
+            }
+        try:
+            result = json.loads(response.body)
+        except (ValueError, UnicodeError):
+            raise BytesMapError("response.invalid", status=response.status) from None
+        if spec["response"] == "raw":
+            return result
+        if not isinstance(result, dict) or "data" not in result:
+            raise BytesMapError("response.invalid", status=response.status)
+        return result["data"]
+
+    def _check_open(self) -> None:
+        if self._closed or self._owner is not None and self._owner._closed:
+            raise RuntimeError("BytesMap client is closed")
+
+    def close(self) -> None:
+        if not self._closed:
+            self._closed = True
+            if self._owns_transport:
+                self._transport.close()
+
+    def __enter__(self) -> Self:
+        self._check_open()
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()