baiducloud-python-sdk-vdb 0.0.1__py3-none-any.whl

baiducloud_python_sdk_vdb/models/resize_instance_using_post_request.py

@@ -0,0 +1,179 @@
+"""
+Request entity for ResizeInstanceUsingPOSTRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+from baiducloud_python_sdk_vdb.models.milvus_component import MilvusComponent
+
+
+class ResizeInstanceUsingPOSTRequest(AbstractModel):
+    """
+    Request entity for ResizeInstanceUsingPOSTRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(
+        self,
+        engine_type=None,
+        components=None,
+        data_node_num=None,
+        disk_flavor=None,
+        disk_type=None,
+        env=None,
+        instance_id=None,
+        master_node_spec=None,
+        master_num=None,
+        node_spec=None,
+        node_type=None,
+        order_id=None,
+        proxy_node_spec=None,
+        proxy_num=None,
+    ):
+        """
+        Initialize ResizeInstanceUsingPOSTRequest request entity.
+
+        :param engine_type: engine_type parameter
+        :type engine_type: str (optional)
+
+        :param components: components parameter
+        :type components: List[MilvusComponent] (optional)
+
+        :param data_node_num: data_node_num parameter
+        :type data_node_num: int (optional)
+
+        :param disk_flavor: disk_flavor parameter
+        :type disk_flavor: int (optional)
+
+        :param disk_type: disk_type parameter
+        :type disk_type: str (optional)
+
+        :param env: env parameter
+        :type env: str (optional)
+
+        :param instance_id: instance_id parameter
+        :type instance_id: str (optional)
+
+        :param master_node_spec: master_node_spec parameter
+        :type master_node_spec: str (optional)
+
+        :param master_num: master_num parameter
+        :type master_num: int (optional)
+
+        :param node_spec: node_spec parameter
+        :type node_spec: str (optional)
+
+        :param node_type: node_type parameter
+        :type node_type: str (optional)
+
+        :param order_id: order_id parameter
+        :type order_id: str (optional)
+
+        :param proxy_node_spec: proxy_node_spec parameter
+        :type proxy_node_spec: str (optional)
+
+        :param proxy_num: proxy_num parameter
+        :type proxy_num: int (optional)
+        """
+        super().__init__()
+        self.engine_type = engine_type
+        self.components = components
+        self.data_node_num = data_node_num
+        self.disk_flavor = disk_flavor
+        self.disk_type = disk_type
+        self.env = env
+        self.instance_id = instance_id
+        self.master_node_spec = master_node_spec
+        self.master_num = master_num
+        self.node_spec = node_spec
+        self.node_type = node_type
+        self.order_id = order_id
+        self.proxy_node_spec = proxy_node_spec
+        self.proxy_num = proxy_num
+
+    def to_dict(self):
+        """
+        Convert the request entity to a dictionary representation.
+
+        Nested model objects are recursively converted to dictionaries.
+
+        :return: Dictionary representation of the request
+        :rtype: dict
+        """
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.components is not None:
+            result['components'] = [i.to_dict() for i in self.components]
+        if self.data_node_num is not None:
+            result['dataNodeNum'] = self.data_node_num
+        if self.disk_flavor is not None:
+            result['diskFlavor'] = self.disk_flavor
+        if self.disk_type is not None:
+            result['diskType'] = self.disk_type
+        if self.env is not None:
+            result['env'] = self.env
+        if self.instance_id is not None:
+            result['instanceId'] = self.instance_id
+        if self.master_node_spec is not None:
+            result['masterNodeSpec'] = self.master_node_spec
+        if self.master_num is not None:
+            result['masterNum'] = self.master_num
+        if self.node_spec is not None:
+            result['nodeSpec'] = self.node_spec
+        if self.node_type is not None:
+            result['nodeType'] = self.node_type
+        if self.order_id is not None:
+            result['orderId'] = self.order_id
+        if self.proxy_node_spec is not None:
+            result['proxyNodeSpec'] = self.proxy_node_spec
+        if self.proxy_num is not None:
+            result['proxyNum'] = self.proxy_num
+        return result
+
+    def from_dict(self, m):
+        """
+        Populate the request entity from a dictionary.
+
+        Nested dictionaries are recursively converted to model objects.
+
+        :param m: Dictionary containing request data
+        :type m: dict
+
+        :return: Self reference for method chaining
+        :rtype: ResizeInstanceUsingPOSTRequest
+
+        :raises TypeError: If input is not a dictionary or field type mismatch
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('engineType') is not None:
+            self.engine_type = m.get('engineType')
+        if m.get('components') is not None:
+            self.components = [MilvusComponent().from_dict(i) for i in m.get('components')]
+        if m.get('dataNodeNum') is not None:
+            self.data_node_num = m.get('dataNodeNum')
+        if m.get('diskFlavor') is not None:
+            self.disk_flavor = m.get('diskFlavor')
+        if m.get('diskType') is not None:
+            self.disk_type = m.get('diskType')
+        if m.get('env') is not None:
+            self.env = m.get('env')
+        if m.get('instanceId') is not None:
+            self.instance_id = m.get('instanceId')
+        if m.get('masterNodeSpec') is not None:
+            self.master_node_spec = m.get('masterNodeSpec')
+        if m.get('masterNum') is not None:
+            self.master_num = m.get('masterNum')
+        if m.get('nodeSpec') is not None:
+            self.node_spec = m.get('nodeSpec')
+        if m.get('nodeType') is not None:
+            self.node_type = m.get('nodeType')
+        if m.get('orderId') is not None:
+            self.order_id = m.get('orderId')
+        if m.get('proxyNodeSpec') is not None:
+            self.proxy_node_spec = m.get('proxyNodeSpec')
+        if m.get('proxyNum') is not None:
+            self.proxy_num = m.get('proxyNum')
+        return self

baiducloud_python_sdk_vdb/models/resize_instance_using_post_response.py

@@ -0,0 +1,61 @@
+"""
+Request entity for ResizeInstanceUsingPOSTResponse information.
+"""
+
+from baiducloud_python_sdk_core.bce_response import BceResponse
+
+
+class ResizeInstanceUsingPOSTResponse(BceResponse):
+    """
+    ResizeInstanceUsingPOSTResponse
+    """
+
+    def __init__(self, order_id=None):
+        """
+        Initialize ResizeInstanceUsingPOSTResponse response.
+
+        :param order_id: order_id field
+        :type order_id: str (optional)
+        """
+        super().__init__()
+        self.order_id = order_id
+
+    def to_dict(self):
+        """
+        Convert the response instance to a dictionary representation.
+
+        Includes metadata from the parent BceResponse class.
+        Nested model objects are recursively converted to dictionaries.
+
+        :return: Dictionary representation of the response
+        :rtype: dict
+        """
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.metadata is not None:
+            result['metadata'] = dict(self.metadata)
+        if self.order_id is not None:
+            result['orderId'] = self.order_id
+        return result
+
+    def from_dict(self, m):
+        """
+        Populate the response instance from a dictionary.
+
+        Nested dictionaries are recursively converted to model objects.
+
+        :param m: Dictionary containing response data
+        :type m: dict
+
+        :return: Self reference for method chaining
+        :rtype: ResizeInstanceUsingPOSTResponse
+
+        :raises TypeError: If input is not a dictionary or field type mismatch
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('orderId') is not None:
+            self.order_id = m.get('orderId')
+        return self

