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

baiducloud_python_sdk_cprom/models/pod_monitor_item.py

@@ -0,0 +1,92 @@
+"""
+PodMonitorItem information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+from baiducloud_python_sdk_cprom.models.endpoint import Endpoint
+
+
+class PodMonitorItem(AbstractModel):
+    """
+    PodMonitorItem
+    """
+
+    def __init__(self, pod_monitor_name=None, namespace=None, enable=None, create_time=None, endpoints=None):
+        """
+        Initialize PodMonitorItem instance.
+
+        :param pod_monitor_name: Pod Monitor名称
+        :type pod_monitor_name: str (optional)
+
+        :param namespace: Pod Monitor命名空间
+        :type namespace: str (optional)
+
+        :param enable: 是否启用：true/false
+        :type enable: str (optional)
+
+        :param create_time: 创建时间
+        :type create_time: str (optional)
+
+        :param endpoints: 端点信息
+        :type endpoints: List[Endpoint] (optional)
+        """
+        super().__init__()
+        self.pod_monitor_name = pod_monitor_name
+        self.namespace = namespace
+        self.enable = enable
+        self.create_time = create_time
+        self.endpoints = endpoints
+
+    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.pod_monitor_name is not None:
+            result['podMonitorName'] = self.pod_monitor_name
+        if self.namespace is not None:
+            result['namespace'] = self.namespace
+        if self.enable is not None:
+            result['enable'] = self.enable
+        if self.create_time is not None:
+            result['createTime'] = self.create_time
+        if self.endpoints is not None:
+            result['endpoints'] = [i.to_dict() for i in self.endpoints]
+        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: PodMonitorItem
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('podMonitorName') is not None:
+            self.pod_monitor_name = m.get('podMonitorName')
+        if m.get('namespace') is not None:
+            self.namespace = m.get('namespace')
+        if m.get('enable') is not None:
+            self.enable = m.get('enable')
+        if m.get('createTime') is not None:
+            self.create_time = m.get('createTime')
+        if m.get('endpoints') is not None:
+            self.endpoints = [Endpoint().from_dict(i) for i in m.get('endpoints')]
+        return self

baiducloud_python_sdk_cprom/models/pod_monitor_spec.py

@@ -0,0 +1,80 @@
+"""
+PodMonitorSpec information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+from baiducloud_python_sdk_cprom.models.namespace_selector import NamespaceSelector
+
+from baiducloud_python_sdk_cprom.models.pod_metrics_endpoint import PodMetricsEndpoint
+
+from baiducloud_python_sdk_cprom.models.label_selector import LabelSelector
+
+
+class PodMonitorSpec(AbstractModel):
+    """
+    PodMonitorSpec
+    """
+
+    def __init__(self, namespace_selector=None, pod_metrics_endpoints=None, selector=None):
+        """
+        Initialize PodMonitorSpec instance.
+
+        :param namespace_selector: namespace_selector attribute
+        :type namespace_selector: NamespaceSelector (optional)
+
+        :param pod_metrics_endpoints: 采集端点配置列表
+        :type pod_metrics_endpoints: List[PodMetricsEndpoint] (optional)
+
+        :param selector: selector attribute
+        :type selector: LabelSelector (optional)
+        """
+        super().__init__()
+        self.namespace_selector = namespace_selector
+        self.pod_metrics_endpoints = pod_metrics_endpoints
+        self.selector = selector
+
+    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.namespace_selector is not None:
+            result['namespaceSelector'] = self.namespace_selector.to_dict()
+        if self.pod_metrics_endpoints is not None:
+            result['podMetricsEndpoints'] = [i.to_dict() for i in self.pod_metrics_endpoints]
+        if self.selector is not None:
+            result['selector'] = self.selector.to_dict()
+        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: PodMonitorSpec
+
+        :raises TypeError: If input is not a dictionary type
+        :raises ValueError: If nested model conversion fails
+        """
+        m = m or dict()
+        if m.get('namespaceSelector') is not None:
+            self.namespace_selector = NamespaceSelector().from_dict(m.get('namespaceSelector'))
+        if m.get('podMetricsEndpoints') is not None:
+            self.pod_metrics_endpoints = [PodMetricsEndpoint().from_dict(i) for i in m.get('podMetricsEndpoints')]
+        if m.get('selector') is not None:
+            self.selector = LabelSelector().from_dict(m.get('selector'))
+        return self

baiducloud_python_sdk_cprom/models/remote_read_request.py

@@ -0,0 +1,90 @@
+"""
+Request entity for RemoteReadRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class RemoteReadRequest(AbstractModel):
+    """
+    Request entity for RemoteReadRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(self, remote_read_url, query, step, start, end):
+        """
+        Initialize RemoteReadRequest request entity.
+
+        :param remote_read_url: remote_read_url parameter
+        :type remote_read_url: str (required)
+
+        :param query: query parameter
+        :type query: str (required)
+
+        :param step: step parameter
+        :type step: int (required)
+
+        :param start: start parameter
+        :type start: int (required)
+
+        :param end: end parameter
+        :type end: int (required)
+        """
+        super().__init__()
+        self.remote_read_url = remote_read_url
+        self.query = query
+        self.step = step
+        self.start = start
+        self.end = end
+
+    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.query is not None:
+            result['query'] = self.query
+        if self.step is not None:
+            result['step'] = self.step
+        if self.start is not None:
+            result['start'] = self.start
+        if self.end is not None:
+            result['end'] = self.end
+        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: RemoteReadRequest
+
+        :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('remoteReadUrl') is not None:
+            self.remote_read_url = m.get('remoteReadUrl')
+        if m.get('query') is not None:
+            self.query = m.get('query')
+        if m.get('step') is not None:
+            self.step = m.get('step')
+        if m.get('start') is not None:
+            self.start = m.get('start')
+        if m.get('end') is not None:
+            self.end = m.get('end')
+        return self

baiducloud_python_sdk_cprom/models/remote_read_response.py

@@ -0,0 +1,127 @@
+"""
+Request entity for RemoteReadResponse information.
+"""
+
+from baiducloud_python_sdk_core.bce_response import BceResponse
+
+
+class RemoteReadResponse(BceResponse):
+    """
+    RemoteReadResponse
+    """
+
+    def __init__(
+        self,
+        status=None,
+        is_partial=None,
+        data=None,
+        data_result_type=None,
+        data_result=None,
+        data_result_metric=None,
+        data_result_values=None,
+        data_result_value=None,
+    ):
+        """
+        Initialize RemoteReadResponse response.
+
+        :param status: 请求是否成功。
+        :type status: str (optional)
+
+        :param is_partial: 查询结果是否为部分数据。
+        :type is_partial: bool (optional)
+
+        :param data: data field
+        :type data: object (optional)
+
+        :param data_result_type: 查询结果类型，如 `matrix` 或 `vector`。
+        :type data_result_type: str (optional)
+
+        :param data_result: 查询结果列表，列表项包含 `metric` 以及 `values` 或 `value` 等信息。
+        :type data_result: List[object] (optional)
+
+        :param data_result_metric: 查询指标的所有维度。
+        :type data_result_metric: Dict[str, object] (optional)
+
+        :param data_result_values: 区间查询返回的样本点列表，每个元素为 `[时间戳, 数值]`。
+        :type data_result_values: List[object] (optional)
+
+        :param data_result_value: 即时查询返回的单个样本点，格式为 `[时间戳, 数值]`。
+        :type data_result_value: List[object] (optional)
+        """
+        super().__init__()
+        self.status = status
+        self.is_partial = is_partial
+        self.data = data
+        self.data_result_type = data_result_type
+        self.data_result = data_result
+        self.data_result_metric = data_result_metric
+        self.data_result_values = data_result_values
+        self.data_result_value = data_result_value
+
+    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.status is not None:
+            result['status'] = self.status
+        if self.is_partial is not None:
+            result['isPartial'] = self.is_partial
+        if self.data is not None:
+            result['data'] = self.data
+        if self.data_result_type is not None:
+            result['data.resultType'] = self.data_result_type
+        if self.data_result is not None:
+            result['data.result'] = self.data_result
+        if self.data_result_metric is not None:
+            result['data.result[].metric'] = self.data_result_metric
+        if self.data_result_values is not None:
+            result['data.result[].values'] = self.data_result_values
+        if self.data_result_value is not None:
+            result['data.result[].value'] = self.data_result_value
+        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: RemoteReadResponse
+
+        :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('status') is not None:
+            self.status = m.get('status')
+        if m.get('isPartial') is not None:
+            self.is_partial = m.get('isPartial')
+        if m.get('data') is not None:
+            self.data = m.get('data')
+        if m.get('data.resultType') is not None:
+            self.data_result_type = m.get('data.resultType')
+        if m.get('data.result') is not None:
+            self.data_result = m.get('data.result')
+        if m.get('data.result[].metric') is not None:
+            self.data_result_metric = m.get('data.result[].metric')
+        if m.get('data.result[].values') is not None:
+            self.data_result_values = m.get('data.result[].values')
+        if m.get('data.result[].value') is not None:
+            self.data_result_value = m.get('data.result[].value')
+        return self

baiducloud_python_sdk_cprom/models/remote_write_request.py

@@ -0,0 +1,90 @@
+"""
+Request entity for RemoteWriteRequest information.
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class RemoteWriteRequest(AbstractModel):
+    """
+    Request entity for RemoteWriteRequest operation.
+
+    This class encapsulates all parameters for the API request.
+    """
+
+    def __init__(self, remote_write_url, body, content_type, content_encoding, instance_id, authorization):
+        """
+        Initialize RemoteWriteRequest request entity.
+
+        :param remote_write_url: remote_write_url parameter
+        :type remote_write_url: str (required)
+
+        :param body: body parameter
+        :type body: bytearray (required)
+
+        :param content_type: content_type parameter
+        :type content_type: str (required)
+
+        :param content_encoding: content_encoding parameter
+        :type content_encoding: str (required)
+
+        :param instance_id: instance_id parameter
+        :type instance_id: str (required)
+
+        :param authorization: authorization parameter
+        :type authorization: str (required)
+        """
+        super().__init__()
+        self.remote_write_url = remote_write_url
+        self.body = body
+        self.content_type = content_type
+        self.content_encoding = content_encoding
+        self.instance_id = instance_id
+        self.authorization = authorization
+
+    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.body is not None:
+            result['body'] = self.body
+        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: RemoteWriteRequest
+
+        :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('remoteWriteUrl') is not None:
+            self.remote_write_url = m.get('remoteWriteUrl')
+        if m.get('body') is not None:
+            self.body = m.get('body')
+        if m.get('Content-Type') is not None:
+            self.content_type = m.get('Content-Type')
+        if m.get('Content-Encoding') is not None:
+            self.content_encoding = m.get('Content-Encoding')
+        if m.get('InstanceId') is not None:
+            self.instance_id = m.get('InstanceId')
+        if m.get('Authorization') is not None:
+            self.authorization = m.get('Authorization')
+        return self

