gongxiangp2/yedir/volc-sdk-python-main/volcengine/tls/data.py

# coding=utf-8
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import re
from typing import List, Dict

from volcengine.tls.const import *


def pascal_to_snake(pascal: str) -> str:
    return re.sub(r"(?P<key>[A-Z])", r"_\g<key>", pascal).lower().strip('_')


def snake_to_pascal(snake: str) -> str:
    return ''.join(word.title() for word in snake.split('_'))


class TLSData:
    @classmethod
    def set_attributes(cls, data: dict):
        if data is None or len(data) == 0:
            return None

        tls_data_dict = {}

        for key in data.keys():
            tls_data_dict[pascal_to_snake(key)] = data[key]

        tls_data = cls()

        for key in tls_data.__dict__.keys():
            tls_data.__dict__[key] = None

        tls_data.__dict__.update(tls_data_dict)

        return tls_data

    def json(self):
        json_data = {}

        for key in self.__dict__.keys():
            if self.__dict__[key] is not None:
                json_data[snake_to_pascal(key)] = self.__dict__[key]

        return json_data


class TagInfo(TLSData):
    def __init__(self, key: str, value: str = None):
        """
        :param key: 标签Key的值
        :param value: 标签Value的值
        """
        self.key = key
        self.value = value


class ProjectInfo(TLSData):
    def __init__(self, project_name: str = None, project_id: str = None, description: str = None,
                 create_time: str = None, inner_net_domain: str = None, topic_count: int = None,
                 iam_project_name: str = None, tags: List[TagInfo] = None):
        self.project_name = project_name
        self.project_id = project_id
        self.description = description
        self.create_time = create_time
        self.inner_net_domain = inner_net_domain
        self.topic_count = topic_count
        self.iam_project_name = iam_project_name
        self.tags = tags

    @classmethod
    def set_attributes(cls, data: dict):
        project_info = super(ProjectInfo, cls).set_attributes(data)

        if TAGS in data:
            tags = data[TAGS]
            project_info.tags = []
            for i in range(len(tags)):
                project_info.tags.append(TagInfo(tags[i].get(KEY), tags[i].get(VALUE)))

        return project_info

    def get_inner_net_domain(self):
        """
        :return:内网连接域名
        :rtype:str
        """
        return self.inner_net_domain

    def get_create_time(self):
        """
        :return: 创建时间
        :rtype: str
        """
        return self.create_time

    def get_project_id(self):
        """
        :return: 日志项目 ID
        :rtype: str
        """
        return self.project_id

    def get_description(self):
        """
        :return:日志项目描述
        :rtype: str
        """
        return self.description

    def get_project_name(self):
        """
        :return:日志项目名称
        :rtype:str
        """
        return self.project_name

    def get_topic_count(self):
        """
        :return:日志项目下的日志主题数量
        :rtype:int
        """
        return self.topic_count

    def get_iam_project_name(self):
        """
        :return: 日志项目所属的IAM项目
        :rtype: str
        """
        return self.iam_project_name

    def get_tags(self):
        """
        :return: 日志项目标签信息
        :rtype: List[TagInfo]
        """
        return self.tags


class TopicInfo(TLSData):
    def __init__(self, topic_name: str = None, topic_id: str = None, project_id: str = None, ttl: int = None,
                 create_time: str = None, modify_time: str = None, shard_count: int = None, description: str = None,
                 auto_split: bool = None, max_split_shard: int = None, enable_tracking: bool = None,
                 time_key: str = None, time_format: str = None, tags: List[TagInfo] = None, log_public_ip: bool = None,
                 enable_hot_ttl: bool = None, hot_ttl: int = None, cold_ttl: int = None, archive_ttl: int = None):
        self.topic_name = topic_name
        self.topic_id = topic_id
        self.project_id = project_id
        self.ttl = ttl
        self.create_time = create_time
        self.modify_time = modify_time
        self.shard_count = shard_count
        self.description = description
        self.auto_split = auto_split
        self.max_split_shard = max_split_shard
        self.enable_tracking = enable_tracking
        self.time_key = time_key
        self.time_format = time_format
        self.tags = tags
        self.log_public_ip = log_public_ip
        self.enable_hot_ttl = enable_hot_ttl
        self.hot_ttl = hot_ttl
        self.cold_ttl = cold_ttl
        self.archive_ttl = archive_ttl

    @classmethod
    def set_attributes(cls, data: dict):
        topic_name = data.get(TOPIC_NAME)
        topic_id = data.get(TOPIC_ID)
        project_id = data.get(PROJECT_ID)
        ttl = data.get(TTL)
        create_time = data.get(CREATE_TIME)
        modify_time = data.get(MODIFY_TIME)
        shard_count = data.get(SHARD_COUNT)
        description = data.get(DESCRIPTION)
        auto_split = data.get(AUTO_SPLIT)
        max_split_shard = data.get(MAX_SPLIT_SHARD)
        enable_tracking = data.get(ENABLE_TRACKING)
        time_key = data.get(TIME_KEY)
        time_format = data.get(TIME_FORMAT)
        topic_tags = None
        log_public_ip = data.get(LOG_PUBLIC_IP)
        enable_hot_ttl = data.get(ENABLE_HOT_TTL)
        hot_ttl = data.get(HOT_TTL)
        cold_ttl = data.get(COLD_TTL)
        archive_ttl = data.get(ARCHIVE_TTL)

        tags = data.get(TAGS)
        if tags is not None:
            topic_tags = []
            for i in range(len(tags)):
                topic_tags.append(TagInfo(tags[i].get(KEY), tags[i].get(VALUE)))

        return cls(topic_name, topic_id, project_id, ttl, create_time, modify_time, shard_count, description,
                   auto_split, max_split_shard, enable_tracking, time_key, time_format, topic_tags, log_public_ip,
                   enable_hot_ttl, hot_ttl, cold_ttl, archive_ttl)

    def get_create_time(self):
        """
        :return: 创建时间
        :rtype: str
        """
        return self.create_time

    def get_project_id(self):
        """
        :return: 日志项目 ID
        :rtype: str
        """
        return self.project_id

    def get_modify_time(self):
        """
        :return:修改时间
        :rtype: str
        """
        return self.modify_time

    def get_shard_count(self):
        """
        :return:日志分区的数量
        :rtype: int
        """
        return self.shard_count

    def get_topic_name(self):
        """
        :return: 日志主题名称
        :rtype: str
        """
        return self.topic_name

    def get_description(self):
        """
        :return:日志主题描述
        :rtype: str
        """
        return self.description

    def get_topic_id(self):
        """

        :return: 日志主题 ID
        :rtype: str
        """
        return self.topic_id

    def get_ttl(self):
        """
        :return: 日志在日志服务中的保存时间, 单位天
        :rtype: int
        """
        return self.ttl

    def is_auto_split(self):
        """
        :return: 是否开启分区的自动分裂功能
        :rtype: bool
        """
        return self.auto_split

    def get_max_split_shard(self):
        """
        :return: 分区的最大分裂数
        :rtype: int
        """
        return self.max_split_shard

    def is_enable_tracking(self):
        """
        :return: 是否开启了WebTracking功能
        :rtype: bool
        """
        return self.enable_tracking

    def get_time_key(self):
        """
        :return: 日志时间字段的字段名称
        :rtype: str
        """
        return self.time_key

    def get_time_format(self):
        """
        :return: 时间字段的解析格式
        :rtype: str
        """
        return self.time_format

    def get_tags(self):
        """
        :return: 日志主题标签信息
        :rtype: List[TagInfo]
        """
        return self.tags

    def get_log_public_ip(self):
        """
        :return: 是否开启了记录外网IP功能
        :rtype: bool
        """
        return self.log_public_ip


