pixelarraylib 1.0.0__py3-none-any.whl

arraylib/aliyun/content_scanner.py

@@ -0,0 +1,253 @@
+import json
+import traceback
+from typing import Union
+from alibabacloud_green20220302.client import Client
+from alibabacloud_green20220302.models import (
+    TextModerationRequest,
+    TextModerationPlusRequest,
+    ImageModerationRequest,
+    VideoModerationRequest,
+    VideoModerationResultRequest,
+    VoiceModerationRequest,
+    VoiceModerationResultRequest,
+)
+from alibabacloud_tea_openapi.models import Config
+from alibabacloud_tea_util import models as util_models
+from arraylib.monitor.feishu import Feishu
+feishu_alert = Feishu("devtoolkit服务报警")
+
+class ContentScanner:
+    def __init__(self, access_key_id, access_key_secret, region_id):
+        self.client = Client(
+            Config(
+                access_key_id=access_key_id,
+                access_key_secret=access_key_secret,
+                region_id=region_id,
+                connect_timeout=30000,
+                read_timeout=60000,
+                endpoint=f"green-cip.{region_id}.aliyuncs.com",
+            )
+        )
+
+    def scan_text(
+        self, content: str, service: str = "ugc_moderation_byllm", use_plus: bool = True
+    ) -> Union[dict, bool]:
+        """
+        description:
+            文本内容检测
+        parameters:
+            content(str): 要检测的文本内容，不同的service有不同的上限，具体可以查看官网
+            service(str): 服务类型，可选值 comment_detection（普通版）, llm_query_moderation（Plus版）, ugc_moderation_byllm（Plus版）
+            use_plus(bool): 是否使用Plus版API
+        return:
+            result(dict): 检测结果
+            status(bool): 是否成功
+        """
+
+        if not content.strip():
+            return {}, False
+
+        try:
+            if use_plus:
+                response = self.client.text_moderation_plus(
+                    TextModerationPlusRequest(
+                        service=service,
+                        service_parameters=json.dumps({"content": content}),
+                    )
+                )
+            else:
+                response = self.client.text_moderation_with_options(
+                    TextModerationRequest(
+                        service=service,
+                        service_parameters=json.dumps({"content": content}),
+                    ),
+                    util_models.RuntimeOptions(
+                        read_timeout=10000, connect_timeout=10000
+                    ),
+                )
+            return (
+                (response.body.to_map(), True)
+                if response.status_code == 200
+                else ({}, False)
+            )
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return {}, False
+
+    def scan_image(
+        self, oss_region_id: str, oss_bucket_name: str, oss_object_key: str, service: str = "baselineCheck"
+    ) -> Union[dict, bool]:
+        """
+        description:
+            图片内容检测（同步方式）
+        parameters:
+            oss_region_id(str): 图片OSS地域ID
+            oss_bucket_name(str): 图片OSS桶名
+            oss_object_key(str): 图片OSS对象key
+            service(str): 服务类型，可选值：enhance（增强版）, baselineCheck（基础版）
+        return:
+            result(dict): 检测结果
+            status(bool): 是否成功
+        """
+
+        try:
+            response = self.client.image_moderation_with_options(
+                ImageModerationRequest(
+                    service=service,
+                    service_parameters=json.dumps(
+                        {
+                            "ossRegionId": oss_region_id,
+                            "ossBucketName": oss_bucket_name,
+                            "ossObjectName": oss_object_key,
+                        }
+                    ),
+                ),
+                util_models.RuntimeOptions(read_timeout=10000, connect_timeout=10000),
+            )
+            return (
+                (response.body.to_map(), True)
+                if response.status_code == 200
+                else ({}, False)
+            )
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return {}, False
+
+    def scan_video(
+        self, oss_region_id: str, oss_bucket_name: str, oss_object_key: str, service: str = "videoDetection"
+    ) -> Union[dict, bool]:
+        """
+        description:
+            视频内容异步检测
+        parameters:
+            oss_region_id(str): 视频OSS地域ID
+            oss_bucket_name(str): 视频OSS桶名
+            oss_object_key(str): 视频OSS对象key
+            service(str): 服务类型，默认为"videoDetection"
+        return:
+            task_id(str): 任务ID
+            status(bool): 是否成功
+        """
+        try:
+            response = self.client.video_moderation_with_options(
+                VideoModerationRequest(
+                    service=service,
+                    service_parameters=json.dumps(
+                        {
+                            "ossRegionId": oss_region_id,
+                            "ossBucketName": oss_bucket_name,
+                            "ossObjectName": oss_object_key,
+                            "audioScenes": ["antispam"],
+                            "scenes": ["porn", "terrorism"],
+                            "bizType": "default",
+                        }
+                    ),
+                ),
+                util_models.RuntimeOptions(read_timeout=10000, connect_timeout=10000),
+            )
+            return (
+                (response.body.to_map()["Data"]["TaskId"], True)
+                if response.status_code == 200
+                else ("", False)
+            )
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return "", False
+
+    def get_video_result(
+        self, task_id: str, service: str = "videoDetection"
+    ) -> Union[dict, bool]:
+        """
+        描述:
+            获取视频内容检测结果
+        参数:
+            task_id(str): 任务ID
+            service(str): 服务类型，默认为"videoDetection"
+        返回:
+            result(dict): 检测结果
+            status(bool): 是否成功
+        """
+        try:
+            response = self.client.video_moderation_result_with_options(
+                VideoModerationResultRequest(
+                    service=service,
+                    service_parameters=json.dumps({"taskId": task_id}),
+                ),
+                util_models.RuntimeOptions(read_timeout=10000, connect_timeout=10000),
+            )
+            return (
+                (response.body.to_map(), True)
+                if response.status_code == 200
+                else ({}, False)
+            )
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return {}, False
+
+    def scan_voice(
+        self, oss_region_id: str, oss_bucket_name: str, oss_object_key: str, service: str = "audio_media_detection"
+    ) -> Union[str, bool]:
+        """
+        描述:
+            语音内容检测
+        参数:
+            oss_region_id(str): 语音OSS地域ID
+            oss_bucket_name(str): 语音OSS桶名
+            oss_object_key(str): 语音OSS对象key
+            service(str): 服务类型，默认为"audio_media_detection"
+        返回:
+            task_id(str): 任务ID
+            status(bool): 是否成功
+        """
+        try:
+            response = self.client.voice_moderation_with_options(
+                VoiceModerationRequest(
+                    service=service,
+                    service_parameters=json.dumps(
+                        {
+                            "ossRegionId": oss_region_id,
+                            "ossBucketName": oss_bucket_name,
+                            "ossObjectName": oss_object_key,
+                        }
+                    ),
+                ),
+                util_models.RuntimeOptions(read_timeout=10000, connect_timeout=10000),
+            )
+            return (
+                (response.body.to_map()["Data"]["TaskId"], True)
+                if response.status_code == 200
+                else ("", False)
+            )
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return "", False
+
+    def get_voice_result(
+        self, task_id: str, service: str = "audio_media_detection"
+    ) -> Union[dict, bool]:
+        """
+        描述:
+            获取语音内容检测结果
+        参数:
+            task_id(str): 任务ID
+            service(str): 服务类型，默认为"audio_media_detection"
+        返回:
+            result(dict): 检测结果
+            status(bool): 是否成功
+        """
+        try:
+            response = self.client.voice_moderation_result_with_options(
+                VoiceModerationResultRequest(
+                    service=service,
+                    service_parameters=json.dumps({"taskId": task_id}),
+                ),
+                util_models.RuntimeOptions(read_timeout=10000, connect_timeout=10000),
+            )
+            return (
+                (response.body.to_map(), True)
+                if response.status_code == 200
+                else ({}, False)
+            )
+        except Exception as e:
+            feishu_alert.send(traceback.format_exc())
+            return {}, False