baiducloud_python_sdk_vdb/models/set_comment_using_post_request.py

@@ -0,0 +1,88 @@
+"""
+Request entity for SetCommentUsingPOSTRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class SetCommentUsingPOSTRequest(AbstractModel):
+    """
+    Request entity for SetCommentUsingPOSTRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(self, instance_id, engine_type=None, backup_id=None, batch_id=None, comment=None):
+        """
+        Initialize SetCommentUsingPOSTRequest request entity.
+
+        :param instance_id: instance_id parameter
+        :type instance_id: str (required)
+
+        :param engine_type: engine_type parameter
+        :type engine_type: str (optional)
+
+        :param backup_id: backup_id parameter
+        :type backup_id: str (optional)
+
+        :param batch_id: batch_id parameter
+        :type batch_id: str (optional)
+
+        :param comment: comment parameter
+        :type comment: str (optional)
+        """
+        super().__init__()
+        self.instance_id = instance_id
+        self.engine_type = engine_type
+        self.backup_id = backup_id
+        self.batch_id = batch_id
+        self.comment = comment
+
+    def to_dict(self):
+        """
+        Convert the request entity to a dictionary representation.
+
+        Nested model objects are recursively converted to dictionaries.
+
+        :return: Dictionary representation of the request
+        :rtype: dict
+        """
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.backup_id is not None:
+            result['backupId'] = self.backup_id
+        if self.batch_id is not None:
+            result['batchId'] = self.batch_id
+        if self.comment is not None:
+            result['comment'] = self.comment
+        return result
+
+    def from_dict(self, m):
+        """
+        Populate the request entity from a dictionary.
+
+        Nested dictionaries are recursively converted to model objects.
+
+        :param m: Dictionary containing request data
+        :type m: dict
+
+        :return: Self reference for method chaining
+        :rtype: SetCommentUsingPOSTRequest
+
+        :raises TypeError: If input is not a dictionary or field type mismatch
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('instanceId') is not None:
+            self.instance_id = m.get('instanceId')
+        if m.get('engineType') is not None:
+            self.engine_type = m.get('engineType')
+        if m.get('backupId') is not None:
+            self.backup_id = m.get('backupId')
+        if m.get('batchId') is not None:
+            self.batch_id = m.get('batchId')
+        if m.get('comment') is not None:
+            self.comment = m.get('comment')
+        return self

baiducloud_python_sdk_vdb/models/set_config_using_post_request.py

@@ -0,0 +1,90 @@
+"""
+Request entity for SetConfigUsingPOSTRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class SetConfigUsingPOSTRequest(AbstractModel):
+    """
+    Request entity for SetConfigUsingPOSTRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(
+        self, instance_id, engine_type=None, auto_backup_config=None, auto_backup_enabled=None, is_encrypt=None
+    ):
+        """
+        Initialize SetConfigUsingPOSTRequest request entity.
+
+        :param instance_id: instance_id parameter
+        :type instance_id: str (required)
+
+        :param engine_type: engine_type parameter
+        :type engine_type: str (optional)
+
+        :param auto_backup_config: auto_backup_config parameter
+        :type auto_backup_config: str (optional)
+
+        :param auto_backup_enabled: auto_backup_enabled parameter
+        :type auto_backup_enabled: bool (optional)
+
+        :param is_encrypt: is_encrypt parameter
+        :type is_encrypt: str (optional)
+        """
+        super().__init__()
+        self.instance_id = instance_id
+        self.engine_type = engine_type
+        self.auto_backup_config = auto_backup_config
+        self.auto_backup_enabled = auto_backup_enabled
+        self.is_encrypt = is_encrypt
+
+    def to_dict(self):
+        """
+        Convert the request entity to a dictionary representation.
+
+        Nested model objects are recursively converted to dictionaries.
+
+        :return: Dictionary representation of the request
+        :rtype: dict
+        """
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.auto_backup_config is not None:
+            result['autoBackupConfig'] = self.auto_backup_config
+        if self.auto_backup_enabled is not None:
+            result['autoBackupEnabled'] = self.auto_backup_enabled
+        if self.is_encrypt is not None:
+            result['isEncrypt'] = self.is_encrypt
+        return result
+
+    def from_dict(self, m):
+        """
+        Populate the request entity from a dictionary.
+
+        Nested dictionaries are recursively converted to model objects.
+
+        :param m: Dictionary containing request data
+        :type m: dict
+
+        :return: Self reference for method chaining
+        :rtype: SetConfigUsingPOSTRequest
+
+        :raises TypeError: If input is not a dictionary or field type mismatch
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('instanceId') is not None:
+            self.instance_id = m.get('instanceId')
+        if m.get('engineType') is not None:
+            self.engine_type = m.get('engineType')
+        if m.get('autoBackupConfig') is not None:
+            self.auto_backup_config = m.get('autoBackupConfig')
+        if m.get('autoBackupEnabled') is not None:
+            self.auto_backup_enabled = m.get('autoBackupEnabled')
+        if m.get('isEncrypt') is not None:
+            self.is_encrypt = m.get('isEncrypt')
+        return self

