flatmark 1.0.0__py3-none-any.whl

flatmark/models/problem.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.problem_errors_type_0_item import ProblemErrorsType0Item
+
+
+T = TypeVar("T", bound="Problem")
+
+
+@_attrs_define
+class Problem:
+    """The RFC 9457 error body. Every error response uses it.
+
+    Attributes:
+        title (str): Short human-readable summary of the status.
+        status (int): The HTTP status code, repeated in the body.
+        detail (str): What went wrong with this request.
+        instance (str): The request path that produced the error.
+        code (str): Stable machine-readable error code. Branch on this, not on the text.
+        type_ (str | Unset): Problem type URI (RFC 9457). Default: 'about:blank'.
+        request_id (None | str | Unset): Correlation id for this request; quote it when asking for support.
+        errors (list[ProblemErrorsType0Item] | None | Unset): Per-field validation failures. Present on 422 only.
+        upgrade_url (None | str | Unset): Where to add credits or move to a larger plan. Present on 402/403/429.
+    """
+
+    title: str
+    status: int
+    detail: str
+    instance: str
+    code: str
+    type_: str | Unset = "about:blank"
+    request_id: None | str | Unset = UNSET
+    errors: list[ProblemErrorsType0Item] | None | Unset = UNSET
+    upgrade_url: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        title = self.title
+
+        status = self.status
+
+        detail = self.detail
+
+        instance = self.instance
+
+        code = self.code
+
+        type_ = self.type_
+
+        request_id: None | str | Unset
+        if isinstance(self.request_id, Unset):
+            request_id = UNSET
+        else:
+            request_id = self.request_id
+
+        errors: list[dict[str, Any]] | None | Unset
+        if isinstance(self.errors, Unset):
+            errors = UNSET
+        elif isinstance(self.errors, list):
+            errors = []
+            for errors_type_0_item_data in self.errors:
+                errors_type_0_item = errors_type_0_item_data.to_dict()
+                errors.append(errors_type_0_item)
+
+        else:
+            errors = self.errors
+
+        upgrade_url: None | str | Unset
+        if isinstance(self.upgrade_url, Unset):
+            upgrade_url = UNSET
+        else:
+            upgrade_url = self.upgrade_url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "title": title,
+                "status": status,
+                "detail": detail,
+                "instance": instance,
+                "code": code,
+            }
+        )
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if request_id is not UNSET:
+            field_dict["request_id"] = request_id
+        if errors is not UNSET:
+            field_dict["errors"] = errors
+        if upgrade_url is not UNSET:
+            field_dict["upgrade_url"] = upgrade_url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.problem_errors_type_0_item import ProblemErrorsType0Item  # noqa: PLC0415
+
+        d = dict(src_dict)
+        title = d.pop("title")
+
+        status = d.pop("status")
+
+        detail = d.pop("detail")
+
+        instance = d.pop("instance")
+
+        code = d.pop("code")
+
+        type_ = d.pop("type", UNSET)
+
+        def _parse_request_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        request_id = _parse_request_id(d.pop("request_id", UNSET))
+
+        def _parse_errors(data: object) -> list[ProblemErrorsType0Item] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                errors_type_0 = []
+                _errors_type_0 = data
+                for errors_type_0_item_data in _errors_type_0:
+                    errors_type_0_item = ProblemErrorsType0Item.from_dict(errors_type_0_item_data)
+
+                    errors_type_0.append(errors_type_0_item)
+
+                return errors_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[ProblemErrorsType0Item] | None | Unset, data)
+
+        errors = _parse_errors(d.pop("errors", UNSET))
+
+        def _parse_upgrade_url(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        upgrade_url = _parse_upgrade_url(d.pop("upgrade_url", UNSET))
+
+        problem = cls(
+            title=title,
+            status=status,
+            detail=detail,
+            instance=instance,
+            code=code,
+            type_=type_,
+            request_id=request_id,
+            errors=errors,
+            upgrade_url=upgrade_url,
+        )
+
+        problem.additional_properties = d
+        return problem
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

flatmark/models/problem_errors_type_0_item.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ProblemErrorsType0Item")
+
+
+@_attrs_define
+class ProblemErrorsType0Item:
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        problem_errors_type_0_item = cls()
+
+        problem_errors_type_0_item.additional_properties = d
+        return problem_errors_type_0_item
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

flatmark/models/rate_limit_info.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="RateLimitInfo")
+
+
+@_attrs_define
+class RateLimitInfo:
+    """How many requests you may still make in the current window. These are the
+    same numbers as the `X-RateLimit-*` response headers. `limit` is the size of the
+    window, `remaining` what is left of it, and `reset` how many seconds until
+    it refills (not a timestamp). All three are `null` in the rare case the
+    counter cannot be read; treat that as "unknown", not zero.
+
+        Attributes:
+            limit (int | None | Unset):
+            remaining (int | None | Unset):
+            reset (int | None | Unset):
+    """
+
+    limit: int | None | Unset = UNSET
+    remaining: int | None | Unset = UNSET
+    reset: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        limit: int | None | Unset
+        if isinstance(self.limit, Unset):
+            limit = UNSET
+        else:
+            limit = self.limit
+
+        remaining: int | None | Unset
+        if isinstance(self.remaining, Unset):
+            remaining = UNSET
+        else:
+            remaining = self.remaining
+
+        reset: int | None | Unset
+        if isinstance(self.reset, Unset):
+            reset = UNSET
+        else:
+            reset = self.reset
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if remaining is not UNSET:
+            field_dict["remaining"] = remaining
+        if reset is not UNSET:
+            field_dict["reset"] = reset
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_limit(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        limit = _parse_limit(d.pop("limit", UNSET))
+
+        def _parse_remaining(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        remaining = _parse_remaining(d.pop("remaining", UNSET))
+
+        def _parse_reset(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        reset = _parse_reset(d.pop("reset", UNSET))
+
+        rate_limit_info = cls(
+            limit=limit,
+            remaining=remaining,
+            reset=reset,
+        )
+
+        rate_limit_info.additional_properties = d
+        return rate_limit_info
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

flatmark/models/sync_convert_response.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.sync_convert_response_meta import SyncConvertResponseMeta
+
+
+T = TypeVar("T", bound="SyncConvertResponse")
+
+
+@_attrs_define
+class SyncConvertResponse:
+    """The result of a direct conversion.
+
+    Attributes:
+        markdown (str): The document as Markdown.
+        meta (SyncConvertResponseMeta | Unset): Details about the source: `filename`, and `title` when the document has
+            one.
+    """
+
+    markdown: str
+    meta: SyncConvertResponseMeta | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        markdown = self.markdown
+
+        meta: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.meta, Unset):
+            meta = self.meta.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "markdown": markdown,
+            }
+        )
+        if meta is not UNSET:
+            field_dict["meta"] = meta
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.sync_convert_response_meta import SyncConvertResponseMeta  # noqa: PLC0415
+
+        d = dict(src_dict)
+        markdown = d.pop("markdown")
+
+        _meta = d.pop("meta", UNSET)
+        meta: SyncConvertResponseMeta | Unset
+        if isinstance(_meta, Unset):
+            meta = UNSET
+        else:
+            meta = SyncConvertResponseMeta.from_dict(_meta)
+
+        sync_convert_response = cls(
+            markdown=markdown,
+            meta=meta,
+        )
+
+        sync_convert_response.additional_properties = d
+        return sync_convert_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

