pipesay 0.0.1__tar.gz

pipesay-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,70 @@
+# This workflow will upload a Python Package to PyPI when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Build release distributions
+        run: |
+          # NOTE: put your own distribution build steps here.
+          python -m pip install build
+          python -m build
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+    # Dedicated environments with protections for publishing are strongly recommended.
+    # For more information, see: https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#deployment-protection-rules
+    environment:
+      name: pypi
+      # OPTIONAL: uncomment and update to include your PyPI project URL in the deployment status:
+      # url: https://pypi.org/p/YOURPROJECT
+      #
+      # ALTERNATIVE: if your GitHub Release name is the PyPI project version string
+      # ALTERNATIVE: exactly, uncomment the following line instead:
+      # url: https://pypi.org/project/YOURPROJECT/${{ github.event.release.name }}
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Publish release distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

pipesay-0.0.1/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+*$py.class
+
+.ruff_cache/
+.pytest_cache/
+.mypy_cache/
+
+.venv/
+venv/
+env/
+
+.vscode/
+.idea/
+
+.test/

pipesay-0.0.1/LICENSE

@@ -0,0 +1,7 @@
+Copyright © 2026 OrO-c
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pipesay-0.0.1/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.5
+Name: pipesay
+Version: 0.0.1
+Summary: 一个用管道处理句子的趣味输出工具
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: desktop-notifier
+Requires-Dist: jieba
+Requires-Dist: openai
+Requires-Dist: pyaml
+Requires-Dist: python-cowsay
+Requires-Dist: requests
+Requires-Dist: translators
+Requires-Dist: urllib3
+Description-Content-Type: text/markdown
+
+# PipeSay
+
+> 一个可插拔的「句子流水线」框架：抓取 → 加工 → 输出。
+
+PipeSay 将句子处理抽象为一条可配置的流水线。每个环节都通过装饰器注册、通过 YAML 组合，你无需改动核心代码，就能拼装出自己的玩法。
+
+## 设计理念
+
+- **三段式流水线**：`Fetcher` → `Processor` → `Outputer`，职责清晰，互不耦合。
+- **注册式插件系统**：`@processor('name')` / `@outputer('name')` 一键注册，签名自动反射为可配置参数。
+- **YAML 驱动**：处理器与输出器均以声明式配置组合，支持全局参数与步骤级参数合并。
+- **面向扩展**：核心只提供约定与调度，具体能力全部来自插件。
+
+## 安装
+```bash
+    pip install -r requirements.txt
+```
+
+## 快速开始
+
+从网络获取一言并输出到终端：
+```bash
+    python -m src.pipesay.main hitokoto -o test2.yaml
+```
+
+从本地文件读取、加工后输出：
+```bash
+    python -m src.pipesay.main local -f ./cowsay.txt -s test.yaml -o test2.yaml
+```
+## 命令行
+```text
+    usage: main.py [-h] [-g GENERATIONS] [-s PROCESSER_CONFIG] [-o OUTPUTCONFIG] {local,hitokoto} ...
+```
+| 参数 | 说明 | 默认值 |
+| --- | --- | --- |
+| `-g, --generations` | 生成次数 | `1` |
+| `-s, --processor-config` | 处理器流水线配置 | `None` |
+| `-o, --outputer-config` | 输出器流水线配置 | `None` |
+
+子命令：
+
+- `local`：`-f/--file` 指定本地文件（默认 `./cowsay.txt`）。
+- `hitokoto`：`-c/--category` 指定分类（可多选，默认全部）。
+
+## 配置
+
+处理器配置：
+```yaml
+    pipeline:
+      - processor: to_weak
+      - processor: i18n
+        params:
+          lan: [en, ja]
+
+    global: {}
+```
+输出器配置：
+```yaml
+    outputs:
+      - outputer: term
+        params:
+          auto_clear: True
+
+    global: {}
+```
+`params` 会与 `global` 中同名步骤的配置合并，步骤级优先。
+
+## 扩展
+
+新增处理器：
+```python
+    from src.pipesay.processor.base import processor
+
+    @processor('shout')
+    def shout(sentences: list, mark: str = '!', log=None):
+        """给每句话加上强调符号"""
+        return [s + mark for s in sentences]
+```
+新增输出器：
+```python
+    from src.pipesay.outputers.base import outputer
+
+    @outputer('count')
+    def count(sentences: list, log=None):
+        """只统计句子数量"""
+        log(f"共 {len(sentences)} 句")
+```
+注册后即可在 YAML 中直接引用。函数签名中的 `sentences` 与 `log` 会被自动跳过，其余参数反射为可配置项。
+
+查看已注册的步骤：
+```python
+    from src.pipesay.processor.base import Processor
+    from src.pipesay.outputers.base import Outputer
+
+    Processor.list_all()
+    Outputer.list_all()
+```
+## 项目结构
+```text
+    src/pipesay/
+    ├── main.py                # 入口
+    ├── constants/             # 常量
+    ├── fetcher/               # 获取器
+    ├── processor/             # 处理器与注册表
+    ├── outputers/             # 输出器与注册表
+    ├── core/                  # 流水线执行器与注册装饰器
+    ├── parser/                # 命令行解析
+    └── utils/                 # 通用工具
+```
+## 工作原理
+```text
+    Fetcher ──▶ Processor ──▶ Outputer
+                  ▲               ▲
+             pipeline.yaml   outputs.yaml
+```
+1. `Fetcher` 按模式返回 `list[str]`。
+2. `Processor` 读取 `pipeline` 段，按序加工并逐级传递。
+3. `Outputer` 读取 `outputs` 段，将结果交给输出器展示。
+
+## License
+
+MIT

