scorable 1.6.4__py3-none-any.whl

root/generated/openapi_aclient/models/judge_list.py

@@ -0,0 +1,156 @@
+# 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 datetime import datetime
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing_extensions import Self
+
+from root.generated.openapi_aclient.models.evaluator_inputs_value import EvaluatorInputsValue
+from root.generated.openapi_aclient.models.nested_evaluator import NestedEvaluator
+from root.generated.openapi_aclient.models.status_enum import StatusEnum
+
+
+class JudgeList(BaseModel):
+    """
+    JudgeList
+    """  # noqa: E501
+
+    id: StrictStr
+    name: StrictStr
+    intent: StrictStr
+    created_at: Optional[datetime]
+    status: StatusEnum
+    inputs: Dict[str, EvaluatorInputsValue] = Field(
+        description="Schema defining the input parameters required for execution. The schema consists of variables defined in the prompt template (predicate) and special variables like functions, contexts, and expected output."
+    )
+    evaluators: List[NestedEvaluator]
+    meta: Dict[str, Any] = Field(alias="_meta")
+    __properties: ClassVar[List[str]] = [
+        "id",
+        "name",
+        "intent",
+        "created_at",
+        "status",
+        "inputs",
+        "evaluators",
+        "_meta",
+    ]
+
+    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 JudgeList 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.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set(
+            [
+                "id",
+                "intent",
+                "created_at",
+                "status",
+                "inputs",
+                "evaluators",
+                "meta",
+            ]
+        )
+
+        _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 value in inputs (dict)
+        _field_dict = {}
+        if self.inputs:
+            for _key in self.inputs:
+                if self.inputs[_key]:
+                    _field_dict[_key] = self.inputs[_key].to_dict()
+            _dict["inputs"] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each item in evaluators (list)
+        _items = []
+        if self.evaluators:
+            for _item in self.evaluators:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["evaluators"] = _items
+        # set to None if created_at (nullable) is None
+        # and model_fields_set contains the field
+        if self.created_at is None and "created_at" in self.model_fields_set:
+            _dict["created_at"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of JudgeList 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"),
+                "name": obj.get("name"),
+                "intent": obj.get("intent"),
+                "created_at": obj.get("created_at"),
+                "status": obj.get("status"),
+                "inputs": dict((_k, EvaluatorInputsValue.from_dict(_v)) for _k, _v in obj["inputs"].items())
+                if obj.get("inputs") is not None
+                else None,
+                "evaluators": [NestedEvaluator.from_dict(_item) for _item in obj["evaluators"]]
+                if obj.get("evaluators") is not None
+                else None,
+                "_meta": obj.get("_meta"),
+            }
+        )
+        return _obj

root/generated/openapi_aclient/models/judge_rectifier_request_request.py

@@ -0,0 +1,114 @@
+# 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 Annotated, Self
+
+from root.generated.openapi_aclient.models.evaluator_execution_functions_request import (
+    EvaluatorExecutionFunctionsRequest,
+)
+
+
+class JudgeRectifierRequestRequest(BaseModel):
+    """
+    JudgeRectifierRequestRequest
+    """  # noqa: E501
+
+    request: Optional[StrictStr] = ""
+    response: Optional[StrictStr] = ""
+    contexts: Optional[List[Annotated[str, Field(min_length=1, strict=True)]]] = None
+    functions: Optional[List[EvaluatorExecutionFunctionsRequest]] = None
+    expected_output: Optional[Annotated[str, Field(strict=True, max_length=3500000)]] = None
+    tags: Optional[List[Annotated[str, Field(min_length=1, strict=True, max_length=1000)]]] = None
+    __properties: ClassVar[List[str]] = ["request", "response", "contexts", "functions", "expected_output", "tags"]
+
+    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 JudgeRectifierRequestRequest 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 functions (list)
+        _items = []
+        if self.functions:
+            for _item in self.functions:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["functions"] = _items
+        # set to None if expected_output (nullable) is None
+        # and model_fields_set contains the field
+        if self.expected_output is None and "expected_output" in self.model_fields_set:
+            _dict["expected_output"] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of JudgeRectifierRequestRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "request": obj.get("request") if obj.get("request") is not None else "",
+                "response": obj.get("response") if obj.get("response") is not None else "",
+                "contexts": obj.get("contexts"),
+                "functions": [EvaluatorExecutionFunctionsRequest.from_dict(_item) for _item in obj["functions"]]
+                if obj.get("functions") is not None
+                else None,
+                "expected_output": obj.get("expected_output"),
+                "tags": obj.get("tags"),
+            }
+        )
+        return _obj

