truefoundry 0.3.3__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

truefoundry/ml/autogen/client/models/metric_dto.py

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+"""
+FastAPI
+
+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
+import pprint
+import re  # noqa: F401
+from typing import Optional, Union
+
+from truefoundry.pydantic_v1 import BaseModel, Field, StrictFloat, StrictInt, StrictStr
+
+
+class MetricDto(BaseModel):
+    """
+    MetricDto
+    """
+
+    key: StrictStr = Field(...)
+    value: Optional[Union[StrictFloat, StrictInt]] = None
+    timestamp: Optional[StrictInt] = None
+    step: Optional[StrictInt] = 0
+    __properties = ["key", "value", "timestamp", "step"]
+
+    class Config:
+        """Pydantic configuration"""
+
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> MetricDto:
+        """Create an instance of MetricDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True, exclude={}, exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> MetricDto:
+        """Create an instance of MetricDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return MetricDto.parse_obj(obj)
+
+        _obj = MetricDto.parse_obj(
+            {
+                "key": obj.get("key"),
+                "value": obj.get("value"),
+                "timestamp": obj.get("timestamp"),
+                "step": obj.get("step") if obj.get("step") is not None else 0,
+            }
+        )
+        return _obj

truefoundry/ml/autogen/client/models/mime_type.py

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+"""
+FastAPI
+
+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
+
+import json
+import re  # noqa: F401
+
+from aenum import Enum
+
+
+class MimeType(str, Enum):
+    """
+    +label=MIME Type +usage=MIME type of the content
+    """
+
+    """
+    allowed enum values
+    """
+    TEXT_SLASH_PLAIN = "text/plain"
+    APPLICATION_SLASH_JSON = "application/json"
+    IMAGE_SLASH_PNG = "image/png"
+    IMAGE_SLASH_JPEG = "image/jpeg"
+    APPLICATION_SLASH_X_MINUS_DIRECTORY = "application/x-directory"
+
+    @classmethod
+    def from_json(cls, json_str: str) -> MimeType:
+        """Create an instance of MimeType from a JSON string"""
+        return MimeType(json.loads(json_str))

truefoundry/ml/autogen/client/models/model_configuration.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+"""
+FastAPI
+
+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
+import pprint
+import re  # noqa: F401
+from typing import Any, Dict, Optional
+
+from truefoundry.ml.autogen.client.models.parameters import Parameters
+from truefoundry.pydantic_v1 import BaseModel, Field, StrictStr, constr, validator
+
+
+class ModelConfiguration(BaseModel):
+    """
+    +label=Model Configuration +icon=fa-cogs:#326ce5 +message=Configuration details for the provider and corresponding config +usage=Define the provider and its configuration +docs=Configuration settings specific to the provider, including model settings and other parameters.  # noqa: E501
+    """
+
+    provider: StrictStr = Field(
+        default=...,
+        description='+label=Provider Name +usage=Name of the provider, must be non-empty, e.g., "openai", "google_gemini"',
+    )
+    model: constr(strict=True) = Field(
+        default=...,
+        description="+label=Model name +usage=Model name, must be non-empty",
+    )
+    parameters: Optional[Parameters] = Field(
+        default=None,
+        description="+usage=Parameters for the provider +label=Parameters +docs=Key-value pairs to store additional parameters for the provider",
+    )
+    extra_parameters: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="+usage=Extra parameters for the provider +label=Extra Parameters +docs=Additional parameters for the provider",
+    )
+    __properties = ["provider", "model", "parameters", "extra_parameters"]
+
+    @validator("model")
+    def model_validate_regular_expression(cls, value):
+        """Validates the regular expression"""
+        if not re.match(r"^[a-zA-Z][a-zA-Z0-9\-]{1,30}[a-zA-Z0-9]$", value):
+            raise ValueError(
+                r"must validate the regular expression /^[a-zA-Z][a-zA-Z0-9\-]{1,30}[a-zA-Z0-9]$/"
+            )
+        return value
+
+    class Config:
+        """Pydantic configuration"""
+
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> ModelConfiguration:
+        """Create an instance of ModelConfiguration from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True, exclude={}, exclude_none=True)
+        # override the default output from truefoundry.pydantic_v1 by calling `to_dict()` of parameters
+        if self.parameters:
+            _dict["parameters"] = self.parameters.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ModelConfiguration:
+        """Create an instance of ModelConfiguration from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ModelConfiguration.parse_obj(obj)
+
+        _obj = ModelConfiguration.parse_obj(
+            {
+                "provider": obj.get("provider"),
+                "model": obj.get("model"),
+                "parameters": Parameters.from_dict(obj.get("parameters"))
+                if obj.get("parameters") is not None
+                else None,
+                "extra_parameters": obj.get("extra_parameters"),
+            }
+        )
+        return _obj

truefoundry/ml/autogen/client/models/model_dto.py

@@ -0,0 +1,122 @@
+# coding: utf-8
+
+"""
+FastAPI
+
+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
+import pprint
+import re  # noqa: F401
+from datetime import datetime
+from typing import Optional
+
+from truefoundry.ml.autogen.client.models.artifact_type import ArtifactType
+from truefoundry.ml.autogen.client.models.experiment_dto import ExperimentDto
+from truefoundry.ml.autogen.client.models.model_version_dto import ModelVersionDto
+from truefoundry.pydantic_v1 import BaseModel, StrictBool, StrictStr
+
+
+class ModelDto(BaseModel):
+    """
+    ModelDto
+    """
+
+    id: Optional[StrictStr] = None
+    experiment_id: Optional[StrictStr] = None
+    type: Optional[ArtifactType] = None
+    name: Optional[StrictStr] = None
+    fqn: Optional[StrictStr] = None
+    description: Optional[StrictStr] = None
+    created_by: Optional[StrictStr] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    artifact_storage_root: Optional[StrictStr] = None
+    latest_version: Optional[ModelVersionDto] = None
+    monitoring_enabled: Optional[StrictBool] = None
+    experiment: Optional[ExperimentDto] = None
+    __properties = [
+        "id",
+        "experiment_id",
+        "type",
+        "name",
+        "fqn",
+        "description",
+        "created_by",
+        "created_at",
+        "updated_at",
+        "artifact_storage_root",
+        "latest_version",
+        "monitoring_enabled",
+        "experiment",
+    ]
+
+    class Config:
+        """Pydantic configuration"""
+
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> ModelDto:
+        """Create an instance of ModelDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True, exclude={}, exclude_none=True)
+        # override the default output from truefoundry.pydantic_v1 by calling `to_dict()` of latest_version
+        if self.latest_version:
+            _dict["latest_version"] = self.latest_version.to_dict()
+        # override the default output from truefoundry.pydantic_v1 by calling `to_dict()` of experiment
+        if self.experiment:
+            _dict["experiment"] = self.experiment.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ModelDto:
+        """Create an instance of ModelDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ModelDto.parse_obj(obj)
+
+        _obj = ModelDto.parse_obj(
+            {
+                "id": obj.get("id"),
+                "experiment_id": obj.get("experiment_id"),
+                "type": obj.get("type"),
+                "name": obj.get("name"),
+                "fqn": obj.get("fqn"),
+                "description": obj.get("description"),
+                "created_by": obj.get("created_by"),
+                "created_at": obj.get("created_at"),
+                "updated_at": obj.get("updated_at"),
+                "artifact_storage_root": obj.get("artifact_storage_root"),
+                "latest_version": ModelVersionDto.from_dict(obj.get("latest_version"))
+                if obj.get("latest_version") is not None
+                else None,
+                "monitoring_enabled": obj.get("monitoring_enabled"),
+                "experiment": ExperimentDto.from_dict(obj.get("experiment"))
+                if obj.get("experiment") is not None
+                else None,
+            }
+        )
+        return _obj

