Add a python client library

We still don't have any documentation and things are in flux, but you can report your OpenAI API calls to OpenPipe now.

client-libs/python/openpipe/api_client/models/__init__.py

@@ -0,0 +1,15 @@
+""" Contains all the data models used in inputs/outputs """
+
+from .external_api_check_cache_json_body import ExternalApiCheckCacheJsonBody
+from .external_api_check_cache_json_body_tags import ExternalApiCheckCacheJsonBodyTags
+from .external_api_check_cache_response_200 import ExternalApiCheckCacheResponse200
+from .external_api_report_json_body import ExternalApiReportJsonBody
+from .external_api_report_json_body_tags import ExternalApiReportJsonBodyTags
+
+__all__ = (
+    "ExternalApiCheckCacheJsonBody",
+    "ExternalApiCheckCacheJsonBodyTags",
+    "ExternalApiCheckCacheResponse200",
+    "ExternalApiReportJsonBody",
+    "ExternalApiReportJsonBodyTags",
+)

client-libs/python/openpipe/api_client/models/external_api_check_cache_json_body.py

@@ -0,0 +1,70 @@
+from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union
+
+from attrs import define
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.external_api_check_cache_json_body_tags import ExternalApiCheckCacheJsonBodyTags
+
+
+T = TypeVar("T", bound="ExternalApiCheckCacheJsonBody")
+
+
+@define
+class ExternalApiCheckCacheJsonBody:
+    """
+    Attributes:
+        requested_at (float): Unix timestamp in milliseconds
+        req_payload (Union[Unset, Any]): JSON-encoded request payload
+        tags (Union[Unset, ExternalApiCheckCacheJsonBodyTags]): Extra tags to attach to the call for filtering. Eg {
+            "userId": "123", "promptId": "populate-title" }
+    """
+
+    requested_at: float
+    req_payload: Union[Unset, Any] = UNSET
+    tags: Union[Unset, "ExternalApiCheckCacheJsonBodyTags"] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        requested_at = self.requested_at
+        req_payload = self.req_payload
+        tags: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.tags, Unset):
+            tags = self.tags.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "requestedAt": requested_at,
+            }
+        )
+        if req_payload is not UNSET:
+            field_dict["reqPayload"] = req_payload
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.external_api_check_cache_json_body_tags import ExternalApiCheckCacheJsonBodyTags
+
+        d = src_dict.copy()
+        requested_at = d.pop("requestedAt")
+
+        req_payload = d.pop("reqPayload", UNSET)
+
+        _tags = d.pop("tags", UNSET)
+        tags: Union[Unset, ExternalApiCheckCacheJsonBodyTags]
+        if isinstance(_tags, Unset):
+            tags = UNSET
+        else:
+            tags = ExternalApiCheckCacheJsonBodyTags.from_dict(_tags)
+
+        external_api_check_cache_json_body = cls(
+            requested_at=requested_at,
+            req_payload=req_payload,
+            tags=tags,
+        )
+
+        return external_api_check_cache_json_body

client-libs/python/openpipe/api_client/models/external_api_check_cache_json_body_tags.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define, field
+
+T = TypeVar("T", bound="ExternalApiCheckCacheJsonBodyTags")
+
+
+@define
+class ExternalApiCheckCacheJsonBodyTags:
+    """Extra tags to attach to the call for filtering. Eg { "userId": "123", "promptId": "populate-title" }"""
+
+    additional_properties: Dict[str, str] = field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        external_api_check_cache_json_body_tags = cls()
+
+        external_api_check_cache_json_body_tags.additional_properties = d
+        return external_api_check_cache_json_body_tags
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

client-libs/python/openpipe/api_client/models/external_api_check_cache_response_200.py

@@ -0,0 +1,38 @@
+from typing import Any, Dict, Type, TypeVar, Union
+
+from attrs import define
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ExternalApiCheckCacheResponse200")
+
+
+@define
+class ExternalApiCheckCacheResponse200:
+    """
+    Attributes:
+        resp_payload (Union[Unset, Any]): JSON-encoded response payload
+    """
+
+    resp_payload: Union[Unset, Any] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        resp_payload = self.resp_payload
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update({})
+        if resp_payload is not UNSET:
+            field_dict["respPayload"] = resp_payload
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        resp_payload = d.pop("respPayload", UNSET)
+
+        external_api_check_cache_response_200 = cls(
+            resp_payload=resp_payload,
+        )
+
+        return external_api_check_cache_response_200