class FullTextInfo(TLSData):
    def __init__(self, case_sensitive: bool = None, delimiter: str = None, include_chinese: bool = False):
        """
        :param case_sensitive: 是否大小写敏感
        :type case_sensitive:bool
        :param delimiter:全文索引的分词符
        :type delimiter:string
        :param include_chinese:是否包含中文
        :type include_chinese:bool
        """
        self.case_sensitive = case_sensitive
        self.delimiter = delimiter
        self.include_chinese = include_chinese

    def get_delimiter(self):
        """
        :return: 全文索引的分词符
        :rtype: string
        """
        return self.delimiter

    def get_case_sensitive(self):
        """
        :return: 是否大小写敏感
        :rtype: bool
        """
        return self.case_sensitive

    def get_include_chinese(self):
        """
        :return:是否包含中文
        :rtype: bool
        """
        return self.include_chinese

    @classmethod
    def set_attributes(cls, data: dict):
        case_sensitive = data.get(CASE_SENSITIVE)
        delimiter = data.get(DELIMITER)
        include_chinese = data.get(INCLUDE_CHINESE)

        return cls(case_sensitive, delimiter, include_chinese)


class ValueInfo(TLSData):
    def __init__(self, value_type: str, delimiter: str = None, case_sensitive: bool = False,
                 include_chinese: bool = False, sql_flag: bool = False, index_all: bool = False, json_keys = None):
        self.value_type = value_type
        self.delimiter = delimiter
        self.case_sensitive = case_sensitive
        self.include_chinese = include_chinese
        self.sql_flag = sql_flag
        self.index_all = index_all

        if value_type == "json":
            self.json_keys = json_keys
        else:
            self.json_keys = None

    @classmethod
    def set_attributes(cls, data: dict):
        value_type = data.get(VALUE_TYPE)
        delimiter = data.get(DELIMITER)
        case_sensitive = data.get(CASE_SENSITIVE)
        include_chinese = data.get(INCLUDE_CHINESE)
        sql_flag = data.get(SQL_FLAG)
        index_all = data.get(INDEX_ALL)
        json_keys = data.get(JSON_KEYS)

        return cls(value_type, delimiter, case_sensitive, include_chinese, sql_flag, index_all, json_keys)


class KeyValueInfo(TLSData):
    def __init__(self, key: str, value: ValueInfo):
        """
        :param key:需要配置键值索引的字段名称
        :type key:string
        :param value:需要配置键值索引的字段描述信息
        :type value:string
        """
        self.key = key
        self.value = value

    def json(self):
        return {KEY: self.key, VALUE: self.value.json()}


class AnalysisResult(TLSData):
    def __init__(self, analysis_schema: List[str] = None, analysis_type: dict = None, analysis_data: List[dict] = None):
        self.analysis_schema = analysis_schema
        self.analysis_type = analysis_type
        self.analysis_data = analysis_data

    def get_analysis_schema(self):
        """
        :return:日志分析列的名称
        :rtype:List[str]
        """
        return self.analysis_schema

    def get_analysis_type(self):
        """
        :return:日志分析列对应的属性
        :rtype:dict
        """
        return self.analysis_type

    def get_analysis_data(self):
        """
        :return:分析结果返回的键值对
        :rtype:List[dict]
        """
        return self.analysis_data

    @classmethod
    def set_attributes(cls, data: dict):
        analysis_schema = data.get(SCHEMA)
        analysis_type = data.get(TYPE)
        analysis_data = data.get(DATA)

        return cls(analysis_schema, analysis_type, analysis_data)


class SearchResult(TLSData):
    def __init__(self, result_status: str = None, hit_count: int = None, list_over: bool = None, analysis: bool = None,
                 count: int = None, limit: int = None, context: str = None, logs: List[dict] = None,
                 analysis_result: AnalysisResult = None):
        self.result_status = result_status
        self.hit_count = hit_count
        self.list_over = list_over
        self.analysis = analysis
        self.count = count
        self.limit = limit
        self.context = context
        self.logs = logs
        self.analysis_result = analysis_result

    def get_list_over(self):
        """
        :return: 是否已返回全部结果
        :rtype:bool
        """
        return self.list_over

    def get_analysis_result(self):
        """
        :return: 分析结果
        :rtype: AnalysisResult
        """
        return self.analysis_result

    def get_result_status(self):
        """
        :return: 查询的状态
        :rtype:str
        """
        return self.result_status

    def get_count(self):
        """
        :return: 分析请求命中的条目数
        :rtype: int
        """
        return self.count

    def get_limit(self):
        """
        :return:请求中指定返回的 Limit 条目数
        :rtype: int
        """
        return self.limit

    def get_context(self):
        """
        :return:仅检索日志时，翻页上下文
        :rtype: str
        """
        return self.context

    def get_hit_count(self):
        """
        :return:搜索匹配的总条目数
        :rtype: int
        """
        return self.hit_count

    def get_analysis(self):
        """
        :return:是否分析请求
        :rtype:bool
        """
        return self.analysis

    def get_logs(self):
        """
        :return:检索日志结果
        :rtype: List[dict]
        """
        return self.logs

    @classmethod
    def set_attributes(cls, data: dict):
        search_result = super(SearchResult, cls).set_attributes(data)

        if ANALYSIS_RESULT in data:
            search_result.analysis_result = AnalysisResult.set_attributes(data=data[ANALYSIS_RESULT])

        return search_result


class QueryResp(TLSData):
    def __init__(self, topic_id: str = None, shard_id: int = None, inclusive_begin_key: str = None,
                 exclusive_end_key: str = None, status: str = None, modify_time: str = None):
        self.topic_id = topic_id
        self.shard_id = shard_id
        self.inclusive_begin_key = inclusive_begin_key
        self.exclusive_end_key = exclusive_end_key
        self.status = status
        self.modify_time = modify_time

    def get_exclusive_end_key(self):
        """
        :return:分区结束的 key 值
        :rtype:str
        """
        return self.exclusive_end_key

    def get_inclusive_begin_key(self):
        """
        :return:分区起始的 key 值
        :rtype:str
        """
        return self.inclusive_begin_key

    def get_shard_id(self):
        """
        :return:日志主题的分区 ID
        :rtype: int
        """
        return self.shard_id

    def get_modify_time(self):
        """
        :return:分区修改时间
        :rtype:str
        """
        return self.modify_time

    def get_topic_id(self):
        """
        :return:日志主题的 ID
        :rtype:str
        """
        return self.topic_id

    def get_status(self):
        """
        :return:分区状态 readwrite：读写，readonly：只读。
        :rtype:str
        """
        return self.status


class HistogramInfo(TLSData):
    def __init__(self, time: int = None, count: int = None):
        self.time = time
        self.count = count

    def get_count(self):
        """
        :return:子区间中对应搜索结果的数量
        :rtype:int
        """
        return self.count

    def get_time(self):
        """
        :return:子区间的起始时间点，单位为毫秒
        :rtype:long
        """
        return self.time

class HistogramInfoV1(TLSData):
    def __init__(self, count: int = None, start_time: int = None, end_time: int = None, result_status: str = None):
        self.count = count
        self.start_time = start_time
        self.end_time = end_time
        self.result_status = result_status

    def get_count(self):
        """
        :return:子区间中对应搜索结果的数量，即该时段内符合条件的日志条数
        :rtype:int
        """
        return self.count

    def get_start_time(self):
        """
        :return:查询的开始时间点，单位为毫秒
        :rtype:long
        """
        return self.start_time

    def get_end_time(self):
        """
        :return:查询的开始时间点，单位为毫秒
        :rtype:long
        """
        return self.end_time

    def get_result_status(self):
        """
        :return:查询的状态
        :rtype:str
        """
        return self.result_status


