sammler-sdk 1.0.0__tar.gz

sammler_sdk-1.0.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: sammler-sdk
+Version: 1.0.0
+Summary: Python SDK for interacting with Sammler GraphQL API
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0
+
+# Sammler Python SDK
+
+Python client for interacting with the Sammler GraphQL API.
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Code Generation
+
+To regenerate the client using `ariadne-codegen`:
+
+```bash
+# Set up a virtual environment
+python3 -m venv .venv
+source .venv/bin/activate
+
+# Install tools
+pip install ariadne-codegen[http]
+
+# Generate client
+ariadne-codegen
+```
+
+## Usage
+
+```python
+import asyncio
+from sammler import SammlerClient
+
+async def main():
+    async with SammlerClient(api_key="your_api_key") as client:
+        collections = await client.get_collections()
+        for col in collections:
+            print(col.name)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

sammler_sdk-1.0.0/README.md

@@ -0,0 +1,41 @@
+# Sammler Python SDK
+
+Python client for interacting with the Sammler GraphQL API.
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Code Generation
+
+To regenerate the client using `ariadne-codegen`:
+
+```bash
+# Set up a virtual environment
+python3 -m venv .venv
+source .venv/bin/activate
+
+# Install tools
+pip install ariadne-codegen[http]
+
+# Generate client
+ariadne-codegen
+```
+
+## Usage
+
+```python
+import asyncio
+from sammler import SammlerClient
+
+async def main():
+    async with SammlerClient(api_key="your_api_key") as client:
+        collections = await client.get_collections()
+        for col in collections:
+            print(col.name)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

sammler_sdk-1.0.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sammler-sdk"
+version = "1.0.0"
+description = "Python SDK for interacting with Sammler GraphQL API"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "httpx>=0.24.0",
+    "pydantic>=2.0"
+]
+
+[tool.ariadne-codegen]
+remote_schema_url = "https://sammler-api-3f60d.web.app"
+queries_path = "../graphql/operations.graphql"
+target_package_name = "graphql"
+target_package_path = "sammler"
+client_type = "async"

sammler_sdk-1.0.0/sammler/__init__.py

@@ -0,0 +1,15 @@
+from .client import SammlerClient
+from .graphql.get_collections import GetCollectionsCollections
+from .graphql.get_collection import GetCollectionCollection, GetCollectionCollectionItems
+from .graphql.get_items import GetItemsItems
+from .graphql.get_item import GetItemItem, GetItemItemCollection
+
+__all__ = [
+    "SammlerClient",
+    "GetCollectionsCollections",
+    "GetCollectionCollection",
+    "GetCollectionCollectionItems",
+    "GetItemsItems",
+    "GetItemItem",
+    "GetItemItemCollection",
+]

sammler_sdk-1.0.0/sammler/client.py

@@ -0,0 +1,61 @@
+import httpx
+from typing import List, Optional, Any
+from .graphql.client import Client
+from .graphql.get_collections import GetCollectionsCollections
+from .graphql.get_collection import GetCollectionCollection
+from .graphql.get_items import GetItemsItems
+from .graphql.get_item import GetItemItem
+
+class SammlerClient:
+    def __init__(
+        self,
+        api_key: str,
+        endpoint: str = "https://sammler-api-3f60d.web.app",
+        headers: Optional[dict] = None,
+    ):
+        self.endpoint = endpoint
+        req_headers = {
+            "x-api-key": api_key,
+            **(headers or {})
+        }
+        self.http_client = httpx.AsyncClient(headers=req_headers)
+        self.client = Client(url=self.endpoint, http_client=self.http_client)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def close(self):
+        await self.http_client.aclose()
+
+    async def get_collections(self) -> List[GetCollectionsCollections]:
+        """Retrieve all collections belonging to the authenticated developer profile."""
+        response = await self.client.get_collections()
+        return response.collections
+
+    async def get_collection(self, id: str) -> Optional[GetCollectionCollection]:
+        """Retrieve a single collection by its ID, including all items inside it."""
+        response = await self.client.get_collection(id=id)
+        return response.collection
+
+    async def get_items(self) -> List[GetItemsItems]:
+        """Retrieve all collection items belonging to the authenticated developer profile."""
+        response = await self.client.get_items()
+        return response.items
+
+    async def get_item(self, id: str) -> Optional[GetItemItem]:
+        """Retrieve a single collection item by its ID, including its associated collection."""
+        response = await self.client.get_item(id=id)
+        return response.item
+
+    @property
+    def raw_client(self) -> Client:
+        """Exposes the raw underlying generated SDK client methods."""
+        return self.client
+
+    @property
+    def httpx_client(self) -> httpx.AsyncClient:
+        """Exposes the underlying httpx.AsyncClient instance."""
+        return self.http_client

