quantcdn-client 4.8.0__py3-none-any.whl

quantcdn/models/chat_with_ai_agent200_response.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    QuantCDN API
+
+    Unified API for QuantCDN Admin and QuantCloud Platform services
+
+    The version of the OpenAPI document: 4.8.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
+from typing import Any, ClassVar, Dict, List, Optional
+from quantcdn.models.chat_with_ai_agent200_response_response import ChatWithAIAgent200ResponseResponse
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ChatWithAIAgent200Response(BaseModel):
+    """
+    ChatWithAIAgent200Response
+    """ # noqa: E501
+    session_id: Optional[StrictStr] = Field(default=None, alias="sessionId")
+    response: Optional[ChatWithAIAgent200ResponseResponse] = None
+    __properties: ClassVar[List[str]] = ["sessionId", "response"]
+
+    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 ChatWithAIAgent200Response 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 response
+        if self.response:
+            _dict['response'] = self.response.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ChatWithAIAgent200Response from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "sessionId": obj.get("sessionId"),
+            "response": ChatWithAIAgent200ResponseResponse.from_dict(obj["response"]) if obj.get("response") is not None else None
+        })
+        return _obj
+
+

quantcdn/models/chat_with_ai_agent200_response_response.py

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+"""
+    QuantCDN API
+
+    Unified API for QuantCDN Admin and QuantCloud Platform services
+
+    The version of the OpenAPI document: 4.8.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
+from typing import Any, ClassVar, Dict, List, Optional
+from quantcdn.models.chat_with_ai_agent200_response_response_usage import ChatWithAIAgent200ResponseResponseUsage
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ChatWithAIAgent200ResponseResponse(BaseModel):
+    """
+    ChatWithAIAgent200ResponseResponse
+    """ # noqa: E501
+    text: Optional[StrictStr] = None
+    stop_reason: Optional[StrictStr] = Field(default=None, alias="stopReason")
+    usage: Optional[ChatWithAIAgent200ResponseResponseUsage] = None
+    tool_results: Optional[List[Dict[str, Any]]] = Field(default=None, alias="toolResults")
+    __properties: ClassVar[List[str]] = ["text", "stopReason", "usage", "toolResults"]
+
+    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 ChatWithAIAgent200ResponseResponse 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 usage
+        if self.usage:
+            _dict['usage'] = self.usage.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ChatWithAIAgent200ResponseResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "text": obj.get("text"),
+            "stopReason": obj.get("stopReason"),
+            "usage": ChatWithAIAgent200ResponseResponseUsage.from_dict(obj["usage"]) if obj.get("usage") is not None else None,
+            "toolResults": obj.get("toolResults")
+        })
+        return _obj
+
+

quantcdn/models/chat_with_ai_agent200_response_response_usage.py

@@ -0,0 +1,89 @@
+# coding: utf-8
+
+"""
+    QuantCDN API
+
+    Unified API for QuantCDN Admin and QuantCloud Platform services
+
+    The version of the OpenAPI document: 4.8.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, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ChatWithAIAgent200ResponseResponseUsage(BaseModel):
+    """
+    ChatWithAIAgent200ResponseResponseUsage
+    """ # noqa: E501
+    input_tokens: Optional[StrictInt] = Field(default=None, alias="inputTokens")
+    output_tokens: Optional[StrictInt] = Field(default=None, alias="outputTokens")
+    __properties: ClassVar[List[str]] = ["inputTokens", "outputTokens"]
+
+    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 ChatWithAIAgent200ResponseResponseUsage 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ChatWithAIAgent200ResponseResponseUsage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "inputTokens": obj.get("inputTokens"),
+            "outputTokens": obj.get("outputTokens")
+        })
+        return _obj
+
+

quantcdn/models/chat_with_ai_agent_request.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    QuantCDN API
+
+    Unified API for QuantCDN Admin and QuantCloud Platform services
+
+    The version of the OpenAPI document: 4.8.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, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ChatWithAIAgentRequest(BaseModel):
+    """
+    ChatWithAIAgentRequest
+    """ # noqa: E501
+    message: StrictStr = Field(description="The user's message to the agent")
+    session_id: Optional[StrictStr] = Field(default=None, description="Optional session ID to continue a conversation", alias="sessionId")
+    user_id: Optional[StrictStr] = Field(default=None, description="Optional user identifier for session isolation", alias="userId")
+    stream: Optional[StrictBool] = Field(default=False, description="Whether to stream the response (SSE)")
+    __properties: ClassVar[List[str]] = ["message", "sessionId", "userId", "stream"]
+
+    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 ChatWithAIAgentRequest 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ChatWithAIAgentRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "message": obj.get("message"),
+            "sessionId": obj.get("sessionId"),
+            "userId": obj.get("userId"),
+            "stream": obj.get("stream") if obj.get("stream") is not None else False
+        })
+        return _obj
+
+