pipesay-0.0.1/README.md

@@ -0,0 +1,122 @@
+# PipeSay
+
+> 一个可插拔的「句子流水线」框架：抓取 → 加工 → 输出。
+
+PipeSay 将句子处理抽象为一条可配置的流水线。每个环节都通过装饰器注册、通过 YAML 组合，你无需改动核心代码，就能拼装出自己的玩法。
+
+## 设计理念
+
+- **三段式流水线**：`Fetcher` → `Processor` → `Outputer`，职责清晰，互不耦合。
+- **注册式插件系统**：`@processor('name')` / `@outputer('name')` 一键注册，签名自动反射为可配置参数。
+- **YAML 驱动**：处理器与输出器均以声明式配置组合，支持全局参数与步骤级参数合并。
+- **面向扩展**：核心只提供约定与调度，具体能力全部来自插件。
+
+## 安装
+```bash
+    pip install -r requirements.txt
+```
+
+## 快速开始
+
+从网络获取一言并输出到终端：
+```bash
+    python -m src.pipesay.main hitokoto -o test2.yaml
+```
+
+从本地文件读取、加工后输出：
+```bash
+    python -m src.pipesay.main local -f ./cowsay.txt -s test.yaml -o test2.yaml
+```
+## 命令行
+```text
+    usage: main.py [-h] [-g GENERATIONS] [-s PROCESSER_CONFIG] [-o OUTPUTCONFIG] {local,hitokoto} ...
+```
+| 参数 | 说明 | 默认值 |
+| --- | --- | --- |
+| `-g, --generations` | 生成次数 | `1` |
+| `-s, --processor-config` | 处理器流水线配置 | `None` |
+| `-o, --outputer-config` | 输出器流水线配置 | `None` |
+
+子命令：
+
+- `local`：`-f/--file` 指定本地文件（默认 `./cowsay.txt`）。
+- `hitokoto`：`-c/--category` 指定分类（可多选，默认全部）。
+
+## 配置
+
+处理器配置：
+```yaml
+    pipeline:
+      - processor: to_weak
+      - processor: i18n
+        params:
+          lan: [en, ja]
+
+    global: {}
+```
+输出器配置：
+```yaml
+    outputs:
+      - outputer: term
+        params:
+          auto_clear: True
+
+    global: {}
+```
+`params` 会与 `global` 中同名步骤的配置合并，步骤级优先。
+
+## 扩展
+
+新增处理器：
+```python
+    from src.pipesay.processor.base import processor
+
+    @processor('shout')
+    def shout(sentences: list, mark: str = '!', log=None):
+        """给每句话加上强调符号"""
+        return [s + mark for s in sentences]
+```
+新增输出器：
+```python
+    from src.pipesay.outputers.base import outputer
+
+    @outputer('count')
+    def count(sentences: list, log=None):
+        """只统计句子数量"""
+        log(f"共 {len(sentences)} 句")
+```
+注册后即可在 YAML 中直接引用。函数签名中的 `sentences` 与 `log` 会被自动跳过，其余参数反射为可配置项。
+
+查看已注册的步骤：
+```python
+    from src.pipesay.processor.base import Processor
+    from src.pipesay.outputers.base import Outputer
+
+    Processor.list_all()
+    Outputer.list_all()
+```
+## 项目结构
+```text
+    src/pipesay/
+    ├── main.py                # 入口
+    ├── constants/             # 常量
+    ├── fetcher/               # 获取器
+    ├── processor/             # 处理器与注册表
+    ├── outputers/             # 输出器与注册表
+    ├── core/                  # 流水线执行器与注册装饰器
+    ├── parser/                # 命令行解析
+    └── utils/                 # 通用工具
+```
+## 工作原理
+```text
+    Fetcher ──▶ Processor ──▶ Outputer
+                  ▲               ▲
+             pipeline.yaml   outputs.yaml
+```
+1. `Fetcher` 按模式返回 `list[str]`。
+2. `Processor` 读取 `pipeline` 段，按序加工并逐级传递。
+3. `Outputer` 读取 `outputs` 段，将结果交给输出器展示。
+
+## License
+
+MIT

