ogx_open_client 1.0.3.dev0__py3-none-any.whl

ogx_client/api/batches_api.py

@@ -0,0 +1,1247 @@
+# coding: utf-8
+
+# Copyright (c) The OGX Contributors.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+"""
+    OGX Specification - Stable & Experimental APIs
+
+    This is the specification of the OGX that provides                     a set of endpoints and their corresponding interfaces that are     tailored to                     best leverage Llama Models.      **🔗 COMBINED**: This specification includes both stable production-ready APIs     and experimental pre-release APIs. Use stable APIs for production deployments     and experimental APIs for testing new features.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+import importlib
+import json
+import logging
+import re
+import sys
+import warnings
+
+from pydantic import validate_call, Field, SkipValidation, StrictFloat, StrictStr, StrictInt
+from typing import Any
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Optional
+from typing_extensions import Annotated
+from ogx_client.models.batch import Batch
+from ogx_client.models.create_batch_request import CreateBatchRequest
+from ogx_client.models.list_batches_response import ListBatchesResponse
+
+from ogx_client.api_client import ApiClient, RequestSerialized
+from ogx_client.api_response import ApiResponse
+from ogx_client.rest import RESTResponseType
+from ogx_client.stream import Stream
+from ogx_client.lib._utils import pascal_to_snake_case
+
+
+class BatchesApi:
+    """NOTE: This class is auto generated by OpenAPI Generator
+    Ref: https://openapi-generator.tech
+
+    Do not edit the class manually.
+    """
+
+    def __init__(self, api_client=None) -> None:
+        if api_client is None:
+            api_client = ApiClient.get_default()
+        self.api_client = api_client
+        self.logger = logging.getLogger(BatchesApi.__name__)
+
+        # Child API attributes (set by OgxClient based on x-nesting-path)
+
+
+    def _create_event_stream(self, response_data: RESTResponseType, stream_type_name: str) -> Stream[Any]:
+        """Create a typed event stream from an SSE response.
+
+        Args:
+            response_data: The raw HTTP response containing the SSE stream.
+            stream_type_name: The schema name for the streaming response type
+                (e.g., 'OpenAIChatCompletionChunk', 'OpenAIResponseObjectStream').
+        """
+        # Import the stream type class once
+        stream_class = None
+        discriminator_map = None
+        discriminator_property = None
+        try:
+            module_name = pascal_to_snake_case(stream_type_name)
+            model_module = importlib.import_module('ogx_client.models.' + module_name)
+            stream_class = getattr(model_module, stream_type_name)
+            # Check if the stream type has a discriminator (e.g., oneOf with propertyName)
+            discriminator_map = getattr(stream_class, 'discriminator_value_class_map', None)
+            discriminator_property = getattr(stream_class, 'discriminator_property_name', None)
+        except (ImportError, ModuleNotFoundError, AttributeError) as e:
+            self.logger.debug(f"Could not import stream type {stream_type_name}: {e}")
+
+        def stream_decoder(data_str: str) -> Any:
+            if not data_str:
+                return None
+            try:
+                data = json.loads(data_str)
+            except json.JSONDecodeError:
+                return data_str
+
+            # If we have a discriminator, resolve the specific variant class
+            if discriminator_map and discriminator_property:
+                disc_value = data.get(discriminator_property, '')
+                variant_class_name = discriminator_map.get(disc_value)
+                if variant_class_name:
+                    try:
+                        variant_module_name = pascal_to_snake_case(variant_class_name)
+                        variant_module = importlib.import_module('ogx_client.models.' + variant_module_name)
+                        variant_class = getattr(variant_module, variant_class_name)
+                        return variant_class.from_dict(data)
+                    except Exception as e:
+                        self.logger.debug(f"Failed to deserialize as {variant_class_name}: {e}")
+
+            # Non-discriminated: deserialize as stream type directly
+            if stream_class is not None:
+                try:
+                    result = stream_class.from_dict(data)
+                    # Unwrap oneOf/anyOf wrappers
+                    if hasattr(result, 'actual_instance') and result.actual_instance is not None:
+                        return result.actual_instance
+                    return result
+                except Exception as e:
+                    self.logger.debug(f"Failed to deserialize as {stream_type_name}: {e}")
+
+            # Final fallback: return raw dict
+            return data
+
+        return Stream(
+            response=response_data.response,
+            client=self.api_client,
+            decoder=stream_decoder,
+        )
+
+
+    @validate_call
+    def cancel(
+        self,
+        batch_id: Annotated[StrictStr, Field(description="The ID of the batch to cancel.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> Batch:
+        """Cancel a batch that is in progress.
+
+        Cancel a batch that is in progress.
+
+        :param batch_id: The ID of the batch to cancel. (required)
+        :type batch_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._cancel_serialize(
+            batch_id=batch_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "Batch",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def cancel_with_http_info(
+        self,
+        batch_id: Annotated[StrictStr, Field(description="The ID of the batch to cancel.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> ApiResponse[Batch]:
+        """Cancel a batch that is in progress.
+
+        Cancel a batch that is in progress.
+
+        :param batch_id: The ID of the batch to cancel. (required)
+        :type batch_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._cancel_serialize(
+            batch_id=batch_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "Batch",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def cancel_without_preload_content(
+        self,
+        batch_id: Annotated[StrictStr, Field(description="The ID of the batch to cancel.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> RESTResponseType:
+        """Cancel a batch that is in progress.
+
+        Cancel a batch that is in progress.
+
+        :param batch_id: The ID of the batch to cancel. (required)
+        :type batch_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._cancel_serialize(
+            batch_id=batch_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "Batch",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _cancel_serialize(
+        self,
+        batch_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        if batch_id is not None:
+            _path_params['batch_id'] = batch_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v1/batches/{batch_id}/cancel',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+    @validate_call
+    def retrieve(
+        self,
+        batch_id: Annotated[StrictStr, Field(description="The ID of the batch to retrieve.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> Batch:
+        """Retrieve information about a specific batch.
+
+        Retrieve information about a specific batch.
+
+        :param batch_id: The ID of the batch to retrieve. (required)
+        :type batch_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._retrieve_serialize(
+            batch_id=batch_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "Batch",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def retrieve_with_http_info(
+        self,
+        batch_id: Annotated[StrictStr, Field(description="The ID of the batch to retrieve.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> ApiResponse[Batch]:
+        """Retrieve information about a specific batch.
+
+        Retrieve information about a specific batch.
+
+        :param batch_id: The ID of the batch to retrieve. (required)
+        :type batch_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._retrieve_serialize(
+            batch_id=batch_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "Batch",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def retrieve_without_preload_content(
+        self,
+        batch_id: Annotated[StrictStr, Field(description="The ID of the batch to retrieve.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> RESTResponseType:
+        """Retrieve information about a specific batch.
+
+        Retrieve information about a specific batch.
+
+        :param batch_id: The ID of the batch to retrieve. (required)
+        :type batch_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._retrieve_serialize(
+            batch_id=batch_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "Batch",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _retrieve_serialize(
+        self,
+        batch_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        if batch_id is not None:
+            _path_params['batch_id'] = batch_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/v1/batches/{batch_id}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+    @validate_call
+    def create(
+        self,
+        create_batch_request: CreateBatchRequest | None = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+        **kwargs: Any
+    ) -> Batch:
+        """Create a new batch for processing multiple API requests.
+
+        Create a new batch for processing multiple API requests.
+
+        :param create_batch_request: (required)
+        :type create_batch_request: CreateBatchRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+        # If body param not provided, construct from kwargs
+        if create_batch_request is None and kwargs:
+            try:
+                # Try proper type conversion via from_json
+                create_batch_request = CreateBatchRequest.from_json(json.dumps(kwargs))
+            except Exception:
+                # Fall back to lenient construction for complex/flexible types
+                # Server will still validate the final request
+                create_batch_request = CreateBatchRequest.model_construct(**kwargs)
+        
+
+        _param = self._create_serialize(
+            create_batch_request=create_batch_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "Batch",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+            '409': None,
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def create_with_http_info(
+        self,
+        create_batch_request: CreateBatchRequest | None = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+        **kwargs: Any
+    ) -> ApiResponse[Batch]:
+        """Create a new batch for processing multiple API requests.
+
+        Create a new batch for processing multiple API requests.
+
+        :param create_batch_request: (required)
+        :type create_batch_request: CreateBatchRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+        # If body param not provided, construct from kwargs
+        if create_batch_request is None and kwargs:
+            try:
+                # Try proper type conversion via from_json
+                create_batch_request = CreateBatchRequest.from_json(json.dumps(kwargs))
+            except Exception:
+                # Fall back to lenient construction for complex/flexible types
+                # Server will still validate the final request
+                create_batch_request = CreateBatchRequest.model_construct(**kwargs)
+        
+
+        _param = self._create_serialize(
+            create_batch_request=create_batch_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "Batch",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+            '409': None,
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def create_without_preload_content(
+        self,
+        create_batch_request: CreateBatchRequest | None = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+        **kwargs: Any
+    ) -> RESTResponseType:
+        """Create a new batch for processing multiple API requests.
+
+        Create a new batch for processing multiple API requests.
+
+        :param create_batch_request: (required)
+        :type create_batch_request: CreateBatchRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+        # If body param not provided, construct from kwargs
+        if create_batch_request is None and kwargs:
+            try:
+                # Try proper type conversion via from_json
+                create_batch_request = CreateBatchRequest.from_json(json.dumps(kwargs))
+            except Exception:
+                # Fall back to lenient construction for complex/flexible types
+                # Server will still validate the final request
+                create_batch_request = CreateBatchRequest.model_construct(**kwargs)
+        
+
+        _param = self._create_serialize(
+            create_batch_request=create_batch_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "Batch",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+            '409': None,
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _create_serialize(
+        self,
+        create_batch_request,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if create_batch_request is not None:
+            _body_params = create_batch_request
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v1/batches',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+    @validate_call
+    def list(
+        self,
+        after: Annotated[Optional[StrictStr], Field(description="Optional cursor for pagination. Returns batches after this ID.")] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of batches to return. Defaults to 20.")] = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> ListBatchesResponse:
+        """List all batches for the current user.
+
+        List all batches for the current user.
+
+        :param after: Optional cursor for pagination. Returns batches after this ID.
+        :type after: str
+        :param limit: Maximum number of batches to return. Defaults to 20.
+        :type limit: int
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._list_serialize(
+            after=after,
+            limit=limit,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "ListBatchesResponse",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def list_with_http_info(
+        self,
+        after: Annotated[Optional[StrictStr], Field(description="Optional cursor for pagination. Returns batches after this ID.")] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of batches to return. Defaults to 20.")] = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> ApiResponse[ListBatchesResponse]:
+        """List all batches for the current user.
+
+        List all batches for the current user.
+
+        :param after: Optional cursor for pagination. Returns batches after this ID.
+        :type after: str
+        :param limit: Maximum number of batches to return. Defaults to 20.
+        :type limit: int
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._list_serialize(
+            after=after,
+            limit=limit,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "ListBatchesResponse",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def list_without_preload_content(
+        self,
+        after: Annotated[Optional[StrictStr], Field(description="Optional cursor for pagination. Returns batches after this ID.")] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="Maximum number of batches to return. Defaults to 20.")] = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> RESTResponseType:
+        """List all batches for the current user.
+
+        List all batches for the current user.
+
+        :param after: Optional cursor for pagination. Returns batches after this ID.
+        :type after: str
+        :param limit: Maximum number of batches to return. Defaults to 20.
+        :type limit: int
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._list_serialize(
+            after=after,
+            limit=limit,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "ListBatchesResponse",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _list_serialize(
+        self,
+        after,
+        limit,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        # process the query parameters
+        if after is not None:
+            
+            _query_params.append(('after', after))
+            
+        if limit is not None:
+            
+            _query_params.append(('limit', limit))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/v1/batches',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+