sammler_sdk-1.0.0/sammler/graphql/__init__.py

@@ -0,0 +1,42 @@
+# Generated by ariadne-codegen
+
+from .async_base_client import AsyncBaseClient
+from .base_model import BaseModel, Upload
+from .client import Client
+from .exceptions import (
+    GraphQLClientError,
+    GraphQLClientGraphQLError,
+    GraphQLClientGraphQLMultiError,
+    GraphQLClientHttpError,
+    GraphQLClientInvalidResponseError,
+)
+from .get_collection import (
+    GetCollection,
+    GetCollectionCollection,
+    GetCollectionCollectionItems,
+)
+from .get_collections import GetCollections, GetCollectionsCollections
+from .get_item import GetItem, GetItemItem, GetItemItemCollection
+from .get_items import GetItems, GetItemsItems
+
+__all__ = [
+    "AsyncBaseClient",
+    "BaseModel",
+    "Client",
+    "GetCollection",
+    "GetCollectionCollection",
+    "GetCollectionCollectionItems",
+    "GetCollections",
+    "GetCollectionsCollections",
+    "GetItem",
+    "GetItemItem",
+    "GetItemItemCollection",
+    "GetItems",
+    "GetItemsItems",
+    "GraphQLClientError",
+    "GraphQLClientGraphQLError",
+    "GraphQLClientGraphQLMultiError",
+    "GraphQLClientHttpError",
+    "GraphQLClientInvalidResponseError",
+    "Upload",
+]

sammler_sdk-1.0.0/sammler/graphql/async_base_client.py