pipesay-0.0.1/main.py

@@ -0,0 +1,22 @@
+from src.pipesay.fetcher.fetcher import Fetcher
+from src.pipesay.outputers import outputer_utils  # noqa: F401
+from src.pipesay.outputers.base import Outputer
+from src.pipesay.parser.parser import arg_process
+from src.pipesay.processor import processer_utils  # noqa: F401
+from src.pipesay.processor.base import Processor
+from src.pipesay.utils.utils import clear_screen, enter_to_next
+
+
+def main():
+    args = arg_process()
+    fetcher = Fetcher(args.get('fetcher_mode'), args.get('generations'), args.get('category'), args.get('file_path'),).new_fetcher()
+    fetch_sentences = fetcher()
+    processor = Processor(config_path=args.get('processer_config'))
+    speak_sentences = processor.process(fetch_sentences)
+    enter_to_next("已经处理完成，按回车开始输出")
+    clear_screen()
+    outputer = Outputer(config_path=args.get('outputer_config'))
+    outputer.fire(speak_sentences)
+
+if __name__ == "__main__":
+    main()

pipesay-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pipesay"
+version = "0.0.1"
+description = "一个用管道处理句子的趣味输出工具"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "python-cowsay",
+    "desktop_notifier",
+    "jieba",
+    "openai",
+    "pyaml",
+    "requests",
+    "translators",
+    "urllib3"
+]
+
+[project.scripts]
+pipesay = "pipesay.main:main"

pipesay-0.0.1/requirements.txt

@@ -0,0 +1,8 @@
+python-cowsay==6.1
+desktop_notifier==6.2.0
+jieba==0.42.1
+openai==3.13.0
+PyYAML==6.0.3
+Requests==2.34.2
+translators==6.0.4
+urllib3==2.7.0

pipesay-0.0.1/src/pipesay/__init__.py

@@ -0,0 +1,9 @@
+# src/pipesay/__init__.py
+from pipesay.core.pipeline import Pipeline
+from pipesay.core.registry import register
+from pipesay.fetcher.fetcher import Fetcher
+from pipesay.outputers.base import Outputer
+from pipesay.processor.base import Processor
+
+__version__ = "0.0.1"
+__all__ = ["Fetcher", "Outputer", "Pipeline", "Processor", "register"]

pipesay-0.0.1/src/pipesay/constants/constants.py

@@ -0,0 +1,3 @@
+DEFAULT_FILE = "./cowsay.txt"
+DEFAULT_LINES = ['我正在说一句废话\n', '你说得对\n', '敏捷的那啥越过啥玩意我忘了\n']
+YIYAN_CATEGORY = {"a": "动画", "b": "漫画", "c": "游戏", "d": "文学", "e": "原创", "f": "来自网络", "g": "其他", "h": "影视", "i": "诗词", "j": "网易云", "k": "哲学", "l": "抖机灵"}

