adaline-api 1.0.0__py3-none-any.whl

adaline_api/models/function_parameter_type.py

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+"""
+    Adaline API
+
+    API for managing Adaline deployments, logs, and core type definitions.
+
+    The version of the OpenAPI document: 1.0.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, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from adaline_api.models.response_schema_property_type_enum_inner import ResponseSchemaPropertyTypeEnumInner
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionParameterType(BaseModel):
+    """
+    FunctionParameterType
+    """ # noqa: E501
+    any_of: Optional[List[Any]] = Field(default=None, alias="anyOf")
+    type: Optional[StrictStr] = None
+    default: Optional[Any] = None
+    title: Optional[StrictStr] = None
+    description: Optional[Annotated[str, Field(strict=True, max_length=4096)]] = None
+    properties: Optional[Dict[str, Any]] = None
+    required: Optional[List[StrictStr]] = None
+    min_items: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, alias="minItems")
+    max_items: Optional[StrictInt] = Field(default=None, alias="maxItems")
+    items: Optional[Dict[str, Any]] = Field(default=None, description="Recursive structure to handle nested arrays and objects")
+    enum: Optional[List[Optional[ResponseSchemaPropertyTypeEnumInner]]] = Field(default=None, description="Enum for allowed values")
+    minimum: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Minimum value for number")
+    maximum: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="Maximum value for number")
+    min_length: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="Minimum length for string", alias="minLength")
+    max_length: Optional[StrictInt] = Field(default=None, description="Maximum length for string", alias="maxLength")
+    __properties: ClassVar[List[str]] = ["anyOf", "type", "default", "title", "description", "properties", "required", "minItems", "maxItems", "items", "enum", "minimum", "maximum", "minLength", "maxLength"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['object', 'array', 'number', 'string', 'boolean', 'null']):
+            raise ValueError("must be one of enum values ('object', 'array', 'number', 'string', 'boolean', 'null')")
+        return 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 FunctionParameterType 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 enum (list)
+        _items = []
+        if self.enum:
+            for _item_enum in self.enum:
+                if _item_enum:
+                    _items.append(_item_enum.to_dict())
+            _dict['enum'] = _items
+        # set to None if default (nullable) is None
+        # and model_fields_set contains the field
+        if self.default is None and "default" in self.model_fields_set:
+            _dict['default'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FunctionParameterType from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "anyOf": obj.get("anyOf"),
+            "type": obj.get("type"),
+            "default": obj.get("default"),
+            "title": obj.get("title"),
+            "description": obj.get("description"),
+            "properties": obj.get("properties"),
+            "required": obj.get("required"),
+            "minItems": obj.get("minItems"),
+            "maxItems": obj.get("maxItems"),
+            "items": obj.get("items"),
+            "enum": [ResponseSchemaPropertyTypeEnumInner.from_dict(_item) for _item in obj["enum"]] if obj.get("enum") is not None else None,
+            "minimum": obj.get("minimum"),
+            "maximum": obj.get("maximum"),
+            "minLength": obj.get("minLength"),
+            "maxLength": obj.get("maxLength")
+        })
+        return _obj
+
+

adaline_api/models/function_parameters.py

@@ -0,0 +1,115 @@
+# coding: utf-8
+
+"""
+    Adaline API
+
+    API for managing Adaline deployments, logs, and core type definitions.
+
+    The version of the OpenAPI document: 1.0.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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from adaline_api.models.function_parameter import FunctionParameter
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionParameters(BaseModel):
+    """
+    Complete JSON schema for function/tool parameters object
+    """ # noqa: E501
+    type: StrictStr
+    title: Optional[StrictStr] = None
+    defs: Optional[Dict[str, Any]] = Field(default=None, alias="$defs")
+    properties: Optional[Dict[str, FunctionParameter]] = None
+    required: Optional[List[StrictStr]] = None
+    __properties: ClassVar[List[str]] = ["type", "title", "$defs", "properties", "required"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['object']):
+            raise ValueError("must be one of enum values ('object')")
+        return 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 FunctionParameters 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 value in properties (dict)
+        _field_dict = {}
+        if self.properties:
+            for _key_properties in self.properties:
+                if self.properties[_key_properties]:
+                    _field_dict[_key_properties] = self.properties[_key_properties].to_dict()
+            _dict['properties'] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FunctionParameters from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "title": obj.get("title"),
+            "$defs": obj.get("$defs"),
+            "properties": dict(
+                (_k, FunctionParameter.from_dict(_v))
+                for _k, _v in obj["properties"].items()
+            )
+            if obj.get("properties") is not None
+            else None,
+            "required": obj.get("required")
+        })
+        return _obj
+
+

adaline_api/models/function_parameters_type.py