baiducloud_python_sdk_cprom/models/repeat_notify_config.py

@@ -0,0 +1,90 @@
+"""
+RepeatNotifyConfig information
+"""
+
+from baiducloud_python_sdk_core.abstract_model import AbstractModel
+
+
+class RepeatNotifyConfig(AbstractModel):
+    """
+    RepeatNotifyConfig
+    """
+
+    def __init__(self, enabled=None, interval_hour=None, interval_min=None, max_count=None, strategy=None):
+        """
+        Initialize RepeatNotifyConfig instance.
+
+        :param enabled: 是否开启重复通知
+        :type enabled: bool (optional)
+
+        :param interval_hour: 重复通知间隔小时数
+        :type interval_hour: int (optional)
+
+        :param interval_min: 重复通知间隔分钟数
+        :type interval_min: int (optional)
+
+        :param max_count: 最大重复通知次数
+        :type max_count: int (optional)
+
+        :param strategy: 重复通知策略
+        :type strategy: str (optional)
+        """
+        super().__init__()
+        self.enabled = enabled
+        self.interval_hour = interval_hour
+        self.interval_min = interval_min
+        self.max_count = max_count
+        self.strategy = strategy
+
+    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.interval_hour is not None:
+            result['intervalHour'] = self.interval_hour
+        if self.interval_min is not None:
+            result['intervalMin'] = self.interval_min
+        if self.max_count is not None:
+            result['maxCount'] = self.max_count
+        if self.strategy is not None:
+            result['strategy'] = self.strategy
+        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: RepeatNotifyConfig
+
+        :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('intervalHour') is not None:
+            self.interval_hour = m.get('intervalHour')
+        if m.get('intervalMin') is not None:
+            self.interval_min = m.get('intervalMin')
+        if m.get('maxCount') is not None:
+            self.max_count = m.get('maxCount')
+        if m.get('strategy') is not None:
+            self.strategy = m.get('strategy')
+        return self