root/generated/openapi_aclient/models/judge_rectifier_response.py

@@ -0,0 +1,121 @@
+# 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
+
+from root.generated.openapi_aclient.models.evaluator_result import EvaluatorResult
+
+
+class JudgeRectifierResponse(BaseModel):
+    """
+    JudgeRectifierResponse
+    """  # noqa: E501
+
+    evaluator_results: List[EvaluatorResult] = Field(description="List of results from each evaluator")
+    improved_response: StrictStr = Field(description="Improved response from rectifier")
+    original_response: StrictStr = Field(description="Original response before rectification")
+    original_evaluator_results: List[EvaluatorResult] = Field(
+        description="List of evaluation results for the original response"
+    )
+    __properties: ClassVar[List[str]] = [
+        "evaluator_results",
+        "improved_response",
+        "original_response",
+        "original_evaluator_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 JudgeRectifierResponse 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_results (list)
+        _items = []
+        if self.evaluator_results:
+            for _item in self.evaluator_results:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["evaluator_results"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in original_evaluator_results (list)
+        _items = []
+        if self.original_evaluator_results:
+            for _item in self.original_evaluator_results:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["original_evaluator_results"] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of JudgeRectifierResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "evaluator_results": [EvaluatorResult.from_dict(_item) for _item in obj["evaluator_results"]]
+                if obj.get("evaluator_results") is not None
+                else None,
+                "improved_response": obj.get("improved_response"),
+                "original_response": obj.get("original_response"),
+                "original_evaluator_results": [
+                    EvaluatorResult.from_dict(_item) for _item in obj["original_evaluator_results"]
+                ]
+                if obj.get("original_evaluator_results") is not None
+                else None,
+            }
+        )
+        return _obj

root/generated/openapi_aclient/models/judge_request.py

@@ -0,0 +1,108 @@
+# 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_aclient.models.evaluator_reference_request import EvaluatorReferenceRequest
+from root.generated.openapi_aclient.models.status_enum import StatusEnum
+
+
+class JudgeRequest(BaseModel):
+    """
+    JudgeRequest
+    """  # noqa: E501
+
+    evaluator_references: Optional[List[EvaluatorReferenceRequest]] = None
+    intent: Annotated[str, Field(min_length=1, strict=True)] = Field(description="Intent for the judge")
+    name: Annotated[str, Field(min_length=3, strict=True, max_length=512)]
+    stage: Optional[Annotated[str, Field(strict=True, max_length=255)]] = None
+    status: StatusEnum
+    __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 JudgeRequest 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 JudgeRequest 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_aclient/models/model.py

@@ -0,0 +1,126 @@
+# 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 Annotated, Self
+
+
+class Model(BaseModel):
+    """
+    Model
+    """  # noqa: E501
+
+    default_key: Optional[Annotated[str, Field(strict=True, max_length=4000)]] = None
+    id: StrictStr
+    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[StrictStr] = None
+    name: Annotated[str, Field(strict=True, max_length=100)]
+    url: Optional[Annotated[str, Field(strict=True, max_length=1024)]] = None
+    __properties: ClassVar[List[str]] = [
+        "default_key",
+        "id",
+        "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 Model 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.
+        * OpenAPI `readOnly` fields are excluded.
+        """
+        excluded_fields: Set[str] = set(
+            [
+                "id",
+            ]
+        )
+
+        _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 Model 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"),
+                "id": obj.get("id"),
+                "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