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

baiducloud_python_sdk_vdb/models/log_service.py

@@ -0,0 +1,82 @@
+"""
+LogService information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class LogService(AbstractModel):
+    """
+    LogService
+    """
+
+    def __init__(self, enabled=None, log_store_name=None, project=None, retention_days=None):
+        """
+        Initialize LogService instance.
+
+        :param enabled:
+        :type enabled: bool (optional)
+
+        :param log_store_name:
+        :type log_store_name: str (optional)
+
+        :param project:
+        :type project: str (optional)
+
+        :param retention_days:
+        :type retention_days: int (optional)
+        """
+        super().__init__()
+        self.enabled = enabled
+        self.log_store_name = log_store_name
+        self.project = project
+        self.retention_days = retention_days
+
+    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.enabled is not None:
+            result['enabled'] = self.enabled
+        if self.log_store_name is not None:
+            result['logStoreName'] = self.log_store_name
+        if self.project is not None:
+            result['project'] = self.project
+        if self.retention_days is not None:
+            result['retentionDays'] = self.retention_days
+        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: LogService
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('enabled') is not None:
+            self.enabled = m.get('enabled')
+        if m.get('logStoreName') is not None:
+            self.log_store_name = m.get('logStoreName')
+        if m.get('project') is not None:
+            self.project = m.get('project')
+        if m.get('retentionDays') is not None:
+            self.retention_days = m.get('retentionDays')
+        return self

baiducloud_python_sdk_vdb/models/logging_service.py

@@ -0,0 +1,82 @@
+"""
+LoggingService information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class LoggingService(AbstractModel):
+    """
+    LoggingService
+    """
+
+    def __init__(self, enabled=None, log_type=None, status=None, supported=None):
+        """
+        Initialize LoggingService instance.
+
+        :param enabled:
+        :type enabled: bool (optional)
+
+        :param log_type:
+        :type log_type: str (optional)
+
+        :param status:
+        :type status: str (optional)
+
+        :param supported:
+        :type supported: bool (optional)
+        """
+        super().__init__()
+        self.enabled = enabled
+        self.log_type = log_type
+        self.status = status
+        self.supported = supported
+
+    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.enabled is not None:
+            result['enabled'] = self.enabled
+        if self.log_type is not None:
+            result['logType'] = self.log_type
+        if self.status is not None:
+            result['status'] = self.status
+        if self.supported is not None:
+            result['supported'] = self.supported
+        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: LoggingService
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('enabled') is not None:
+            self.enabled = m.get('enabled')
+        if m.get('logType') is not None:
+            self.log_type = m.get('logType')
+        if m.get('status') is not None:
+            self.status = m.get('status')
+        if m.get('supported') is not None:
+            self.supported = m.get('supported')
+        return self

baiducloud_python_sdk_vdb/models/manual_backup_using_post_request.py

@@ -0,0 +1,72 @@
+"""
+Request entity for ManualBackupUsingPOSTRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class ManualBackupUsingPOSTRequest(AbstractModel):
+    """
+    Request entity for ManualBackupUsingPOSTRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(self, instance_id, engine_type=None, comment=None):
+        """
+        Initialize ManualBackupUsingPOSTRequest 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 comment: comment parameter
+        :type comment: str (optional)
+        """
+        super().__init__()
+        self.instance_id = instance_id
+        self.engine_type = engine_type
+        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.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: ManualBackupUsingPOSTRequest
+
+        :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('comment') is not None:
+            self.comment = m.get('comment')
+        return self

baiducloud_python_sdk_vdb/models/milvus_component.py

@@ -0,0 +1,82 @@
+"""
+MilvusComponent information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class MilvusComponent(AbstractModel):
+    """
+    MilvusComponent
+    """
+
+    def __init__(self, disk_size_type=None, replicas=None, spec=None, type=None):
+        """
+        Initialize MilvusComponent instance.
+
+        :param disk_size_type:
+        :type disk_size_type: str (optional)
+
+        :param replicas:
+        :type replicas: int (optional)
+
+        :param spec:
+        :type spec: str (optional)
+
+        :param type:
+        :type type: str (optional)
+        """
+        super().__init__()
+        self.disk_size_type = disk_size_type
+        self.replicas = replicas
+        self.spec = spec
+        self.type = type
+
+    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.disk_size_type is not None:
+            result['diskSizeType'] = self.disk_size_type
+        if self.replicas is not None:
+            result['replicas'] = self.replicas
+        if self.spec is not None:
+            result['spec'] = self.spec
+        if self.type is not None:
+            result['type'] = self.type
+        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: MilvusComponent
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('diskSizeType') is not None:
+            self.disk_size_type = m.get('diskSizeType')
+        if m.get('replicas') is not None:
+            self.replicas = m.get('replicas')
+        if m.get('spec') is not None:
+            self.spec = m.get('spec')
+        if m.get('type') is not None:
+            self.type = m.get('type')
+        return self

baiducloud_python_sdk_vdb/models/milvus_node.py

@@ -0,0 +1,115 @@
+"""
+MilvusNode information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class MilvusNode(AbstractModel):
+    """
+    MilvusNode
+    """
+
+    def __init__(
+        self,
+        availability_zone=None,
+        component_type=None,
+        fixed_ip=None,
+        floating_ip=None,
+        node_id=None,
+        port=None,
+        status=None,
+    ):
+        """
+        Initialize MilvusNode instance.
+
+        :param availability_zone:
+        :type availability_zone: str (optional)
+
+        :param component_type:
+        :type component_type: str (optional)
+
+        :param fixed_ip:
+        :type fixed_ip: str (optional)
+
+        :param floating_ip:
+        :type floating_ip: str (optional)
+
+        :param node_id:
+        :type node_id: str (optional)
+
+        :param port:
+        :type port: int (optional)
+
+        :param status:
+        :type status: str (optional)
+        """
+        super().__init__()
+        self.availability_zone = availability_zone
+        self.component_type = component_type
+        self.fixed_ip = fixed_ip
+        self.floating_ip = floating_ip
+        self.node_id = node_id
+        self.port = port
+        self.status = status
+
+    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.availability_zone is not None:
+            result['availabilityZone'] = self.availability_zone
+        if self.component_type is not None:
+            result['componentType'] = self.component_type
+        if self.fixed_ip is not None:
+            result['fixedIp'] = self.fixed_ip
+        if self.floating_ip is not None:
+            result['floatingIp'] = self.floating_ip
+        if self.node_id is not None:
+            result['nodeId'] = self.node_id
+        if self.port is not None:
+            result['port'] = self.port
+        if self.status is not None:
+            result['status'] = self.status
+        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: MilvusNode
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('availabilityZone') is not None:
+            self.availability_zone = m.get('availabilityZone')
+        if m.get('componentType') is not None:
+            self.component_type = m.get('componentType')
+        if m.get('fixedIp') is not None:
+            self.fixed_ip = m.get('fixedIp')
+        if m.get('floatingIp') is not None:
+            self.floating_ip = m.get('floatingIp')
+        if m.get('nodeId') is not None:
+            self.node_id = m.get('nodeId')
+        if m.get('port') is not None:
+            self.port = m.get('port')
+        if m.get('status') is not None:
+            self.status = m.get('status')
+        return self