@@ -0,0 +1,395 @@
+# Generated by ariadne-codegen
+
+import asyncio
+import enum
+import json
+from collections.abc import AsyncIterator
+from typing import IO, Any, Optional, TypeVar, cast
+from uuid import uuid4
+
+import httpx
+from pydantic import BaseModel
+from pydantic_core import to_jsonable_python
+
+from .base_model import UNSET, Upload
+from .exceptions import (
+    GraphQLClientError,
+    GraphQLClientGraphQLMultiError,
+    GraphQLClientHttpError,
+    GraphQLClientInvalidMessageFormat,
+    GraphQLClientInvalidResponseError,
+)
+
+try:
+    from websockets import (  # type: ignore[import-not-found,unused-ignore]
+        ClientConnection,
+    )
+    from websockets import (  # type: ignore[import-not-found,unused-ignore]
+        connect as ws_connect,
+    )
+    from websockets.typing import (  # type: ignore[import-not-found,unused-ignore]
+        Data,
+        Origin,
+        Subprotocol,
+    )
+except ImportError:
+    from contextlib import asynccontextmanager
+
+    @asynccontextmanager  # type: ignore
+    async def ws_connect(*args, **kwargs):
+        raise NotImplementedError("Subscriptions require 'websockets' package.")
+        yield
+
+    ClientConnection = Any  # type: ignore[misc,assignment,unused-ignore]
+    Data = Any  # type: ignore[misc,assignment,unused-ignore]
+    Origin = Any  # type: ignore[misc,assignment,unused-ignore]
+
+    def Subprotocol(*args, **kwargs):  # type: ignore # noqa: N802, N803
+        raise NotImplementedError("Subscriptions require 'websockets' package.")
+
+
+Self = TypeVar("Self", bound="AsyncBaseClient")
+
+GRAPHQL_TRANSPORT_WS = "graphql-transport-ws"
+
+
+class GraphQLTransportWSMessageType(str, enum.Enum):
+    CONNECTION_INIT = "connection_init"
+    CONNECTION_ACK = "connection_ack"
+    PING = "ping"
+    PONG = "pong"
+    SUBSCRIBE = "subscribe"
+    NEXT = "next"
+    ERROR = "error"
+    COMPLETE = "complete"
+
+
+class AsyncBaseClient:
+    def __init__(
+        self,
+        url: str = "",
+        headers: Optional[dict[str, str]] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+        ws_url: str = "",
+        ws_headers: Optional[dict[str, Any]] = None,
+        ws_origin: Optional[str] = None,
+        ws_connection_init_payload: Optional[dict[str, Any]] = None,
+    ) -> None:
+        self.url = url
+        self.headers = headers
+        self.http_client = (
+            http_client if http_client else httpx.AsyncClient(headers=headers)
+        )
+
+        self.ws_url = ws_url
+        self.ws_headers = ws_headers or {}
+        self.ws_origin = Origin(ws_origin) if ws_origin else None
+        self.ws_connection_init_payload = ws_connection_init_payload
+
+    async def __aenter__(self: Self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: object,
+        exc_val: object,
+        exc_tb: object,
+    ) -> None:
+        await self.http_client.aclose()
+
+    async def execute(
+        self,
+        query: str,
+        operation_name: Optional[str] = None,
+        variables: Optional[dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        processed_variables, files, files_map = self._process_variables(variables)
+
+        if files and files_map:
+            return await self._execute_multipart(
+                query=query,
+                operation_name=operation_name,
+                variables=processed_variables,
+                files=files,
+                files_map=files_map,
+                **kwargs,
+            )
+
+        return await self._execute_json(
+            query=query,
+            operation_name=operation_name,
+            variables=processed_variables,
+            **kwargs,
+        )
+
+    def get_data(self, response: httpx.Response) -> dict[str, Any]:
+        if not response.is_success:
+            raise GraphQLClientHttpError(
+                status_code=response.status_code, response=response
+            )
+
+        try:
+            response_json = response.json()
+        except ValueError as exc:
+            raise GraphQLClientInvalidResponseError(response=response) from exc
+
+        if (not isinstance(response_json, dict)) or (
+            "data" not in response_json and "errors" not in response_json
+        ):
+            raise GraphQLClientInvalidResponseError(response=response)
+
+        data = response_json.get("data")
+        errors = response_json.get("errors")
+
+        if errors:
+            raise GraphQLClientGraphQLMultiError.from_errors_dicts(
+                errors_dicts=errors, data=data
+            )
+
+        return cast(dict[str, Any], data)
+
+    async def execute_ws(
+        self,
+        query: str,
+        operation_name: Optional[str] = None,
+        variables: Optional[dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[dict[str, Any]]:
+        headers = self.ws_headers.copy()
+        headers.update(kwargs.pop("additional_headers", {}))
+
+        merged_kwargs: dict[str, Any] = {"origin": self.ws_origin}
+        merged_kwargs.update(kwargs)
+        merged_kwargs["additional_headers"] = headers
+
+        operation_id = str(uuid4())
+        async with ws_connect(
+            self.ws_url,
+            subprotocols=[Subprotocol(GRAPHQL_TRANSPORT_WS)],
+            **merged_kwargs,
+        ) as websocket:
+            await self._send_connection_init(websocket)
+            # Wait for connection_ack; some servers (e.g. Hasura) send ping before
+            # connection_ack, so we loop and handle pings until we get ack.
+            try:
+                await asyncio.wait_for(
+                    self._wait_for_connection_ack(websocket),
+                    timeout=5.0,
+                )
+            except asyncio.TimeoutError as exc:
+                raise GraphQLClientError(
+                    "Connection ack not received within 5 seconds"
+                ) from exc
+            await self._send_subscribe(
+                websocket,
+                operation_id=operation_id,
+                query=query,
+                operation_name=operation_name,
+                variables=variables,
+            )
+
+            async for message in websocket:
+                data = await self._handle_ws_message(message, websocket)
+                if data and "connection_ack" not in data:
+                    yield data
+
+    def _process_variables(
+        self, variables: Optional[dict[str, Any]]
+    ) -> tuple[
+        dict[str, Any], dict[str, tuple[str, IO[bytes], str]], dict[str, list[str]]
+    ]:
+        if not variables:
+            return {}, {}, {}
+
+        serializable_variables = self._convert_dict_to_json_serializable(variables)
+        return self._get_files_from_variables(serializable_variables)
+
+    def _convert_dict_to_json_serializable(
+        self, dict_: dict[str, Any]
+    ) -> dict[str, Any]:
+        return {
+            key: self._convert_value(value)
+            for key, value in dict_.items()
+            if value is not UNSET
+        }
+
+    def _convert_value(self, value: Any) -> Any:
+        if isinstance(value, BaseModel):
+            return value.model_dump(by_alias=True, exclude_unset=True)
+        if isinstance(value, list):
+            return [self._convert_value(item) for item in value]
+        return value
+
+    def _get_files_from_variables(
+        self, variables: dict[str, Any]
+    ) -> tuple[
+        dict[str, Any], dict[str, tuple[str, IO[bytes], str]], dict[str, list[str]]
+    ]:
+        files_map: dict[str, list[str]] = {}
+        files_list: list[Upload] = []
+
+        def separate_files(path: str, obj: Any) -> Any:
+            if isinstance(obj, list):
+                nulled_list = []
+                for index, value in enumerate(obj):
+                    value = separate_files(f"{path}.{index}", value)
+                    nulled_list.append(value)
+                return nulled_list
+
+            if isinstance(obj, dict):
+                nulled_dict = {}
+                for key, value in obj.items():
+                    value = separate_files(f"{path}.{key}", value)
+                    nulled_dict[key] = value
+                return nulled_dict
+
+            if isinstance(obj, Upload):
+                if obj in files_list:
+                    file_index = files_list.index(obj)
+                    files_map[str(file_index)].append(path)
+                else:
+                    file_index = len(files_list)
+                    files_list.append(obj)
+                    files_map[str(file_index)] = [path]
+                return None
+
+            return obj
+
+        nulled_variables = separate_files("variables", variables)
+        files: dict[str, tuple[str, IO[bytes], str]] = {
+            str(i): (file_.filename, cast(IO[bytes], file_.content), file_.content_type)
+            for i, file_ in enumerate(files_list)
+        }
+        return nulled_variables, files, files_map
+
+    async def _execute_multipart(
+        self,
+        query: str,
+        operation_name: Optional[str],
+        variables: dict[str, Any],
+        files: dict[str, tuple[str, IO[bytes], str]],
+        files_map: dict[str, list[str]],
+        **kwargs: Any,
+    ) -> httpx.Response:
+        data = {
+            "operations": json.dumps(
+                {
+                    "query": query,
+                    "operationName": operation_name,
+                    "variables": variables,
+                },
+                default=to_jsonable_python,
+            ),
+            "map": json.dumps(files_map, default=to_jsonable_python),
+        }
+
+        return await self.http_client.post(
+            url=self.url, data=data, files=files, **kwargs
+        )
+
+    async def _execute_json(
+        self,
+        query: str,
+        operation_name: Optional[str],
+        variables: dict[str, Any],
+        **kwargs: Any,
+    ) -> httpx.Response:
+        headers: dict[str, str] = {"Content-type": "application/json"}
+        headers.update(kwargs.get("headers", {}))
+
+        merged_kwargs: dict[str, Any] = kwargs.copy()
+        merged_kwargs["headers"] = headers
+
+        return await self.http_client.post(
+            url=self.url,
+            content=json.dumps(
+                {
+                    "query": query,
+                    "operationName": operation_name,
+                    "variables": variables,
+                },
+                default=to_jsonable_python,
+            ),
+            **merged_kwargs,
+        )
+
+    async def _send_connection_init(self, websocket: ClientConnection) -> None:
+        payload: dict[str, Any] = {
+            "type": GraphQLTransportWSMessageType.CONNECTION_INIT.value
+        }
+        if self.ws_connection_init_payload:
+            payload["payload"] = self.ws_connection_init_payload
+        await websocket.send(json.dumps(payload))
+
+    async def _wait_for_connection_ack(self, websocket: ClientConnection) -> None:
+        """Read messages until connection_ack; handle ping/pong in between."""
+        async for message in websocket:
+            data = await self._handle_ws_message(message, websocket)
+            if data is not None and "connection_ack" in data:
+                return
+
+    async def _send_subscribe(
+        self,
+        websocket: ClientConnection,
+        operation_id: str,
+        query: str,
+        operation_name: Optional[str] = None,
+        variables: Optional[dict[str, Any]] = None,
+    ) -> None:
+        payload_inner: dict[str, Any] = {
+            "query": query,
+            "operationName": operation_name,
+        }
+        if variables:
+            payload_inner["variables"] = self._convert_dict_to_json_serializable(
+                variables
+            )
+        payload: dict[str, Any] = {
+            "id": operation_id,
+            "type": GraphQLTransportWSMessageType.SUBSCRIBE.value,
+            "payload": payload_inner,
+        }
+        await websocket.send(json.dumps(payload))
+
+    async def _handle_ws_message(
+        self,
+        message: Data,
+        websocket: ClientConnection,
+        expected_type: Optional[GraphQLTransportWSMessageType] = None,
+    ) -> Optional[dict[str, Any]]:
+        try:
+            message_dict = json.loads(message)
+        except json.JSONDecodeError as exc:
+            raise GraphQLClientInvalidMessageFormat(message=message) from exc
+
+        type_ = message_dict.get("type")
+        payload = message_dict.get("payload", {})
+
+        if not type_ or type_ not in {t.value for t in GraphQLTransportWSMessageType}:
+            raise GraphQLClientInvalidMessageFormat(message=message)
+
+        if expected_type and expected_type != type_:
+            raise GraphQLClientInvalidMessageFormat(
+                f"Invalid message received. Expected: {expected_type.value}"
+            )
+
+        if type_ == GraphQLTransportWSMessageType.NEXT:
+            if "data" not in payload:
+                raise GraphQLClientInvalidMessageFormat(message=message)
+            return cast(dict[str, Any], payload["data"])
+
+        if type_ == GraphQLTransportWSMessageType.COMPLETE:
+            await websocket.close()
+        elif type_ == GraphQLTransportWSMessageType.PING:
+            await websocket.send(
+                json.dumps({"type": GraphQLTransportWSMessageType.PONG.value})
+            )
+        elif type_ == GraphQLTransportWSMessageType.ERROR:
+            raise GraphQLClientGraphQLMultiError.from_errors_dicts(
+                errors_dicts=payload, data=message_dict
+            )
+        elif type_ == GraphQLTransportWSMessageType.CONNECTION_ACK:
+            return {"connection_ack": True}
+
+        return None

sammler_sdk-1.0.0/sammler/graphql/base_model.py

@@ -0,0 +1,30 @@
+# Generated by ariadne-codegen
+
+from io import IOBase
+
+from pydantic import BaseModel as PydanticBaseModel
+from pydantic import ConfigDict
+
+
+class UnsetType:
+    def __bool__(self) -> bool:
+        return False
+
+
+UNSET = UnsetType()
+
+
+class BaseModel(PydanticBaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=(),
+    )
+
+
+class Upload:
+    def __init__(self, filename: str, content: IOBase, content_type: str):
+        self.filename = filename
+        self.content = content
+        self.content_type = content_type

sammler_sdk-1.0.0/sammler/graphql/client.py

@@ -0,0 +1,128 @@
+# Generated by ariadne-codegen
+# Source: ../graphql/operations.graphql
+
+from typing import Any
+
+from .async_base_client import AsyncBaseClient
+from .get_collection import GetCollection
+from .get_collections import GetCollections
+from .get_item import GetItem
+from .get_items import GetItems
+
+
+def gql(q: str) -> str:
+    return q
+
+
+class Client(AsyncBaseClient):
+    async def get_collections(self, **kwargs: Any) -> GetCollections:
+        query = gql("""
+            query GetCollections {
+              collections {
+                id
+                userId
+                name
+                description
+                type
+                createdAt
+                updatedAt
+              }
+            }
+            """)
+        variables: dict[str, object] = {}
+        response = await self.execute(
+            query=query, operation_name="GetCollections", variables=variables, **kwargs
+        )
+        data = self.get_data(response)
+        return GetCollections.model_validate(data)
+
+    async def get_collection(self, id: str, **kwargs: Any) -> GetCollection:
+        query = gql("""
+            query GetCollection($id: ID!) {
+              collection(id: $id) {
+                id
+                userId
+                name
+                description
+                type
+                createdAt
+                updatedAt
+                items {
+                  id
+                  collectionId
+                  name
+                  description
+                  quantity
+                  value
+                  condition
+                  notes
+                  createdAt
+                  updatedAt
+                  photoRef
+                }
+              }
+            }
+            """)
+        variables: dict[str, object] = {"id": id}
+        response = await self.execute(
+            query=query, operation_name="GetCollection", variables=variables, **kwargs
+        )
+        data = self.get_data(response)
+        return GetCollection.model_validate(data)
+
+    async def get_items(self, **kwargs: Any) -> GetItems:
+        query = gql("""
+            query GetItems {
+              items {
+                id
+                userId
+                collectionId
+                name
+                description
+                quantity
+                value
+                condition
+                notes
+                createdAt
+                updatedAt
+                photoRef
+              }
+            }
+            """)
+        variables: dict[str, object] = {}
+        response = await self.execute(
+            query=query, operation_name="GetItems", variables=variables, **kwargs
+        )
+        data = self.get_data(response)
+        return GetItems.model_validate(data)
+
+    async def get_item(self, id: str, **kwargs: Any) -> GetItem:
+        query = gql("""
+            query GetItem($id: ID!) {
+              item(id: $id) {
+                id
+                userId
+                collectionId
+                name
+                description
+                quantity
+                value
+                condition
+                notes
+                createdAt
+                updatedAt
+                photoRef
+                collection {
+                  id
+                  name
+                  type
+                }
+              }
+            }
+            """)
+        variables: dict[str, object] = {"id": id}
+        response = await self.execute(
+            query=query, operation_name="GetItem", variables=variables, **kwargs
+        )
+        data = self.get_data(response)
+        return GetItem.model_validate(data)

sammler_sdk-1.0.0/sammler/graphql/enums.py

@@ -0,0 +1,3 @@
+# Generated by ariadne-codegen
+# Source: https://sammler-api-3f60d.web.app
+

sammler_sdk-1.0.0/sammler/graphql/exceptions.py

@@ -0,0 +1,85 @@
+# Generated by ariadne-codegen
+
+from typing import Any, Optional, Union
+
+import httpx
+
+
+class GraphQLClientError(Exception):
+    """Base exception."""
+
+
+class GraphQLClientHttpError(GraphQLClientError):
+    def __init__(self, status_code: int, response: httpx.Response) -> None:
+        self.status_code = status_code
+        self.response = response
+
+    def __str__(self) -> str:
+        return f"HTTP status code: {self.status_code}"
+
+
+class GraphQLClientInvalidResponseError(GraphQLClientError):
+    def __init__(self, response: httpx.Response) -> None:
+        self.response = response
+
+    def __str__(self) -> str:
+        return "Invalid response format."
+
+
+class GraphQLClientGraphQLError(GraphQLClientError):
+    def __init__(
+        self,
+        message: str,
+        locations: Optional[list[dict[str, int]]] = None,
+        path: Optional[list[str]] = None,
+        extensions: Optional[dict[str, object]] = None,
+        original: Optional[dict[str, object]] = None,
+    ):
+        self.message = message
+        self.locations = locations
+        self.path = path
+        self.extensions = extensions
+        self.original = original
+
+    def __str__(self) -> str:
+        return self.message
+
+    @classmethod
+    def from_dict(cls, error: dict[str, Any]) -> "GraphQLClientGraphQLError":
+        return cls(
+            message=error["message"],
+            locations=error.get("locations"),
+            path=error.get("path"),
+            extensions=error.get("extensions"),
+            original=error,
+        )
+
+
+class GraphQLClientGraphQLMultiError(GraphQLClientError):
+    def __init__(
+        self,
+        errors: list[GraphQLClientGraphQLError],
+        data: Optional[dict[str, Any]] = None,
+    ):
+        self.errors = errors
+        self.data = data
+
+    def __str__(self) -> str:
+        return "; ".join(str(e) for e in self.errors)
+
+    @classmethod
+    def from_errors_dicts(
+        cls, errors_dicts: list[dict[str, Any]], data: Optional[dict[str, Any]] = None
+    ) -> "GraphQLClientGraphQLMultiError":
+        return cls(
+            errors=[GraphQLClientGraphQLError.from_dict(e) for e in errors_dicts],
+            data=data,
+        )
+
+
+class GraphQLClientInvalidMessageFormat(GraphQLClientError):  # noqa: N818
+    def __init__(self, message: Union[str, bytes]) -> None:
+        self.message = message
+
+    def __str__(self) -> str:
+        return "Invalid message format."

sammler_sdk-1.0.0/sammler/graphql/get_collection.py

@@ -0,0 +1,41 @@
+# Generated by ariadne-codegen
+# Source: ../graphql/operations.graphql
+
+from typing import Optional
+
+from pydantic import Field
+
+from .base_model import BaseModel
+
+
+class GetCollection(BaseModel):
+    collection: Optional["GetCollectionCollection"]
+
+
+class GetCollectionCollection(BaseModel):
+    id: str
+    user_id: str = Field(alias="userId")
+    name: str
+    description: Optional[str]
+    type_: str = Field(alias="type")
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
+    items: list["GetCollectionCollectionItems"]
+
+
+class GetCollectionCollectionItems(BaseModel):
+    id: str
+    collection_id: str = Field(alias="collectionId")
+    name: str
+    description: Optional[str]
+    quantity: int
+    value: Optional[float]
+    condition: Optional[str]
+    notes: Optional[str]
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
+    photo_ref: Optional[str] = Field(alias="photoRef")
+
+
+GetCollection.model_rebuild()
+GetCollectionCollection.model_rebuild()

sammler_sdk-1.0.0/sammler/graphql/get_collections.py

@@ -0,0 +1,25 @@
+# Generated by ariadne-codegen
+# Source: ../graphql/operations.graphql
+
+from typing import Optional
+
+from pydantic import Field
+
+from .base_model import BaseModel
+
+
+class GetCollections(BaseModel):
+    collections: list["GetCollectionsCollections"]
+
+
+class GetCollectionsCollections(BaseModel):
+    id: str
+    user_id: str = Field(alias="userId")
+    name: str
+    description: Optional[str]
+    type_: str = Field(alias="type")
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
+
+
+GetCollections.model_rebuild()

sammler_sdk-1.0.0/sammler/graphql/get_item.py

@@ -0,0 +1,38 @@
+# Generated by ariadne-codegen
+# Source: ../graphql/operations.graphql
+
+from typing import Optional
+
+from pydantic import Field
+
+from .base_model import BaseModel
+
+
+class GetItem(BaseModel):
+    item: Optional["GetItemItem"]
+
+
+class GetItemItem(BaseModel):
+    id: str
+    user_id: str = Field(alias="userId")
+    collection_id: str = Field(alias="collectionId")
+    name: str
+    description: Optional[str]
+    quantity: int
+    value: Optional[float]
+    condition: Optional[str]
+    notes: Optional[str]
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
+    photo_ref: Optional[str] = Field(alias="photoRef")
+    collection: "GetItemItemCollection"
+
+
+class GetItemItemCollection(BaseModel):
+    id: str
+    name: str
+    type_: str = Field(alias="type")
+
+
+GetItem.model_rebuild()
+GetItemItem.model_rebuild()

sammler_sdk-1.0.0/sammler/graphql/get_items.py

@@ -0,0 +1,30 @@
+# Generated by ariadne-codegen
+# Source: ../graphql/operations.graphql
+
+from typing import Optional
+
+from pydantic import Field
+
+from .base_model import BaseModel
+
+
+class GetItems(BaseModel):
+    items: list["GetItemsItems"]
+
+
+class GetItemsItems(BaseModel):
+    id: str
+    user_id: str = Field(alias="userId")
+    collection_id: str = Field(alias="collectionId")
+    name: str
+    description: Optional[str]
+    quantity: int
+    value: Optional[float]
+    condition: Optional[str]
+    notes: Optional[str]
+    created_at: str = Field(alias="createdAt")
+    updated_at: str = Field(alias="updatedAt")
+    photo_ref: Optional[str] = Field(alias="photoRef")
+
+
+GetItems.model_rebuild()

sammler_sdk-1.0.0/sammler/graphql/input_types.py

@@ -0,0 +1,3 @@
+# Generated by ariadne-codegen
+# Source: https://sammler-api-3f60d.web.app
+

sammler_sdk-1.0.0/sammler_sdk.egg-info/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: sammler-sdk
+Version: 1.0.0
+Summary: Python SDK for interacting with Sammler GraphQL API
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0
+
+# Sammler Python SDK
+
+Python client for interacting with the Sammler GraphQL API.
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Code Generation
+
+To regenerate the client using `ariadne-codegen`:
+
+```bash
+# Set up a virtual environment
+python3 -m venv .venv
+source .venv/bin/activate
+
+# Install tools
+pip install ariadne-codegen[http]
+
+# Generate client
+ariadne-codegen
+```
+
+## Usage
+
+```python
+import asyncio
+from sammler import SammlerClient
+
+async def main():
+    async with SammlerClient(api_key="your_api_key") as client:
+        collections = await client.get_collections()
+        for col in collections:
+            print(col.name)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

sammler_sdk-1.0.0/sammler_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+README.md
+pyproject.toml
+sammler/__init__.py
+sammler/client.py
+sammler/graphql/__init__.py
+sammler/graphql/async_base_client.py
+sammler/graphql/base_model.py
+sammler/graphql/client.py
+sammler/graphql/enums.py
+sammler/graphql/exceptions.py
+sammler/graphql/get_collection.py
+sammler/graphql/get_collections.py
+sammler/graphql/get_item.py
+sammler/graphql/get_items.py
+sammler/graphql/input_types.py
+sammler_sdk.egg-info/PKG-INFO
+sammler_sdk.egg-info/SOURCES.txt
+sammler_sdk.egg-info/dependency_links.txt
+sammler_sdk.egg-info/requires.txt
+sammler_sdk.egg-info/top_level.txt

sammler_sdk-1.0.0/sammler_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

sammler_sdk-1.0.0/sammler_sdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+httpx>=0.24.0
+pydantic>=2.0

sammler_sdk-1.0.0/sammler_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+sammler

sammler_sdk-1.0.0/setup.cfg

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