ogx_open_client 1.0.3.dev1__tar.gz → 1.0.3.dev3__tar.gz

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ogx_open_client
-Version: 1.0.3.dev1
+Version: 1.0.3.dev3
 Summary: OpenAPI-generated Python client for OGX (alternative SDK with OpenAPI Generator tooling)
 Home-page: 
 Author: OpenAPI Generator community

ogx_open_client-1.0.3.dev3/ogx_open_client/api_response.py

@@ -0,0 +1,59 @@
+"""API response object."""
+
+from __future__ import annotations
+import json as _json
+from typing import Any, Generic, Mapping, TypeVar
+from pydantic import Field, StrictInt, StrictBytes, BaseModel
+
+T = TypeVar("T")
+
+class ApiResponse(BaseModel, Generic[T]):
+    """
+    API response object.
+
+    Supports two construction styles:
+    - Normal: ApiResponse(status_code=200, headers=..., data=..., raw_data=b"...")
+    - Stainless-compatible: ApiResponse(raw=httpx_response, cast_to=MyModel, ...)
+      Used by OGXAsLibraryClient to wrap in-process responses.
+    """
+
+    status_code: StrictInt = Field(description="HTTP status code")
+    headers: Mapping[str, str] | None = Field(None, description="HTTP headers")
+    data: T = Field(default=None, description="Deserialized data given the data type")
+    raw_data: StrictBytes = Field(default=b"", description="Raw data (HTTP response body)")
+
+    model_config = {
+        "arbitrary_types_allowed": True
+    }
+
+    def __init__(self, *, raw: Any = None, cast_to: Any = None, **kwargs: Any) -> None:
+        # Accept and ignore stainless-specific kwargs (client, options, stream, stream_cls, retries_taken)
+        for key in ("client", "options", "stream", "stream_cls", "retries_taken"):
+            kwargs.pop(key, None)
+        if raw is not None:
+            super().__init__(
+                status_code=raw.status_code,
+                headers=dict(raw.headers) if raw.headers else None,
+                data=None,
+                raw_data=raw.content if isinstance(raw.content, bytes) else b"",
+                **kwargs,
+            )
+            object.__setattr__(self, "_raw", raw)
+            object.__setattr__(self, "_cast_to", cast_to)
+        else:
+            super().__init__(**kwargs)
+            object.__setattr__(self, "_raw", None)
+            object.__setattr__(self, "_cast_to", None)
+
+    def parse(self, *, to: Any = None) -> Any:
+        """Parse the raw response into the target type."""
+        cast_to = to or getattr(self, "_cast_to", None)
+        raw = getattr(self, "_raw", None)
+        if raw is None or cast_to is None:
+            return self.data
+        data = raw.json()
+        if hasattr(cast_to, "from_dict"):
+            return cast_to.from_dict(data)
+        if hasattr(cast_to, "model_validate"):
+            return cast_to.model_validate(data)
+        return data

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/async_api_response.py

@@ -9,18 +9,32 @@ T = TypeVar("T")
 
 class AsyncApiResponse(Generic[T]):
     """
-    Async API response object
-    """
+    Async API response object.
 
-    def __init__(self, response: httpx.Response) -> None:
-        """
-        Initialize AsyncApiResponse.
+    Supports two construction styles:
+    - Normal: AsyncApiResponse(response=httpx_response)
+    - Stainless-compatible: AsyncApiResponse(raw=httpx_response, cast_to=MyModel, stream=True, stream_cls=AsyncStream[T], ...)
+      Used by OGXAsLibraryClient to wrap in-process responses.
+    """
 
-        :param response: httpx.Response object
-        """
-        self._response = response
+    def __init__(
+        self,
+        response: httpx.Response | None = None,
+        *,
+        raw: httpx.Response | None = None,
+        cast_to: Any = None,
+        stream: bool = False,
+        stream_cls: Any = None,
+        **kwargs: Any,
+    ) -> None:
+        self._response = response or raw
+        if self._response is None:
+            raise ValueError("Either 'response' or 'raw' must be provided")
         self._data: T | None = None
         self._raw_data: bytes | None = None
+        self._cast_to = cast_to
+        self._stream = stream
+        self._stream_cls = stream_cls
 
     @property
     def status_code(self) -> int:
@@ -70,23 +84,39 @@ class AsyncApiResponse(Generic[T]):
         """
         Parse the response data.
 
