stigg-api-client-v2 0.693.0__py3-none-any.whl → 5.9.0__py3-none-any.whl

stigg/generated/apply_subscription.py

@@ -1,12 +1,10 @@
-# Generated by ariadne-codegen on 2023-12-07 19:22
+# Generated by ariadne-codegen
 # Source: operations.graphql
 
-from typing import Optional
-
 from pydantic import Field
 
 from .base_model import BaseModel
-from .fragments import SubscriptionFragment
+from .fragments import ApplySubscriptionFragment
 
 
 class ApplySubscription(BaseModel):
@@ -15,14 +13,8 @@ class ApplySubscription(BaseModel):
     )
 
 
-class ApplySubscriptionApplySubscription(BaseModel):
-    subscription: Optional["ApplySubscriptionApplySubscriptionSubscription"]
-
-
-class ApplySubscriptionApplySubscriptionSubscription(SubscriptionFragment):
+class ApplySubscriptionApplySubscription(ApplySubscriptionFragment):
     pass
 
 
-ApplySubscription.update_forward_refs()
-ApplySubscriptionApplySubscription.update_forward_refs()
-ApplySubscriptionApplySubscriptionSubscription.update_forward_refs()
+ApplySubscription.model_rebuild()

stigg/generated/archive_customer.py

@@ -1,4 +1,4 @@
-# Generated by ariadne-codegen on 2023-12-07 19:22
+# Generated by ariadne-codegen
 # Source: operations.graphql
 
 from pydantic import Field
@@ -14,5 +14,4 @@ class ArchiveCustomerArchiveCustomer(BaseModel):
     customer_id: str = Field(alias="customerId")
 
 
-ArchiveCustomer.update_forward_refs()
-ArchiveCustomerArchiveCustomer.update_forward_refs()
+ArchiveCustomer.model_rebuild()

stigg/generated/async_base_client.py

@@ -1,26 +1,32 @@
-# Generated by ariadne-codegen on 2023-12-07 19:22
+# Generated by ariadne-codegen
 
 import enum
 import json
-from typing import Any, AsyncIterator, Dict, Optional, TypeVar, cast
+from typing import IO, Any, AsyncIterator, Dict, List, Optional, Tuple, TypeVar, cast
 from uuid import uuid4
 
 import httpx
 from pydantic import BaseModel
-from pydantic.json import pydantic_encoder
+from pydantic_core import to_jsonable_python
 
-from .base_model import UNSET
+from .base_model import UNSET, Upload
 from .exceptions import (
     GraphQLClientGraphQLMultiError,
     GraphQLClientHttpError,
     GraphQLClientInvalidMessageFormat,
-    GraphQlClientInvalidResponseError,
+    GraphQLClientInvalidResponseError,
 )
 
 try:
-    from websockets.client import WebSocketClientProtocol
-    from websockets.client import connect as ws_connect
-    from websockets.typing import Data, Origin, Subprotocol
+    from websockets.client import (  # type: ignore[import-not-found,unused-ignore]
+        WebSocketClientProtocol,
+        connect as ws_connect,
+    )
+    from websockets.typing import (  # type: ignore[import-not-found,unused-ignore]
+        Data,
+        Origin,
+        Subprotocol,
+    )
 except ImportError:
     from contextlib import asynccontextmanager
 
@@ -29,10 +35,12 @@ except ImportError:
         raise NotImplementedError("Subscriptions require 'websockets' package.")
         yield  # pylint: disable=unreachable
 
-    WebSocketClientProtocol = Any  # type: ignore
-    Data = Any  # type: ignore
-    Origin = Any  # type: ignore
-    Subprotocol = Any  # type: ignore
+    WebSocketClientProtocol = 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 # pylint: disable=invalid-name
+        raise NotImplementedError("Subscriptions require 'websockets' package.")
 
 
 Self = TypeVar("Self", bound="AsyncBaseClient")
@@ -67,6 +75,7 @@ class AsyncBaseClient:
         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