pipesay-0.0.1/src/pipesay/core/pipeline.py

@@ -0,0 +1,89 @@
+import asyncio
+import inspect
+
+import yaml
+
+
+class Pipeline:
+    """
+    通用管道执行器。
+    子类只需要提供：
+        - registry：注册表字典
+        - section：配置里的键名（'pipeline' / 'outputs'）
+        - label：日志里显示的名字（'Processor' / 'Outputer'）
+    """
+    registry: dict = {}
+    section: str = ''
+    label: str = 'Pipeline'
+
+    def __init__(self, config_path=None, config_dict=None):
+        if config_dict:
+            self.config = config_dict
+        elif config_path:
+            with open(config_path, 'r', encoding='utf-8') as f:
+                self.config = yaml.safe_load(f)
+        else:
+            raise ValueError("必须提供 config_path 或 config_dict")
+
+        self.steps = self.config.get(self.section, [])
+        self.global_config = self.config.get('global', {})
+
+    def run(self, items: list) -> list:
+        current = items
+        total = len(self.steps)
+        for idx, step in enumerate(self.steps, 1):
+            name = step.get('name') or step.get('processor') or step.get('outputer')
+            params = step.get('params', {})
+
+            if name not in self.registry:
+                raise ValueError(
+                    f"未知步骤: {name}，已注册: {list(self.registry.keys())}"
+                )
+
+            self.log(f'⏳ [{idx}/{total}] 执行 {name}')
+            func = self.registry[name]['func']
+            final_params = {**self.global_config.get(name, {}), **params}
+
+            try:
+                result = self._call(func, current, final_params)
+                current = result
+                self.log(f'✅ {name} 完成')
+            except Exception as e:
+                self.log(f'❌ {name} 失败: {e}')
+                raise
+
+        self.log(f'{self.label} 全部处理完成！')
+        return current
+
+    def _call(self, func, items, params):
+        """统一注入 log，统一处理 async"""
+        params = {**params, 'log': self.log}
+        result = func(items, **params)
+        if inspect.iscoroutine(result):
+            result = asyncio.run(result)
+        return result
+
+    def log(self, message: str):
+        print(message)
+
+    @classmethod
+    def list_all(cls):
+        print("\n" + "=" * 60)
+        print(f"已注册的 {cls.label}:")
+        print("=" * 60)
+        for name, info in cls.registry.items():
+            print(f"\n【{name}】")
+            if info['doc']:
+                print(f"  说明: {info['doc']}")
+            if info['params']:
+                print("  参数:")
+                for pname, pinfo in info['params'].items():
+                    required = "必填" if pinfo['required'] else "可选"
+                    default = (
+                        f"，默认: {pinfo['default']}"
+                        if pinfo['default'] is not None else ""
+                    )
+                    print(f"    - {pname}: {pinfo['type']} ({required}{default})")
+            else:
+                print("  无参数")
+        print("=" * 60)

pipesay-0.0.1/src/pipesay/core/registry.py

@@ -0,0 +1,38 @@
+import inspect
+from collections.abc import Callable
+
+
+def register(registry: dict, name: str | None = None):
+    """
+    通用注册装饰器。
+    用法：
+        @register(PROCESSOR_REGISTRY, 'reverse')
+        def reverse(sentences, log=None): ...
+    """
+    def decorator(func: Callable):
+        key = name or func.__name__
+        registry[key] = {
+            'func': func,
+            'params': extract_params(func),
+            'doc': func.__doc__ or '',
+        }
+        return func          # 不套 wrapper，注册就是注册
+    return decorator
+
+
+def extract_params(func: Callable) -> dict:
+    """从函数签名反射出可配置参数，跳过 self / sentences / log"""
+    sig = inspect.signature(func)
+    params = {}
+    for pname, param in sig.parameters.items():
+        if pname in ('self', 'sentences', 'log'):
+            continue
+        if param.default is inspect.Parameter.empty:
+            params[pname] = {'type': 'any', 'default': None, 'required': True}
+        else:
+            params[pname] = {
+                'type': type(param.default).__name__,
+                'default': param.default,
+                'required': False,
+            }
+    return params

pipesay-0.0.1/src/pipesay/fetcher/fetcher.py

