scorable 1.6.4__py3-none-any.whl

root/generated/openapi_client/models/paginated_objective_list_list.py

@@ -0,0 +1,111 @@
+# 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, StrictStr
+from typing_extensions import Self
+
+from root.generated.openapi_client.models.objective_list import ObjectiveList
+
+
+class PaginatedObjectiveListList(BaseModel):
+    """
+    PaginatedObjectiveListList
+    """  # noqa: E501
+
+    next: Optional[StrictStr] = None
+    previous: Optional[StrictStr] = None
+    results: List[ObjectiveList]
+    __properties: ClassVar[List[str]] = ["next", "previous", "results"]
+
+    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 PaginatedObjectiveListList 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 results (list)
+        _items = []
+        if self.results:
+            for _item in self.results:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["results"] = _items
+        # set to None if next (nullable) is None
+        # and model_fields_set contains the field
+        if self.next is None and "next" in self.model_fields_set:
+            _dict["next"] = None
+
+        # set to None if previous (nullable) is None
+        # and model_fields_set contains the field
+        if self.previous is None and "previous" in self.model_fields_set:
+            _dict["previous"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PaginatedObjectiveListList from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "next": obj.get("next"),
+                "previous": obj.get("previous"),
+                "results": [ObjectiveList.from_dict(_item) for _item in obj["results"]]
+                if obj.get("results") is not None
+                else None,
+            }
+        )
+        return _obj

root/generated/openapi_client/models/patched_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_client.models.evaluator_demonstrations_request import EvaluatorDemonstrationsRequest
+from root.generated.openapi_client.models.input_variable_request import InputVariableRequest
+from root.generated.openapi_client.models.model_params_request import ModelParamsRequest
+from root.generated.openapi_client.models.reference_variable_request import ReferenceVariableRequest
+from root.generated.openapi_client.models.status_enum import StatusEnum
+
+
+class PatchedEvaluatorRequest(BaseModel):
+    """
+    PatchedEvaluatorRequest
+    """  # 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: Optional[Annotated[str, Field(min_length=2, strict=True, max_length=1000)]] = None
+    objective_id: Optional[StrictStr] = None
+    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: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=100000)]] = None
+    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 PatchedEvaluatorRequest 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 PatchedEvaluatorRequest 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_client/models/patched_judge_request.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
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated, Self
+
+from root.generated.openapi_client.models.evaluator_reference_request import EvaluatorReferenceRequest
+from root.generated.openapi_client.models.status_enum import StatusEnum
+
+
+class PatchedJudgeRequest(BaseModel):
+    """
+    PatchedJudgeRequest
+    """  # noqa: E501
+
+    evaluator_references: Optional[List[EvaluatorReferenceRequest]] = None
+    intent: Optional[Annotated[str, Field(min_length=1, strict=True)]] = Field(
+        default=None, description="Intent for the judge"
+    )
+    name: Optional[Annotated[str, Field(min_length=3, strict=True, max_length=512)]] = None
+    stage: Optional[Annotated[str, Field(strict=True, max_length=255)]] = None
+    status: Optional[StatusEnum] = None
+    __properties: ClassVar[List[str]] = ["evaluator_references", "intent", "name", "stage", "status"]
+
+    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 PatchedJudgeRequest 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_references (list)
+        _items = []
+        if self.evaluator_references:
+            for _item in self.evaluator_references:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["evaluator_references"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PatchedJudgeRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "evaluator_references": [
+                    EvaluatorReferenceRequest.from_dict(_item) for _item in obj["evaluator_references"]
+                ]
+                if obj.get("evaluator_references") is not None
+                else None,
+                "intent": obj.get("intent"),
+                "name": obj.get("name"),
+                "stage": obj.get("stage"),
+                "status": obj.get("status"),
+            }
+        )
+        return _obj

root/generated/openapi_client/models/patched_model_request.py

@@ -0,0 +1,118 @@
+# 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
+from typing_extensions import Annotated, Self
+
+
+class PatchedModelRequest(BaseModel):
+    """
+    PatchedModelRequest
+    """  # noqa: E501
+
+    default_key: Optional[Annotated[str, Field(strict=True, max_length=4000)]] = None
+    max_output_token_count: Optional[Annotated[int, Field(strict=True, ge=800)]] = None
+    max_token_count: Optional[Annotated[int, Field(le=2147483647, strict=True, ge=0)]] = None
+    model: Optional[Annotated[str, Field(min_length=1, strict=True)]] = None
+    name: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=100)]] = None
+    url: Optional[Annotated[str, Field(strict=True, max_length=1024)]] = None
+    __properties: ClassVar[List[str]] = [
+        "default_key",
+        "max_output_token_count",
+        "max_token_count",
+        "model",
+        "name",
+        "url",
+    ]
+
+    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 PatchedModelRequest 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 default_key (nullable) is None
+        # and model_fields_set contains the field
+        if self.default_key is None and "default_key" in self.model_fields_set:
+            _dict["default_key"] = None
+
+        # set to None if max_token_count (nullable) is None
+        # and model_fields_set contains the field
+        if self.max_token_count is None and "max_token_count" in self.model_fields_set:
+            _dict["max_token_count"] = None
+
+        # set to None if url (nullable) is None
+        # and model_fields_set contains the field
+        if self.url is None and "url" in self.model_fields_set:
+            _dict["url"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PatchedModelRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "default_key": obj.get("default_key"),
+                "max_output_token_count": obj.get("max_output_token_count"),
+                "max_token_count": obj.get("max_token_count"),
+                "model": obj.get("model"),
+                "name": obj.get("name"),
+                "url": obj.get("url"),
+            }
+        )
+        return _obj

root/generated/openapi_client/models/patched_objective_request.py

@@ -0,0 +1,113 @@
+# 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_client.models.objective_validator_request import ObjectiveValidatorRequest
+from root.generated.openapi_client.models.status_enum import StatusEnum
+
+
+class PatchedObjectiveRequest(BaseModel):
+    """
+    PatchedObjectiveRequest
+    """  # noqa: E501
+
+    intent: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=100000)]] = None
+    status: Optional[StatusEnum] = None
+    validators: Optional[List[ObjectiveValidatorRequest]] = None
+    force_create: Optional[StrictBool] = Field(
+        default=None, description="Force creation of a new objective. Applies only to PUT requests."
+    )
+    test_dataset_id: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = ["intent", "status", "validators", "force_create", "test_dataset_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 PatchedObjectiveRequest 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 validators (list)
+        _items = []
+        if self.validators:
+            for _item in self.validators:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["validators"] = _items
+        # set to None if test_dataset_id (nullable) is None
+        # and model_fields_set contains the field
+        if self.test_dataset_id is None and "test_dataset_id" in self.model_fields_set:
+            _dict["test_dataset_id"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of PatchedObjectiveRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "intent": obj.get("intent"),
+                "status": obj.get("status"),
+                "validators": [ObjectiveValidatorRequest.from_dict(_item) for _item in obj["validators"]]
+                if obj.get("validators") is not None
+                else None,
+                "force_create": obj.get("force_create"),
+                "test_dataset_id": obj.get("test_dataset_id"),
+            }
+        )
+        return _obj