class TaskInfo(TLSData):
    def __init__(self, task_id: str = None, task_name: str = None, topic_id: str = None, query: str = None,
                 start_time: str = None, end_time: str = None, data_format: str = None, task_status: str = None,
                 compression: str = None, create_time: str = None, log_size: int = None, log_count: int = None):
        self.task_id = task_id
        self.task_name = task_name
        self.topic_id = topic_id
        self.query = query
        self.start_time = start_time
        self.end_time = end_time
        self.data_format = data_format
        self.task_status = task_status
        self.compression = compression
        self.create_time = create_time
        self.log_size = log_size
        self.log_count = log_count

    def get_task_name(self):
        """
        :return:下载任务的名称
        :rtype: str
        """
        return self.task_name

    def get_start_time(self):
        """
        :return:起始时间。格式为 yyyy-MM-dd HH:mm:ss
        :rtype: str
        """
        return self.start_time

    def get_data_format(self):
        """
        :return:导出的文件格式，支持 CSV 文件格式或 JSON 格式
        :rtype: str
        """
        return self.data_format

    def get_task_status(self):
        """
        :return:下载任务状态
        :rtype:str
        """
        return self.task_status

    def get_log_count(self):
        """
        :return:下载的日志条数
        :rtype: int
        """
        return self.log_count

    def get_create_time(self):
        """
        :return:下载任务的创建时间
        :rtype: str
        """
        return self.create_time

    def get_query(self):
        """
        :return:日志检索分析语句
        :rtype:str
        """
        return self.query

    def get_end_time(self):
        """
        :return:结束时间。格式为 yyyy-MM-dd HH:mm:ss
        :rtype: str
        """
        return self.end_time

    def get_task_id(self):
        """
        :return:下载任务的 ID
        :rtype:str
        """
        return self.task_id

    def get_log_size(self):
        """
        :return:下载的日志量，单位为字节（Byte）
        :rtype:long
        """
        return self.log_size

    def get_topic_id(self):
        """
        :return:日志主题名称
        :rtype:str
        """
        return self.topic_id

    def get_compression(self):
        """
        :return:导出文件的压缩格式
        :rtype:str
        """
        return self.compression


class HostInfo(TLSData):
    def __init__(self, ip: str = None, log_collector_version: str = None, heartbeat_status: int = None):
        self.ip = ip
        self.log_collector_version = log_collector_version
        self.heartbeat_status = heartbeat_status

    def get_ip(self):
        """
        :return:机器的 IP 地址
        :rtype: str
        """
        return self.ip

    def get_log_collector_version(self):
        """
        :return:机器安装的 LogCollector 的版本
        :rtype:str
        """
        return self.log_collector_version

    def get_heartbeat_status(self):
        """
        :return:Agent 的心跳状态。0：心跳正常 1：心跳异常。
        :rtype:int
        """
        return self.heartbeat_status


class HostGroupInfo(TLSData):
    def __init__(self, host_group_id: str = None, host_group_name: str = None, host_group_type: str = None,
                 host_identifier: str = None, host_count: int = None, normal_heartbeat_status_count: int = None,
                 abnormal_heartbeat_status_count: int = None, rule_count: int = None,
                 create_time: str = None, modify_time: str = None, auto_update: bool = False,
                 update_start_time: str = None, update_end_time: str = None, agent_latest_version: str = None,
                 service_logging: bool = None, iam_project_name: str = None):
        self.host_group_id = host_group_id
        self.host_group_name = host_group_name
        self.host_group_type = host_group_type
        self.host_identifier = host_identifier
        self.host_count = host_count
        self.normal_heartbeat_status_count = normal_heartbeat_status_count
        self.abnormal_heartbeat_status_count = abnormal_heartbeat_status_count
        self.rule_count = rule_count
        self.create_time = create_time
        self.modify_time = modify_time
        self.auto_update = auto_update
        self.update_start_time = update_start_time
        self.update_end_time = update_end_time
        self.agent_latest_version = agent_latest_version
        self.service_logging = service_logging
        self.iam_project_name = iam_project_name

    def get_update_end_time(self):
        """
        :return: 自动升级的结束时间
        :rtype: str
        """
        return self.update_end_time

    def get_update_start_time(self):
        """
        :return: 自动升级的开始时间
        :rtype: str
        """
        return self.update_start_time

    def get_create_time(self):
        """
        :return: 机器组创建时间
        :rtype: str
        """
        return self.create_time

    def get_host_count(self):
        """
        :return: 机器数量
        :rtype: int
        """
        return self.host_count

    def get_modify_time(self):
        """
        :return: 机器组修改时间
        :rtype: str
        """
        return self.modify_time

    def get_host_group_type(self):
        """
        :return: 机器组类型
        :rtype: str
        """
        return self.host_group_type

    def get_host_group_id(self):
        """
        :return: 机器组ID
        :rtype: str
        """
        return self.host_group_id

    def get_host_identifier(self):
        """
        :return: 机器标识符
        :rtype: str
        """
        return self.host_identifier

    def get_abnormal_heartbeat_status_count(self):
        """
        :return: 心跳异常的机器数量
        :rtype: int
        """
        return self.abnormal_heartbeat_status_count

    def get_auto_update(self):
        """
        :return: 是否开启自动升级功能
        :rtype: bool
        """
        return self.auto_update

    def get_host_group_name(self):
        """
        :return: 机器组名称
        :rtype: str
        """
        return self.host_group_name

    def get_agent_latest_version(self):
        """
        :return: 日志服务发布的LogCollector最新版本号
        :rtype: str
        """
        return self.agent_latest_version

    def get_normal_heartbeat_status_count(self):
        """
        :return: 心跳正常的机器数量
        :rtype: int
        """
        return self.normal_heartbeat_status_count

    def get_rule_count(self):
        """
        :return: 绑定的采集配置的数量
        :rtype: int
        """
        return self.rule_count

    def get_service_logging(self):
        """
        :return: 是否开启Logcollector服务日志功能
        :rtype: bool
        """
        return self.service_logging

    def get_iam_project_name(self):
        """
        :return: 机器组所属的IAM项目
        :rtype: str
        """
        return self.iam_project_name


class FilterKeyRegex(TLSData):
    def __init__(self, key: str, regex: str):
        """
        :param key: 过滤字段的名称
        :type key:str
        :param regex:过滤字段的日志内容需要匹配的正则表达式
        :type regex:str
        """
        self.key = key
        self.regex = regex

    @classmethod
    def set_attributes(cls, data: dict):
        key = data.get(KEY)
        regex = data.get(REGEX)

        return cls(key, regex)


class LogTemplate(TLSData):
    def __init__(self, log_type: str, log_format: str):
        """
        :param log_type:日志模板的类型：Nginx
        :type log_type:str
        :param log_format:日志模板内容
        :type log_format:str
        """
        self.log_type = log_type
        self.log_format = log_format

    def json(self):
        return {TYPE: self.log_type, FORMAT: self.log_format}