@@ -84,13 +93,30 @@ class AsyncBaseClient:
         await self.http_client.aclose()
 
     async def execute(
-        self, query: str, variables: Optional[Dict[str, Any]] = None
+        self,
+        query: str,
+        operation_name: Optional[str] = None,
+        variables: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
     ) -> httpx.Response:
-        payload: Dict[str, Any] = {"query": query}
-        if variables:
-            payload["variables"] = self._convert_dict_to_json_serializable(variables)
-        content = json.dumps(payload, default=pydantic_encoder)
-        return await self.http_client.post(url=self.url, content=content)
+        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:
@@ -101,12 +127,14 @@ class AsyncBaseClient:
         try:
             response_json = response.json()
         except ValueError as exc:
-            raise GraphQlClientInvalidResponseError(response=response) from exc
+            raise GraphQLClientInvalidResponseError(response=response) from exc
 
-        if (not isinstance(response_json, dict)) or ("data" not in response_json):
-            raise GraphQlClientInvalidResponseError(response=response)
+        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["data"]
+        data = response_json.get("data")
         errors = response_json.get("errors")
 
         if errors:
@@ -114,23 +142,40 @@ class AsyncBaseClient:
                 errors_dicts=errors, data=data
             )
 
-        return cast(dict[str, Any], data)
+        return cast(Dict[str, Any], data)
 
     async def execute_ws(
-        self, query: str, variables: Optional[Dict[str, Any]] = None
+        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.get("extra_headers", {}))
+
+        merged_kwargs: Dict[str, Any] = {"origin": self.ws_origin}
+        merged_kwargs.update(kwargs)
+        merged_kwargs["extra_headers"] = headers
+
         operation_id = str(uuid4())
         async with ws_connect(
             self.ws_url,
             subprotocols=[Subprotocol(GRAPHQL_TRANSPORT_WS)],
-            origin=self.ws_origin,
-            extra_headers=self.ws_headers,
+            **merged_kwargs,
         ) as websocket:
             await self._send_connection_init(websocket)
+            # wait for connection_ack from server
+            await self._handle_ws_message(
+                await websocket.recv(),
+                websocket,
+                expected_type=GraphQLTransportWSMessageType.CONNECTION_ACK,
+            )
             await self._send_subscribe(
                 websocket,
                 operation_id=operation_id,
                 query=query,
+                operation_name=operation_name,
                 variables=variables,
             )
 
@@ -139,6 +184,17 @@ class AsyncBaseClient:
                 if 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]:
@@ -150,11 +206,104 @@ class AsyncBaseClient:
 
     def _convert_value(self, value: Any) -> Any:
         if isinstance(value, BaseModel):
-            return value.dict(by_alias=True, exclude_unset=True)
+            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: WebSocketClientProtocol) -> None:
         payload: Dict[str, Any] = {
             "type": GraphQLTransportWSMessageType.CONNECTION_INIT.value
@@ -168,12 +317,13 @@ class AsyncBaseClient:
         websocket: WebSocketClientProtocol,
         operation_id: str,
         query: str,
+        operation_name: Optional[str] = None,
         variables: Optional[Dict[str, Any]] = None,
     ) -> None:
         payload: Dict[str, Any] = {
             "id": operation_id,
             "type": GraphQLTransportWSMessageType.SUBSCRIBE.value,
-            "payload": {"query": query},
+            "payload": {"query": query, "operationName": operation_name},
         }
         if variables:
             payload["payload"]["variables"] = self._convert_dict_to_json_serializable(
@@ -182,7 +332,10 @@ class AsyncBaseClient:
         await websocket.send(json.dumps(payload))
 
     async def _handle_ws_message(
-        self, message: Data, websocket: WebSocketClientProtocol
+        self,
+        message: Data,
+        websocket: WebSocketClientProtocol,
+        expected_type: Optional[GraphQLTransportWSMessageType] = None,
     ) -> Optional[Dict[str, Any]]:
         try:
             message_dict = json.loads(message)
@@ -195,6 +348,11 @@ class AsyncBaseClient:
         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)