@@ -0,0 +1,142 @@
+import random
+import time
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3 import Retry
+
+from src.pipesay.constants.constants import YIYAN_CATEGORY
+
+
+class Fetcher:
+    def __init__(self, fetch_mode: str, generations: int, category: list, file_path: str):
+        self.mode = fetch_mode
+        self.generations = generations
+        self.category = category
+        self.file_path = file_path
+    
+    def new_fetcher(self):
+        fdict = {
+            "hitokoto": self.hitokoto,
+            "local": self.local
+        }
+        func = fdict.get(self.mode)
+        if func is None:
+            raise ValueError(f"{self.mode}不是一个有效的模式")
+        return func
+    
+    
+    def hitokoto(self):
+        """
+        控制对Hitokoto服务的请求及对其结果的格式化
+        
+        Args:
+            generations(int): 需要的句子数量
+            category(str): 需要的分类
+        
+        
+        Returns:
+            list: 一个包含字符串的列表，每个字符串是一个完整的句子。
+                句子格式为："“句子内容”\n   ————出处"
+                例如: [
+                    "“你不努力，你得到的一切一定会被夺走！”\n   ————Posherlunch"
+                    "“生命璀璨美丽，却成为众人的囚笼。”\n   ————黑暗之魂2"
+                ]
+        """
+        
+        sentences = []
+        last_sentence = ""
+        retry_word = ""
+        
+        while len(sentences) < self.generations:
+            print(f"{retry_word}正在向Hitokoto一言获取{len(sentences) + 1}/{self.generations}个句子...", end=" ")
+            fetch_sentence, author, from_work = self._fetch_hitokoto()
+            print(" ✅")
+        
+            if len(sentences) == 0 or fetch_sentence != last_sentence:
+                if author is not None:
+                    sen_from = f"————{author}  《{from_work}》"
+                else:
+                    sen_from = f"————《{from_work}》"
+                width = len(fetch_sentence) + 4
+                sentences.append(f"“{fetch_sentence}”\n{sen_from:>{width}}")
+                last_sentence = fetch_sentence
+                retry_word = ""
+            elif last_sentence == fetch_sentence:
+                print("由于api方缓存问题，此句和上句重复，本程序将睡2秒再重新获取😋")
+                retry_word = "🔄 重试："
+                time.sleep(2)
+            
+        return sentences
+
+
+    def _category_to_dict(self):
+        """将分类名称列表转换为 Hitokoto API 的分类代码。
+    
+            
+        Returns:
+            dict: API 参数字典，格式为 {'c': ['a', 'k']}
+                如果 categories 为空，返回空字典 {}
+        """
+        
+        choose = []
+        for c in self.category:
+            for category, name in YIYAN_CATEGORY.items():
+                if c == name:
+                    choose.append(category)
+                    break
+        return {"c": choose} if choose else {}
+    
+    
+    def _fetch_hitokoto(self):
+        """
+        向Hitokoto服务请求并获得句子信息
+        
+        Args:
+            params(dict): 需要在请求后附加的url参数，以此控制筛选分类 
+        Returns:
+            str: 句子本身
+            str: 句子的言者/作者
+            str: 出处
+        
+        
+        Raises:
+            requests.exceptions.Timeout: 请求超时被抛出
+        """
+        
+        retry_strategy = Retry(
+        total=3,                     # 最多重试 3 次（不算第一次请求）
+        backoff_factor=1,            # 重试间隔：1s, 2s, 4s（指数退避）
+        status_forcelist=[500, 502, 503, 504],  # 碰到这些 HTTP 状态码就重试
+        allowed_methods=["GET", "POST"]          # 允许重试的方法（默认只有 GET）
+    )
+        
+        session = requests.Session()
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        session.mount('http://', adapter)
+        session.mount('https://', adapter)
+        
+        try:
+            r = session.get('https://v1.hitokoto.cn', timeout=(3.5, 6.5), params=self._category_to_dict())
+        except requests.exceptions.Timeout:
+            print("请求超时，请您检查网络和Hitokoto服务状态，并稍后再试")
+            raise
+        
+        return r.json()["hitokoto"], r.json()["from_who"], r.json()["from"]
+
+
+
+
+    def local(self):
+        """
+        从本地文件中挑选句子
+        
+        Returns:
+            list: 句子列表
+        """
+        sentences = []
+        with open(file=self.file_path, mode="r") as f:
+            local_sentence = f.readlines()
+            for i in range(self.generations):
+                sentences.append(random.choice(local_sentence))
+        return sentences