baiducloud_python_sdk_vdb/models/subnet.py

@@ -0,0 +1,90 @@
+"""
+Subnet information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class Subnet(AbstractModel):
+    """
+    Subnet
+    """
+
+    def __init__(self, az=None, cidr=None, name=None, short_id=None, subnet_id=None):
+        """
+        Initialize Subnet instance.
+
+        :param az:
+        :type az: str (optional)
+
+        :param cidr:
+        :type cidr: str (optional)
+
+        :param name:
+        :type name: str (optional)
+
+        :param short_id:
+        :type short_id: str (optional)
+
+        :param subnet_id:
+        :type subnet_id: str (optional)
+        """
+        super().__init__()
+        self.az = az
+        self.cidr = cidr
+        self.name = name
+        self.short_id = short_id
+        self.subnet_id = subnet_id
+
+    def to_dict(self):
+        """
+        Convert the model instance to a dictionary representation.
+
+        Nested model objects are recursively converted to dictionaries.
+
+        :return: Dictionary representation of the model
+        :rtype: dict
+        """
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.az is not None:
+            result['az'] = self.az
+        if self.cidr is not None:
+            result['cidr'] = self.cidr
+        if self.name is not None:
+            result['name'] = self.name
+        if self.short_id is not None:
+            result['shortId'] = self.short_id
+        if self.subnet_id is not None:
+            result['subnetId'] = self.subnet_id
+        return result
+
+    def from_dict(self, m):
+        """
+        Populate the model instance from a dictionary.
+
+        Nested dictionaries are recursively converted to model objects.
+
+        :param m: Dictionary containing model data
+        :type m: dict
+
+        :return: Self reference for method chaining
+        :rtype: Subnet
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('az') is not None:
+            self.az = m.get('az')
+        if m.get('cidr') is not None:
+            self.cidr = m.get('cidr')
+        if m.get('name') is not None:
+            self.name = m.get('name')
+        if m.get('shortId') is not None:
+            self.short_id = m.get('shortId')
+        if m.get('subnetId') is not None:
+            self.subnet_id = m.get('subnetId')
+        return self