truefoundry/ml/autogen/client/models/model_response_dto.py

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+"""
+FastAPI
+
+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
+import pprint
+import re  # noqa: F401
+
+from truefoundry.ml.autogen.client.models.model_dto import ModelDto
+from truefoundry.pydantic_v1 import BaseModel, Field
+
+
+class ModelResponseDto(BaseModel):
+    """
+    ModelResponseDto
+    """
+
+    model: ModelDto = Field(...)
+    __properties = ["model"]
+
+    class Config:
+        """Pydantic configuration"""
+
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> ModelResponseDto:
+        """Create an instance of ModelResponseDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True, exclude={}, exclude_none=True)
+        # override the default output from truefoundry.pydantic_v1 by calling `to_dict()` of model
+        if self.model:
+            _dict["model"] = self.model.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ModelResponseDto:
+        """Create an instance of ModelResponseDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ModelResponseDto.parse_obj(obj)
+
+        _obj = ModelResponseDto.parse_obj(
+            {
+                "model": ModelDto.from_dict(obj.get("model"))
+                if obj.get("model") is not None
+                else None
+            }
+        )
+        return _obj

truefoundry/ml/autogen/client/models/model_schema_dto.py

@@ -0,0 +1,85 @@
+# coding: utf-8
+
+"""
+FastAPI
+
+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
+import pprint
+import re  # noqa: F401
+from typing import Optional
+
+from truefoundry.ml.autogen.client.models.feature_dto import FeatureDto
+from truefoundry.ml.autogen.client.models.prediction_type import PredictionType
+from truefoundry.pydantic_v1 import BaseModel, conlist
+
+
+class ModelSchemaDto(BaseModel):
+    """
+    ModelSchemaDto
+    """
+
+    features: Optional[conlist(FeatureDto)] = None
+    prediction: Optional[PredictionType] = None
+    __properties = ["features", "prediction"]
+
+    class Config:
+        """Pydantic configuration"""
+
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> ModelSchemaDto:
+        """Create an instance of ModelSchemaDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True, exclude={}, exclude_none=True)
+        # override the default output from truefoundry.pydantic_v1 by calling `to_dict()` of each item in features (list)
+        _items = []
+        if self.features:
+            for _item in self.features:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["features"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ModelSchemaDto:
+        """Create an instance of ModelSchemaDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ModelSchemaDto.parse_obj(obj)
+
+        _obj = ModelSchemaDto.parse_obj(
+            {
+                "features": [
+                    FeatureDto.from_dict(_item) for _item in obj.get("features")
+                ]
+                if obj.get("features") is not None
+                else None,
+                "prediction": obj.get("prediction"),
+            }
+        )
+        return _obj

