arthur-client 1.3.0__py3-none-any.whl → 1.4.1055__py3-none-any.whl

arthur_client/api_bindings/models/scope_schema_tag.py

@@ -0,0 +1,44 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class ScopeSchemaTag(str, Enum):
+    """
+    ScopeSchemaTag
+    """
+
+    """
+    allowed enum values
+    """
+    LLM_CONTEXT = 'llm_context'
+    LLM_PROMPT = 'llm_prompt'
+    LLM_RESPONSE = 'llm_response'
+    PRIMARY_TIMESTAMP = 'primary_timestamp'
+    CATEGORICAL = 'categorical'
+    CONTINUOUS = 'continuous'
+    PREDICTION = 'prediction'
+    GROUND_TRUTH = 'ground_truth'
+    PIN_IN_DEEP_DIVE = 'pin_in_deep_dive'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of ScopeSchemaTag from a JSON string"""
+        return cls(json.loads(json_str))
+
+

arthur_client/api_bindings/models/sensitive_data_plane.py

@@ -0,0 +1,117 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from arthur_client.api_bindings.models.data_plane_capabilities import DataPlaneCapabilities
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SensitiveDataPlane(BaseModel):
+    """
+    SensitiveDataPlane
+    """ # noqa: E501
+    created_at: datetime = Field(description="Time of record creation.")
+    updated_at: datetime = Field(description="Time of last record update.")
+    id: StrictStr = Field(description="ID of the data plane.")
+    name: StrictStr = Field(description="Name of data plane.")
+    workspace_id: StrictStr = Field(description="ID of the parent workspace.")
+    description: StrictStr = Field(description="Description of data plane.")
+    user_id: StrictStr = Field(description="ID of the data plane's underlying user.")
+    last_check_in_time: Optional[datetime]
+    capabilities: DataPlaneCapabilities = Field(description="Capabilities for this data plane.")
+    client_id: SecretStr = Field(description="ID of the auth client.")
+    client_secret: SecretStr = Field(description="Auth client secret.")
+    __properties: ClassVar[List[str]] = ["created_at", "updated_at", "id", "name", "workspace_id", "description", "user_id", "last_check_in_time", "capabilities", "client_id", "client_secret"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SensitiveDataPlane from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of capabilities
+        if self.capabilities:
+            _dict['capabilities'] = self.capabilities.to_dict()
+        # set to None if last_check_in_time (nullable) is None
+        # and model_fields_set contains the field
+        if self.last_check_in_time is None and "last_check_in_time" in self.model_fields_set:
+            _dict['last_check_in_time'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SensitiveDataPlane from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "created_at": obj.get("created_at"),
+            "updated_at": obj.get("updated_at"),
+            "id": obj.get("id"),
+            "name": obj.get("name"),
+            "workspace_id": obj.get("workspace_id"),
+            "description": obj.get("description"),
+            "user_id": obj.get("user_id"),
+            "last_check_in_time": obj.get("last_check_in_time"),
+            "capabilities": DataPlaneCapabilities.from_dict(obj["capabilities"]) if obj.get("capabilities") is not None else None,
+            "client_id": obj.get("client_id"),
+            "client_secret": obj.get("client_secret")
+        })
+        return _obj
+
+

arthur_client/api_bindings/models/sensitive_user.py

@@ -0,0 +1,142 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from arthur_client.api_bindings.models.credentials import Credentials
+from arthur_client.api_bindings.models.user_type import UserType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SensitiveUser(BaseModel):
+    """
+    SensitiveUser
+    """ # noqa: E501
+    created_at: datetime = Field(description="Time of record creation.")
+    updated_at: datetime = Field(description="Time of last record update.")
+    organization_id: StrictStr = Field(description="The ID of the Arthur organization the user belongs to.")
+    id: StrictStr = Field(description="Unique user ID assigned by Arthur.")
+    first_name: StrictStr = Field(description="The user's first name.")
+    last_name: Optional[StrictStr]
+    email: Optional[StrictStr] = None
+    picture: Optional[StrictStr] = None
+    user_type: UserType = Field(description="The type of user.")
+    data_plane_id: Optional[StrictStr] = None
+    client_id: Optional[StrictStr] = None
+    organization_name: StrictStr = Field(description="Name of user's Arthur organization.")
+    credentials: Credentials
+    __properties: ClassVar[List[str]] = ["created_at", "updated_at", "organization_id", "id", "first_name", "last_name", "email", "picture", "user_type", "data_plane_id", "client_id", "organization_name", "credentials"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SensitiveUser from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of credentials
+        if self.credentials:
+            _dict['credentials'] = self.credentials.to_dict()
+        # set to None if last_name (nullable) is None
+        # and model_fields_set contains the field
+        if self.last_name is None and "last_name" in self.model_fields_set:
+            _dict['last_name'] = None
+
+        # set to None if email (nullable) is None
+        # and model_fields_set contains the field
+        if self.email is None and "email" in self.model_fields_set:
+            _dict['email'] = None
+
+        # set to None if picture (nullable) is None
+        # and model_fields_set contains the field
+        if self.picture is None and "picture" in self.model_fields_set:
+            _dict['picture'] = None
+
+        # set to None if data_plane_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.data_plane_id is None and "data_plane_id" in self.model_fields_set:
+            _dict['data_plane_id'] = None
+
+        # set to None if client_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.client_id is None and "client_id" in self.model_fields_set:
+            _dict['client_id'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SensitiveUser from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "created_at": obj.get("created_at"),
+            "updated_at": obj.get("updated_at"),
+            "organization_id": obj.get("organization_id"),
+            "id": obj.get("id"),
+            "first_name": obj.get("first_name"),
+            "last_name": obj.get("last_name"),
+            "email": obj.get("email"),
+            "picture": obj.get("picture"),
+            "user_type": obj.get("user_type"),
+            "data_plane_id": obj.get("data_plane_id"),
+            "client_id": obj.get("client_id"),
+            "organization_name": obj.get("organization_name"),
+            "credentials": Credentials.from_dict(obj["credentials"]) if obj.get("credentials") is not None else None
+        })
+        return _obj
+
+

arthur_client/api_bindings/models/service_account_credentials.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ServiceAccountCredentials(BaseModel):
+    """
+    ServiceAccountCredentials
+    """ # noqa: E501
+    client_id: StrictStr = Field(description="The service account client ID.")
+    client_secret: SecretStr = Field(description="The service account client secret.")
+    __properties: ClassVar[List[str]] = ["client_id", "client_secret"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ServiceAccountCredentials from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ServiceAccountCredentials from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "client_id": obj.get("client_id"),
+            "client_secret": obj.get("client_secret")
+        })
+        return _obj
+
+

arthur_client/api_bindings/models/sketch_metric.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from arthur_client.api_bindings.models.sketch_time_series import SketchTimeSeries
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SketchMetric(BaseModel):
+    """
+    SketchMetric
+    """ # noqa: E501
+    name: StrictStr = Field(description="Name of the metric.")
+    sketch_series: List[SketchTimeSeries] = Field(description="List of sketch-based time series to upload for the metric.")
+    __properties: ClassVar[List[str]] = ["name", "sketch_series"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SketchMetric from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in sketch_series (list)
+        _items = []
+        if self.sketch_series:
+            for _item_sketch_series in self.sketch_series:
+                if _item_sketch_series:
+                    _items.append(_item_sketch_series.to_dict())
+            _dict['sketch_series'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SketchMetric from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "name": obj.get("name"),
+            "sketch_series": [SketchTimeSeries.from_dict(_item) for _item in obj["sketch_series"]] if obj.get("sketch_series") is not None else None
+        })
+        return _obj
+
+

arthur_client/api_bindings/models/sketch_point.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SketchPoint(BaseModel):
+    """
+    SketchPoint
+    """ # noqa: E501
+    timestamp: datetime = Field(description="Timestamp with timezone. Should be the timestamp of the start of the interval covered by 'value'.")
+    value: StrictStr = Field(description="Base64-encoded string representation of a sketch.")
+    __properties: ClassVar[List[str]] = ["timestamp", "value"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SketchPoint from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SketchPoint from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "timestamp": obj.get("timestamp"),
+            "value": obj.get("value")
+        })
+        return _obj
+
+

arthur_client/api_bindings/models/sketch_time_series.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+    Arthur Scope
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List
+from arthur_client.api_bindings.models.dimension import Dimension
+from arthur_client.api_bindings.models.sketch_point import SketchPoint
+from typing import Optional, Set
+from typing_extensions import Self
+
+class SketchTimeSeries(BaseModel):
+    """
+    SketchTimeSeries
+    """ # noqa: E501
+    dimensions: List[Dimension] = Field(description="List of dimensions for the series. If multiple dimensions are uploaded with the same key, the one that is kept is undefined.")
+    values: List[SketchPoint] = Field(description="List of sketch-based time series points.")
+    __properties: ClassVar[List[str]] = ["dimensions", "values"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of SketchTimeSeries from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in dimensions (list)
+        _items = []
+        if self.dimensions:
+            for _item_dimensions in self.dimensions:
+                if _item_dimensions:
+                    _items.append(_item_dimensions.to_dict())
+            _dict['dimensions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in values (list)
+        _items = []
+        if self.values:
+            for _item_values in self.values:
+                if _item_values:
+                    _items.append(_item_values.to_dict())
+            _dict['values'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of SketchTimeSeries from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "dimensions": [Dimension.from_dict(_item) for _item in obj["dimensions"]] if obj.get("dimensions") is not None else None,
+            "values": [SketchPoint.from_dict(_item) for _item in obj["values"]] if obj.get("values") is not None else None
+        })
+        return _obj
+
+