pipesay-0.0.1/src/pipesay/outputers/base.py

@@ -0,0 +1,21 @@
+from src.pipesay.core.pipeline import Pipeline
+from src.pipesay.core.registry import register
+
+OUTPUTER_REGISTRY: dict = {}
+
+
+def outputer(name: str | None = None):
+    return register(OUTPUTER_REGISTRY, name)
+
+
+class Outputer(Pipeline):
+    registry = OUTPUTER_REGISTRY
+    section = 'outputs'
+    label = 'Outputer'
+
+    def fire(self, sentences: list) -> None:
+        self.run(sentences)
+
+    @staticmethod
+    def list_outputers():
+        Outputer.list_all()

pipesay-0.0.1/src/pipesay/outputers/outputer_utils.py

@@ -0,0 +1,49 @@
+import asyncio
+
+from desktop_notifier import DesktopNotifier, Urgency
+
+from src.pipesay.outputers.base import outputer
+from src.pipesay.utils.utils import clear_screen, enter_to_next
+
+
+@outputer('term')
+def normal_terminal(sentences: list, auto_clear: bool=True, log=None):
+    for index, text in enumerate(sentences):
+        print(text)
+        if index + 1 != len(sentences):
+            print("=" * 30)
+            enter_to_next("按回车来看下一句吧！")
+            print("\n\n")
+            if auto_clear:
+                clear_screen()
+
+
+@outputer('file')
+def to_file(sentences: list, file_path: str, log=None):
+    lines = [item + '\n\n' for item in sentences]
+    with open(file=file_path, mode='a', encoding='utf-8') as f:
+        f.writelines(lines)
+
+@outputer('notify')
+async def notify(sentences: list, level: str='normal', log=None):
+    URGENCY_MAP = {
+        "low": Urgency.Low,
+        "normal": Urgency.Normal,
+        "critical": Urgency.Critical,
+    }
+
+    urgency = URGENCY_MAP[level]
+
+    notifier = DesktopNotifier(app_name="批量通知演示")
+
+    for message in sentences:
+        await notifier.send(
+            title="PipeSay",
+            message=message,
+            urgency=urgency,
+            sound=True,
+        )
+
+    await asyncio.sleep(3)
+
+    log(f"已发送 {len(sentences)} 条通知，类型：{level}")

pipesay-0.0.1/src/pipesay/parser/parser.py

@@ -0,0 +1,53 @@
+import argparse
+
+from src.pipesay.constants import constants
+
+
+def _arg_parser() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='PipeSay句子流水线')
+    parser.add_argument('-g', '--generations', type=int, default=1, help='生成次数（默认：1）')
+    parser.add_argument('-s', '--processor-config', dest="processer_config", type=str, default=None, help='processer流水线配置')
+    parser.add_argument('-o', '--outputer-config', dest="outputer_config", type=str, default=None, help='outputer流水线配置')
+    
+    subparsers = parser.add_subparsers(dest='mode', required=True, help='选择获取模式')
+    
+    local_parser = subparsers.add_parser('local', help='从本地文件读取一言')
+    local_parser.add_argument('-f', '--file', default=constants.DEFAULT_FILE, help='本地文件')
+    
+    hitokoto_parser = subparsers.add_parser('hitokoto', help='从网络获取')
+    hitokoto_parser.add_argument('-c', '--category', nargs='*', choices=constants.YIYAN_CATEGORY.values(), default=constants.YIYAN_CATEGORY.values(), help='分类')
+
+    return parser.parse_args()
+
+
+def arg_process():
+    args = _arg_parser()
+    if args.generations <= 0:
+        raise ValueError("请输入一个正整数生成次数")
+    if args.mode == "local":
+        if args.file == constants.DEFAULT_FILE:
+            with open(args.file, 'a+') as f:
+                first_char = f.read(1)
+                if not first_char:
+                    print("语录文件是空的，已为您创建并写入了一定的内置语句")
+                    with open(args.file, 'w') as fw:
+                        fw.writelines(constants.DEFAULT_LINES)
+        else:
+            try:
+                with open(args.file, 'r') as f:
+                    first_char = f.read(1)
+                    if not first_char:
+                            raise RuntimeError(f"{args.file}是空的！")
+            except FileNotFoundError:
+                print("没有找到您的文件")
+                raise
+    
+    config = {
+        "fetcher_mode": args.mode,
+        "generations": args.generations,
+        "file_path": args.file if args.mode == 'local' else None,
+        "category": args.category if args.mode == 'hitokoto' else None,
+        "processer_config": args.processer_config,
+        "outputer_config": args.outputer_config
+    }
+    return config