baiducloud_python_sdk_vdb/models/target_package.py

@@ -0,0 +1,74 @@
+"""
+TargetPackage information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class TargetPackage(AbstractModel):
+    """
+    TargetPackage
+    """
+
+    def __init__(self, target_milvus_kernel_version=None, target_package_version=None, upgrade_note=None):
+        """
+        Initialize TargetPackage instance.
+
+        :param target_milvus_kernel_version:
+        :type target_milvus_kernel_version: str (optional)
+
+        :param target_package_version:
+        :type target_package_version: str (optional)
+
+        :param upgrade_note:
+        :type upgrade_note: str (optional)
+        """
+        super().__init__()
+        self.target_milvus_kernel_version = target_milvus_kernel_version
+        self.target_package_version = target_package_version
+        self.upgrade_note = upgrade_note
+
+    def to_dict(self):
+        """
+        Convert the model instance to a dictionary representation.
+
+        Nested model objects are recursively converted to dictionaries.
+
+        :return: Dictionary representation of the model
+        :rtype: dict
+        """
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        if self.target_milvus_kernel_version is not None:
+            result['targetMilvusKernelVersion'] = self.target_milvus_kernel_version
+        if self.target_package_version is not None:
+            result['targetPackageVersion'] = self.target_package_version
+        if self.upgrade_note is not None:
+            result['upgradeNote'] = self.upgrade_note
+        return result
+
+    def from_dict(self, m):
+        """
+        Populate the model instance from a dictionary.
+
+        Nested dictionaries are recursively converted to model objects.
+
+        :param m: Dictionary containing model data
+        :type m: dict
+
+        :return: Self reference for method chaining
+        :rtype: TargetPackage
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('targetMilvusKernelVersion') is not None:
+            self.target_milvus_kernel_version = m.get('targetMilvusKernelVersion')
+        if m.get('targetPackageVersion') is not None:
+            self.target_package_version = m.get('targetPackageVersion')
+        if m.get('upgradeNote') is not None:
+            self.upgrade_note = m.get('upgradeNote')
+        return self

baiducloud_python_sdk_vdb/models/unbind_eip_using_post_request.py

@@ -0,0 +1,64 @@
+"""
+Request entity for UnbindEipUsingPostRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class UnbindEipUsingPostRequest(AbstractModel):
+    """
+    Request entity for UnbindEipUsingPostRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(self, instance_id, engine_type=None):
+        """
+        Initialize UnbindEipUsingPostRequest request entity.
+
+        :param instance_id: instance_id parameter
+        :type instance_id: str (required)
+
+        :param engine_type: engine_type parameter
+        :type engine_type: str (optional)
+        """
+        super().__init__()
+        self.instance_id = instance_id
+        self.engine_type = engine_type
+
+    def to_dict(self):
+        """
+        Convert the request entity to a dictionary representation.
+
+        Nested model objects are recursively converted to dictionaries.
+
+        :return: Dictionary representation of the request
+        :rtype: dict
+        """
+        _map = super().to_dict()
+        if _map is not None:
+            return _map
+        result = dict()
+        return result
+
+    def from_dict(self, m):
+        """
+        Populate the request entity from a dictionary.
+
+        Nested dictionaries are recursively converted to model objects.
+
+        :param m: Dictionary containing request data
+        :type m: dict
+
+        :return: Self reference for method chaining
+        :rtype: UnbindEipUsingPostRequest
+
+        :raises TypeError: If input is not a dictionary or field type mismatch
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('instanceId') is not None:
+            self.instance_id = m.get('instanceId')
+        if m.get('engineType') is not None:
+            self.engine_type = m.get('engineType')
+        return self