+        Handles both normal and stainless-compatible construction styles.
+
         :param cast_to: Optional type to cast the response to
         :return: Parsed response data
         """
-        if cast_to is None:
+        # Stainless-compatible streaming: construct the stream class directly
+        if self._stream and self._stream_cls:
+            from typing import get_args
+            args = get_args(self._stream_cls)
+            chunk_type = args[0] if args else None
+            return self._stream_cls(  # type: ignore
+                response=self._response,
+                client=None,
+                cast_to=chunk_type,
+            )
+
+        # Stainless-compatible non-streaming: use stored cast_to
+        effective_cast_to = cast_to or self._cast_to
+        if effective_cast_to is None:
             return await self.json()  # type: ignore
 
         # Handle different response types
-        if cast_to == bytes:
+        if effective_cast_to == bytes:
             return await self.read()  # type: ignore
-        elif cast_to == str:
+        elif effective_cast_to == str:
             return await self.text()  # type: ignore
         else:
             # Assume JSON response that can be parsed
             json_data = await self.json()
-            if hasattr(cast_to, 'model_validate'):
-                # Pydantic model
-                return cast_to.model_validate(json_data)  # type: ignore
+            if hasattr(effective_cast_to, 'from_dict'):
+                return effective_cast_to.from_dict(json_data)  # type: ignore
+            elif hasattr(effective_cast_to, 'model_validate'):
+                return effective_cast_to.model_validate(json_data)  # type: ignore
             else:
                 return json_data  # type: ignore
 

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/async_stream.py

@@ -21,16 +21,17 @@ class AsyncStream(Generic[T]):
     def __init__(
         self,
         response: httpx.Response,
-        client: AsyncApiClient,
+        client: AsyncApiClient | None = None,
         *,
         cast_to: type[T] | None = None,
         decoder: Callable[[str], T] | None = None,
+        **kwargs: Any,
     ) -> None:
         """
         Initialize AsyncStream.
 
         :param response: httpx.Response object with streaming enabled
