kobil-core 1.2.0__tar.gz

kobil_core-1.2.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: kobil-core
+Version: 1.2.0
+Summary: Shared foundation for the KOBIL SDK family: OAuth token acquisition/caching and an HTTP base for typed clients.
+License: MIT
+Project-URL: Repository, https://github.com/uveysservetoglu/kobil-sdks
+Keywords: kobil,sdk,oauth2,core
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# kobil-core
+
+Shared foundation for the KOBIL SDK family (`kobil-payment`, `kobil-chat`, `kobil-sign`, …).
+
+You normally don't use this directly — the module packages depend on it. Provides:
+
+- **`DefaultTokenProvider`** — OAuth2 `client_credentials` token acquisition with in-memory
+  caching (honours `expires_in`). Modes: `post` (form body, default) or `basic`.
+- **`KobilError`** — base exception all module exceptions extend (`status_code`, `response_body`).
+- **`ServiceClient`** — HTTP base for typed clients (bearer + send + error wrapping; JSON,
+  multipart, and binary-download helpers) built on the standard library (`urllib`).
+- **`credentials_from_env()`** — reads `KOBIL_TOKEN_ENDPOINT`, `KOBIL_CLIENT_ID`,
+  `KOBIL_CLIENT_SECRET`, `KOBIL_TOKEN_AUTH_MODE`.
+
+Pure standard library — no third-party dependencies. Python 3.8+.
+
+## License
+
+MIT

kobil_core-1.2.0/README.md

@@ -0,0 +1,19 @@
+# kobil-core
+
+Shared foundation for the KOBIL SDK family (`kobil-payment`, `kobil-chat`, `kobil-sign`, …).
+
+You normally don't use this directly — the module packages depend on it. Provides:
+
+- **`DefaultTokenProvider`** — OAuth2 `client_credentials` token acquisition with in-memory
+  caching (honours `expires_in`). Modes: `post` (form body, default) or `basic`.
+- **`KobilError`** — base exception all module exceptions extend (`status_code`, `response_body`).
+- **`ServiceClient`** — HTTP base for typed clients (bearer + send + error wrapping; JSON,
+  multipart, and binary-download helpers) built on the standard library (`urllib`).
+- **`credentials_from_env()`** — reads `KOBIL_TOKEN_ENDPOINT`, `KOBIL_CLIENT_ID`,
+  `KOBIL_CLIENT_SECRET`, `KOBIL_TOKEN_AUTH_MODE`.
+
+Pure standard library — no third-party dependencies. Python 3.8+.
+
+## License
+
+MIT

kobil_core-1.2.0/kobil/core/__init__.py

@@ -0,0 +1,18 @@
+"""kobil.core — shared foundation for the KOBIL SDK family."""
+
+from .client import ServiceClient, build_multipart, new_uuid, prune
+from .credentials import Credentials, credentials_from_env
+from .error import KobilError
+from .token import DefaultTokenProvider, TokenProvider
+
+__all__ = [
+    "Credentials",
+    "credentials_from_env",
+    "KobilError",
+    "TokenProvider",
+    "DefaultTokenProvider",
+    "ServiceClient",
+    "build_multipart",
+    "new_uuid",
+    "prune",
+]

kobil_core-1.2.0/kobil/core/client.py