class ExtractRule(TLSData):
    def __init__(self, delimiter: str = None, begin_regex: str = None, log_regex: str = None, keys: List[str] = None,
                 time_key: str = None, time_format: str = None, filter_key_regex: List[FilterKeyRegex] = None,
                 un_match_up_load_switch: bool = None, un_match_log_key: str = None, log_template: LogTemplate = None,
                 quote: str = None):
        """
        :param delimiter: 日志分隔符
        :type delimiter: str
        :param begin_regex: 第一行日志需要匹配的正则表达式
        :type begin_regex: str
        :param log_regex: 整条日志需要匹配的正则表达式
        :type log_regex: str
        :param keys: 日志字段名称
        :type keys: List[str]
        :param time_key: 日志时间字段的字段名称
        :type time_key: str
        :param time_format: 时间字段的解析格式
        :type time_format: str
        :param filter_key_regex: 时间字段的解析格式
        :type filter_key_regex: List[FilterKeyRegex]
        :param un_match_up_load_switch: 是否上传解析失败的日志
        :type un_match_up_load_switch: bool
        :param un_match_log_key: 当上传解析失败的日志时，解析失败的日志的key名称
        :type un_match_log_key: str
        :param log_template: 根据指定的日志模板自动提取日志字段
        :type log_template: LogTemplate
        :param quote: 引用符
        :type quote: str
        """
        assert (time_key is None and time_format is None) or (time_key is not None and time_format is not None)
        assert (un_match_up_load_switch is None and un_match_log_key is None) or \
               (un_match_up_load_switch is not None and un_match_log_key is not None)

        self.delimiter = delimiter
        self.begin_regex = begin_regex
        self.log_regex = log_regex
        self.keys = keys
        self.time_key = time_key
        self.time_format = time_format
        self.filter_key_regex = filter_key_regex
        self.un_match_up_load_switch = un_match_up_load_switch
        self.un_match_log_key = un_match_log_key
        self.log_template = log_template
        self.quote = quote

    @classmethod
    def set_attributes(cls, data: dict):
        extract_rule = super(ExtractRule, cls).set_attributes(data)

        if FILTER_KEY_REGEX in data:
            extract_rule.filter_key_regex = []
            for one_filter_key_regex in data[FILTER_KEY_REGEX]:
                extract_rule.filter_key_regex.append(FilterKeyRegex.set_attributes(data=one_filter_key_regex))
        if LOG_TEMPLATE in data:
            extract_rule.log_template = LogTemplate(log_type=data[LOG_TEMPLATE].get(TYPE),
                                                    log_format=data[LOG_TEMPLATE].get(FORMAT))

        return extract_rule

    def json(self):
        json_data = super(ExtractRule, self).json()

        if self.filter_key_regex is not None:
            json_data[FILTER_KEY_REGEX] = []
            for regex in self.filter_key_regex:
                json_data[FILTER_KEY_REGEX].append(regex.json())
        if self.log_template is not None:
            json_data[LOG_TEMPLATE] = self.log_template.json()

        return json_data


class ExcludePath(TLSData):
    def __init__(self, path_type: str, value: str):
        """
        :param path_type:采集路径类型，File或Path
        :type path_type:str
        :param value:采集绝对路径
        :type value:str
        """
        assert path_type == "File" or path_type == "Path"

        self.path_type = path_type
        self.value = value

    def get_path_type(self):
        """
        :return: 采集路径类型，File或Path
        :rtype: str
        """
        return self.path_type

    def get_value(self):
        """
        :return: 采集绝对路径
        :rtype: str
        """
        return self.value

    @classmethod
    def set_attributes(cls, data: dict):
        path_type = data.get(TYPE)
        value = data.get(VALUE)

        return cls(path_type, value)

    def json(self):
        return {TYPE: self.path_type, VALUE: self.value}


class ParsePathRule(TLSData):
    def __init__(self, path_sample: str, regex: str, keys: List[str]):
        """
        :param path_sample:实际场景的采集路径样例
        :type path_sample:str
        :param regex: 用于提取路径字段的正则表达式
        :type regex:str
        :param keys:字段名称列表
        :type keys: List[str]
        """
        self.path_sample = path_sample
        self.regex = regex
        self.keys = keys

    def get_path_sample(self):
        """
        :return: 实际场景的采集路径样例
        :rtype: str
        """
        return self.path_sample

    def get_regex(self):
        """
        :return: 用于提取路径字段的正则表达式
        :rtype: str
        """
        return self.regex

    def get_keys(self):
        """
        :return: 字段名称列表
        :rtype:  List[str]
        """
        return self.keys

    @classmethod
    def set_attributes(cls, data: dict):
        path_sample = data.get(PATH_SAMPLE)
        regex = data.get(REGEX)
        keys = data.get(KEYS)

        return cls(path_sample, regex, keys)


class ShardHashKey(TLSData):
    def __init__(self, hash_key: str):
        """
        :param hash_key:日志组的 HashKey
        :type hash_key: str
        """
        self.hash_key = hash_key

    def get_hash_key(self):
        """
        :return:日志组的 HashKey
        :rtype: str
        """
        return self.hash_key


class Plugin(TLSData):
    def __init__(self, processors: List[Dict]):
        """
        :param processors: LogCollector插件
        :type processors: List[Dict]
        """
        self.processors = processors

    def get_processors(self):
        """
        :return: LogCollector插件
        :rtype: List[Dict]
        """
        return self.processors

    def json(self):
        return {PROCESSORS: self.processors}


class Advanced(TLSData):
    def __init__(self, close_inactive: int = 60, close_timeout: int = 0,
                 close_removed: bool = False, close_renamed: bool = False, close_eof: bool = False):
        """
        :param close_inactive: 释放日志文件句柄的等待时间
        :type close_inactive: int
        :param close_timeout: LogCollector监控日志文件的最大时长
        :type close_timeout: int
        :param close_removed: 日志文件被移除之后，是否释放该日志文件的句柄
        :type close_removed: bool
        :param close_renamed: 日志文件被重命名之后，是否释放该日志文件的句柄
        :type close_renamed: bool
        :param close_eof: 读取至日志文件的末尾之后，是否释放该日志文件的句柄
        :type close_eof: bool
        """
        self.close_inactive = close_inactive
        self.close_timeout = close_timeout
        self.close_removed = close_removed
        self.close_renamed = close_renamed
        self.close_eof = close_eof

    def get_close_inactive(self):
        """
        :return: 释放日志文件句柄的等待时间
        :rtype: int
        """
        return self.close_inactive

    def get_close_timeout(self):
        """
        :return: LogCollector监控日志文件的最大时长
        :rtype: int
        """
        return self.close_timeout

    def get_close_removed(self):
        """
        :return: 日志文件被移除之后，是否释放该日志文件的句柄
        :rtype: bool
        """
        return self.close_removed

    def get_close_renamed(self):
        """
        :return: 日志文件被重命名之后，是否释放该日志文件的句柄
        :rtype: bool
        """
        return self.close_renamed

    def get_close_eof(self):
        """
        :return: 读取至日志文件的末尾之后，是否释放该日志文件的句柄
        :rtype: bool
        """
        return self.close_eof

    def json(self):
        return {CLOSE_INACTIVE: self.close_inactive, CLOSE_TIMEOUT: self.close_timeout,
                CLOSE_REMOVED: self.close_removed, CLOSE_RENAMED: self.close_renamed, CLOSE_EOF: self.close_eof}