-        :param client: AsyncApiClient instance
+        :param client: AsyncApiClient instance (optional for library client usage)
         :param cast_to: Optional type to cast streamed data to
         :param decoder: Optional custom decoder function
         """

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/models/conversation_item_list.py

@@ -33,12 +33,12 @@ class ConversationItemList(BaseModel):
     """
     List of conversation items with pagination.
     """ # noqa: E501
-    object: Optional[StrictStr] = Field(default=None, description="The type of object returned, must be list.")
     data: List[OpenAIResponseMessageOutput11Variants] = Field(description="List of conversation items")
+    object: Optional[StrictStr] = Field(default=None, description="The type of object returned, must be list.")
     first_id: Optional[StrictStr]
     last_id: Optional[StrictStr]
     has_more: StrictBool = Field(description="Whether there are more items available.")
-    __properties: ClassVar[list[str]] = ["object", "data", "first_id", "last_id", "has_more"]
+    __properties: ClassVar[list[str]] = ["data", "object", "first_id", "last_id", "has_more"]
 
     @field_validator('object')
     def object_validate_enum(cls, value):
@@ -80,6 +80,23 @@ class ConversationItemList(BaseModel):
         return value
 
 
+    # Make this model iterable/indexable to access the data field directly
+    # This allows: for item in response: ... and response[0]
+    def __iter__(self):
+        """Iterate over items in the data field"""
+        return iter(self.data if self.data is not None else [])
+
+    def __getitem__(self, index):
+        """Get item by index from the data field"""
+        if self.data is None:
+            raise IndexError("list index out of range")
+        return self.data[index]
+
+    def __len__(self):
+        """Get length of the data field"""
+        return len(self.data) if self.data is not None else 0
+
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
@@ -146,8 +163,8 @@ class ConversationItemList(BaseModel):
 
         _obj = cls.model_validate({
             k: v for k, v in {
-            "object": obj.get("object"),
             "data": [OpenAIResponseMessageOutput11Variants.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "object": obj.get("object"),
             "first_id": obj.get("first_id"),
             "last_id": obj.get("last_id"),
             "has_more": obj.get("has_more"),

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/models/list_batches_response.py

@@ -33,12 +33,12 @@ class ListBatchesResponse(BaseModel):
     """
     Response containing a list of batch objects.
     """ # noqa: E501
-    object: Optional[StrictStr] = None
     data: List[Batch] = Field(description="List of batch objects")
+    object: Optional[StrictStr] = None
     first_id: Optional[StrictStr] = None
     last_id: Optional[StrictStr] = None
     has_more: Optional[StrictBool] = Field(default=False, description="Whether there are more batches available")
-    __properties: ClassVar[list[str]] = ["object", "data", "first_id", "last_id", "has_more"]
+    __properties: ClassVar[list[str]] = ["data", "object", "first_id", "last_id", "has_more"]
 
     @field_validator('object')
     def object_validate_enum(cls, value):
@@ -80,6 +80,23 @@ class ListBatchesResponse(BaseModel):
         return value
 
 
+    # Make this model iterable/indexable to access the data field directly
+    # This allows: for item in response: ... and response[0]
+    def __iter__(self):
+        """Iterate over items in the data field"""
+        return iter(self.data if self.data is not None else [])
+
+    def __getitem__(self, index):
+        """Get item by index from the data field"""
+        if self.data is None:
+            raise IndexError("list index out of range")
+        return self.data[index]
+
+    def __len__(self):
+        """Get length of the data field"""
+        return len(self.data) if self.data is not None else 0
+
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
@@ -146,8 +163,8 @@ class ListBatchesResponse(BaseModel):
 
         _obj = cls.model_validate({
             k: v for k, v in {
-            "object": obj.get("object"),
             "data": [Batch.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "object": obj.get("object"),
             "first_id": obj.get("first_id"),
             "last_id": obj.get("last_id"),
             "has_more": obj.get("has_more") if obj.get("has_more") is not None else False,

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/models/open_ai_embeddings_response.py

@@ -35,11 +35,11 @@ class OpenAIEmbeddingsResponse(BaseModel):
     """
     Response from an OpenAI-compatible embeddings request.
     """ # noqa: E501
-    object: Optional[StrictStr] = Field(default=None, description="The object type.")
     data: Annotated[List[OpenAIEmbeddingData], Field(min_length=1)] = Field(description="List of embedding data objects.")
+    object: Optional[StrictStr] = Field(default=None, description="The object type.")
     model: StrictStr = Field(description="The model that was used to generate the embeddings.")
     usage: OpenAIEmbeddingUsage = Field(description="Usage information.")
-    __properties: ClassVar[list[str]] = ["object", "data", "model", "usage"]
+    __properties: ClassVar[list[str]] = ["data", "object", "model", "usage"]
 
     @field_validator('object')
     def object_validate_enum(cls, value):
@@ -81,6 +81,23 @@ class OpenAIEmbeddingsResponse(BaseModel):
         return value
 
 
+    # Make this model iterable/indexable to access the data field directly
+    # This allows: for item in response: ... and response[0]
+    def __iter__(self):
+        """Iterate over items in the data field"""
+        return iter(self.data if self.data is not None else [])
+
+    def __getitem__(self, index):
+        """Get item by index from the data field"""
+        if self.data is None:
+            raise IndexError("list index out of range")
+        return self.data[index]
+
+    def __len__(self):
+        """Get length of the data field"""
+        return len(self.data) if self.data is not None else 0
+
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
@@ -149,8 +166,8 @@ class OpenAIEmbeddingsResponse(BaseModel):
 
         _obj = cls.model_validate({
             k: v for k, v in {
-            "object": obj.get("object"),
             "data": [OpenAIEmbeddingData.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "object": obj.get("object"),
             "model": obj.get("model"),
             "usage": OpenAIEmbeddingUsage.from_dict(obj["usage"]) if obj.get("usage") is not None else None,
             }.items() if k in obj

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/models/open_ai_list_models_response.py

@@ -33,9 +33,9 @@ class OpenAIListModelsResponse(BaseModel):
     """
     Response containing a list of OpenAI model objects.
     """ # noqa: E501
-    object: Optional[StrictStr] = None
     data: List[OpenAIModel] = Field(description="List of OpenAI model objects.")
-    __properties: ClassVar[list[str]] = ["object", "data"]
+    object: Optional[StrictStr] = None
+    __properties: ClassVar[list[str]] = ["data", "object"]
 
     @field_validator('object')
     def object_validate_enum(cls, value):
@@ -77,6 +77,23 @@ class OpenAIListModelsResponse(BaseModel):
         return value
 
 
+    # Make this model iterable/indexable to access the data field directly
+    # This allows: for item in response: ... and response[0]
+    def __iter__(self):
+        """Iterate over items in the data field"""
+        return iter(self.data if self.data is not None else [])
+
+    def __getitem__(self, index):
+        """Get item by index from the data field"""
+        if self.data is None:
+            raise IndexError("list index out of range")
+        return self.data[index]
+
+    def __len__(self):
+        """Get length of the data field"""
+        return len(self.data) if self.data is not None else 0
+
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
@@ -133,8 +150,8 @@ class OpenAIListModelsResponse(BaseModel):
 
         _obj = cls.model_validate({
             k: v for k, v in {
-            "object": obj.get("object"),
             "data": [OpenAIModel.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "object": obj.get("object"),
             }.items() if k in obj
         })
         return _obj

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/models/vector_store_file_content_response.py

@@ -33,11 +33,11 @@ class VectorStoreFileContentResponse(BaseModel):
     """
     Represents the parsed content of a vector store file.
     """ # noqa: E501
-    object: Optional[StrictStr] = None
     data: List[VectorStoreContent]
+    object: Optional[StrictStr] = None
     has_more: StrictBool
     next_page: Optional[StrictStr] = None
-    __properties: ClassVar[list[str]] = ["object", "data", "has_more", "next_page"]
+    __properties: ClassVar[list[str]] = ["data", "object", "has_more", "next_page"]
 
     @field_validator('object')
     def object_validate_enum(cls, value):
@@ -79,6 +79,23 @@ class VectorStoreFileContentResponse(BaseModel):
         return value
 
 
+    # Make this model iterable/indexable to access the data field directly
+    # This allows: for item in response: ... and response[0]
+    def __iter__(self):
+        """Iterate over items in the data field"""
+        return iter(self.data if self.data is not None else [])
+
+    def __getitem__(self, index):
+        """Get item by index from the data field"""
+        if self.data is None:
+            raise IndexError("list index out of range")
+        return self.data[index]
+
+    def __len__(self):
+        """Get length of the data field"""
+        return len(self.data) if self.data is not None else 0
+
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
@@ -140,8 +157,8 @@ class VectorStoreFileContentResponse(BaseModel):
 
         _obj = cls.model_validate({
             k: v for k, v in {
-            "object": obj.get("object"),
             "data": [VectorStoreContent.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "object": obj.get("object"),
             "has_more": obj.get("has_more"),
             "next_page": obj.get("next_page"),
             }.items() if k in obj

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/models/vector_store_files_list_in_batch_response.py

@@ -33,12 +33,12 @@ class VectorStoreFilesListInBatchResponse(BaseModel):
     """
     Response from listing files in a vector store file batch.
     """ # noqa: E501
-    object: Optional[StrictStr] = None
     data: List[VectorStoreFileObject]
+    object: Optional[StrictStr] = None
     first_id: StrictStr
     last_id: StrictStr
     has_more: StrictBool
-    __properties: ClassVar[list[str]] = ["object", "data", "first_id", "last_id", "has_more"]
+    __properties: ClassVar[list[str]] = ["data", "object", "first_id", "last_id", "has_more"]
 
     @field_validator('object')
     def object_validate_enum(cls, value):
@@ -80,6 +80,23 @@ class VectorStoreFilesListInBatchResponse(BaseModel):
         return value
 
 
+    # Make this model iterable/indexable to access the data field directly
+    # This allows: for item in response: ... and response[0]
+    def __iter__(self):
+        """Iterate over items in the data field"""
+        return iter(self.data if self.data is not None else [])
+
+    def __getitem__(self, index):
+        """Get item by index from the data field"""
+        if self.data is None:
+            raise IndexError("list index out of range")
+        return self.data[index]
+
+    def __len__(self):
+        """Get length of the data field"""
+        return len(self.data) if self.data is not None else 0
+
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
@@ -136,8 +153,8 @@ class VectorStoreFilesListInBatchResponse(BaseModel):
 
         _obj = cls.model_validate({
             k: v for k, v in {
-            "object": obj.get("object"),
             "data": [VectorStoreFileObject.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "object": obj.get("object"),
             "first_id": obj.get("first_id"),
             "last_id": obj.get("last_id"),
             "has_more": obj.get("has_more"),

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/models/vector_store_list_files_response.py

@@ -33,12 +33,12 @@ class VectorStoreListFilesResponse(BaseModel):
     """
     Response from listing files in a vector store.
     """ # noqa: E501
-    object: Optional[StrictStr] = None
     data: List[VectorStoreFileObject]
+    object: Optional[StrictStr] = None
     first_id: StrictStr
     last_id: StrictStr
     has_more: StrictBool
-    __properties: ClassVar[list[str]] = ["object", "data", "first_id", "last_id", "has_more"]
+    __properties: ClassVar[list[str]] = ["data", "object", "first_id", "last_id", "has_more"]
 
     @field_validator('object')
     def object_validate_enum(cls, value):
@@ -80,6 +80,23 @@ class VectorStoreListFilesResponse(BaseModel):
         return value
 
 
+    # Make this model iterable/indexable to access the data field directly
+    # This allows: for item in response: ... and response[0]
+    def __iter__(self):
+        """Iterate over items in the data field"""
+        return iter(self.data if self.data is not None else [])
+
+    def __getitem__(self, index):
+        """Get item by index from the data field"""
+        if self.data is None:
+            raise IndexError("list index out of range")
+        return self.data[index]
+
+    def __len__(self):
+        """Get length of the data field"""
+        return len(self.data) if self.data is not None else 0
+
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
@@ -136,8 +153,8 @@ class VectorStoreListFilesResponse(BaseModel):
 
         _obj = cls.model_validate({
             k: v for k, v in {
-            "object": obj.get("object"),
             "data": [VectorStoreFileObject.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "object": obj.get("object"),
             "first_id": obj.get("first_id"),
             "last_id": obj.get("last_id"),
             "has_more": obj.get("has_more"),

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/models/vector_store_list_response.py

@@ -33,12 +33,12 @@ class VectorStoreListResponse(BaseModel):
     """
     Response from listing vector stores.
     """ # noqa: E501
-    object: Optional[StrictStr] = None
     data: List[VectorStoreObject]
+    object: Optional[StrictStr] = None
     first_id: StrictStr
     last_id: StrictStr
     has_more: StrictBool
-    __properties: ClassVar[list[str]] = ["object", "data", "first_id", "last_id", "has_more"]
+    __properties: ClassVar[list[str]] = ["data", "object", "first_id", "last_id", "has_more"]
 
     @field_validator('object')
     def object_validate_enum(cls, value):
@@ -80,6 +80,23 @@ class VectorStoreListResponse(BaseModel):
         return value
 
 
+    # Make this model iterable/indexable to access the data field directly
+    # This allows: for item in response: ... and response[0]
+    def __iter__(self):
+        """Iterate over items in the data field"""
+        return iter(self.data if self.data is not None else [])
+
+    def __getitem__(self, index):
+        """Get item by index from the data field"""
+        if self.data is None:
+            raise IndexError("list index out of range")
+        return self.data[index]
+
+    def __len__(self):
+        """Get length of the data field"""
+        return len(self.data) if self.data is not None else 0
+
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
@@ -136,8 +153,8 @@ class VectorStoreListResponse(BaseModel):
 
         _obj = cls.model_validate({
             k: v for k, v in {
-            "object": obj.get("object"),
             "data": [VectorStoreObject.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
+            "object": obj.get("object"),
             "first_id": obj.get("first_id"),
             "last_id": obj.get("last_id"),
             "has_more": obj.get("has_more"),

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client/models/vector_store_search_response_page.py

@@ -33,12 +33,12 @@ class VectorStoreSearchResponsePage(BaseModel):
     """
     Paginated response from searching a vector store.
     """ # noqa: E501
+    data: List[VectorStoreSearchResponse]
     object: Optional[StrictStr] = None
     search_query: List[StrictStr]
-    data: List[VectorStoreSearchResponse]
     has_more: StrictBool
     next_page: Optional[StrictStr] = None
-    __properties: ClassVar[list[str]] = ["object", "search_query", "data", "has_more", "next_page"]
+    __properties: ClassVar[list[str]] = ["data", "object", "search_query", "has_more", "next_page"]
 
     @field_validator('object')
     def object_validate_enum(cls, value):
@@ -80,6 +80,23 @@ class VectorStoreSearchResponsePage(BaseModel):
         return value
 
 
+    # Make this model iterable/indexable to access the data field directly
+    # This allows: for item in response: ... and response[0]
+    def __iter__(self):
+        """Iterate over items in the data field"""
+        return iter(self.data if self.data is not None else [])
+
+    def __getitem__(self, index):
+        """Get item by index from the data field"""
+        if self.data is None:
+            raise IndexError("list index out of range")
+        return self.data[index]
+
+    def __len__(self):
+        """Get length of the data field"""
+        return len(self.data) if self.data is not None else 0
+
+
 
     def to_str(self) -> str:
         """Returns the string representation of the model using alias"""
@@ -141,9 +158,9 @@ class VectorStoreSearchResponsePage(BaseModel):
 
         _obj = cls.model_validate({
             k: v for k, v in {
+            "data": [VectorStoreSearchResponse.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
             "object": obj.get("object"),
             "search_query": obj.get("search_query"),
-            "data": [VectorStoreSearchResponse.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None,
             "has_more": obj.get("has_more"),
             "next_page": obj.get("next_page"),
             }.items() if k in obj

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/ogx_open_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ogx_open_client
-Version: 1.0.3.dev1
+Version: 1.0.3.dev3
 Summary: OpenAPI-generated Python client for OGX (alternative SDK with OpenAPI Generator tooling)
 Home-page: 
 Author: OpenAPI Generator community

{ogx_open_client-1.0.3.dev1 → ogx_open_client-1.0.3.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ogx_open_client"
-version = "1.0.3.dev1"
+version = "1.0.3.dev3"
 description = "OpenAPI-generated Python client for OGX (alternative SDK with OpenAPI Generator tooling)"
 authors = [
   {name = "The OGX Contributors", email = "contributors@ogx.dev"},

ogx_open_client-1.0.3.dev1/ogx_open_client/api_response.py

@@ -1,21 +0,0 @@
-"""API response object."""
-
-from __future__ import annotations
-from typing import Generic, Mapping, TypeVar
-from pydantic import Field, StrictInt, StrictBytes, BaseModel
-
-T = TypeVar("T")
-
-class ApiResponse(BaseModel, Generic[T]):
-    """
-    API response object
-    """
-
-    status_code: StrictInt = Field(description="HTTP status code")
-    headers: Mapping[str, str] | None = Field(None, description="HTTP headers")
-    data: T = Field(description="Deserialized data given the data type")
-    raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
-
-    model_config = {
-        "arbitrary_types_allowed": True
-    }