@@ -0,0 +1,93 @@
+"""HTTP base for typed KOBIL service clients."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+import uuid
+from typing import Any, Dict, Mapping, Optional
+
+from .error import KobilError
+from .token import TokenProvider
+
+
+def new_uuid() -> str:
+    return str(uuid.uuid4())
+
+
+def prune(data: Mapping[str, Any]) -> Dict[str, Any]:
+    """Removes keys whose value is None so optional fields are omitted."""
+    return {k: v for k, v in data.items() if v is not None}
+
+
+def build_multipart(fields: Mapping[str, str], files: Mapping[str, Mapping[str, Any]]) -> "tuple[str, bytes]":
+    """Builds a multipart/form-data body. Returns (content_type, body_bytes)."""
+    boundary = "----KobilBoundary" + uuid.uuid4().hex
+    eol = b"\r\n"
+    body = bytearray()
+
+    for name, value in fields.items():
+        body += b"--" + boundary.encode() + eol
+        body += f'Content-Disposition: form-data; name="{name}"'.encode() + eol + eol
+        body += str(value).encode() + eol
+
+    for name, file in files.items():
+        filename = file.get("filename", "file")
+        content_type = file.get("content_type", "application/octet-stream")
+        content = file["content"]
+        if isinstance(content, str):
+            content = content.encode()
+        body += b"--" + boundary.encode() + eol
+        body += f'Content-Disposition: form-data; name="{name}"; filename="{filename}"'.encode() + eol
+        body += f"Content-Type: {content_type}".encode() + eol + eol
+        body += content + eol
+
+    body += b"--" + boundary.encode() + b"--" + eol
+    return f"multipart/form-data; boundary={boundary}", bytes(body)
+
+
+class ServiceClient:
+    """Base client: attaches the bearer token, sends the request, wraps failures."""
+
+    def __init__(self, tokens: TokenProvider) -> None:
+        self._tokens = tokens
+
+    def _make_error(self, message: str, status_code: Optional[int] = None,
+                    response_body: Optional[str] = None, cause: Optional[BaseException] = None) -> KobilError:
+        return KobilError(message, status_code, response_body, cause)
+
+    def send_json(self, method: str, url: str, body: Optional[Mapping[str, Any]] = None) -> Dict[str, Any]:
+        headers = {"Accept": "application/json"}
+        data = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(prune(body), ensure_ascii=False).encode()
+        raw = self._request(method, url, headers, data)
+        return json.loads(raw) if raw else {}
+
+    def send_multipart(self, method: str, url: str, fields: Mapping[str, str],
+                       files: Mapping[str, Mapping[str, Any]]) -> Dict[str, Any]:
+        content_type, data = build_multipart(fields, files)
+        headers = {"Accept": "application/json", "Content-Type": content_type}
+        raw = self._request(method, url, headers, data)
+        return json.loads(raw) if raw else {}
+
+    def send_for_bytes(self, method: str, url: str) -> bytes:
+        return self._request(method, url, {"Accept": "application/octet-stream"}, None, decode=False)
+
+    def _request(self, method: str, url: str, headers: Mapping[str, str],
+                 data: Optional[bytes], decode: bool = True):
+        merged = {**headers, "Authorization": f"Bearer {self._tokens.get_token()}"}
+        request = urllib.request.Request(url, data=data, method=method, headers=merged)
+        try:
+            with urllib.request.urlopen(request) as response:
+                raw = response.read()
+        except urllib.error.HTTPError as exc:
+            error_body = exc.read().decode(errors="replace")
+            raise self._make_error(
+                f"KOBIL API returned {exc.code} for {method} {url}.", exc.code, error_body
+            ) from exc
+        except Exception as exc:  # noqa: BLE001 - wrap transport errors
+            raise self._make_error(f"An error occurred while calling {method} {url}.", cause=exc) from exc
+        return raw if not decode else raw.decode()

kobil_core-1.2.0/kobil/core/credentials.py

@@ -0,0 +1,41 @@
+"""Shared OAuth2 credentials for the KOBIL SDK family."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class Credentials:
+    """OAuth2 credentials shared by every KOBIL SDK module."""
+
+    token_endpoint: str = ""
+    client_id: str = ""
+    client_secret: str = ""
+    token_auth_mode: str = "post"  # "post" or "basic"
+    default_token_ttl_seconds: int = 280
+    token_expiry_skew_seconds: int = 20
+
+
+def credentials_from_env(**overrides: Any) -> Credentials:
+    """Build credentials, falling back to KOBIL_* environment variables."""
+
+    def pick(key: str, env: str) -> str:
+        value = overrides.get(key)
+        if isinstance(value, str) and value:
+            return value
+        return os.environ.get(env, "")
+
+    raw_mode = overrides.get("token_auth_mode") or os.environ.get("KOBIL_TOKEN_AUTH_MODE") or "post"
+    mode = "basic" if str(raw_mode).lower() in ("basic", "client_secret_basic") else "post"
+
+    return Credentials(
+        token_endpoint=pick("token_endpoint", "KOBIL_TOKEN_ENDPOINT"),
+        client_id=pick("client_id", "KOBIL_CLIENT_ID"),
+        client_secret=pick("client_secret", "KOBIL_CLIENT_SECRET"),
+        token_auth_mode=mode,
+        default_token_ttl_seconds=int(overrides.get("default_token_ttl_seconds") or 280),
+        token_expiry_skew_seconds=int(overrides.get("token_expiry_skew_seconds") or 20),
+    )

kobil_core-1.2.0/kobil/core/error.py

@@ -0,0 +1,26 @@
+"""Base exception for the KOBIL SDK family."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+class KobilError(Exception):
+    """Base exception for all KOBIL SDK modules.
+
+    Module-specific exceptions (KobilPaymentError, KobilChatError, …) extend this,
+    so callers can catch ``KobilError`` to handle any KOBIL failure uniformly.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response_body: Optional[str] = None,
+        cause: Optional[BaseException] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_body = response_body
+        if cause is not None:
+            self.__cause__ = cause

kobil_core-1.2.0/kobil/core/token.py

