fittins 1.0.0__tar.gz

fittins-1.0.0/LICENSE

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

fittins-1.0.0/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: fittins
+Version: 1.0.0
+Summary: Official Python library for the Fittins AI API: premium AI fashion photos and videos from your product photos.
+Author-email: Fittins AI <support@fittins.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://fittins.ai
+Project-URL: Documentation, https://fittins.ai/docs/api
+Project-URL: Support, https://fittins.ai/support
+Keywords: fittins,ai,fashion,on-model,virtual-try-on,product-photos,fashion-video,api,sdk
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Fittins AI for Python
+
+The official library for the [Fittins AI API](https://fittins.ai/docs/api). Fittins AI is a premium AI fashion generation service: studio-quality on-model photos up to 8K and fashion videos up to 4K, made from your product photos.
+
+The API is included in the Pro, Business and Enterprise plans and uses the same credits as the website. Create a key in **Profile → API keys** on [fittins.ai](https://fittins.ai).
+
+```bash
+pip install fittins
+```
+
+Needs Python 3.10 or later, and has no dependencies. Use it on your server: never put an API key in a web page or an app.
+
+## Create a photo
+
+```python
+from fittins import Fittins
+
+fittins = Fittins()  # reads FITTINS_API_KEY
+
+generation = fittins.images.create(
+    product_images=[{"url": "https://cdn.mystore.com/p/dress.jpg"}],
+    model_id="mdl_lib_DM5rQvl3KtlR7nqumd6I",
+    prompt="full body, soft studio light, front view",
+    aspect_ratio="3:4",
+    quality="4k",
+    metadata={"sku": "DRESS-RED-M"},
+)
+
+done = fittins.generations.wait(generation["id"])
+
+if done["status"] == "succeeded":
+    print(done["output"]["url"])  # a download link, valid for 24 hours
+else:
+    print(done["error"]["code"], done["error"]["message"])
+```
+
+## What's included
+
+| | |
+|---|---|
+| `images.create` · `videos.create` | Start a photo or a video |
+| `generations.get` · `list` · `list_all` · `wait` · `delete` | Follow, list and delete results |
+| `uploads.create` | Upload a product photo (a path, bytes or an open file) |
+| `files.download` | Get a result's bytes |
+| `models` · `locations` | `list`, `get`, and `create` a custom one |
+| `webhook_endpoints` | `create`, `list`, `delete`, `rotate_secret` |
+| `usage.get` · `account.get` | Calls and credits per day, and plan and balance |
+
+Answers are plain dictionaries, with type hints in `fittins.types`. Field names are the same as in the [API reference](https://fittins.ai/docs/api).
+
+## Retries and safe creates
+
+Failed requests are sent up to 2 more times, with a growing pause. After a 429, the library waits for the time in `Retry-After`.
+
+Each create gets an `Idempotency-Key` that its retries reuse, so a retry can't charge twice. To protect against your own job running twice, pass a key you can repeat:
+
+```python
+fittins.images.create(idempotency_key=f"photo-{sku}", **params)
+```
+
+Uploads, webhook endpoint changes and deletes are only retried after a 429, because sending them twice could do the work twice.
+
+Set your own limits with `Fittins(max_retries=4, timeout=60.0)`.
+
+## Errors
+
+```python
+from fittins import APIError
+
+try:
+    fittins.images.create(**params)
+except APIError as error:
+    if error.code == "insufficient_credits":
+        ...  # error.status, error.code, error.message, error.param, error.request_id
+    else:
+        raise
+```
+
+`APIConnectionError` means no answer arrived. `WaitTimeoutError` means `generations.wait` ran out of time; the generation may still finish. A generation that fails after being accepted isn't raised: check `status` and `error`.
+
+## Webhooks
+
+```python
+import os
+
+from flask import Flask, request
+from fittins import WebhookVerificationError, verify_webhook
+
+app = Flask(__name__)
+
+@app.post("/webhooks/fittins")
+def fittins_webhook():
+    try:
+        event = verify_webhook(
+            request.get_data(),
+            request.headers.get("Fittins-Signature"),
+            os.environ["FITTINS_WEBHOOK_SECRET"],
+        )
+    except WebhookVerificationError:
+        return "", 400
+    if event["type"] == "generation.succeeded":
+        print(event["data"]["object"]["output"]["url"])
+    return "", 200
+```
+
+Pass the body exactly as received, before any JSON parsing.
+
+## Testing without credits
+
+Keys that start with `fit_test_` run the checks on your request and return a sample result, without using the AI or any credits.
+
+## More
+
+[API documentation](https://fittins.ai/docs/api) · [Support](https://fittins.ai/support)

fittins-1.0.0/README.md

@@ -0,0 +1,114 @@
+# Fittins AI for Python
+
+The official library for the [Fittins AI API](https://fittins.ai/docs/api). Fittins AI is a premium AI fashion generation service: studio-quality on-model photos up to 8K and fashion videos up to 4K, made from your product photos.
+
+The API is included in the Pro, Business and Enterprise plans and uses the same credits as the website. Create a key in **Profile → API keys** on [fittins.ai](https://fittins.ai).
+
+```bash
+pip install fittins
+```
+
+Needs Python 3.10 or later, and has no dependencies. Use it on your server: never put an API key in a web page or an app.
+
+## Create a photo
+
+```python
+from fittins import Fittins
+
+fittins = Fittins()  # reads FITTINS_API_KEY
+
+generation = fittins.images.create(
+    product_images=[{"url": "https://cdn.mystore.com/p/dress.jpg"}],
+    model_id="mdl_lib_DM5rQvl3KtlR7nqumd6I",
+    prompt="full body, soft studio light, front view",
+    aspect_ratio="3:4",
+    quality="4k",
+    metadata={"sku": "DRESS-RED-M"},
+)
+
+done = fittins.generations.wait(generation["id"])
+
+if done["status"] == "succeeded":
+    print(done["output"]["url"])  # a download link, valid for 24 hours
+else:
+    print(done["error"]["code"], done["error"]["message"])
+```
+
+## What's included
+
+| | |
+|---|---|
+| `images.create` · `videos.create` | Start a photo or a video |
+| `generations.get` · `list` · `list_all` · `wait` · `delete` | Follow, list and delete results |
+| `uploads.create` | Upload a product photo (a path, bytes or an open file) |
+| `files.download` | Get a result's bytes |
+| `models` · `locations` | `list`, `get`, and `create` a custom one |
+| `webhook_endpoints` | `create`, `list`, `delete`, `rotate_secret` |
+| `usage.get` · `account.get` | Calls and credits per day, and plan and balance |
+
+Answers are plain dictionaries, with type hints in `fittins.types`. Field names are the same as in the [API reference](https://fittins.ai/docs/api).
+
+## Retries and safe creates
+
+Failed requests are sent up to 2 more times, with a growing pause. After a 429, the library waits for the time in `Retry-After`.
+
+Each create gets an `Idempotency-Key` that its retries reuse, so a retry can't charge twice. To protect against your own job running twice, pass a key you can repeat:
+
+```python
+fittins.images.create(idempotency_key=f"photo-{sku}", **params)
+```
+
+Uploads, webhook endpoint changes and deletes are only retried after a 429, because sending them twice could do the work twice.
+
+Set your own limits with `Fittins(max_retries=4, timeout=60.0)`.
+
+## Errors
+
+```python
+from fittins import APIError
+
+try:
+    fittins.images.create(**params)
+except APIError as error:
+    if error.code == "insufficient_credits":
+        ...  # error.status, error.code, error.message, error.param, error.request_id
+    else:
+        raise
+```
+
+`APIConnectionError` means no answer arrived. `WaitTimeoutError` means `generations.wait` ran out of time; the generation may still finish. A generation that fails after being accepted isn't raised: check `status` and `error`.
+
+## Webhooks
+
+```python
+import os
+
+from flask import Flask, request
+from fittins import WebhookVerificationError, verify_webhook
+
+app = Flask(__name__)
+
+@app.post("/webhooks/fittins")
+def fittins_webhook():
+    try:
+        event = verify_webhook(
+            request.get_data(),
+            request.headers.get("Fittins-Signature"),
+            os.environ["FITTINS_WEBHOOK_SECRET"],
+        )
+    except WebhookVerificationError:
+        return "", 400
+    if event["type"] == "generation.succeeded":
+        print(event["data"]["object"]["output"]["url"])
+    return "", 200
+```
+
+Pass the body exactly as received, before any JSON parsing.
+
+## Testing without credits
+
+Keys that start with `fit_test_` run the checks on your request and return a sample result, without using the AI or any credits.
+
+## More
+
+[API documentation](https://fittins.ai/docs/api) · [Support](https://fittins.ai/support)

fittins-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fittins"
+dynamic = ["version"]
+description = "Official Python library for the Fittins AI API: premium AI fashion photos and videos from your product photos."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Fittins AI", email = "support@fittins.ai" }]
+keywords = ["fittins", "ai", "fashion", "on-model", "virtual-try-on", "product-photos", "fashion-video", "api", "sdk"]
+classifiers = [
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://fittins.ai"
+Documentation = "https://fittins.ai/docs/api"
+Support = "https://fittins.ai/support"
+
+[tool.setuptools.dynamic]
+version = { attr = "fittins._version.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+fittins = ["py.typed"]

fittins-1.0.0/setup.cfg

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

fittins-1.0.0/src/fittins/__init__.py

@@ -0,0 +1,19 @@
+"""Official Python library for the Fittins AI API."""
+
+from . import types
+from ._client import Fittins
+from ._version import __version__
+from .errors import APIConnectionError, APIError, FittinsError, WaitTimeoutError, WebhookVerificationError
+from .webhooks import verify_webhook
+
+__all__ = [
+    "APIConnectionError",
+    "APIError",
+    "Fittins",
+    "FittinsError",
+    "WaitTimeoutError",
+    "WebhookVerificationError",
+    "__version__",
+    "types",
+    "verify_webhook",
+]

fittins-1.0.0/src/fittins/_client.py

@@ -0,0 +1,352 @@
+from __future__ import annotations
+
+import http.client
+import json
+import os
+import random
+import ssl
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import TYPE_CHECKING, Any, BinaryIO, Callable, Dict, Iterator, List, Mapping, Optional, Tuple, TypedDict, Union
+
+from ._version import __version__
+from .errors import APIConnectionError, APIError, FittinsError, WaitTimeoutError, parse_api_error
+from .types import (
+    Account,
+    CreateImageParams,
+    CreateLocationParams,
+    CreateModelParams,
+    CreateVideoParams,
+    Deleted,
+    Generation,
+    GenerationStatus,
+    GenerationType,
+    Location,
+    Model,
+    Upload,
+    Usage,
+    WebhookEndpoint,
+    WebhookEventType,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal, Unpack
+
+DEFAULT_BASE_URL = "https://api.fittins.ai/v1"
+DEFAULT_TIMEOUT = 120.0
+DEFAULT_MAX_RETRIES = 2
+DEFAULT_WAIT_TIMEOUT = 20 * 60.0
+DEFAULT_WAIT_INTERVAL = 5.0
+# A longer Retry-After than this goes back to the caller instead of being waited out.
+MAX_RETRY_AFTER_SECONDS = 60.0
+RETRY_BASE = 0.5
+RETRY_MAX = 8.0
+TRANSIENT_STATUS = {500, 502, 503, 504}
+FINISHED = {"succeeded", "failed", "canceled"}
+NETWORK_ERRORS = (urllib.error.URLError, http.client.HTTPException, ConnectionError, TimeoutError, ssl.SSLError, OSError)
+
+FileInput = Union[str, "os.PathLike[str]", bytes, bytearray, BinaryIO]
+
+
+class ListResponse(TypedDict):
+    object: str
+    data: List[Any]
+    has_more: bool
+    next_cursor: Optional[str]
+
+
+def _backoff(attempt: int) -> float:
+    ceiling = min(RETRY_MAX, RETRY_BASE * 2**attempt)
+    return ceiling / 2 + random.random() * (ceiling / 2)
+
+
+def _retry_delay(error: APIError, repeatable: bool, attempt: int) -> Optional[float]:
+    if error.status != 429 and not (repeatable and error.status in TRANSIENT_STATUS):
+        return None
+    if error.retry_after is None:
+        return _backoff(attempt)
+    return None if error.retry_after > MAX_RETRY_AFTER_SECONDS else error.retry_after
+
+
+def _segment(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+def _multipart(filename: str, content: bytes, content_type: str) -> Tuple[bytes, str]:
+    boundary = uuid.uuid4().hex
+    safe_name = filename.replace("\\", "_").replace('"', "_").replace("\r", "_").replace("\n", "_")
+    head = (
+        f"--{boundary}\r\n"
+        f'Content-Disposition: form-data; name="file"; filename="{safe_name}"\r\n'
+        f"Content-Type: {content_type}\r\n\r\n"
+    ).encode("utf-8")
+    return head + content + f"\r\n--{boundary}--\r\n".encode("ascii"), f"multipart/form-data; boundary={boundary}"
+
+
+def _read_file(file: FileInput, filename: Optional[str]) -> Tuple[bytes, str]:
+    if isinstance(file, (bytes, bytearray)):
+        return bytes(file), filename or "product"
+    if isinstance(file, (str, os.PathLike)):
+        with open(file, "rb") as handle:
+            return handle.read(), filename or os.path.basename(os.fspath(file))
+    name = getattr(file, "name", None)
+    return file.read(), filename or (os.path.basename(name) if isinstance(name, str) else "product")
+
+
+class _Images:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def create(self, *, idempotency_key: Optional[str] = None, **params: "Unpack[CreateImageParams]") -> Generation:
+        """Create an on-model photo. Answers at once with a queued generation."""
+        return self._client._create("/images", params, idempotency_key)
+
+
+class _Videos:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def create(self, *, idempotency_key: Optional[str] = None, **params: "Unpack[CreateVideoParams]") -> Generation:
+        """Create a fashion video. Answers at once with a queued generation."""
+        return self._client._create("/videos", params, idempotency_key)
+
+
+class _Generations:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        status: Optional[GenerationStatus] = None,
+        type: Optional[GenerationType] = None,
+        limit: Optional[int] = None,
+        cursor: Optional[str] = None,
+    ) -> ListResponse:
+        query = {"status": status, "type": type, "limit": limit, "cursor": cursor}
+        return self._client._json("GET", "/generations", query=query, repeatable=True)
+
+    def list_all(
+        self,
+        *,
+        status: Optional[GenerationStatus] = None,
+        type: Optional[GenerationType] = None,
+        limit: Optional[int] = None,
+    ) -> Iterator[Generation]:
+        """Every generation matching the filters, across pages, newest first."""
+        cursor: Optional[str] = None
+        while True:
+            page = self.list(status=status, type=type, limit=limit, cursor=cursor)
+            yield from page["data"]
+            if not page["has_more"] or not page["next_cursor"]:
+                return
+            cursor = page["next_cursor"]
+
+    def get(self, id: str) -> Generation:
+        return self._client._json("GET", f"/generations/{_segment(id)}", repeatable=True)
+
+    def delete(self, id: str) -> Union[Generation, Deleted]:
+        """Cancel a queued generation, or delete a finished one with its files."""
+        return self._client._json("DELETE", f"/generations/{_segment(id)}")
+
+    def wait(self, id: str, *, timeout: float = DEFAULT_WAIT_TIMEOUT, interval: float = DEFAULT_WAIT_INTERVAL) -> Generation:
+        """Checks until the generation succeeded, failed or was canceled, and returns it."""
+        deadline = time.monotonic() + timeout
+        while True:
+            generation = self.get(id)
+            if generation["status"] in FINISHED:
+                return generation
+            left = deadline - time.monotonic()
+            if left <= 0:
+                raise WaitTimeoutError(id, generation["status"], timeout)
+            self._client._sleep(min(interval, left))
+
+
+class _Uploads:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def create(self, file: FileInput, *, filename: Optional[str] = None, content_type: str = "application/octet-stream") -> Upload:
+        """Upload a product photo: a path, bytes or an open file. PNG, JPEG, WebP or HEIC, up to 10 MB."""
+        content, name = _read_file(file, filename)
+        body, header = _multipart(name, content, content_type)
+        return self._client._json("POST", "/uploads", raw=body, content_type=header)
+
+
+class _Files:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def download(self, file_id: str) -> bytes:
+        """The full-quality file: a PNG or an MP4."""
+        return self._client._send("GET", f"/files/{_segment(file_id)}/content", repeatable=True)
+
+
+class _Models:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def list(self, *, source: "Optional[Literal['library', 'custom']]" = None) -> ListResponse:
+        return self._client._json("GET", "/models", query={"source": source}, repeatable=True)
+
+    def get(self, id: str) -> Model:
+        return self._client._json("GET", f"/models/{_segment(id)}", repeatable=True)
+
+    def create(self, *, idempotency_key: Optional[str] = None, **params: "Unpack[CreateModelParams]") -> Generation:
+        """Create a custom model from a description or a reference photo."""
+        return self._client._create("/models", params, idempotency_key)
+
+
+class _Locations:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def list(self, *, source: "Optional[Literal['library', 'custom']]" = None) -> ListResponse:
+        return self._client._json("GET", "/locations", query={"source": source}, repeatable=True)
+
+    def get(self, id: str) -> Location:
+        return self._client._json("GET", f"/locations/{_segment(id)}", repeatable=True)
+
+    def create(self, *, idempotency_key: Optional[str] = None, **params: "Unpack[CreateLocationParams]") -> Generation:
+        """Create a custom location from a description or a reference photo."""
+        return self._client._create("/locations", params, idempotency_key)
+
+
+class _WebhookEndpoints:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def create(self, *, url: str, events: Optional[List[WebhookEventType]] = None) -> WebhookEndpoint:
+        """The answer holds the signing secret, shown only once."""
+        body: Dict[str, Any] = {"url": url}
+        if events is not None:
+            body["events"] = events
+        return self._client._json("POST", "/webhook_endpoints", body=body)
+
+    def list(self) -> ListResponse:
+        return self._client._json("GET", "/webhook_endpoints", repeatable=True)
+
+    def delete(self, id: str) -> Deleted:
+        return self._client._json("DELETE", f"/webhook_endpoints/{_segment(id)}")
+
+    def rotate_secret(self, id: str) -> WebhookEndpoint:
+        """The answer holds the new secret, shown only once. The old one keeps signing for 24 hours."""
+        return self._client._json("POST", f"/webhook_endpoints/{_segment(id)}/rotate_secret")
+
+
+class _Usage:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def get(self, *, from_: Optional[str] = None, to: Optional[str] = None) -> Usage:
+        """Dates are YYYY-MM-DD."""
+        return self._client._json("GET", "/usage", query={"from": from_, "to": to}, repeatable=True)
+
+
+class _Account:
+    def __init__(self, client: "Fittins") -> None:
+        self._client = client
+
+    def get(self) -> Account:
+        return self._client._json("GET", "/account", repeatable=True)
+
+
+class Fittins:
+    """Client for the Fittins AI API. ``api_key`` defaults to FITTINS_API_KEY."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        key = api_key or os.environ.get("FITTINS_API_KEY")
+        if not key:
+            raise FittinsError("Missing API key. Pass api_key or set FITTINS_API_KEY. Keys are in Profile → API keys on fittins.ai.")
+        self.__api_key = key
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._timeout = timeout
+        self._sleep: Callable[[float], None] = time.sleep
+
+        self.images = _Images(self)
+        self.videos = _Videos(self)
+        self.generations = _Generations(self)
+        self.uploads = _Uploads(self)
+        self.files = _Files(self)
+        self.models = _Models(self)
+        self.locations = _Locations(self)
+        self.webhook_endpoints = _WebhookEndpoints(self)
+        self.usage = _Usage(self)
+        self.account = _Account(self)
+
+    def __repr__(self) -> str:
+        return f"Fittins(base_url={self._base_url!r})"
+
+    def _create(self, path: str, params: Mapping[str, Any], idempotency_key: Optional[str]) -> Any:
+        return self._json("POST", path, body=dict(params), idempotency_key=idempotency_key or str(uuid.uuid4()), repeatable=True)
+
+    def _json(self, method: str, path: str, **call: Any) -> Any:
+        return json.loads(self._send(method, path, **call).decode("utf-8"))
+
+    def _attempt(self, request: urllib.request.Request) -> Tuple[int, Mapping[str, str], bytes]:
+        try:
+            with urllib.request.urlopen(request, timeout=self._timeout) as response:
+                return response.status, response.headers, response.read()
+        except urllib.error.HTTPError as error:
+            with error:
+                return error.code, error.headers, error.read()
+
+    def _send(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Mapping[str, Any]] = None,
+        body: Any = None,
+        raw: Optional[bytes] = None,
+        content_type: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+        repeatable: bool = False,
+    ) -> bytes:
+        url = f"{self._base_url}{path}"
+        pairs = [(name, value) for name, value in (query or {}).items() if value is not None]
+        if pairs:
+            url = f"{url}?{urllib.parse.urlencode(pairs)}"
+
+        headers = {"Authorization": f"Bearer {self.__api_key}", "User-Agent": f"fittins-python/{__version__}"}
+        data = raw
+        if body is not None:
+            data = json.dumps(body, ensure_ascii=False).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+        elif content_type is not None:
+            headers["Content-Type"] = content_type
+        if idempotency_key is not None:
+            headers["Idempotency-Key"] = idempotency_key
+
+        attempt = 0
+        while True:
+            request = urllib.request.Request(url, data=data, headers=headers, method=method)
+            try:
+                status, response_headers, content = self._attempt(request)
+            except NETWORK_ERRORS as error:
+                if repeatable and attempt < self._max_retries:
+                    self._sleep(_backoff(attempt))
+                    attempt += 1
+                    continue
+                raise APIConnectionError(f"No answer from the Fittins API for {method} {path}.") from error
+
+            if 200 <= status < 300:
+                return content
+
+            api_error = parse_api_error(status, response_headers, content)
+            delay = _retry_delay(api_error, repeatable, attempt)
+            if delay is None or attempt >= self._max_retries:
+                raise api_error
+            self._sleep(delay)
+            attempt += 1

fittins-1.0.0/src/fittins/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"