client-libs/python/openpipe/api_client/models/external_api_report_json_body.py

@@ -0,0 +1,101 @@
+from typing import TYPE_CHECKING, Any, Dict, Type, TypeVar, Union
+
+from attrs import define
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.external_api_report_json_body_tags import ExternalApiReportJsonBodyTags
+
+
+T = TypeVar("T", bound="ExternalApiReportJsonBody")
+
+
+@define
+class ExternalApiReportJsonBody:
+    """
+    Attributes:
+        requested_at (float): Unix timestamp in milliseconds
+        received_at (float): Unix timestamp in milliseconds
+        req_payload (Union[Unset, Any]): JSON-encoded request payload
+        resp_payload (Union[Unset, Any]): JSON-encoded response payload
+        status_code (Union[Unset, float]): HTTP status code of response
+        error_message (Union[Unset, str]): User-friendly error message
+        tags (Union[Unset, ExternalApiReportJsonBodyTags]): Extra tags to attach to the call for filtering. Eg {
+            "userId": "123", "promptId": "populate-title" }
+    """
+
+    requested_at: float
+    received_at: float
+    req_payload: Union[Unset, Any] = UNSET
+    resp_payload: Union[Unset, Any] = UNSET
+    status_code: Union[Unset, float] = UNSET
+    error_message: Union[Unset, str] = UNSET
+    tags: Union[Unset, "ExternalApiReportJsonBodyTags"] = UNSET
+
+    def to_dict(self) -> Dict[str, Any]:
+        requested_at = self.requested_at
+        received_at = self.received_at
+        req_payload = self.req_payload
+        resp_payload = self.resp_payload
+        status_code = self.status_code
+        error_message = self.error_message
+        tags: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.tags, Unset):
+            tags = self.tags.to_dict()
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(
+            {
+                "requestedAt": requested_at,
+                "receivedAt": received_at,
+            }
+        )
+        if req_payload is not UNSET:
+            field_dict["reqPayload"] = req_payload
+        if resp_payload is not UNSET:
+            field_dict["respPayload"] = resp_payload
+        if status_code is not UNSET:
+            field_dict["statusCode"] = status_code
+        if error_message is not UNSET:
+            field_dict["errorMessage"] = error_message
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.external_api_report_json_body_tags import ExternalApiReportJsonBodyTags
+
+        d = src_dict.copy()
+        requested_at = d.pop("requestedAt")
+
+        received_at = d.pop("receivedAt")
+
+        req_payload = d.pop("reqPayload", UNSET)
+
+        resp_payload = d.pop("respPayload", UNSET)
+
+        status_code = d.pop("statusCode", UNSET)
+
+        error_message = d.pop("errorMessage", UNSET)
+
+        _tags = d.pop("tags", UNSET)
+        tags: Union[Unset, ExternalApiReportJsonBodyTags]
+        if isinstance(_tags, Unset):
+            tags = UNSET
+        else:
+            tags = ExternalApiReportJsonBodyTags.from_dict(_tags)
+
+        external_api_report_json_body = cls(
+            requested_at=requested_at,
+            received_at=received_at,
+            req_payload=req_payload,
+            resp_payload=resp_payload,
+            status_code=status_code,
+            error_message=error_message,
+            tags=tags,
+        )
+
+        return external_api_report_json_body

client-libs/python/openpipe/api_client/models/external_api_report_json_body_tags.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define, field
+
+T = TypeVar("T", bound="ExternalApiReportJsonBodyTags")
+
+
+@define
+class ExternalApiReportJsonBodyTags:
+    """Extra tags to attach to the call for filtering. Eg { "userId": "123", "promptId": "populate-title" }"""
+
+    additional_properties: Dict[str, str] = field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        external_api_report_json_body_tags = cls()
+
+        external_api_report_json_body_tags.additional_properties = d
+        return external_api_report_json_body_tags
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: str) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties