scorable 1.6.4__py3-none-any.whl

root/generated/openapi_aclient/models/evaluator_reference.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+Root Signals API
+
+Root Signals JSON API provides a way to access Root Signals using provisioned API token
+
+The version of the OpenAPI document: 1.0.0 (latest)
+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, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing_extensions import Self
+
+
+class EvaluatorReference(BaseModel):
+    """
+    EvaluatorReference
+    """  # noqa: E501
+
+    id: StrictStr
+    version_id: Optional[StrictStr] = Field(
+        default=None, description="Optional version ID. If not provided, the latest version will be tracked."
+    )
+    __properties: ClassVar[List[str]] = ["id", "version_id"]
+
+    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 EvaluatorReference 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,
+        )
+        # set to None if version_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.version_id is None and "version_id" in self.model_fields_set:
+            _dict["version_id"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EvaluatorReference from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"id": obj.get("id"), "version_id": obj.get("version_id")})
+        return _obj

root/generated/openapi_aclient/models/evaluator_reference_request.py

@@ -0,0 +1,90 @@
+# coding: utf-8
+
+"""
+Root Signals API
+
+Root Signals JSON API provides a way to access Root Signals using provisioned API token
+
+The version of the OpenAPI document: 1.0.0 (latest)
+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, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing_extensions import Self
+
+
+class EvaluatorReferenceRequest(BaseModel):
+    """
+    EvaluatorReferenceRequest
+    """  # noqa: E501
+
+    id: StrictStr
+    version_id: Optional[StrictStr] = Field(
+        default=None, description="Optional version ID. If not provided, the latest version will be tracked."
+    )
+    __properties: ClassVar[List[str]] = ["id", "version_id"]
+
+    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 EvaluatorReferenceRequest 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,
+        )
+        # set to None if version_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.version_id is None and "version_id" in self.model_fields_set:
+            _dict["version_id"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EvaluatorReferenceRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"id": obj.get("id"), "version_id": obj.get("version_id")})
+        return _obj

root/generated/openapi_aclient/models/evaluator_request.py

@@ -0,0 +1,194 @@
+# coding: utf-8
+
+"""
+Root Signals API
+
+Root Signals JSON API provides a way to access Root Signals using provisioned API token
+
+The version of the OpenAPI document: 1.0.0 (latest)
+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, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing_extensions import Annotated, Self
+
+from root.generated.openapi_aclient.models.evaluator_demonstrations_request import EvaluatorDemonstrationsRequest
+from root.generated.openapi_aclient.models.input_variable_request import InputVariableRequest
+from root.generated.openapi_aclient.models.model_params_request import ModelParamsRequest
+from root.generated.openapi_aclient.models.reference_variable_request import ReferenceVariableRequest
+from root.generated.openapi_aclient.models.status_enum import StatusEnum
+
+
+class EvaluatorRequest(BaseModel):
+    """
+    EvaluatorRequest
+    """  # noqa: E501
+
+    change_note: Optional[StrictStr] = None
+    evaluator_demonstrations: Optional[List[EvaluatorDemonstrationsRequest]] = None
+    input_variables: Optional[List[InputVariableRequest]] = None
+    model_params: Optional[ModelParamsRequest] = None
+    models: Optional[List[Annotated[str, Field(min_length=1, strict=True)]]] = Field(
+        default=None,
+        description="Primary model (index 0) and an optional list of fallback models to use if the primary model is not available. If not provided, a default model will be used.",
+    )
+    name: Annotated[str, Field(min_length=2, strict=True, max_length=1000)]
+    objective_id: StrictStr
+    objective_version_id: Optional[StrictStr] = Field(
+        default=None,
+        description="Optionally pin the Skill to a specific version of an Objective. If not provided, the latest version of the objective will be used and followed.",
+    )
+    overwrite: Optional[StrictBool] = Field(
+        default=False, description="Overwrite existing skill with the same name. Only for POST requests."
+    )
+    prompt: Annotated[str, Field(min_length=1, strict=True, max_length=100000)]
+    reference_variables: Optional[List[ReferenceVariableRequest]] = None
+    status: Optional[StatusEnum] = None
+    system_message: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = [
+        "change_note",
+        "evaluator_demonstrations",
+        "input_variables",
+        "model_params",
+        "models",
+        "name",
+        "objective_id",
+        "objective_version_id",
+        "overwrite",
+        "prompt",
+        "reference_variables",
+        "status",
+        "system_message",
+    ]
+
+    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 EvaluatorRequest 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 evaluator_demonstrations (list)
+        _items = []
+        if self.evaluator_demonstrations:
+            for _item in self.evaluator_demonstrations:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["evaluator_demonstrations"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in input_variables (list)
+        _items = []
+        if self.input_variables:
+            for _item in self.input_variables:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["input_variables"] = _items
+        # override the default output from pydantic by calling `to_dict()` of model_params
+        if self.model_params:
+            _dict["model_params"] = self.model_params.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in reference_variables (list)
+        _items = []
+        if self.reference_variables:
+            for _item in self.reference_variables:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["reference_variables"] = _items
+        # set to None if change_note (nullable) is None
+        # and model_fields_set contains the field
+        if self.change_note is None and "change_note" in self.model_fields_set:
+            _dict["change_note"] = None
+
+        # set to None if evaluator_demonstrations (nullable) is None
+        # and model_fields_set contains the field
+        if self.evaluator_demonstrations is None and "evaluator_demonstrations" in self.model_fields_set:
+            _dict["evaluator_demonstrations"] = None
+
+        # set to None if model_params (nullable) is None
+        # and model_fields_set contains the field
+        if self.model_params is None and "model_params" in self.model_fields_set:
+            _dict["model_params"] = None
+
+        # set to None if objective_version_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.objective_version_id is None and "objective_version_id" in self.model_fields_set:
+            _dict["objective_version_id"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EvaluatorRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "change_note": obj.get("change_note"),
+                "evaluator_demonstrations": [
+                    EvaluatorDemonstrationsRequest.from_dict(_item) for _item in obj["evaluator_demonstrations"]
+                ]
+                if obj.get("evaluator_demonstrations") is not None
+                else None,
+                "input_variables": [InputVariableRequest.from_dict(_item) for _item in obj["input_variables"]]
+                if obj.get("input_variables") is not None
+                else None,
+                "model_params": ModelParamsRequest.from_dict(obj["model_params"])
+                if obj.get("model_params") is not None
+                else None,
+                "models": obj.get("models"),
+                "name": obj.get("name"),
+                "objective_id": obj.get("objective_id"),
+                "objective_version_id": obj.get("objective_version_id"),
+                "overwrite": obj.get("overwrite") if obj.get("overwrite") is not None else False,
+                "prompt": obj.get("prompt"),
+                "reference_variables": [
+                    ReferenceVariableRequest.from_dict(_item) for _item in obj["reference_variables"]
+                ]
+                if obj.get("reference_variables") is not None
+                else None,
+                "status": obj.get("status"),
+                "system_message": obj.get("system_message"),
+            }
+        )
+        return _obj

root/generated/openapi_aclient/models/evaluator_result.py

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+"""
+Root Signals API
+
+Root Signals JSON API provides a way to access Root Signals using provisioned API token
+
+The version of the OpenAPI document: 1.0.0 (latest)
+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, ClassVar, Dict, List, Optional, Set, Union
+
+from pydantic import BaseModel, ConfigDict, StrictFloat, StrictInt, StrictStr
+from typing_extensions import Self
+
+
+class EvaluatorResult(BaseModel):
+    """
+    EvaluatorResult
+    """  # noqa: E501
+
+    evaluator_name: StrictStr
+    score: Optional[Union[StrictFloat, StrictInt]]
+    justification: Optional[StrictStr]
+    evaluator_id: StrictStr
+    evaluator_version_id: StrictStr
+    __properties: ClassVar[List[str]] = [
+        "evaluator_name",
+        "score",
+        "justification",
+        "evaluator_id",
+        "evaluator_version_id",
+    ]
+
+    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 EvaluatorResult 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,
+        )
+        # set to None if score (nullable) is None
+        # and model_fields_set contains the field
+        if self.score is None and "score" in self.model_fields_set:
+            _dict["score"] = None
+
+        # set to None if justification (nullable) is None
+        # and model_fields_set contains the field
+        if self.justification is None and "justification" in self.model_fields_set:
+            _dict["justification"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EvaluatorResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "evaluator_name": obj.get("evaluator_name"),
+                "score": obj.get("score"),
+                "justification": obj.get("justification"),
+                "evaluator_id": obj.get("evaluator_id"),
+                "evaluator_version_id": obj.get("evaluator_version_id"),
+            }
+        )
+        return _obj