@@ -0,0 +1,115 @@
+# coding: utf-8
+
+"""
+    Adaline API
+
+    API for managing Adaline deployments, logs, and core type definitions.
+
+    The version of the OpenAPI document: 1.0.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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from adaline_api.models.function_parameter_type import FunctionParameterType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionParametersType(BaseModel):
+    """
+    FunctionParametersType
+    """ # noqa: E501
+    type: StrictStr
+    title: Optional[StrictStr] = None
+    defs: Optional[Dict[str, Any]] = Field(default=None, alias="$defs")
+    properties: Optional[Dict[str, FunctionParameterType]] = None
+    required: Optional[List[StrictStr]] = None
+    __properties: ClassVar[List[str]] = ["type", "title", "$defs", "properties", "required"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['object']):
+            raise ValueError("must be one of enum values ('object')")
+        return 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 FunctionParametersType 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 value in properties (dict)
+        _field_dict = {}
+        if self.properties:
+            for _key_properties in self.properties:
+                if self.properties[_key_properties]:
+                    _field_dict[_key_properties] = self.properties[_key_properties].to_dict()
+            _dict['properties'] = _field_dict
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FunctionParametersType from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "title": obj.get("title"),
+            "$defs": obj.get("$defs"),
+            "properties": dict(
+                (_k, FunctionParameterType.from_dict(_v))
+                for _k, _v in obj["properties"].items()
+            )
+            if obj.get("properties") is not None
+            else None,
+            "required": obj.get("required")
+        })
+        return _obj
+
+

adaline_api/models/function_request_http.py

@@ -0,0 +1,121 @@
+# coding: utf-8
+
+"""
+    Adaline API
+
+    API for managing Adaline deployments, logs, and core type definitions.
+
+    The version of the OpenAPI document: 1.0.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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from adaline_api.models.function_request_retry import FunctionRequestRetry
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionRequestHttp(BaseModel):
+    """
+    HTTP request configuration for executing function/tool calls via REST API
+    """ # noqa: E501
+    type: StrictStr
+    method: StrictStr
+    url: StrictStr
+    headers: Optional[Dict[str, StrictStr]] = None
+    query: Optional[Dict[str, StrictStr]] = None
+    body: Optional[Dict[str, Any]] = None
+    proxy_url: Optional[StrictStr] = Field(default=None, alias="proxyUrl")
+    proxy_headers: Optional[Dict[str, StrictStr]] = Field(default=None, alias="proxyHeaders")
+    retry: Optional[FunctionRequestRetry] = None
+    __properties: ClassVar[List[str]] = ["type", "method", "url", "headers", "query", "body", "proxyUrl", "proxyHeaders", "retry"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['http']):
+            raise ValueError("must be one of enum values ('http')")
+        return value
+
+    @field_validator('method')
+    def method_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['get', 'post']):
+            raise ValueError("must be one of enum values ('get', 'post')")
+        return 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 FunctionRequestHttp 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 retry
+        if self.retry:
+            _dict['retry'] = self.retry.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FunctionRequestHttp from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "method": obj.get("method"),
+            "url": obj.get("url"),
+            "headers": obj.get("headers"),
+            "query": obj.get("query"),
+            "body": obj.get("body"),
+            "proxyUrl": obj.get("proxyUrl"),
+            "proxyHeaders": obj.get("proxyHeaders"),
+            "retry": FunctionRequestRetry.from_dict(obj["retry"]) if obj.get("retry") is not None else None
+        })
+        return _obj
+
+

adaline_api/models/function_request_http_type.py

@@ -0,0 +1,121 @@
+# coding: utf-8
+
+"""
+    Adaline API
+
+    API for managing Adaline deployments, logs, and core type definitions.
+
+    The version of the OpenAPI document: 1.0.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, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from adaline_api.models.function_request_retry_type import FunctionRequestRetryType
+from typing import Optional, Set
+from typing_extensions import Self
+
+class FunctionRequestHttpType(BaseModel):
+    """
+    FunctionRequestHttpType
+    """ # noqa: E501
+    type: StrictStr
+    method: StrictStr
+    url: StrictStr
+    headers: Optional[Dict[str, StrictStr]] = None
+    query: Optional[Dict[str, StrictStr]] = None
+    body: Optional[Dict[str, Any]] = None
+    proxy_url: Optional[StrictStr] = Field(default=None, alias="proxyUrl")
+    proxy_headers: Optional[Dict[str, StrictStr]] = Field(default=None, alias="proxyHeaders")
+    retry: Optional[FunctionRequestRetryType] = None
+    __properties: ClassVar[List[str]] = ["type", "method", "url", "headers", "query", "body", "proxyUrl", "proxyHeaders", "retry"]
+
+    @field_validator('type')
+    def type_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['http']):
+            raise ValueError("must be one of enum values ('http')")
+        return value
+
+    @field_validator('method')
+    def method_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['get', 'post']):
+            raise ValueError("must be one of enum values ('get', 'post')")
+        return 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 FunctionRequestHttpType 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 retry
+        if self.retry:
+            _dict['retry'] = self.retry.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of FunctionRequestHttpType from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "type": obj.get("type"),
+            "method": obj.get("method"),
+            "url": obj.get("url"),
+            "headers": obj.get("headers"),
+            "query": obj.get("query"),
+            "body": obj.get("body"),
+            "proxyUrl": obj.get("proxyUrl"),
+            "proxyHeaders": obj.get("proxyHeaders"),
+            "retry": FunctionRequestRetryType.from_dict(obj["retry"]) if obj.get("retry") is not None else None
+        })
+        return _obj
+
+