class UserDefineRule(TLSData):
    def __init__(self, parse_path_rule: ParsePathRule = None, shard_hash_key: ShardHashKey = None,
                 enable_raw_log: bool = False, fields: dict = None, plugin: Plugin = None, advanced: Advanced = None,
                 tail_files: bool = False):
        """
        :param parse_path_rule: 解析采集路径的规则
        :type parse_path_rule: ParsePathRule
        :param shard_hash_key: 路由日志分区的规则
        :type shard_hash_key: ShardHashKey
        :param enable_raw_log: 是否上传原始日志
        :type enable_raw_log: bool
        :param fields: 为日志添加常量字段
        :type fields: dict
        :param plugin: LogCollector插件配置
        :type plugin: Plugin
        :param advanced: LogCollector扩展配置
        :type advanced: Advanced
        :param tail_files: LogCollector采集策略，即指定LogCollector采集增量日志还是全量日志
        :type tail_files: bool
        """
        self.parse_path_rule = parse_path_rule
        self.shard_hash_key = shard_hash_key
        self.enable_raw_log = enable_raw_log
        self.fields = fields
        self.plugin = plugin
        self.advanced = advanced
        self.tail_files = tail_files

    def get_enable_raw_log(self):
        """
        :return:是否上传原始日志
        :rtype:bool
        """
        return self.enable_raw_log

    def get_shard_hash_key(self):
        """
        :return:路由日志分区的规则
        :rtype: ShardHashKey
        """
        return self.shard_hash_key

    def get_fields(self):
        """
        :return: 为日志添加常量字段
        :rtype: dict
        """
        return self.fields

    def get_parse_path_rule(self):
        """
        :return: 解析采集路径的规则
        :rtype: ParsePathRule
        """
        return self.parse_path_rule

    def get_plugin(self):
        """
        :return: LogCollector插件配置
        :rtype: Plugin
        """
        return self.plugin

    def get_advanced(self):
        """
        :return: LogCollector扩展配置
        :rtype: Advanced
        """
        return self.advanced

    def get_tail_files(self):
        """
        :return: LogCollector采集策略，即指定LogCollector采集增量日志还是全量日志
        :rtype: bool
        """
        return self.tail_files

    @classmethod
    def set_attributes(cls, data: dict):
        user_define_rule = super(UserDefineRule, cls).set_attributes(data)

        if SHARD_HASH_KEY in data:
            user_define_rule.shard_hash_key = ShardHashKey(hash_key=data[SHARD_HASH_KEY].get(HASH_KEY))
        if PARSE_PATH_RULE in data:
            user_define_rule.parse_path_rule = ParsePathRule.set_attributes(data[PARSE_PATH_RULE])
        if PLUGIN in data:
            user_define_rule.plugin = Plugin(processors=data[PLUGIN].get(PROCESSORS))
        if ADVANCED in data:
            user_define_rule.advanced = Advanced(close_inactive=data[ADVANCED].get(CLOSE_INACTIVE),
                                                 close_timeout=data[ADVANCED].get(CLOSE_TIMEOUT),
                                                 close_removed=data[ADVANCED].get(CLOSE_REMOVED),
                                                 close_renamed=data[ADVANCED].get(CLOSE_RENAMED),
                                                 close_eof=data[ADVANCED].get(CLOSE_EOF))

        return user_define_rule

    def json(self):
        json_data = super(UserDefineRule, self).json()

        if self.shard_hash_key is not None:
            json_data[SHARD_HASH_KEY] = self.shard_hash_key.json()
        if self.parse_path_rule is not None:
            json_data[PARSE_PATH_RULE] = self.parse_path_rule.json()
        if self.plugin is not None:
            json_data[PLUGIN] = self.plugin.json()
        if self.advanced is not None:
            json_data[ADVANCED] = self.advanced.json()

        return json_data


class KubernetesRule(TLSData):
    def __init__(self, namespace_name_regex: str = None, workload_type: str = None, workload_name_regex: str = None,
                 include_pod_label_regex: Dict[str, str] = None, exclude_pod_label_regex: Dict[str, str] = None,
                 pod_name_regex: str = None, label_tag: Dict[str, str] = None, annotation_tag: Dict[str, str] = None):
        """
        :param namespace_name_regex: 待采集的Kubernetes Namespace名称，不指定Namespace名称时表示采集全部容器
        :type namespace_name_regex: str
        :param workload_type: 通过工作负载的类型指定采集的容器，仅支持选择一种类型
        :type workload_type: str
        :param workload_name_regex: 通过工作负载的名称指定待采集的容器
        :type workload_name_regex: str
        :param include_pod_label_regex: Pod Label白名单用于指定待采集的容器
        :type include_pod_label_regex: Dict[str, str]
        :param exclude_pod_label_regex: 通过Pod Label黑名单指定不采集的容器，不启用表示采集全部容器
        :type exclude_pod_label_regex: Dict[str, str]
        :param pod_name_regex: Pod名称用于指定待采集的容器
        :type pod_name_regex: str
        :param label_tag: 是否将Kubernetes Label作为日志标签，添加到原始日志数据中
        :type label_tag: Dict[str, str]
        :param annotation_tag: 是否将Kubernetes Annotation作为日志标签，添加到原始日志数据中
        :type annotation_tag: Dict[str, str]
        """
        self.namespace_name_regex = namespace_name_regex
        self.workload_type = workload_type
        self.workload_name_regex = workload_name_regex
        self.include_pod_label_regex = include_pod_label_regex
        self.exclude_pod_label_regex = exclude_pod_label_regex
        self.pod_name_regex = pod_name_regex
        self.label_tag = label_tag
        self.annotation_tag = annotation_tag

    def get_include_pod_label_regex(self):
        """
        :return: Pod Label 白名单用于指定待采集的容器
        :rtype:Dict[str, str]
        """
        return self.include_pod_label_regex

    def get_workload_name_regex(self):
        """
        :return: 通过工作负载的名称指定待采集的容器
        :rtype:str
        """
        return self.workload_name_regex

    def get_pod_name_regex(self):
        """
        :return: Pod名称用于指定待采集的容器
        :rtype: str
        """
        return self.pod_name_regex

    def get_exclude_pod_label_regex(self):
        """
        :return: 通过 Pod Label 黑名单指定不采集的容器，不启用表示采集全部容器
        :rtype: ict[str, str]
        """
        return self.exclude_pod_label_regex

    def get_label_tag(self):
        """
        :return: 是否将 Kubernetes Label 作为日志标签，添加到原始日志数据中
        :rtype: Dict[str, str]
        """
        return self.label_tag

    def get_namespace_name_regex(self):
        """
        :return: 待采集的 Kubernetes Namespace 名称，不指定 Namespace 名称时表示采集全部容器
        :rtype: str
        """
        return self.namespace_name_regex

    def get_workload_type(self):
        """
        :return:通过工作负载的类型指定采集的容器，仅支持选择一种类型
        :rtype: str
        """
        return self.workload_type

    def get_annotation_tag(self):
        """
        :return: 是否将Kubernetes Annotation作为日志标签，添加到原始日志数据中
        :rtype: Dict[str, str]
        """
        return self.annotation_tag


