jwf-common-python 1.0.0__py3-none-any.whl

jwf_common_python/translate/tencent.py

@@ -0,0 +1,194 @@
+"""腾讯云旧版 TMT 文本翻译的兼容封装。"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from jwf_common_python.translate import SentenceInfo, Translate, WordInfo
+
+SDK_REQUIREMENT = "tencentcloud-sdk-python-common>=3.0.1042,<4"
+
+
+class TencentTranslate(Translate):
+    """兼容已有 TMT 账号，SDK 在实例化时加载，请求失败直接抛出异常。
+
+    使用官方 CommonClient 调用 TextTranslate，无需安装 TMT 产品 SDK。
+    该接口已发布下线公告，状态见 README。
+    """
+
+    def __init__(
+        self,
+        secret_id: str,
+        secret_key: str,
+        *,
+        region: str = "ap-shanghai",
+        endpoint: str = "tmt.tencentcloudapi.com",
+        project_id: int = 0,
+        timeout: float = 30,
+        token: str | None = None,
+    ) -> None:
+        for name, value in (
+            ("secret_id", secret_id),
+            ("secret_key", secret_key),
+            ("region", region),
+            ("endpoint", endpoint),
+        ):
+            if not isinstance(value, str) or not value.strip():
+                raise ValueError(f"{name} 不能为空")
+        if (
+            isinstance(project_id, bool)
+            or not isinstance(project_id, int)
+            or project_id < 0
+        ):
+            raise ValueError("project_id 必须为非负整数")
+        if timeout <= 0:
+            raise ValueError("timeout 必须大于 0")
+        if token is not None and (not isinstance(token, str) or not token.strip()):
+            raise ValueError("token 必须为非空字符串或 None")
+
+        try:
+            from tencentcloud.common.common_client import CommonClient
+            from tencentcloud.common.credential import Credential
+            from tencentcloud.common.profile.client_profile import ClientProfile
+            from tencentcloud.common.profile.http_profile import HttpProfile
+        except ImportError as exc:
+            raise ImportError(f"请先安装腾讯云公共 SDK：pip install '{SDK_REQUIREMENT}'") from exc
+
+        profile = ClientProfile()
+        profile.httpProfile = HttpProfile(endpoint=endpoint, reqTimeout=timeout)
+        self.client = CommonClient(
+            "tmt",
+            "2018-03-21",
+            Credential(secret_id, secret_key, token=token),
+            region,
+            profile,
+        )
+        self.project_id = project_id
+        self._closed = False
+
+    @staticmethod
+    def _language_code(code: str) -> str:
+        if not isinstance(code, str) or not code.strip():
+            raise ValueError("语言代码不能为空")
+        return {"zh-CN": "zh"}.get(code, code)
+
+    def translate(
+        self,
+        word_or_sentence: str,
+        source_language_code: str = "en",
+        target_language_code: str = "zh",
+        *,
+        untranslated_text: str | None = None,
+    ) -> dict[str, Any]:
+        """返回完整 Response 响应体，包括 TargetText、Source、Target、RequestId。
+
+        支持源语言 auto、项目通用的 zh-CN 别名和原生语言代码。
+        每次创建独立参数字典；不打印、不写文件、不吞异常。
+        """
+        if self._closed:
+            raise RuntimeError("腾讯翻译客户端已关闭")
+        if not isinstance(word_or_sentence, str) or not word_or_sentence.strip():
+            raise ValueError("待翻译文本不能为空")
+        source = self._language_code(source_language_code)
+        target = self._language_code(target_language_code)
+        if target == "auto":
+            raise ValueError("目标语言不能为 auto")
+        if untranslated_text is not None and not isinstance(untranslated_text, str):
+            raise TypeError("untranslated_text 必须为字符串或 None")
+
+        params = {
+            "SourceText": word_or_sentence,
+            "Source": source,
+            "Target": target,
+            "ProjectId": self.project_id,
+        }
+        if untranslated_text is not None:
+            params["UntranslatedText"] = untranslated_text
+        response = self.client.call_json("TextTranslate", params)
+        result = response.get("Response") if isinstance(response, dict) else None
+        if not isinstance(result, dict) or not isinstance(
+            result.get("TargetText"), str
+        ):
+            raise ValueError("腾讯翻译响应缺少有效的 TargetText")
+        return result
+
+    def translate_word(
+        self,
+        word: str,
+        source_language_code: str = "en",
+        target_language_code: str = "zh",
+    ) -> dict[str, Any]:
+        """通过文本接口翻译单词，附带原文 word，供标准化函数使用。"""
+        return {
+            **self.translate(word, source_language_code, target_language_code),
+            "word": word,
+        }
+
+    def translate_sentence(
+        self,
+        sentence: str,
+        source_language_code: str = "en",
+        target_language_code: str = "zh",
+    ) -> dict[str, Any]:
+        """翻译句子，附带原文 sentence，供标准化函数使用。"""
+        return {
+            **self.translate(sentence, source_language_code, target_language_code),
+            "sentence": sentence,
+        }
+
+    @classmethod
+    def format_word_response(cls, response: dict) -> WordInfo:
+        """格式化 translate_word 的结果，保留原始响应于 extended_info。
+
+        TMT 不提供词典元数据：词性 Other、频率 0.0、空例句/变体/音频均为
+        标准结构占位值；normalized 字段使用原文和译文，不额外推断词形。
+        """
+        word = response["word"]
+        translation = response["TargetText"]
+        return {
+            "normalized_word": word,
+            "display_word": word,
+            "translations": [
+                {
+                    "normalized": translation,
+                    "display": translation,
+                    "pos_tag": ("Other", "其他"),
+                    "frequency": 0.0,
+                    "examples": [],
+                }
+            ],
+            "shapes": [],
+            "audio_data": b"",
+            "extended_info": dict(response),
+        }
+
+    @classmethod
+    def format_sentence_response(cls, response: dict) -> SentenceInfo:
+        """格式化 translate_sentence 的结果；文本接口不提供音频。"""
+        return {
+            "sentence": response["sentence"],
+            "translations": [response["TargetText"]],
+            "audio_data": b"",
+        }
+
+    @classmethod
+    def download_audio_file(cls, url: str) -> bytes:
+        raise NotImplementedError("TMT 文本翻译不提供音频，请使用独立的 TTS 服务")
+
+    def close(self) -> None:
+        if not self._closed:
+            try:
+                # SDK 没有公共 close 接口；新版使用 Session，旧版逐请求发送。
+                session = getattr(self.client.request.conn, "_session", None)
+                if session is not None:
+                    session.close()
+            finally:
+                self._closed = True
+
+    def __enter__(self):
+        if self._closed:
+            raise RuntimeError("腾讯翻译客户端已关闭")
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        self.close()

jwf_common_python/tts/microsoft.py

@@ -0,0 +1,87 @@
+import requests
+from typing import Literal
+
+# 定义支持的语言类型
+LanguageType = Literal["en", "zh"]
+# 定义tts语音风格配置
+AudioStyle = {
+    "en":{
+         # 输出音频风格: 当前是美国英语，Andrew Multilingual
+        "language_code": "en-US",
+        "name": "en-US-AndrewMultilingualNeural"
+    },
+    "zh":{
+        "language_code": "zh-CN",
+        # 云健
+        "name": "zh-CN-YunjianNeural"
+    }
+}
+
+class TTSMicrosoft:
+    """[参考](https://learn.microsoft.com/en-us/azure/ai-services/speech-service/index-text-to-speech)
+    [获取指定区域的语音列表,比如日本西](https://japanwest.tts.speech.microsoft.com/cognitiveservices/voices/list)
+    """
+
+    def __init__(self, key: str, location_region: str, language: LanguageType = "en") -> None:
+        # 查看自己的服务
+        self.location_region = location_region
+        self.key = key
+        self.language = language
+        # app name
+        self.user_agent = "language_backend"
+
+        # 获取token的url, 该url可能不存在
+        self.access_token_url = f"https://{self.location_region}.api.cognitive.microsoft.com/sts/v1.0/issueToken"
+        # 文本转语音的url, 该url可能不存在
+        self.txt_to_speech_url = f"https://{self.location_region}.tts.speech.microsoft.com/cognitiveservices/v1"
+
+        # 输出格式,当前是: 非流式，24赫兹
+        self.output_format = "riff-24khz-16bit-mono-pcm"
+
+        # 输出音频风格是男性
+        self.gender = "Male"
+        
+        # 音频风格
+        self.language_code = AudioStyle[self.language]["language_code"]
+        self.name = AudioStyle[self.language]["name"]
+        print(self.language_code, self.name)
+        
+
+    def fetch_access_token(self):
+        """获取转换文本时,携带的access token"""
+        request = requests.post(
+            self.access_token_url,
+            headers={
+                "Ocp-Apim-Subscription-Key": self.key,
+            },
+        )
+        return request.text
+
+    def generate_xml_data(self, text: str):
+        """将要转换的文本封装为xml格式"""
+        data = f"""
+        <speak version='1.0' xml:lang='{self.language_code}'>
+            <voice xml:lang='{self.language_code}' xml:gender='{self.gender}'
+            name='{self.name}'>
+                {text}
+            </voice>
+        </speak>
+        """
+        return data
+
+    def convert_text_to_speech(self, text: str) -> bytes:
+        """将文本转换为语音"""
+        r = requests.post(
+            self.txt_to_speech_url,
+            headers={
+                "Content-Type": "application/ssml+xml",
+                "X-Microsoft-OutputFormat": self.output_format,
+                "User-Agent": self.user_agent,
+                "Authorization": f"Bearer {self.fetch_access_token()}",
+            },
+            data=self.generate_xml_data(text),
+        )
+        print(self.generate_xml_data(text))
+        print(r.status_code, r.content)
+        
+        return r.content

jwf_common_python/utils/image_utils.py

@@ -0,0 +1,18 @@
+import io
+
+try:
+    from PIL import Image, ImageDraw
+except ImportError as exc:
+    raise ImportError(
+        "Couldn't import pil. pip install --upgrade tencentcloud"
+    ) from exc
+
+
+def create_image(width: int, height: int, color: tuple[int, int, int]) -> bytes:
+    # TODO 导入检测
+    image = Image.new("RGB", (width, height), color)
+    # create a memory buffer to store image
+    buffer = io.BytesIO()
+    image.save(buffer, format="PNG")
+    image_data = buffer.getvalue()
+    return image_data

jwf_common_python/utils/tencent_utils.py

@@ -0,0 +1,51 @@
+import datetime
+import hashlib
+import hmac
+from datetime import timedelta
+
+
+# 参考签名工具
+def generate_tencent_key(secret_key,key,secret_id,method="get",**kwargs) -> str:
+    # 1. KeyTime
+    current_time = datetime.datetime.now()
+    future_time = current_time + timedelta(minutes=30)
+
+    start = current_time.timestamp()
+    end = future_time.timestamp()
+
+    key_time = f"{int(start)};{int(end)}"
+    print(f"步骤一: key_time: {key_time}\n")
+
+
+    # 2. SignKey
+    sign_key = hmac.new(
+        secret_key.encode("utf-8"), key_time.encode("utf-8"), hashlib.sha1
+    ).hexdigest()
+    print(f"步骤二: sign_key: {sign_key}\n")
+
+
+    # 5. http_string
+    http_string = f"{method}\n/{key}\n\n\n"
+
+    # http_string = f"put\n/{key}\n\n\n"
+    print(f"步骤五： http_string: {repr(http_string)}\n")  # get\n/picture.jpg\n\n\n
+
+    # 6. StringToSign
+    sha1 = hashlib.sha1()
+    sha1.update(http_string.encode("utf-8"))
+    http_string_sha1 = sha1.hexdigest()
+    string_to_sign = f"sha1\n{key_time}\n{http_string_sha1}\n"
+    print(f"步骤六: string_to_sign: {repr(string_to_sign)}\n")
+
+
+    # 7. Signature
+    signature = hmac.new(
+        sign_key.encode("utf-8"), string_to_sign.encode("utf-8"), hashlib.sha1
+    ).hexdigest()
+    print(f"步骤七: signature: {signature}")
+
+
+    # 8. authorization
+    authorization = f"q-sign-algorithm=sha1&q-ak={secret_id}&q-sign-time={key_time}&q-key-time={key_time}&q-header-list=&q-url-param-list=&q-signature={signature}"
+    print(f"authorizaton: {authorization}\n")
+    return authorization

jwf_common_python/utils/utils.py

@@ -0,0 +1,46 @@
+import logging
+import smtplib
+from email.mime.text import MIMEText
+
+
+def calculate_relative_value(input_data: list, db_data: list) -> float:
+    """计算input_data中db_data所占的比例"""
+    # 去重
+    input_data_unique: set = set(input_data)
+    db_data_unique: set = set(db_data)
+    # 获取交集.
+    # 获取input_data中db_data的数据
+    intersection: set = input_data_unique.intersection(db_data_unique)
+
+    # 获取input_data中db_data所占的比例
+    result: float = len(intersection) / len(input_data_unique)
+    return result
+
+
+class SendEmail:
+    def __init__(self, config: dict) -> None:
+        if not set(config).issubset({"host", "port", "user", "passwd"}):
+            raise ValueError("config must contain host, user, pass, sender")
+        self.host = config["host"]
+        self.user = config["user"]
+        self.port = config["port"]
+        self.passwd = config["passwd"]
+
+    def send_txt_message(
+        self, receivers: list, subject: str, content: str
+    ) -> tuple[bool, str]:
+        """发送文本邮件, 返回发送状态和错误信息"""
+        message = MIMEText(content, "plain", "utf-8")
+        message["From"] = f"{self.user}"
+        message["To"] = ",".join(receivers)
+        message["Subject"] = subject
+
+        try:
+            smtpObj = smtplib.SMTP_SSL(self.host, self.port)
+            smtpObj.login(self.user, self.passwd)
+            smtpObj.sendmail(self.user, receivers, message.as_string())
+            logging.info(f"mail has been send successfully. {receivers}")
+            return True, "success"
+        except smtplib.SMTPException as e:
+            logging.error(e)
+            return False, str(e)

jwf_common_python/video/__init__.py

@@ -0,0 +1,5 @@
+"""基于本机 FFmpeg 的视频探测和无重编码合并工具。"""
+
+from .merge import merge_directory, merge_videos, probe_video
+
+__all__ = ["probe_video", "merge_videos", "merge_directory"]

jwf_common_python/video/merge.py

@@ -0,0 +1,276 @@
+"""合并本地视频，不拼接 Shell 命令、不修改源文件或全局日志。"""
+
+from __future__ import annotations
+
+import errno
+import json
+import math
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+
+def _timeout(value: float | None) -> None:
+    if value is not None and (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(value)
+        or value <= 0
+    ):
+        raise ValueError("timeout 必须为有限的正数或 None")
+
+
+def _binary(name: str | Path) -> str:
+    executable = shutil.which(os.fspath(name))
+    if executable is None:
+        raise FileNotFoundError(f"未找到可执行文件 {name}，请安装 FFmpeg 或传入完整路径")
+    return executable
+
+
+def _input_file(path: str | Path) -> Path:
+    source = Path(path).expanduser().resolve(strict=True)
+    if not source.is_file():
+        raise ValueError(f"输入不是普通文件：{source}")
+    return source
+
+
+def _run(command: list[str], timeout: float | None):
+    result = subprocess.run(
+        command,
+        stdin=subprocess.DEVNULL,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=True,
+        timeout=timeout,
+    )
+    # 命令均使用 error 日志级别；有些读取错误会记录日志但仍返回 0。
+    if result.stderr.strip():
+        raise RuntimeError(f"FFmpeg 工具报告错误：{result.stderr.strip()}")
+    return result
+
+
+def _probe(path: Path, binary: str, timeout: float | None) -> dict[str, Any]:
+    result = _run(
+        [
+            binary,
+            "-v",
+            "error",
+            "-show_streams",
+            "-show_format",
+            "-of",
+            "json",
+            str(path),
+        ],
+        timeout,
+    )
+    metadata = json.loads(result.stdout)
+    streams = metadata.get("streams") if isinstance(metadata, dict) else None
+    if not isinstance(streams, list) or not all(
+        isinstance(stream, dict) for stream in streams
+    ):
+        raise ValueError(f"ffprobe 响应缺少有效 streams：{path}")
+    if not any(stream.get("codec_type") == "video" for stream in streams):
+        raise ValueError(f"文件不包含视频流：{path}")
+    return metadata
+
+
+def probe_video(
+    path: str | Path,
+    *,
+    ffprobe: str | Path = "ffprobe",
+    timeout: float | None = 30,
+) -> dict[str, Any]:
+    """返回 ffprobe 完整 JSON；缺少工具、无视频流及执行失败均抛出异常。"""
+    _timeout(timeout)
+    return _probe(_input_file(path), _binary(ffprobe), timeout)
+
+
+def _stream_signature(stream: dict[str, Any]) -> tuple:
+    fields = ["codec_type", "codec_name", "time_base"]
+    if stream.get("codec_type") == "video":
+        fields += [
+            "profile",
+            "width",
+            "height",
+            "pix_fmt",
+            "r_frame_rate",
+            "sample_aspect_ratio",
+            "field_order",
+        ]
+    elif stream.get("codec_type") == "audio":
+        fields += ["sample_fmt", "sample_rate", "channels", "channel_layout"]
+    return tuple(stream.get(field) for field in fields)
+
+
+def _publish(staged: Path, output: Path, overwrite: bool) -> None:
+    if overwrite:
+        staged.replace(output)
+        return
+    try:
+        # 同一文件系统上独占创建最终路径，避免覆盖并发产生的文件。
+        os.link(staged, output)
+        return
+    except OSError as exc:
+        if exc.errno not in {errno.EPERM, errno.ENOTSUP, errno.EXDEV}:
+            raise
+    # 不支持硬链接的文件系统使用独占复制，失败时清理本次新建的输出。
+    created = False
+    try:
+        with output.open("xb") as destination:
+            created = True
+            with staged.open("rb") as source:
+                shutil.copyfileobj(source, destination)
+    except BaseException:
+        if created:
+            output.unlink(missing_ok=True)
+        raise
+
+
+def merge_videos(
+    inputs: Iterable[str | Path],
+    output_path: str | Path,
+    *,
+    overwrite: bool = False,
+    ffmpeg: str | Path = "ffmpeg",
+    ffprobe: str | Path = "ffprobe",
+    timeout: float | None = None,
+) -> Path:
+    """按输入顺序无重编码合并，返回最终输出的绝对路径。
+
+    检查流数量/顺序、编码、时间基、分辨率、帧率及音频参数，不自动转码。
+    输出父目录必须已存在；默认不覆盖，输出不能是任何输入的别名。
+    先在输出父目录的独立临时目录中生成并探测结果，再提交到目标路径。
+    timeout 对每个子进程分别生效。CalledProcessError.stderr 保留 FFmpeg 错误。
+    """
+    _timeout(timeout)
+    if not isinstance(overwrite, bool):
+        raise TypeError("overwrite 必须为布尔值")
+    if isinstance(inputs, (str, Path)):
+        raise TypeError("inputs 必须为路径的可迭代对象，例如 [first, second]")
+    sources = [_input_file(path) for path in inputs]
+    if not sources:
+        raise ValueError("至少需要一个输入视频")
+    for source in sources:
+        if "\n" in str(source) or "\r" in str(source):
+            raise ValueError("视频路径不能包含换行符")
+    output = Path(output_path).expanduser().resolve()
+    if not output.suffix:
+        raise ValueError("输出路径需要扩展名，以指定封装格式")
+    if not output.parent.is_dir():
+        raise FileNotFoundError(f"输出父目录不存在：{output.parent}")
+    if any(
+        source == output or (output.exists() and source.samefile(output))
+        for source in sources
+    ):
+        raise ValueError("输出路径不能是输入文件或其别名")
+    if output.exists():
+        if not output.is_file():
+            raise ValueError("输出路径不是普通文件")
+        if not overwrite:
+            raise FileExistsError(output)
+    ffmpeg_binary = _binary(ffmpeg)
+    ffprobe_binary = _binary(ffprobe)
+    first_info = _probe(sources[0], ffprobe_binary, timeout)
+    signature = [_stream_signature(stream) for stream in first_info["streams"]]
+    for source in sources[1:]:
+        info = _probe(source, ffprobe_binary, timeout)
+        if [_stream_signature(stream) for stream in info["streams"]] != signature:
+            raise ValueError(f"音视频流参数不一致，不能直接合并：{source}")
+
+    with tempfile.TemporaryDirectory(
+        prefix=".video-merge-", dir=output.parent
+    ) as folder:
+        workspace = Path(folder)
+        manifest = workspace / "inputs.ffconcat"
+        lines = ["ffconcat version 1.0"]
+        for source in sources:
+            escaped = source.as_posix().replace("'", "'\\''")
+            lines.append(f"file '{escaped}'")
+        manifest.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        staged = workspace / ("merged" + output.suffix)
+        _run(
+            [
+                ffmpeg_binary,
+                "-nostdin",
+                "-hide_banner",
+                "-loglevel",
+                "error",
+                "-n",
+                "-f",
+                "concat",
+                "-safe",
+                "0",
+                "-i",
+                str(manifest),
+                "-map",
+                "0",
+                "-c",
+                "copy",
+                str(staged),
+            ],
+            timeout,
+        )
+        if not staged.is_file() or not staged.stat().st_size:
+            raise RuntimeError("FFmpeg 未生成有效输出文件")
+        merged = _probe(staged, ffprobe_binary, timeout)
+
+        def codecs(info):
+            return [
+                (stream.get("codec_type"), stream.get("codec_name"))
+                for stream in info["streams"]
+            ]
+
+        if codecs(merged) != codecs(first_info):
+            raise RuntimeError("合并输出的音视频流与输入不一致")
+        _publish(staged, output, overwrite)
+    return output
+
+
+def merge_directory(
+    input_directory: str | Path,
+    output_path: str | Path,
+    *,
+    extensions: Iterable[str] = (".mp4",),
+    **options,
+) -> Path:
+    """合并目录首层的视频，按自然文件名排序，排除已有目标文件。
+
+    默认选择 .mp4（不区分扩展名大小写）；例如 clip2.mp4 排在 clip10.mp4 前。
+    可用 extensions 选择其他封装格式，options 同 merge_videos。
+    """
+    directory = Path(input_directory).expanduser().resolve(strict=True)
+    if not directory.is_dir():
+        raise NotADirectoryError(directory)
+    if isinstance(extensions, str):
+        raise TypeError("extensions 必须为扩展名的可迭代对象")
+    suffixes = set()
+    for suffix in extensions:
+        if not isinstance(suffix, str) or not suffix.lstrip("."):
+            raise ValueError("扩展名不能为空")
+        suffixes.add("." + suffix.lstrip(".").lower())
+    if not suffixes:
+        raise ValueError("extensions 不能为空")
+    output = Path(output_path).expanduser().resolve()
+    sources = [
+        path
+        for path in directory.iterdir()
+        if path.is_file()
+        and path.suffix.lower() in suffixes
+        and path.resolve() != output
+    ]
+
+    def natural_key(path):
+        parts = tuple(
+            int(part) if part.isdigit() else part
+            for part in re.split(r"(\d+)", path.name.casefold())
+        )
+        return parts, path.name.casefold(), path.name
+
+    return merge_videos(sorted(sources, key=natural_key), output, **options)