arraylib/aliyun/domain.py

@@ -0,0 +1,434 @@
+from alibabacloud_alidns20150109.client import Client as Alidns20150109Client
+from alibabacloud_tea_openapi import models as open_api_models
+from alibabacloud_alidns20150109 import models as alidns_20150109_models
+from alibabacloud_tea_util import models as util_models
+from typing import Optional, Dict, Any
+
+
+class DomainUtils:
+    def __init__(self, access_key_id: str, access_key_secret: str, domain_name: str):
+        self.domain_name = domain_name
+        self.client = self._create_client(access_key_id, access_key_secret)
+
+    def _create_client(
+        self, access_key_id: str, access_key_secret: str
+    ) -> Alidns20150109Client:
+        config = open_api_models.Config(
+            access_key_id=access_key_id,
+            access_key_secret=access_key_secret,
+        )
+        config.endpoint = "alidns.cn-hangzhou.aliyuncs.com"
+        return Alidns20150109Client(config)
+
+    def list_domain_records(self) -> tuple[list, bool]:
+        """
+        description:
+            列出域名解析记录
+        return:
+            records: 解析记录列表
+            success: 操作是否成功
+        """
+        all_records = []
+        page_number = 1
+        page_size = 20
+        runtime = util_models.RuntimeOptions()
+        try:
+            while True:
+                describe_domain_records_request = (
+                    alidns_20150109_models.DescribeDomainRecordsRequest(
+                        domain_name=self.domain_name,
+                        page_number=page_number,
+                        page_size=page_size,
+                    )
+                )
+                response = self.client.describe_domain_records_with_options(
+                    describe_domain_records_request, runtime
+                )
+                records = response.body.domain_records.to_map()["Record"]
+                if records:
+                    all_records.extend(records)
+                total_count = getattr(response.body, "total_count", None)
+                if total_count is not None:
+                    if page_number * page_size >= total_count:
+                        break
+                else:
+                    # 如果没有total_count字段，判断本次返回数量是否小于page_size
+                    if not records or len(records) < page_size:
+                        break
+                page_number += 1
+            return all_records, True
+        except Exception as error:
+            return [], False
+
+    async def list_domain_records_async(self) -> tuple[list, bool]:
+        """
+        description:
+            异步列出域名解析记录
+        return:
+            records: 解析记录列表
+            success: 操作是否成功
+        """
+        all_records = []
+        page_number = 1
+        page_size = 20
+        runtime = util_models.RuntimeOptions()
+        try:
+            while True:
+                describe_domain_records_request = (
+                    alidns_20150109_models.DescribeDomainRecordsRequest(
+                        domain_name=self.domain_name,
+                        page_number=page_number,
+                        page_size=page_size,
+                    )
+                )
+                response = await self.client.describe_domain_records_with_options_async(
+                    describe_domain_records_request, runtime
+                )
+                # 兼容同步接口的处理方式
+                records = response.body.domain_records.to_map()["Record"]
+                if records:
+                    all_records.extend(records)
+                total_count = getattr(response.body, "total_count", None)
+                if total_count is not None:
+                    if page_number * page_size >= total_count:
+                        break
+                else:
+                    # 如果没有total_count字段，判断本次返回数量是否小于page_size
+                    if not records or len(records) < page_size:
+                        break
+                page_number += 1
+            return all_records, True
+        except Exception as error:
+            return [], False
+
+    def add_domain_record(
+        self,
+        rr: str,
+        type: str,
+        value: str,
+        ttl: int = 600,
+        line: str = "default",
+        priority: Optional[int] = None,
+    ) -> tuple[bool, str]:
+        """
+        description:
+            添加域名解析记录
+        parameters:
+            rr: 主机记录，如 www, @, *
+            type: 记录类型，如 A, CNAME, MX, TXT 等
+            value: 记录值
+            ttl: TTL值，默认600秒
+            line: 解析线路，默认default
+            priority: 优先级，仅MX记录需要
+        return:
+            success: 操作是否成功
+            record_id: 记录ID
+        """
+        runtime = util_models.RuntimeOptions()
+        try:
+            request = alidns_20150109_models.AddDomainRecordRequest(
+                domain_name=self.domain_name,
+                rr=rr,
+                type=type,
+                value=value,
+                ttl=ttl,
+                line=line,
+            )
+
+            if priority is not None:
+                request.priority = priority
+
+            response = self.client.add_domain_record_with_options(request, runtime)
+
+            if response.body.record_id:
+                return True, response.body.record_id
+            else:
+                return False, None
+
+        except Exception as error:
+            return False, None
+
+    async def add_domain_record_async(
+        self,
+        rr: str,
+        type: str,
+        value: str,
+        ttl: int = 600,
+        line: str = "default",
+        priority: Optional[int] = None,
+    ) -> tuple[bool, str]:
+        """
+        description:
+            异步添加域名解析记录
+        parameters:
+            rr: 主机记录，如 www, @, *
+            type: 记录类型，如 A, CNAME, MX, TXT 等
+            value: 记录值
+            ttl: TTL值，默认600秒
+            line: 解析线路，默认default
+            priority: 优先级，仅MX记录需要
+        return:
+            success: 操作是否成功
+            record_id: 记录ID
+        """
+        runtime = util_models.RuntimeOptions()
+        try:
+            request = alidns_20150109_models.AddDomainRecordRequest(
+                domain_name=self.domain_name,
+                rr=rr,
+                type=type,
+                value=value,
+                ttl=ttl,
+                line=line,
+            )
+
+            if priority is not None:
+                request.priority = priority
+
+            response = await self.client.add_domain_record_with_options_async(
+                request, runtime
+            )
+
+            if response.body.record_id:
+                return True, response.body.record_id
+            else:
+                return False, None
+
+        except Exception as error:
+            return False, None
+
+    def delete_domain_record(self, record_id: str) -> bool:
+        """
+        description:
+            删除域名解析记录
+        parameters:
+            record_id: 记录ID
+        return:
+            success: 操作是否成功
+        """
+        runtime = util_models.RuntimeOptions()
+        try:
+            request = alidns_20150109_models.DeleteDomainRecordRequest(
+                record_id=record_id
+            )
+
+            response = self.client.delete_domain_record_with_options(request, runtime)
+
+            if response.body.request_id:
+                return True
+            else:
+                return False
+
+        except Exception as error:
+            return False
+
+    async def delete_domain_record_async(self, record_id: str) -> bool:
+        """
+        description:
+            异步删除域名解析记录
+        parameters:
+            record_id: 记录ID
+        return:
+            success: 操作是否成功
+        """
+        runtime = util_models.RuntimeOptions()
+        try:
+            request = alidns_20150109_models.DeleteDomainRecordRequest(
+                record_id=record_id
+            )
+
+            response = await self.client.delete_domain_record_with_options_async(
+                request, runtime
+            )
+
+            if response.body.request_id:
+                return True
+            else:
+                return False
+
+        except Exception as error:
+            return False
+
+    def update_domain_record(
+        self,
+        record_id: str,
+        rr: str,
+        type: str,
+        value: str,
+        ttl: int = 600,
+        line: str = "default",
+        priority: Optional[int] = None,
+    ) -> tuple[bool, str]:
+        """
+        description:
+            更新域名解析记录
+        parameters:
+            record_id: 记录ID
+            rr: 主机记录，如 www, @, *
+            type: 记录类型，如 A, CNAME, MX, TXT 等
+            value: 记录值
+            ttl: TTL值，默认600秒
+            line: 解析线路，默认default
+            priority: 优先级，仅MX记录需要
+        return:
+            success: 操作是否成功
+            record_id: 记录ID
+        """
+        runtime = util_models.RuntimeOptions()
+        try:
+            request = alidns_20150109_models.UpdateDomainRecordRequest(
+                record_id=record_id,
+                rr=rr,
+                type=type,
+                value=value,
+                ttl=ttl,
+                line=line,
+            )
+
+            if priority is not None:
+                request.priority = priority
+
+            response = self.client.update_domain_record_with_options(request, runtime)
+
+            if response.body.record_id:
+                return True, response.body.record_id
+            else:
+                return False, None
+
+        except Exception as error:
+            return False, None
+
+    async def update_domain_record_async(
+        self,
+        record_id: str,
+        rr: str,
+        type: str,
+        value: str,
+        ttl: int = 600,
+        line: str = "default",
+        priority: Optional[int] = None,
+    ) -> tuple[bool, str]:
+        """
+        description:
+            异步更新域名解析记录
+        parameters:
+            record_id: 记录ID
+            rr: 主机记录，如 www, @, *
+            type: 记录类型，如 A, CNAME, MX, TXT 等
+            value: 记录值
+            ttl: TTL值，默认600秒
+            line: 解析线路，默认default
+            priority: 优先级，仅MX记录需要
+        return:
+            success: 操作是否成功
+            record_id: 记录ID
+        """
+        runtime = util_models.RuntimeOptions()
+        try:
+            request = alidns_20150109_models.UpdateDomainRecordRequest(
+                record_id=record_id,
+                rr=rr,
+                type=type,
+                value=value,
+                ttl=ttl,
+                line=line,
+            )
+
+            if priority is not None:
+                request.priority = priority
+
+            response = await self.client.update_domain_record_with_options_async(
+                request, runtime
+            )
+
+            if response.body.record_id:
+                return True, response.body.record_id
+            else:
+                return False, None
+
+        except Exception as error:
+            return False, None
+
+    def find_record_by_rr_and_type(
+        self, rr: str, type: str
+    ) -> Optional[Dict[str, Any]]:
+        """
+        description:
+            根据主机记录和记录类型查找记录
+        parameters:
+            rr: 主机记录
+            type: 记录类型
+        return:
+            找到的记录字典，如果没找到返回None
+        """
+        records, success = self.list_domain_records()
+        if not success:
+            return None
+
+        for record in records:
+            if record.get("RR") == rr and record.get("Type") == type:
+                return record
+        return None
+
+    async def find_record_by_rr_and_type_async(
+        self, rr: str, type: str
+    ) -> Optional[Dict[str, Any]]:
+        """
+        description:
+            异步根据主机记录和记录类型查找记录
+        parameters:
+            rr: 主机记录
+            type: 记录类型
+        return:
+            找到的记录字典，如果没找到返回None
+        """
+        records, success = await self.list_domain_records_async()
+        if not success:
+            return None
+
+        for record in records:
+            if record.get("RR") == rr and record.get("Type") == type:
+                return record
+        return None
+
+    def delete_record_by_rr_and_type(self, rr: str, type: str) -> tuple[bool, str]:
+        """
+        description:
+            根据主机记录和记录类型删除记录
+        parameters:
+            rr: 主机记录
+            type: 记录类型
+        return:
+            success: 操作是否成功
+        """
+        record = self.find_record_by_rr_and_type(rr, type)
+        if not record:
+            return False
+
+        record_id = record.get("RecordId")
+        if not record_id:
+            return False
+
+        return self.delete_domain_record(record_id)
+
+    async def delete_record_by_rr_and_type_async(
+        self, rr: str, type: str
+    ) -> tuple[bool, str]:
+        """
+        description:
+            异步根据主机记录和记录类型删除记录
+        parameters:
+            rr: 主机记录
+            type: 记录类型
+        return:
+            success: 操作是否成功
+        """
+        record = await self.find_record_by_rr_and_type_async(rr, type)
+        if not record:
+            return False
+
+        record_id = record.get("RecordId")
+        if not record_id:
+            return False
+
+        return await self.delete_domain_record_async(record_id)