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

baiducloud_python_sdk_vdb/models/update_instance_domain_request.py

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

baiducloud_python_sdk_vdb/models/update_instance_name_request.py

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

baiducloud_python_sdk_vdb/models/vdb_auto_renew_rule.py

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

baiducloud_python_sdk_vdb/models/vdb_pricing_query_response.py

@@ -0,0 +1,166 @@
+"""
+VdbPricingQueryResponse information
+"""
+
+from baiducloud_python_sdk_core.bce_response import BceResponse
+
+from baiducloud_python_sdk_vdb.models.multi_year_result import MultiYearResult
+
+
+class VdbPricingQueryResponse(BceResponse):
+    """
+    VdbPricingQueryResponse
+    """
+
+    def __init__(
+        self,
+        catalog_price=None,
+        component_type=None,
+        discount=None,
+        discount_type=None,
+        multi_year_result=None,
+        origin_discount=None,
+        origin_price=None,
+        price=None,
+        price_id=None,
+        price_name=None,
+        price_type=None,
+        real_catalog_price=None,
+    ):
+        """
+        Initialize VdbPricingQueryResponse instance.
+
+        :param catalog_price:
+        :type catalog_price: float (optional)
+
+        :param component_type:
+        :type component_type: str (optional)
+
+        :param discount:
+        :type discount: float (optional)
+
+        :param discount_type:
+        :type discount_type: str (optional)
+
+        :param multi_year_result: multi_year_result attribute
+        :type multi_year_result: MultiYearResult (optional)
+
+        :param origin_discount:
+        :type origin_discount: float (optional)
+
+        :param origin_price:
+        :type origin_price: float (optional)
+
+        :param price:
+        :type price: float (optional)
+
+        :param price_id:
+        :type price_id: int (optional)
+
+        :param price_name:
+        :type price_name: str (optional)
+
+        :param price_type:
+        :type price_type: str (optional)
+
+        :param real_catalog_price:
+        :type real_catalog_price: float (optional)
+        """
+        super().__init__()
+        self.catalog_price = catalog_price
+        self.component_type = component_type
+        self.discount = discount
+        self.discount_type = discount_type
+        self.multi_year_result = multi_year_result
+        self.origin_discount = origin_discount
+        self.origin_price = origin_price
+        self.price = price
+        self.price_id = price_id
+        self.price_name = price_name
+        self.price_type = price_type
+        self.real_catalog_price = real_catalog_price
+
+    def to_dict(self):
+        """
+        Convert the model instance to a dictionary representation.
+
+        Nested model objects are recursively converted to dictionaries.
+
+        Includes metadata from the parent BceResponse class.
+
+        :return: Dictionary representation of the model
+        :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.catalog_price is not None:
+            result['catalogPrice'] = self.catalog_price
+        if self.component_type is not None:
+            result['componentType'] = self.component_type
+        if self.discount is not None:
+            result['discount'] = self.discount
+        if self.discount_type is not None:
+            result['discountType'] = self.discount_type
+        if self.multi_year_result is not None:
+            result['multiYearResult'] = self.multi_year_result.to_dict()
+        if self.origin_discount is not None:
+            result['originDiscount'] = self.origin_discount
+        if self.origin_price is not None:
+            result['originPrice'] = self.origin_price
+        if self.price is not None:
+            result['price'] = self.price
+        if self.price_id is not None:
+            result['priceId'] = self.price_id
+        if self.price_name is not None:
+            result['priceName'] = self.price_name
+        if self.price_type is not None:
+            result['priceType'] = self.price_type
+        if self.real_catalog_price is not None:
+            result['realCatalogPrice'] = self.real_catalog_price
+        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: VdbPricingQueryResponse
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('catalogPrice') is not None:
+            self.catalog_price = m.get('catalogPrice')
+        if m.get('componentType') is not None:
+            self.component_type = m.get('componentType')
+        if m.get('discount') is not None:
+            self.discount = m.get('discount')
+        if m.get('discountType') is not None:
+            self.discount_type = m.get('discountType')
+        if m.get('multiYearResult') is not None:
+            self.multi_year_result = MultiYearResult().from_dict(m.get('multiYearResult'))
+        if m.get('originDiscount') is not None:
+            self.origin_discount = m.get('originDiscount')
+        if m.get('originPrice') is not None:
+            self.origin_price = m.get('originPrice')
+        if m.get('price') is not None:
+            self.price = m.get('price')
+        if m.get('priceId') is not None:
+            self.price_id = m.get('priceId')
+        if m.get('priceName') is not None:
+            self.price_name = m.get('priceName')
+        if m.get('priceType') is not None:
+            self.price_type = m.get('priceType')
+        if m.get('realCatalogPrice') is not None:
+            self.real_catalog_price = m.get('realCatalogPrice')
+        return self

baiducloud_python_sdk_vdb/models/zone_detail.py

@@ -0,0 +1,133 @@
+"""
+ZoneDetail information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class ZoneDetail(AbstractModel):
+    """
+    ZoneDetail
+    """
+
+    def __init__(
+        self,
+        api_zone_names=None,
+        available=None,
+        default_subnet_id=None,
+        max_cpu_count=None,
+        max_memory=None,
+        max_storage=None,
+        stock_state=None,
+        zone_name_str=None,
+        zone_names=None,
+    ):
+        """
+        Initialize ZoneDetail instance.
+
+        :param api_zone_names:
+        :type api_zone_names: List[str] (optional)
+
+        :param available:
+        :type available: bool (optional)
+
+        :param default_subnet_id:
+        :type default_subnet_id: str (optional)
+
+        :param max_cpu_count:
+        :type max_cpu_count: int (optional)
+
+        :param max_memory:
+        :type max_memory: int (optional)
+
+        :param max_storage:
+        :type max_storage: int (optional)
+
+        :param stock_state:
+        :type stock_state: int (optional)
+
+        :param zone_name_str:
+        :type zone_name_str: str (optional)
+
+        :param zone_names:
+        :type zone_names: List[str] (optional)
+        """
+        super().__init__()
+        self.api_zone_names = api_zone_names
+        self.available = available
+        self.default_subnet_id = default_subnet_id
+        self.max_cpu_count = max_cpu_count
+        self.max_memory = max_memory
+        self.max_storage = max_storage
+        self.stock_state = stock_state
+        self.zone_name_str = zone_name_str
+        self.zone_names = zone_names
+
+    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.api_zone_names is not None:
+            result['apiZoneNames'] = self.api_zone_names
+        if self.available is not None:
+            result['available'] = self.available
+        if self.default_subnet_id is not None:
+            result['defaultSubnetId'] = self.default_subnet_id
+        if self.max_cpu_count is not None:
+            result['maxCpuCount'] = self.max_cpu_count
+        if self.max_memory is not None:
+            result['maxMemory'] = self.max_memory
+        if self.max_storage is not None:
+            result['maxStorage'] = self.max_storage
+        if self.stock_state is not None:
+            result['stockState'] = self.stock_state
+        if self.zone_name_str is not None:
+            result['zoneNameStr'] = self.zone_name_str
+        if self.zone_names is not None:
+            result['zoneNames'] = self.zone_names
+        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: ZoneDetail
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('apiZoneNames') is not None:
+            self.api_zone_names = m.get('apiZoneNames')
+        if m.get('available') is not None:
+            self.available = m.get('available')
+        if m.get('defaultSubnetId') is not None:
+            self.default_subnet_id = m.get('defaultSubnetId')
+        if m.get('maxCpuCount') is not None:
+            self.max_cpu_count = m.get('maxCpuCount')
+        if m.get('maxMemory') is not None:
+            self.max_memory = m.get('maxMemory')
+        if m.get('maxStorage') is not None:
+            self.max_storage = m.get('maxStorage')
+        if m.get('stockState') is not None:
+            self.stock_state = m.get('stockState')
+        if m.get('zoneNameStr') is not None:
+            self.zone_name_str = m.get('zoneNameStr')
+        if m.get('zoneNames') is not None:
+            self.zone_names = m.get('zoneNames')
+        return self

baiducloud_python_sdk_vdb/models/zone_list_using_get_request.py

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

baiducloud_python_sdk_vdb/models/zone_list_using_get_response.py

@@ -0,0 +1,62 @@
+"""
+Request entity for ZoneListUsingGETResponse information.
+"""
+
+from baiducloud_python_sdk_core.bce_response import BceResponse
+from baiducloud_python_sdk_vdb.models.zone_detail import ZoneDetail
+
+
+class ZoneListUsingGETResponse(BceResponse):
+    """
+    ZoneListUsingGETResponse
+    """
+
+    def __init__(self, zones=None):
+        """
+        Initialize ZoneListUsingGETResponse response.
+
+        :param zones: zones field
+        :type zones: List[ZoneDetail] (optional)
+        """
+        super().__init__()
+        self.zones = zones
+
+    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.zones is not None:
+            result['zones'] = [i.to_dict() for i in self.zones]
+        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: ZoneListUsingGETResponse
+
+        :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('zones') is not None:
+            self.zones = [ZoneDetail().from_dict(i) for i in m.get('zones')]
+        return self