baiducloud_python_sdk_vdb/models/modify_instance_config_request.py

@@ -0,0 +1,77 @@
+"""
+Request entity for ModifyInstanceConfigRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+from baiducloud_python_sdk_vdb.models.instance_config_user_config import InstanceConfigUserConfig
+
+
+class ModifyInstanceConfigRequest(AbstractModel):
+    """
+    Request entity for ModifyInstanceConfigRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(self, instance_id=None, reason=None, user_configs=None):
+        """
+        Initialize ModifyInstanceConfigRequest request entity.
+
+        :param instance_id: instance_id parameter
+        :type instance_id: str (optional)
+
+        :param reason: reason parameter
+        :type reason: str (optional)
+
+        :param user_configs: user_configs parameter
+        :type user_configs: List[InstanceConfigUserConfig] (optional)
+        """
+        super().__init__()
+        self.instance_id = instance_id
+        self.reason = reason
+        self.user_configs = user_configs
+
+    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.instance_id is not None:
+            result['instanceId'] = self.instance_id
+        if self.reason is not None:
+            result['reason'] = self.reason
+        if self.user_configs is not None:
+            result['userConfigs'] = [i.to_dict() for i in self.user_configs]
+        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: ModifyInstanceConfigRequest
+
+        :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('reason') is not None:
+            self.reason = m.get('reason')
+        if m.get('userConfigs') is not None:
+            self.user_configs = [InstanceConfigUserConfig().from_dict(i) for i in m.get('userConfigs')]
+        return self

baiducloud_python_sdk_vdb/models/modify_password_using_post_request.py

@@ -0,0 +1,88 @@
+"""
+Request entity for ModifyPasswordUsingPOSTRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class ModifyPasswordUsingPOSTRequest(AbstractModel):
+    """
+    Request entity for ModifyPasswordUsingPOSTRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(self, instance_id, engine_type=None, vdb_from=None, password=None, username=None):
+        """
+        Initialize ModifyPasswordUsingPOSTRequest 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 vdb_from: vdb_from parameter
+        :type vdb_from: str (optional)
+
+        :param password: password parameter
+        :type password: str (optional)
+
+        :param username: username parameter
+        :type username: str (optional)
+        """
+        super().__init__()
+        self.instance_id = instance_id
+        self.engine_type = engine_type
+        self.vdb_from = vdb_from
+        self.password = password
+        self.username = username
+
+    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.vdb_from is not None:
+            result['from'] = self.vdb_from
+        if self.password is not None:
+            result['password'] = self.password
+        if self.username is not None:
+            result['username'] = self.username
+        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: ModifyPasswordUsingPOSTRequest
+
+        :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('from') is not None:
+            self.vdb_from = m.get('from')
+        if m.get('password') is not None:
+            self.password = m.get('password')
+        if m.get('username') is not None:
+            self.username = m.get('username')
+        return self

baiducloud_python_sdk_vdb/models/modify_public_access_request.py

@@ -0,0 +1,66 @@
+"""
+Request entity for ModifyPublicAccessRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class ModifyPublicAccessRequest(AbstractModel):
+    """
+    Request entity for ModifyPublicAccessRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(self, instance_id, public_access=None):
+        """
+        Initialize ModifyPublicAccessRequest request entity.
+
+        :param instance_id: instance_id parameter
+        :type instance_id: str (required)
+
+        :param public_access: public_access parameter
+        :type public_access: bool (optional)
+        """
+        super().__init__()
+        self.instance_id = instance_id
+        self.public_access = public_access
+
+    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.public_access is not None:
+            result['publicAccess'] = self.public_access
+        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: ModifyPublicAccessRequest
+
+        :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('publicAccess') is not None:
+            self.public_access = m.get('publicAccess')
+        return self