class ContainerRule(TLSData):
    def __init__(self, stream: str = None, container_name_regex: str = None,
                 include_container_label_regex: Dict[str, str] = None,
                 exclude_container_label_regex: Dict[str, str] = None,
                 include_container_env_regex: Dict[str, str] = None,
                 exclude_container_env_regex: Dict[str, str] = None,
                 env_tag: Dict[str, str] = None, kubernetes_rule: KubernetesRule = None):
        """
        :param stream:采集模式
        :type stream:str
        :param container_name_regex:待采集的容器名称
        :type container_name_regex:str
        :param include_container_label_regex:指定待采集的容器，不启用白名单时指定采集全部容器
        :type include_container_label_regex:Dict[str, str]
        :param exclude_container_label_regex:黑名单用于指定不采集的容器范围，不启用黑名单时表示采集全部容器
        :type exclude_container_label_regex:Dict[str, str]
        :param include_container_env_regex:容器环境变量白名单通过容器环境变量指定待采集的容器，不启用白名单时表示指定采集全部容器
        :type include_container_env_regex:Dict[str, str]
        :param exclude_container_env_regex:容器环境变量黑名单用于指定不采集的容器范围，不启用黑名单时表示采集全部容器
        :type exclude_container_env_regex:Dict[str, str]
        :param env_tag:是否将环境变量作为日志标签，添加到原始日志数据中
        :type env_tag:Dict[str, str]
        :param kubernetes_rule:Kubernetes 容器的采集规则
        :type kubernetes_rule:KubernetesRule
        """
        self.stream = stream
        self.container_name_regex = container_name_regex
        self.include_container_label_regex = include_container_label_regex
        self.exclude_container_label_regex = exclude_container_label_regex
        self.include_container_env_regex = include_container_env_regex
        self.exclude_container_env_regex = exclude_container_env_regex
        self.env_tag = env_tag
        self.kubernetes_rule = kubernetes_rule

    def get_stream(self):
        """
        :return 采集模式
        :rtype str
        """
        return self.stream

    def get_exclude_container_env_regex(self):
        """
        :return: 容器环境变量黑名单用于指定不采集的容器范围，不启用黑名单时表示采集全部容器
        :rtype:Dict[str, str]
        """
        return self.exclude_container_env_regex

    def get_kubernetes_rule(self):
        """
        :return: Kubernetes 容器的采集规则
        :rtype: KubernetesRule
        """
        return self.kubernetes_rule

    def get_include_container_label_regex(self):
        """
        :return: 指定待采集的容器，不启用白名单时指定采集全部容器
        :rtype: Dict[str, str]
        """
        return self.include_container_label_regex

    def get_include_container_env_regex(self):
        """
        :return: 容器环境变量白名单通过容器环境变量指定待采集的容器，不启用白名单时表示指定采集全部容器
        :rtype: Dict[str, str]
        """
        return self.include_container_env_regex

    def get_exclude_container_label_regex(self):
        """
        :return: 黑名单用于指定不采集的容器范围，不启用黑名单时表示采集全部容器
        :rtype: Dict[str, str]
        """
        return self.exclude_container_label_regex

    def get_env_tag(self):
        """
        :return: 是否将环境变量作为日志标签，添加到原始日志数据中
        :rtype: Dict[str, str]
        """
        return self.env_tag

    def get_container_name_regex(self):
        """
        :return:待采集的容器名称
        :rtype: str
        """
        return self.container_name_regex

    @classmethod
    def set_attributes(cls, data: dict):
        container_rule = super(ContainerRule, cls).set_attributes(data)

        if KUBERNETES_RULE in data:
            container_rule.kubernetes_rule = KubernetesRule.set_attributes(data=data[KUBERNETES_RULE])

        return container_rule

    def json(self):
        json_data = super(ContainerRule, self).json()

        if self.kubernetes_rule is not None:
            json_data[KUBERNETES_RULE] = self.kubernetes_rule.json()

        return json_data


class RuleInfo(TLSData):
    def __init__(self, topic_id: str = None, topic_name: str = None, rule_id: str = None, rule_name: str = None,
                 paths: List[str] = None, log_type: str = None, extract_rule: ExtractRule = None,
                 exclude_paths: List[ExcludePath] = None, log_sample: str = None,
                 user_define_rule: UserDefineRule = None, create_time: str = None, modify_time: str = None,
                 input_type: int = None, container_rule: ContainerRule = None):
        self.topic_id = topic_id
        self.topic_name = topic_name
        self.rule_id = rule_id
        self.rule_name = rule_name
        self.paths = paths
        self.log_type = log_type
        self.extract_rule = extract_rule
        self.exclude_paths = exclude_paths
        self.log_sample = log_sample
        self.user_define_rule = user_define_rule
        self.create_time = create_time
        self.modify_time = modify_time
        self.input_type = input_type
        self.container_rule = container_rule

    def get_exclude_paths(self):
        """
        :return:采集黑名单列表
        :rtype:List[ExcludePath]
        """
        return self.exclude_paths

    def get_create_time(self):
        """
        :return:采集配置创建的时间
        :rtype:str
        """
        return self.create_time

    def get_rule_name(self):
        """
        :return:采集配置的名称
        :rtype:str
        """
        return self.rule_name

    def get_container_rule(self):
        """
        :return:容器采集规则。详细说明请查看
        :rtype:ContainerRule
        """
        return self.container_rule

    def get_modify_time(self):
        return self.modify_time

    def get_input_type(self):
        return self.input_type

    def get_user_define_rule(self):
        return self.user_define_rule

    def get_rule_id(self):
        return self.rule_id

    def get_log_type(self):
        return self.log_type

    def get_extract_rule(self):
        return self.extract_rule

    def get_paths(self):
        return self.paths

    def get_topic_name(self):
        return self.topic_name

    def get_topic_id(self):
        return self.topic_id

    def get_log_sample(self):
        return self.log_sample

    @classmethod
    def set_attributes(cls, data: dict):
        rule_info = super(RuleInfo, cls).set_attributes(data)

        if EXTRACT_RULE in data:
            rule_info.extract_rule = ExtractRule.set_attributes(data=data[EXTRACT_RULE])
        if EXCLUDE_PATHS in data:
            rule_info.exclude_paths = []
            for exclude_path in data[EXCLUDE_PATHS]:
                rule_info.exclude_paths.append(ExcludePath.set_attributes(data=exclude_path))
        if USER_DEFINE_RULE in data:
            rule_info.user_define_rule = UserDefineRule.set_attributes(data=data[USER_DEFINE_RULE])
        if CONTAINER_RULE in data:
            rule_info.container_rule = ContainerRule.set_attributes(data=data[CONTAINER_RULE])

        return rule_info


class HostGroupHostsRulesInfo(TLSData):
    def __init__(self, host_group_info: HostGroupInfo, host_infos: List[HostInfo], rule_infos: List[RuleInfo]):
        self.host_group_info = host_group_info
        self.host_infos = host_infos
        self.rule_infos = rule_infos

    def get_rule_infos(self):
        """
        :return:所绑定的采集配置信息列表
        :rtype: List[RuleInfo]
        """
        return self.rule_infos

    def get_host_group_info(self):
        """
        :return: 机器组信息
        :rtype:HostGroupInfo
        """
        return self.host_group_info

    def get_host_infos(self):
        """
        :return:
        :rtype:List[HostInfo]
        """
        return self.host_infos


class Receiver(TLSData):
    def __init__(self, receiver_type: str, receiver_names: List[str], receiver_channels: List[str],
                 start_time: str, end_time: str, webhook: str = None):
        """
        :param receiver_type:接受者类型
        :type receiver_type:str
        :param receiver_names:接收者的名字
        :type receiver_names:List[str]
        :param receiver_channels:通知接收渠道，支持Email、Sms、Phone
        :type receiver_channels:List[str]
        :param start_time:可接收信息的时段中，开始的时间
        :type start_time:str
        :param end_time:可接收信息的时段中
        :type end_time:str
        :param webhook:飞书Webhook请求地址
        :type webhook:str
        """
        self.receiver_type = receiver_type
        self.receiver_names = receiver_names
        self.receiver_channels = receiver_channels
        self.start_time = start_time
        self.end_time = end_time
        self.webhook = webhook

    def get_start_time(self):
        """
        :return:可接收信息的时段中，开始的时间
        :rtype: str
        """
        return self.start_time

    def get_webhook(self):
        """
        :return: 飞书Webhook请求地址
        :rtype: str
        """
        return self.webhook

    def get_receiver_channels(self):
        """
        :return:通知接收渠道，支持Email、Sms、Phone
        :rtype: List[str]
        """
        return self.receiver_channels

    def get_end_time(self):
        """
        :return: 可接收信息的时段中
        :rtype:str
        """
        return self.end_time

    def get_receiver_names(self):
        """
        :return: 接收者的名字
        :rtype: List[str]
        """
        return self.receiver_names

    def get_receiver_type(self):
        """
        :return:接受者类型
        :rtype: str
        """
        return self.receiver_type

    @classmethod
    def set_attributes(cls, data: dict):
        receiver_type = data.get(RECEIVER_TYPE)
        receiver_names = data.get(RECEIVER_NAMES)
        receiver_channels = data.get(RECEIVER_CHANNELS)
        start_time = data.get(START_TIME)
        end_time = data.get(END_TIME)
        webhook = data.get(WEBHOOK)

        return cls(receiver_type, receiver_names, receiver_channels, start_time, end_time, webhook)