pipesay-0.0.1/src/pipesay/processor/base.py

@@ -0,0 +1,21 @@
+from src.pipesay.core.pipeline import Pipeline
+from src.pipesay.core.registry import register
+
+PROCESSOR_REGISTRY: dict = {}
+
+
+def processor(name: str | None = None):
+    return register(PROCESSOR_REGISTRY, name)
+
+
+class Processor(Pipeline):
+    registry = PROCESSOR_REGISTRY
+    section = 'pipeline'
+    label = 'Processor'
+
+    def process(self, sentences: list) -> list:
+        return self.run(sentences)
+
+    @staticmethod
+    def list_processers():
+        Processor.list_all()

pipesay-0.0.1/src/pipesay/processor/processer_utils.py

@@ -0,0 +1,204 @@
+import json
+import random
+import time
+import unicodedata
+from concurrent.futures import ThreadPoolExecutor
+
+import jieba
+import translators as ts
+from cowsay import cowsay, list_cows
+from openai import OpenAI
+
+from src.pipesay.processor.base import processor
+
+
+@processor('reverse')
+def reverse(sentences: list, log=None):
+    """反转字符串"""
+    rl = []
+    for s in sentences:
+        rl.append(s[::-1])
+    return rl
+
+@processor('to_weak')
+def toweak(sentences: list, log=None):
+    """让你的话变得虚弱无比"""
+    PUNCT = set("，。！？；：、")
+    return_list = []
+
+    for s in sentences:
+        parts = []
+        current = ""
+        for char in s:
+            if char in PUNCT:
+                if current:
+                    parts.append(current)
+                parts.append(char)
+                current = ""
+            else:
+                current += char
+        if current:
+            parts.append(current)
+
+        # 先找出所有可分词的片段索引
+        word_part_indices = [i for i, p in enumerate(parts) if p not in PUNCT]
+
+        # 整句只选一个片段来插入省略号
+        if word_part_indices:
+            chosen = random.choice(word_part_indices)
+        else:
+            chosen = None
+
+        result = []
+        for i, part in enumerate(parts):
+            if part in PUNCT:
+                result.append(part)
+            else:
+                words = jieba.lcut(part)
+                if not words:
+                    continue
+                if i == chosen:
+                    idx = random.randint(1, len(words) - 1) if len(words) > 1 else 0
+                    words.insert(idx, "……")
+                result.extend(words)
+
+        return_list.append(''.join(result))
+
+    return return_list
+
+@processor('i18n')
+def i18n(sentences, lan: list, log=None):
+    """保持你原来的函数签名和封装结构"""
+    def _translate_one(s, l):
+        translated = ts.translate_text(s, translator='bing', to_language=l)
+        fixed = unicodedata.normalize('NFKC', translated)
+        time.sleep(0.5)
+        log(f"{l}获取完成啦！为防止风控，i18n工具需要0.5秒再打请求")
+        return fixed
+
+    rl = []
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        for s in sentences:
+            i18n_list = []
+            futures = [executor.submit(_translate_one, s, l) for l in lan]
+            for f in futures:
+                i18n_list.append(f.result())
+            result = ''.join(['\n\n' + item for item in i18n_list])
+            rl.append(result)
+    return rl
+
+
+@processor('ads')
+def ads(sentences, base_url: str, model: str, api_key: str, category: list | None = None, log=None):
+    
+    if category is None:
+        category = ['美食', '科技', '美妆', '旅行', '亲子']
+    
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url,
+    )
+
+    system_prompt = """
+        You are an AI assistant skilled at generating short ad copy in the style of Google Ads.
+        The user will provide a list of categories (e.g., ['Food', 'Tech', 'Beauty']), and you need to randomly select one category from the list and generate an ad for it.
+
+        Requirements:
+
+        Style: Google Ads RSA style. The title should include a selling point + a call to action (CTA). The description should add trust signals or promotional offers.
+        
+        In a user's request, a number is usually attached as the number of ads to generate. You need to generate according to that number, and always return using a JSON list even though the user may only ask for one.
+
+        Output: Strict JSON format with the following two fields:
+
+        "title": no more than 30 characters, attention-grabbing
+
+        "description": no more than 45 characters, including a call to action
+
+        Product/brand names must be fictional but sound realistic and trustworthy.
+
+        Language adaptation: Generate the ad in the primary language of the input category list (if mixed, prefer Chinese).
+
+        Output only the JSON object – no extra text, comments, or Markdown formatting.
+
+        Example 1 (Chinese):
+        INPUT: ['美食', '科技', '美妆', '旅行', '亲子'],2
+        OUTPUT: [{"title": "5999元起｜东京七日半自助游", "description": "正规旅行社，资深导游带队，无强制购物。立即询价！"}, {"title":"青春期孩子不听管教 | 育儿帮", "description": "点击连线专业咨询师"}]
+
+        Example 2 (English):
+        INPUT: ['Electronics', 'Fitness', 'Home'],1
+        OUTPUT: [{"title": "50% Off｜SonicGlide Toothbrush", "description": "Advanced sonic cleaning. Free shipping, order now!"}]
+    """
+
+    user_prompt = f"{category},{len(sentences)}"
+
+    messages = [{"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}]
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        response_format={
+            'type': 'json_object'
+        }
+    )
+
+    llm_result: list = json.loads(response.choices[0].message.content)
+    
+    ad_text: list = [f"\n\n[Ads]\n{r['title']}\n{r['description']}" for r in llm_result]
+    result = [x + y for x, y in zip(sentences, ad_text)]
+    
+    return result
+
+@processor('cowsay')
+def cow(sentences: list, cow: str = "default", random_cow: bool = False, log=None):
+    rl = []
+    
+    if random_cow:
+        cow = random.choice(list_cows())
+    
+    for sentence in sentences:
+        lines = sentence.split("\n")
+        max_line_len = max(len(line) for line in lines)
+        dynamic_width = max_line_len + 4
+        rl.append(cowsay(sentence, cow=cow, width=dynamic_width))
+    
+    return rl
+
+
+@processor('ban')
+def ban(sentences: list, ban_count: int=1, log=None):
+    
+    rl = []
+    
+    for s in sentences:
+        cur_sen = s
+        for a in range(ban_count):
+            index = random.randint(0, len(cur_sen) - 1)
+            cur_sen = cur_sen[:index] + "**" + cur_sen[index+1:]
+        rl.append(cur_sen)
+    
+    return rl
+
+@processor('rep2')
+def replace_repeat(sentences: list, rep_sen: str, log=None):
+    """
+    将rep_sen中的内容循环重复替换sen内容
+    
+    Args:
+        rep_sen(str): 准备好的来循环替换的句子
+    
+    Example:
+        sentence为20个字符
+        >>> print(replace_repeat("Goodbye"))
+        GoodbyeGoodbyeGoodby
+        注意，有一个e因为超出句子长度被截断了哦
+    """
+    rl = []
+    
+    for s in sentences:
+        target_len = len(s)
+        q, r = divmod(target_len, len(rep_sen))
+        result = rep_sen * q + rep_sen[:r]
+        rl.append(result)
+    return rl

pipesay-0.0.1/src/pipesay/utils/utils.py

@@ -0,0 +1,20 @@
+import os
+import subprocess
+
+
+def enter_to_next(prompt):
+    """
+    对程序进行阻塞使用户可以阅读句子/提示信息等再进行下一步
+    
+    Args:
+        prompt(str): 向用户展示的提示信息
+    """
+    
+    input(prompt)
+
+def clear_screen():
+    """清理屏幕上原有信息"""
+    if os.name == 'nt':
+        subprocess.run('cls', shell=True, check=False)
+    else:
+        subprocess.run('clear', shell=True, check=False)