flatmark/models/sync_convert_response_meta.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="SyncConvertResponseMeta")
+
+
+@_attrs_define
+class SyncConvertResponseMeta:
+    """Details about the source: `filename`, and `title` when the document has one."""
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        sync_convert_response_meta = cls()
+
+        sync_convert_response_meta.additional_properties = d
+        return sync_convert_response_meta
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

flatmark/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

flatmark/types.py

@@ -0,0 +1,54 @@
+"""Contains some shared types for properties"""
+
+from collections.abc import Mapping, MutableMapping
+from http import HTTPStatus
+from typing import IO, BinaryIO, Generic, Literal, TypeVar
+
+from attrs import define
+
+
+class Unset:
+    def __bool__(self) -> Literal[False]:
+        return False
+
+
+UNSET: Unset = Unset()
+
+# The types that `httpx.Client(files=)` can accept, copied from that library.
+FileContent = IO[bytes] | bytes | str
+FileTypes = (
+    # (filename, file (or bytes), content_type)
+    tuple[str | None, FileContent, str | None]
+    # (filename, file (or bytes), content_type, headers)
+    | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
+RequestFiles = list[tuple[str, FileTypes]]
+
+
+@define
+class File:
+    """Contains information for file uploads"""
+
+    payload: BinaryIO
+    file_name: str | None = None
+    mime_type: str | None = None
+
+    def to_tuple(self) -> FileTypes:
+        """Return a tuple representation that httpx will accept for multipart/form-data"""
+        return self.file_name, self.payload, self.mime_type
+
+
+T = TypeVar("T")
+
+
+@define
+class Response(Generic[T]):
+    """A response from an endpoint"""
+
+    status_code: HTTPStatus
+    content: bytes
+    headers: MutableMapping[str, str]
+    parsed: T | None
+
+
+__all__ = ["UNSET", "File", "FileTypes", "RequestFiles", "Response", "Unset"]

flatmark-1.0.0.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.3
+Name: flatmark
+Version: 1.0.0
+Summary: A client library for accessing flatmark
+Requires-Dist: httpx>=0.23.1,<0.29.0
+Requires-Dist: attrs>=22.2.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# flatmark — Python SDK
+
+Document to Markdown API and MCP server for PDF, Word, PowerPoint, Excel and HTML. OCR queue for large files. Hosted in Germany.
+
+```sh
+pip install flatmark
+```
+
+[Get an API key](https://flatmark.dev/go/pypi-sdk?to=/app/api-keys) and pass it to the client:
+
+```python
+import os
+
+from flatmark import AuthenticatedClient
+from flatmark.api.account import get_me
+
+client = AuthenticatedClient(
+    base_url="https://api.flatmark.dev",
+    token=os.environ["FLATMARK_API_KEY"],
+    auth_header_name="X-API-Key",
+    prefix="",
+)
+print(get_me.sync(client=client))
+```
+
+Every operation is a module with `sync`, `sync_detailed`, `asyncio` and `asyncio_detailed`; file fields take a `flatmark.types.File(payload=..., file_name=..., mime_type=...)`.
+
+`submit_conversion_job` queues a job: poll `get_job` until its `status` is `succeeded` or `failed`, then fetch `get_conversion_result`.
+
+## Operations
+
+| Operation | Module | What it does |
+|---|---|---|
+| `GET /v1/me` | `flatmark.api.account.get_me` | Your plan, remaining requests, and remaining credits |
+| `GET /v1/jobs/{job_id}` | `flatmark.api.jobs.get_job` | Get one queued job by ID |
+| `GET /v1/jobs` | `flatmark.api.jobs.list_jobs` | List your queued jobs, newest first |
+| `POST /v1/convert` | `flatmark.api.convert.convert_document` | Convert a document to Markdown in one call |
+| `POST /v1/convert/jobs` | `flatmark.api.convert.submit_conversion_job` | Queue a document for conversion with OCR and tables |
+| `GET /v1/convert/jobs/{job_id}/result` | `flatmark.api.convert.get_conversion_result` | Download a queued job's Markdown or JSON |
+
+Generated with openapi-python-client from [`openapi.sdk.json`](../openapi.sdk.json). API reference: https://flatmark.dev/docs · Support: https://flatmark.dev/support

flatmark-1.0.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+flatmark/__init__.py,sha256=VBx6tksa3kON7SQ2NU2DOOX_8J7Bj5B_B-678ZJl8Zw,151
+flatmark/api/__init__.py,sha256=zTSiG_ujSjAqWPyc435YXaX9XTlpMjiJWBbV-f-YtdA,45
+flatmark/api/account/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
+flatmark/api/account/get_me.py,sha256=GN9Sw2c9RoiM0c_8sPGfo-NyYOjHK5CgpqCafIg6LBw,5563
+flatmark/api/convert/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
+flatmark/api/convert/convert_document.py,sha256=ITtuJHYT-uyakG7PGz6FOZ24QvI_7dX6pHg9q0swNIE,7607
+flatmark/api/convert/get_conversion_result.py,sha256=KAT7Qxj_9OGHPWwd7i-IGHCShA4thZNt1KWWWiWwgxI,7226
+flatmark/api/convert/submit_conversion_job.py,sha256=zydSD8oquAHKzRrFwbLYHEo_9Pe-zPpsZdEyYZ5ICA4,9587
+flatmark/api/jobs/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
+flatmark/api/jobs/get_job.py,sha256=L2YTXq7DacaBtHW-EJBSy4gmj3NI4ix0bC3x5w5rekM,4836
+flatmark/api/jobs/list_jobs.py,sha256=cEQy8Mir_Zb4-9wnknIg5avOxKF0WQ4YPDciYp-Jp3E,5739
+flatmark/client.py,sha256=fwU0xJF8ktG6_uvCFZh3I6Lqsmg3WKP89ODUdTunB1A,12306
+flatmark/errors.py,sha256=gO8GBmKqmSNgAg-E5oT-oOyxztvp7V_6XG7OUTT15q0,546
+flatmark/models/__init__.py,sha256=Sv3P-OTUK0e-60LmHo1LjCfi-egoU1IHIUeZxLoZjKo,1137
+flatmark/models/body_convert_document.py,sha256=J867ZqW5crdXhewkbrgT9wslzLNVi8MqUGp2lloW7_M,2001
+flatmark/models/body_submit_conversion_job.py,sha256=haTynh0pY5yU3epBR_v2LBb-VGKgt8pc8aAFhHHft-M,3163
+flatmark/models/credits_info.py,sha256=pz87wsrf0euu3fR-FkZij11VCt70KagsUWT26K0ZEU0,2667
+flatmark/models/get_conversion_result_format.py,sha256=e5XRCuYJo_cAXlVjYilgfBTXxo9dImJUDuOPU9w3-E0,175
+flatmark/models/job_response.py,sha256=akSZO1AYeix20gPxVXwvYKRBcbodnzzqErbrLV3Bb_g,7521
+flatmark/models/job_response_page.py,sha256=kFHOm5MkdLKSXPNeJTVt2oN-Bh_398syVkeL71cj1eY,2720
+flatmark/models/job_response_result_type_0.py,sha256=24Dba3re9lj1i5Q8rENNg34zIFvou8xBlvPWFSkK1gM,1288
+flatmark/models/job_submit_response.py,sha256=ovImvzbssUcNsOFCsRNiKsGi29RLmIuBIvFqIyi61ho,3142
+flatmark/models/me_response.py,sha256=-EQs-1Hsy5HA5zwRBXcwNPlKZckW6CIEofGorStF5qw,4494
+flatmark/models/problem.py,sha256=B65lZ3Qy9T54XPYqwVGGjuhGrvS6037H0SC7ZQNAxfA,6030
+flatmark/models/problem_errors_type_0_item.py,sha256=9VQ3QEopiHNaPf53p_IqChik798_mkZ-KasOf1U3bgc,1288
+flatmark/models/rate_limit_info.py,sha256=YSnjO1M9XjEhEwMlCpysfABaUL-oyA487v4zrVUm2-M,3633
+flatmark/models/sync_convert_response.py,sha256=jp2mqiLtA7J9skKI6Z78EVWuS_DlohADaVLy3Lu75tI,2488
+flatmark/models/sync_convert_response_meta.py,sha256=nVZxT3tixJl6KB8OD7YGxt9pIze5uM8JvzPDcMNfTPE,1378
+flatmark/py.typed,sha256=8ZJUsxZiuOy1oJeVhsTWQhTG_6pTVHVXk5hJL79ebTk,25
+flatmark/types.py,sha256=0We4NPvhIYASRpQ3le41nmJeEAVm42-2VKdzlJ4Ogok,1343
+flatmark-1.0.0.dist-info/WHEEL,sha256=rp-k_VZaX8oABFEtLwG_Df95p8LSKt9-uPyQ4jKH0P4,81
+flatmark-1.0.0.dist-info/METADATA,sha256=Nh70KaIUmtqTsfa0_1X_YBvs4nTY60XCxqtAvequjM0,2023
+flatmark-1.0.0.dist-info/RECORD,,

flatmark-1.0.0.dist-info/WHEEL

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