class QueryRequest(TLSData):
    def __init__(self, topic_id: str, query: str, number: int,
                 start_time_offset: int, end_time_offset: int, topic_name: str = None, time_span_type: str = None,
                 truncated_time: str = None):
        """
        :param topic_id: 日志主题ID
        :type topic_id: str
        :param query: 查询语句，支持的最大长度为1024
        :type query: str
        :param number: 告警对象序号（从1开始递增）
        :type number: int
        :param start_time_offset: 查询范围起始时间相对当前的历史时间，单位为分钟，取值为非正，最大值为0，最小值为-1440
        :type start_time_offset: int
        :param end_time_offset: 查询范围终止时间相对当前的历史时间，单位为分钟，取值为非正，须大于StartTimeOffset，最大值为0，最小值为-1440
        :type end_time_offset: int
        :param topic_name: 告警策略执行的日志主题名称
        :type topic_name: str
        :param time_span_type: 查询是否是整点时间, 新增整点时间,非必填,空白时默认为Relative
        :type time_span_type: str
        :param truncated_time: 对时间取整,对分钟/小时取整
        :type truncated_time: str
        """
        self.topic_id = topic_id
        self.query = query
        self.number = number
        self.start_time_offset = start_time_offset
        self.end_time_offset = end_time_offset
        self.topic_name = topic_name
        self.time_span_type = time_span_type
        self.truncated_time = truncated_time

    def get_number(self):
        """
        :return:告警对象序号；从 1 开始递增
        :rtype: int
        """
        return self.number

    def get_start_time_offset(self):
        """
        :return: 查询范围起始时间相对当前的历史时间，单位为分钟，取值为非正，最大值为 0，最小值为 -1440
        :rtype: int
        """
        return self.start_time_offset

    def get_query(self):
        """
        :return:查询语句，支持的最大长度为 1024
        :rtype: str
        """
        return self.query

    def get_topic_name(self):
        """
        :return: 告警策略执行的日志主题名称
        :rtype: str
        """
        return self.topic_name

    def get_topic_id(self):
        """
        :return: 日志主题 ID
        :rtype: str
        """
        return self.topic_id

    def get_end_time_offset(self):
        """
        :return: 查询范围终止时间相对当前的历史时间，单位为分钟
        :rtype: int
        """
        return self.end_time_offset

    def get_time_span_type(self):
        """
        :return: 查询是否是整点时间, 新增整点时间,非必填,空白时默认为Relative
        :rtype: str
        """
        return self.time_span_type

    def get_truncated_time(self):
        """
        :return: 对时间取整,对分钟/小时取整
        :rtype: str
        """
        return self.truncated_time

    @classmethod
    def set_attributes(cls, data: dict):
        topic_id = data.get(TOPIC_ID)
        topic_name = data.get(TOPIC_NAME)
        query = data.get(QUERY)
        number = data.get(NUMBER)
        start_time_offset = data.get(START_TIME_OFFSET)
        end_time_offset = data.get(END_TIME_OFFSET)
        time_span_type = data.get(TIME_SPAN_TYPE)
        truncated_time = data.get(TRUNCATED_TIME)

        return cls(topic_id, query, number, start_time_offset, end_time_offset, topic_name, time_span_type, truncated_time)


class RequestCycle(TLSData):
    def __init__(self, cycle_type: str, time: int, cron_tab: str = None):
        """
        :param cycle_type: 执行周期类型，Period：周期执行，Fixed：定期执行
        :type cycle_type:str
        :param time:告警任务执行的周期，或者定期执行的时间点。单位为分钟，取值范围为 1~1440
        :type time:int
        :param cron_tab:Cron表达式，日志服务通过 Cron 表达式指定告警任务定时执行。Cron 表达式的最小粒度为分钟，24 小时制
        :type cron_tab:str
        """
        self.cycle_type = cycle_type
        self.time = time
        self.cron_tab = cron_tab

    def get_time(self):
        """
        :return:告警任务执行的周期，或者定期执行的时间点。单位为分钟
        :rtype: int
        """
        return self.time

    def get_cycle_type(self):
        """
        :return:执行周期类型，Period：周期执行，Fixed：定期执行
        :rtype: str
        """
        return self.cycle_type

    def get_cron_tab(self):
        """
        :return:Cron表达式，日志服务通过 Cron 表达式指定告警任务定时执行
        :rtype: str
        """
        return self.cron_tab

    @classmethod
    def set_attributes(cls, data: dict):
        cycle_type = data.get(TYPE)
        time = data.get(TIME)
        cron_tab = data.get(CRON_TAB)

        return cls(cycle_type, time, cron_tab)

    def json(self):
        return {TYPE: self.cycle_type, TIME: self.time, CRON_TAB: self.cron_tab}


class AlarmNotifyGroupInfo(TLSData):
    def __init__(self, alarm_notify_group_name: str = None, alarm_notify_group_id: str = None,
                 notify_type: List[str] = None, receivers: List[Receiver] = None,
                 create_time: str = None, modify_time: str = None, iam_project_name: str = None):
        self.alarm_notify_group_name = alarm_notify_group_name
        self.alarm_notify_group_id = alarm_notify_group_id
        self.notify_type = notify_type
        self.receivers = receivers
        self.create_time = create_time
        self.modify_time = modify_time
        self.iam_project_name = iam_project_name

    def get_alarm_notify_group_name(self):
        """
        :return:告警通知组名称
        :rtype: str
        """
        return self.alarm_notify_group_name

    def get_notify_type(self):
        """
        :return:告警通知的类型：Trigger - 告警触发，Recovery - 告警恢复
        :rtype: List[str]
        """
        return self.notify_type

    def get_create_time(self):
        """
        :return:告警通知组创建的时间
        :rtype:str
        """
        return self.create_time

    def get_receivers(self):
        """
        :return:接收告警的 IAM 用户列表
        :rtype:List[Receiver]
        """
        return self.receivers

    def get_modify_time(self):
        """
        :return:告警通知组修改的时间
        :rtype:str
        """
        return self.modify_time

    def get_alarm_notify_group_id(self):
        """
        :return:告警通知组 ID
        :rtype:str
        """
        return self.alarm_notify_group_id

    def get_iam_project_name(self):
        """
        :return: 告警组所属的IAM项目
        :rtype: str
        """
        return self.iam_project_name

    @classmethod
    def set_attributes(cls, data: dict):
        alarm_notify_group_info = super(AlarmNotifyGroupInfo, cls).set_attributes(data)

        if RECEIVERS in data:
            alarm_notify_group_info.receivers = []
            for receiver in data[RECEIVERS]:
                alarm_notify_group_info.receivers.append(Receiver.set_attributes(data=receiver))

        return alarm_notify_group_info