truefoundry/ml/autogen/client/models/model_version_dto.py

@@ -0,0 +1,163 @@
+# coding: utf-8
+
+"""
+FastAPI
+
+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
+import pprint
+import re  # noqa: F401
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from truefoundry.ml.autogen.client.models.artifact_version_status import (
+    ArtifactVersionStatus,
+)
+from truefoundry.ml.autogen.client.models.metric_dto import MetricDto
+from truefoundry.ml.autogen.client.models.model_schema_dto import ModelSchemaDto
+from truefoundry.pydantic_v1 import BaseModel, StrictBool, StrictInt, StrictStr, conlist
+
+
+class ModelVersionDto(BaseModel):
+    """
+    ModelVersionDto
+    """
+
+    id: Optional[StrictStr] = None
+    model_id: Optional[StrictStr] = None
+    version: Optional[StrictInt] = None
+    fqn: Optional[StrictStr] = None
+    artifact_storage_root: Optional[StrictStr] = None
+    artifact_metadata: Optional[Dict[str, Any]] = None
+    description: Optional[StrictStr] = None
+    status: Optional[ArtifactVersionStatus] = None
+    step: Optional[StrictInt] = 0
+    created_by: Optional[StrictStr] = None
+    model_schema: Optional[ModelSchemaDto] = None
+    custom_metrics: Optional[conlist(Dict[str, Any])] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    model_fqn: Optional[StrictStr] = None
+    data_path: Optional[StrictStr] = None
+    monitoring_enabled: Optional[StrictBool] = False
+    usage_code_snippet: Optional[StrictStr] = None
+    experiment_id: Optional[StrictStr] = None
+    run_id: Optional[StrictStr] = None
+    metrics: Optional[conlist(MetricDto)] = None
+    model_name: Optional[StrictStr] = None
+    model_framework: Optional[StrictStr] = None
+    artifact_size: Optional[StrictInt] = None
+    __properties = [
+        "id",
+        "model_id",
+        "version",
+        "fqn",
+        "artifact_storage_root",
+        "artifact_metadata",
+        "description",
+        "status",
+        "step",
+        "created_by",
+        "model_schema",
+        "custom_metrics",
+        "created_at",
+        "updated_at",
+        "model_fqn",
+        "data_path",
+        "monitoring_enabled",
+        "usage_code_snippet",
+        "experiment_id",
+        "run_id",
+        "metrics",
+        "model_name",
+        "model_framework",
+        "artifact_size",
+    ]
+
+    class Config:
+        """Pydantic configuration"""
+
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> ModelVersionDto:
+        """Create an instance of ModelVersionDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True, exclude={}, exclude_none=True)
+        # override the default output from truefoundry.pydantic_v1 by calling `to_dict()` of model_schema
+        if self.model_schema:
+            _dict["model_schema"] = self.model_schema.to_dict()
+        # override the default output from truefoundry.pydantic_v1 by calling `to_dict()` of each item in metrics (list)
+        _items = []
+        if self.metrics:
+            for _item in self.metrics:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["metrics"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ModelVersionDto:
+        """Create an instance of ModelVersionDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ModelVersionDto.parse_obj(obj)
+
+        _obj = ModelVersionDto.parse_obj(
+            {
+                "id": obj.get("id"),
+                "model_id": obj.get("model_id"),
+                "version": obj.get("version"),
+                "fqn": obj.get("fqn"),
+                "artifact_storage_root": obj.get("artifact_storage_root"),
+                "artifact_metadata": obj.get("artifact_metadata"),
+                "description": obj.get("description"),
+                "status": obj.get("status"),
+                "step": obj.get("step") if obj.get("step") is not None else 0,
+                "created_by": obj.get("created_by"),
+                "model_schema": ModelSchemaDto.from_dict(obj.get("model_schema"))
+                if obj.get("model_schema") is not None
+                else None,
+                "custom_metrics": obj.get("custom_metrics"),
+                "created_at": obj.get("created_at"),
+                "updated_at": obj.get("updated_at"),
+                "model_fqn": obj.get("model_fqn"),
+                "data_path": obj.get("data_path"),
+                "monitoring_enabled": obj.get("monitoring_enabled")
+                if obj.get("monitoring_enabled") is not None
+                else False,
+                "usage_code_snippet": obj.get("usage_code_snippet"),
+                "experiment_id": obj.get("experiment_id"),
+                "run_id": obj.get("run_id"),
+                "metrics": [MetricDto.from_dict(_item) for _item in obj.get("metrics")]
+                if obj.get("metrics") is not None
+                else None,
+                "model_name": obj.get("model_name"),
+                "model_framework": obj.get("model_framework"),
+                "artifact_size": obj.get("artifact_size"),
+            }
+        )
+        return _obj