@@ -0,0 +1,73 @@
+"""OAuth2 token acquisition and caching."""
+
+from __future__ import annotations
+
+import base64
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from .credentials import Credentials
+from .error import KobilError
+
+
+class TokenProvider:
+    """Provides (and caches) OAuth2 access tokens shared across modules."""
+
+    def get_token(self) -> str:  # pragma: no cover - interface
+        raise NotImplementedError
+
+
+class DefaultTokenProvider(TokenProvider):
+    """Acquires tokens via the client_credentials grant (post or basic) and caches them."""
+
+    def __init__(self, credentials: Credentials) -> None:
+        self._c = credentials
+        self._token: str = ""
+        self._expires_at: float = 0.0
+
+    def get_token(self) -> str:
+        if self._token and time.time() < self._expires_at:
+            return self._token
+
+        c = self._c
+        if not c.token_endpoint:
+            raise KobilError("credentials.token_endpoint is required.")
+        if not c.client_id:
+            raise KobilError("credentials.client_id is required.")
+        if not c.client_secret:
+            raise KobilError("credentials.client_secret is required.")
+
+        fields = {"grant_type": "client_credentials"}
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        if c.token_auth_mode == "basic":
+            basic = base64.b64encode(f"{c.client_id}:{c.client_secret}".encode()).decode()
+            headers["Authorization"] = f"Basic {basic}"
+        else:
+            fields["client_id"] = c.client_id
+            fields["client_secret"] = c.client_secret
+
+        data = urllib.parse.urlencode(fields).encode()
+        request = urllib.request.Request(c.token_endpoint, data=data, method="POST", headers=headers)
+
+        try:
+            with urllib.request.urlopen(request) as response:
+                body = response.read().decode()
+        except urllib.error.HTTPError as exc:
+            error_body = exc.read().decode(errors="replace")
+            raise KobilError(f"Token endpoint returned {exc.code}.", exc.code, error_body) from exc
+        except Exception as exc:  # noqa: BLE001 - wrap transport errors
+            raise KobilError("An error occurred while acquiring an access token.", cause=exc) from exc
+
+        parsed = json.loads(body)
+        token = parsed.get("access_token")
+        if not token:
+            raise KobilError("Token endpoint response did not contain an access_token.", None, body)
+
+        expires_in = parsed.get("expires_in") or c.default_token_ttl_seconds
+        ttl = max(1, int(expires_in) - c.token_expiry_skew_seconds)
+        self._token = token
+        self._expires_at = time.time() + ttl
+        return token

kobil_core-1.2.0/kobil_core.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: kobil-core
+Version: 1.2.0
+Summary: Shared foundation for the KOBIL SDK family: OAuth token acquisition/caching and an HTTP base for typed clients.
+License: MIT
+Project-URL: Repository, https://github.com/uveysservetoglu/kobil-sdks
+Keywords: kobil,sdk,oauth2,core
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# kobil-core
+
+Shared foundation for the KOBIL SDK family (`kobil-payment`, `kobil-chat`, `kobil-sign`, …).
+
+You normally don't use this directly — the module packages depend on it. Provides:
+
+- **`DefaultTokenProvider`** — OAuth2 `client_credentials` token acquisition with in-memory
+  caching (honours `expires_in`). Modes: `post` (form body, default) or `basic`.
+- **`KobilError`** — base exception all module exceptions extend (`status_code`, `response_body`).
+- **`ServiceClient`** — HTTP base for typed clients (bearer + send + error wrapping; JSON,
+  multipart, and binary-download helpers) built on the standard library (`urllib`).
+- **`credentials_from_env()`** — reads `KOBIL_TOKEN_ENDPOINT`, `KOBIL_CLIENT_ID`,
+  `KOBIL_CLIENT_SECRET`, `KOBIL_TOKEN_AUTH_MODE`.
+
+Pure standard library — no third-party dependencies. Python 3.8+.
+
+## License
+
+MIT

kobil_core-1.2.0/kobil_core.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+kobil/core/__init__.py
+kobil/core/client.py
+kobil/core/credentials.py
+kobil/core/error.py
+kobil/core/token.py
+kobil_core.egg-info/PKG-INFO
+kobil_core.egg-info/SOURCES.txt
+kobil_core.egg-info/dependency_links.txt
+kobil_core.egg-info/top_level.txt

kobil_core-1.2.0/kobil_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kobil_core-1.2.0/kobil_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+kobil

kobil_core-1.2.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kobil-core"
+version = "1.2.0"
+description = "Shared foundation for the KOBIL SDK family: OAuth token acquisition/caching and an HTTP base for typed clients."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = ["kobil", "sdk", "oauth2", "core"]
+
+[project.urls]
+Repository = "https://github.com/uveysservetoglu/kobil-sdks"
+
+[tool.setuptools.packages.find]
+include = ["kobil*"]
+namespaces = true

kobil_core-1.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+