quantcdn/models/command.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+    QuantCDN API
+
+    Unified API for QuantCDN Admin and QuantCloud Platform services
+
+    The version of the OpenAPI document: 4.8.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, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Command(BaseModel):
+    """
+    Command
+    """ # noqa: E501
+    run_id: Optional[StrictStr] = Field(default=None, alias="runId")
+    run_type: Optional[StrictStr] = Field(default=None, alias="runType")
+    command: Optional[StrictStr] = None
+    status: Optional[StrictStr] = None
+    start_time: Optional[StrictStr] = Field(default=None, alias="startTime")
+    end_time: Optional[StrictStr] = Field(default=None, alias="endTime")
+    exit_code: Optional[StrictInt] = Field(default=None, alias="exitCode")
+    output: Optional[List[StrictStr]] = None
+    schedule_name: Optional[StrictStr] = Field(default=None, alias="scheduleName")
+    target_container_name: Optional[StrictStr] = Field(default=None, alias="targetContainerName")
+    __properties: ClassVar[List[str]] = ["runId", "runType", "command", "status", "startTime", "endTime", "exitCode", "output", "scheduleName", "targetContainerName"]
+
+    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 Command 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,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Command from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "runId": obj.get("runId"),
+            "runType": obj.get("runType"),
+            "command": obj.get("command"),
+            "status": obj.get("status"),
+            "startTime": obj.get("startTime"),
+            "endTime": obj.get("endTime"),
+            "exitCode": obj.get("exitCode"),
+            "output": obj.get("output"),
+            "scheduleName": obj.get("scheduleName"),
+            "targetContainerName": obj.get("targetContainerName")
+        })
+        return _obj
+
+

quantcdn/models/compose.py

@@ -0,0 +1,125 @@
+# coding: utf-8
+
+"""
+    QuantCDN API
+
+    Unified API for QuantCDN Admin and QuantCloud Platform services
+
+    The version of the OpenAPI document: 4.8.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, StrictBool, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from quantcdn.models.container import Container
+from quantcdn.models.spot_configuration import SpotConfiguration
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Compose(BaseModel):
+    """
+    Compose
+    """ # noqa: E501
+    containers: Optional[List[Container]] = None
+    architecture: Optional[StrictStr] = Field(default=None, description="CPU architecture (X86_64 or ARM64)")
+    task_cpu: Optional[StrictInt] = Field(default=None, description="Task-level CPU units (e.g., 256, 512, 1024)", alias="taskCpu")
+    task_memory: Optional[StrictInt] = Field(default=None, description="Task-level memory in MB", alias="taskMemory")
+    min_capacity: Optional[StrictInt] = Field(default=None, description="Minimum number of instances", alias="minCapacity")
+    max_capacity: Optional[StrictInt] = Field(default=None, description="Maximum number of instances", alias="maxCapacity")
+    spot_configuration: Optional[SpotConfiguration] = Field(default=None, alias="spotConfiguration")
+    enable_cross_env_networking: Optional[StrictBool] = Field(default=False, description="Optional. Enable cross-environment networking within the same application. When false (default): Uses shared security group for complete isolation (most secure). When true: Uses app-specific security group to enable communication between environments of the same application (e.g., staging can connect to production database). Note: If enableCrossAppNetworking is true, this setting is overridden.", alias="enableCrossEnvNetworking")
+    enable_cross_app_networking: Optional[StrictBool] = Field(default=False, description="Optional. Enable cross-application networking within the same organization. When false (default): Uses shared/app-specific security group based on enableCrossEnvNetworking. When true: Uses org-specific security group to enable container-to-container communication with ALL applications in the same organization via service discovery (microservices architecture). This setting takes priority over enableCrossEnvNetworking.", alias="enableCrossAppNetworking")
+    __properties: ClassVar[List[str]] = ["containers", "architecture", "taskCpu", "taskMemory", "minCapacity", "maxCapacity", "spotConfiguration", "enableCrossEnvNetworking", "enableCrossAppNetworking"]
+
+    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 Compose 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 containers (list)
+        _items = []
+        if self.containers:
+            for _item_containers in self.containers:
+                if _item_containers:
+                    _items.append(_item_containers.to_dict())
+            _dict['containers'] = _items
+        # override the default output from pydantic by calling `to_dict()` of spot_configuration
+        if self.spot_configuration:
+            _dict['spotConfiguration'] = self.spot_configuration.to_dict()
+        # set to None if enable_cross_env_networking (nullable) is None
+        # and model_fields_set contains the field
+        if self.enable_cross_env_networking is None and "enable_cross_env_networking" in self.model_fields_set:
+            _dict['enableCrossEnvNetworking'] = None
+
+        # set to None if enable_cross_app_networking (nullable) is None
+        # and model_fields_set contains the field
+        if self.enable_cross_app_networking is None and "enable_cross_app_networking" in self.model_fields_set:
+            _dict['enableCrossAppNetworking'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Compose from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "containers": [Container.from_dict(_item) for _item in obj["containers"]] if obj.get("containers") is not None else None,
+            "architecture": obj.get("architecture"),
+            "taskCpu": obj.get("taskCpu"),
+            "taskMemory": obj.get("taskMemory"),
+            "minCapacity": obj.get("minCapacity"),
+            "maxCapacity": obj.get("maxCapacity"),
+            "spotConfiguration": SpotConfiguration.from_dict(obj["spotConfiguration"]) if obj.get("spotConfiguration") is not None else None,
+            "enableCrossEnvNetworking": obj.get("enableCrossEnvNetworking") if obj.get("enableCrossEnvNetworking") is not None else False,
+            "enableCrossAppNetworking": obj.get("enableCrossAppNetworking") if obj.get("enableCrossAppNetworking") is not None else False
+        })
+        return _obj
+
+