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

baiducloud_python_sdk_vdb/models/modify_tls_using_put_request.py

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

baiducloud_python_sdk_vdb/models/multi_year_result.py

@@ -0,0 +1,66 @@
+"""
+MultiYearResult information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class MultiYearResult(AbstractModel):
+    """
+    MultiYearResult
+    """
+
+    def __init__(self, multi_discount=None, multi_year=None):
+        """
+        Initialize MultiYearResult instance.
+
+        :param multi_discount:
+        :type multi_discount: float (optional)
+
+        :param multi_year:
+        :type multi_year: float (optional)
+        """
+        super().__init__()
+        self.multi_discount = multi_discount
+        self.multi_year = multi_year
+
+    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.multi_discount is not None:
+            result['multiDiscount'] = self.multi_discount
+        if self.multi_year is not None:
+            result['multiYear'] = self.multi_year
+        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: MultiYearResult
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('multiDiscount') is not None:
+            self.multi_discount = m.get('multiDiscount')
+        if m.get('multiYear') is not None:
+            self.multi_year = m.get('multiYear')
+        return self

baiducloud_python_sdk_vdb/models/password_using_get_request.py

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

baiducloud_python_sdk_vdb/models/password_using_get_response.py

@@ -0,0 +1,69 @@
+"""
+Request entity for PasswordUsingGETResponse information.
+"""
+
+from baiducloud_python_sdk_core.bce_response import BceResponse
+
+
+class PasswordUsingGETResponse(BceResponse):
+    """
+    PasswordUsingGETResponse
+    """
+
+    def __init__(self, password=None, username=None):
+        """
+        Initialize PasswordUsingGETResponse response.
+
+        :param password: password field
+        :type password: str (optional)
+
+        :param username: username field
+        :type username: str (optional)
+        """
+        super().__init__()
+        self.password = password
+        self.username = username
+
+    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.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 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: PasswordUsingGETResponse
+
+        :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('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/proxy.py

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

baiducloud_python_sdk_vdb/models/record.py

@@ -0,0 +1,144 @@
+"""
+Record information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+from baiducloud_python_sdk_vdb.models.batch_record import BatchRecord
+
+
+class Record(AbstractModel):
+    """
+    Record
+    """
+
+    def __init__(
+        self,
+        backup_type=None,
+        batch_id=None,
+        batch_records=None,
+        comment=None,
+        end_time=None,
+        recoverable=None,
+        start_time=None,
+        status=None,
+        storage_type=None,
+        total_size_bytes=None,
+    ):
+        """
+        Initialize Record instance.
+
+        :param backup_type:
+        :type backup_type: str (optional)
+
+        :param batch_id:
+        :type batch_id: str (optional)
+
+        :param batch_records:
+        :type batch_records: List[BatchRecord] (optional)
+
+        :param comment:
+        :type comment: str (optional)
+
+        :param end_time:
+        :type end_time: str (optional)
+
+        :param recoverable:
+        :type recoverable: str (optional)
+
+        :param start_time:
+        :type start_time: str (optional)
+
+        :param status:
+        :type status: str (optional)
+
+        :param storage_type:
+        :type storage_type: str (optional)
+
+        :param total_size_bytes:
+        :type total_size_bytes: int (optional)
+        """
+        super().__init__()
+        self.backup_type = backup_type
+        self.batch_id = batch_id
+        self.batch_records = batch_records
+        self.comment = comment
+        self.end_time = end_time
+        self.recoverable = recoverable
+        self.start_time = start_time
+        self.status = status
+        self.storage_type = storage_type
+        self.total_size_bytes = total_size_bytes
+
+    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.backup_type is not None:
+            result['backupType'] = self.backup_type
+        if self.batch_id is not None:
+            result['batchId'] = self.batch_id
+        if self.batch_records is not None:
+            result['batchRecords'] = [i.to_dict() for i in self.batch_records]
+        if self.comment is not None:
+            result['comment'] = self.comment
+        if self.end_time is not None:
+            result['endTime'] = self.end_time
+        if self.recoverable is not None:
+            result['recoverable'] = self.recoverable
+        if self.start_time is not None:
+            result['startTime'] = self.start_time
+        if self.status is not None:
+            result['status'] = self.status
+        if self.storage_type is not None:
+            result['storageType'] = self.storage_type
+        if self.total_size_bytes is not None:
+            result['totalSizeBytes'] = self.total_size_bytes
+        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: Record
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('backupType') is not None:
+            self.backup_type = m.get('backupType')
+        if m.get('batchId') is not None:
+            self.batch_id = m.get('batchId')
+        if m.get('batchRecords') is not None:
+            self.batch_records = [BatchRecord().from_dict(i) for i in m.get('batchRecords')]
+        if m.get('comment') is not None:
+            self.comment = m.get('comment')
+        if m.get('endTime') is not None:
+            self.end_time = m.get('endTime')
+        if m.get('recoverable') is not None:
+            self.recoverable = m.get('recoverable')
+        if m.get('startTime') is not None:
+            self.start_time = m.get('startTime')
+        if m.get('status') is not None:
+            self.status = m.get('status')
+        if m.get('storageType') is not None:
+            self.storage_type = m.get('storageType')
+        if m.get('totalSizeBytes') is not None:
+            self.total_size_bytes = m.get('totalSizeBytes')
+        return self

baiducloud_python_sdk_vdb/models/recover_instance_using_post_request.py

@@ -0,0 +1,64 @@
+"""
+Request entity for RecoverInstanceUsingPostRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class RecoverInstanceUsingPostRequest(AbstractModel):
+    """
+    Request entity for RecoverInstanceUsingPostRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(self, instance_id, engine_type=None):
+        """
+        Initialize RecoverInstanceUsingPostRequest 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: RecoverInstanceUsingPostRequest
+
+        :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

baiducloud_python_sdk_vdb/models/recover_using_post_request.py

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