class AlarmPeriodSetting(TLSData):
    def __init__(self, sms: int, phone: int, email: int, general_webhook: int):
        self.sms = sms
        self.phone = phone
        self.email = email
        self.general_webhook = general_webhook

    def json(self):
        return {SMS: self.sms, PHONE: self.phone, EMAIL: self.email, GENERAL_WEBHOOK: self.general_webhook}


class JoinConfig(TLSData):
    def __init__(self, set_operation_type: str = None, condition: str = None):
        self.condition = condition
        self.set_operation_type = set_operation_type


class TriggerCondition(TLSData):
    def __init__(self, severity: str = "notice", condition: str = None, count_condition: str = None):
        self.severity = severity
        self.condition = condition
        self.count_condition = count_condition

class AlarmInfo(TLSData):
    def __init__(self, alarm_name: str = None, alarm_id: str = None, project_id: str = None, status: bool = None,
                 query_request: List[QueryRequest] = None, request_cycle: RequestCycle = None, condition: str = None,
                 trigger_period: int = None, alarm_period: int = None,
                 alarm_notify_group: List[AlarmNotifyGroupInfo] = None, user_define_msg: str = None,
                 create_time: str = None, modify_time: str = None,
                 severity: str = None, alarm_period_detail: AlarmPeriodSetting = None,
                 join_configurations: List[JoinConfig] = None, trigger_conditions: List[TriggerCondition] = None):
        self.alarm_name = alarm_name
        self.alarm_id = alarm_id
        self.project_id = project_id
        self.status = status
        self.query_request = query_request
        self.request_cycle = request_cycle
        self.condition = condition
        self.trigger_period = trigger_period
        self.alarm_period = alarm_period
        self.alarm_notify_group = alarm_notify_group
        self.user_define_msg = user_define_msg
        self.create_time = create_time
        self.modify_time = modify_time
        self.severity = severity
        self.alarm_period_detail = alarm_period_detail
        self.join_configurations = join_configurations
        self.trigger_conditions = trigger_conditions

    def get_alarm_name(self):
        """
        :return:告警策略名称
        :rtype: str
        """
        return self.alarm_name

    def get_alarm_notify_group(self):
        """
        :return:告警对应的通知列表
        :rtype:List[AlarmNotifyGroupInfo]
        """
        return self.alarm_notify_group

    def get_request_cycle(self):
        """
        :return:告警任务的执行周期
        :rtype:RequestCycle
        """
        return self.request_cycle

    def get_alarm_period(self):
        """
        :return:告警重复的周期
        :rtype: int
        """
        return self.alarm_period

    def get_create_time(self):
        """
        :return:创建告警策略的时间
        :rtype:str
        """
        return self.create_time

    def get_modify_time(self):
        """
        :return:告警策略最近修改的时间
        :rtype:str
        """
        return self.modify_time

    def get_user_define_msg(self):
        """
        :return:告警通知的内容
        :rtype:str
        """
        return self.user_define_msg

    def get_condition(self):
        """
        :return:告警触发条件
        :rtype:str
        """
        return self.condition

    def get_query_request(self):
        """
        :return:检索分析语句，可配置 1~3 条
        :rtype:List[QueryRequest]
        """
        return self.query_request

    def get_project_id(self):
        """
        :return:日志项目 ID
        :rtype: str
        """
        return self.project_id

    def get_trigger_period(self):
        """
        :return:持续周期
        :rtype:int
        """
        return self.trigger_period

    def get_alarm_id(self):
        """
        :return:告警策略的 ID
        :rtype: str
        """
        return self.alarm_id

    def get_status(self):
        """
        :return:是否开启告警策略
        :rtype:bool
        """
        return self.status

    def get_severity(self):
        """
        :return: 告警通知的级别，即告警的严重程度
        :rtype: str
        """
        return self.severity

    def get_alarm_period_detail(self):
        """
        :return: 告警通知发送的周期
        :rtype: AlarmPeriodSetting
        """
        return self.alarm_period_detail

    def get_join_configurations(self):
        """
        :return: 告警策略的 Join 配置
        :rtype: List[JoinConfig]
        """
        return self.join_configurations

    def get_trigger_conditions(self):
        """
        :return: 告警策略的触发条件
        :rtype: List[TriggerCondition]
        """
        return self.trigger_conditions

    @classmethod
    def set_attributes(cls, data: dict):
        alarm_info = super(AlarmInfo, cls).set_attributes(data)

        if REQUEST_CYCLE in data:
            alarm_info.request_cycle = RequestCycle.set_attributes(data=data[REQUEST_CYCLE])
        if QUERY_REQUEST in data:
            alarm_info.query_request = []
            for one_query_request in data[QUERY_REQUEST]:
                alarm_info.query_request.append(QueryRequest.set_attributes(data=one_query_request))
        if ALARM_NOTIFY_GROUP in data:
            alarm_info.alarm_notify_group = []
            for alarm_notify_group in data[ALARM_NOTIFY_GROUP]:
                alarm_info.alarm_notify_group.append(AlarmNotifyGroupInfo.set_attributes(data=alarm_notify_group))
        if ALARM_PERIOD_DETAIL in data:
            if len(data[ALARM_PERIOD_DETAIL]) == 0:
                alarm_info.alarm_period_detail = None
            else:
                sms = data[ALARM_PERIOD_DETAIL].get(SMS)
                phone = data[ALARM_PERIOD_DETAIL].get(PHONE)
                email = data[ALARM_PERIOD_DETAIL].get(EMAIL)
                general_webhook = data[ALARM_PERIOD_DETAIL].get(GENERAL_WEBHOOK)
                alarm_info.alarm_period_detail = AlarmPeriodSetting(sms, phone, email, general_webhook)
        if JOIN_CONFIGURATIONS in data and data[JOIN_CONFIGURATIONS] is not None:
            alarm_info.join_configurations = []
            for join_configuration in data[JOIN_CONFIGURATIONS]:
                alarm_info.join_configurations.append(JoinConfig.set_attributes(data=join_configuration))
        if TRIGGER_CONDITIONS in data and data[TRIGGER_CONDITIONS] is not None:
            alarm_info.trigger_conditions = []
            for trigger_condition in data[TRIGGER_CONDITIONS]:
                alarm_info.trigger_conditions.append(TriggerCondition.set_attributes(data=trigger_condition))

        return alarm_info


class ConsumerGroup(TLSData):
    def __init__(self, project_id: str = None, consumer_group_name: str = None,
                 heartbeat_ttl: int = None, ordered_consume: bool = None):
        self.project_id = project_id
        self.consumer_group_name = consumer_group_name
        self.heartbeat_ttl = heartbeat_ttl
        self.ordered_consume = ordered_consume

    @classmethod
    def set_attributes(cls, data: dict):
        project_id = data.get(PROJECT_ID_UPPERCASE)
        consumer_group_name = data.get(CONSUMER_GROUP_NAME)
        heartbeat_ttl = data.get(HEARTBEAT_TTL)
        ordered_consume = data.get(ORDERED_CONSUME)

        return cls(project_id, consumer_group_name, heartbeat_ttl, ordered_consume)


class ConsumeShard(TLSData):
    def __init__(self, topic_id: str = None, shard_id: int = None):
        self.topic_id = topic_id
        self.shard_id = shard_id

    @classmethod
    def set_attributes(cls, data: dict):
        topic_id = data.get(TOPIC_ID_UPPERCASE)
        shard_id = data.get(SHARD_ID_UPPERCASE)

        return cls(topic_id, shard_id)