orbitkit 0.9.12__tar.gz → 0.9.22__tar.gz

{orbitkit-0.9.12/orbitkit.egg-info → orbitkit-0.9.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbitkit
-Version: 0.9.12
+Version: 0.9.22
 Summary: This project is only for Orbit Tech internal use.
 Home-page: https://github.com/clown-0726/orbitkit
 Author: Lilu Cao
@@ -29,6 +29,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: asyncpg>=0.29.0
 Requires-Dist: boto3>=1.40.46
 Requires-Dist: aioboto3>=15.5.0
 Requires-Dist: aiofiles>=25.1.0

orbitkit-0.9.22/orbitkit/VERSION

@@ -0,0 +1 @@
+0.9.22

orbitkit-0.9.22/orbitkit/airflow_handler/file_flow_entry.py

@@ -0,0 +1,46 @@
+"""file_flow 任务下发入口（独立运维工具，旁路）。
+
+通过 orbitkit.airflow_handler.FilingOfficialProcessor 把 MongoDB query 命中的 ID
+派发到 worker 队列。本入口与 .claude/skills/attachments-process-* 4-skill 体系并行，
+**不经 runtime registry**，仅作运维直跑使用。
+
+queue_type 选项：
+
+- ``MineruExtract``     : CPU 队列，默认，吞吐适中、成本低
+- ``MineruExtract-GPU`` : GPU 队列，吞吐高，需要 GPU 资源就绪
+
+切换 queue_type 时通常同步调整 priority（GPU 路径占用更高优先级）。
+
+与 4-skill 体系的关系见项目根 ``CLAUDE.md`` 的「attachments_process/（独立运维工具集，旁路）」段。
+"""
+import csv
+import datetime
+import logging
+import os
+import asyncio
+from orbitkit.airflow_handler.file_flow_entry_process import FilingOfficialProcessor
+from orbitkit.util.secret_manager import SecretManager
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+async def main_loop(max_process_count):
+    SecretManager.load_secret_2_envs(['prod/fileflow/data'])
+    processor = FilingOfficialProcessor(
+        mongo_uri=os.environ['MONGO_URI'],
+        postgres_uri=os.environ['POSTGRES_URI'],
+        aws_access_key_id=os.environ['AWS_ACCESS_KEY_ID'],
+        aws_secret_access_key=os.environ['AWS_SECRET_ACCESS_KEY'],
+        pi2_postgres_uri=os.environ['PG_URI_CX45_USER_FILING']
+    )
+    query_dict = {
+        '_id': 'f_aXz7Y4n9qTlTRyuTc8sWsb',
+    }
+    await processor.process_task_entry(source='filing_data_staging', query=query_dict,
+                                            tags=['daily_increment_data'], allow_parse_over_limit=True,
+                                       priority='1', is_important=False, important_level=1, queue_type='MineruExtract-GPU')
+
+if __name__ == '__main__':
+    asyncio.run(main_loop(1))
+

orbitkit-0.9.22/orbitkit/pdf_chunking/__init__.py

@@ -0,0 +1,62 @@
+"""pdf_chunking：大 PDF 的页数门槛 / 按页切块 / 切块兜底选块（纯计算）。
+
+与 ``pdf_transformer.mineru.transform_chunk_zips`` 是一对：这里负责「切」和
+「决定」，那边负责「合」。本包不调 Router / CDN / PostgreSQL；唯一的外部依赖是
+PyMuPDF（可选，缺失时 :mod:`.pdf_metadata` 一律返回 None，退化为整篇提交）。
+
+提交前::
+
+    from orbitkit.pdf_chunking import count_pdf_pages, decide_pages, plan_chunks
+
+    n = count_pdf_pages(pdf_bytes)                        # None = 数不出，放行
+    d = decide_pages(n, max_pdf_pages=1000, chunk_pages=64,
+                     allow_parse_over_limit=False)
+    if d.reject: ...                                      # 10024，不送 Router
+    plan = plan_chunks(pdf_bytes, chunk_pages=64, should_chunk=d.should_chunk)
+    if plan.chunked:
+        parts = plan.take_parts()                         # 所有权只能取一次
+        names = [plan.part_name(filename, k) for k in range(plan.n_chunks)]
+
+切块兜底（每块一份 ``FilterStats``，整篇 ``Verdict`` 决定按哪些维度选块）::
+
+    from orbitkit.pdf_chunking import bad_chunks, empty_chunks, all_empty
+
+    redo = bad_chunks(stats_per_chunk,
+                      degenerate=record.repetition_failed, rd_threshold=0.06,
+                      bad_block=record.bad_block_failed, bad_block_threshold=0.06)
+"""
+
+from .chunk_fallback import (
+    all_empty,
+    bad_block_chunks,
+    bad_chunks,
+    degenerate_chunks,
+    empty_chunks,
+)
+from .chunk_plan import ChunkPlan, Splitter, plan_chunks
+from .page_limit import PageDecision, decide_pages
+from .pdf_metadata import (
+    HAS_PYMUPDF,
+    PageGeometry,
+    count_pdf_pages,
+    extract_page_geometry,
+    split_pdf_pages,
+)
+
+__all__ = [
+    "PageDecision",
+    "decide_pages",
+    "ChunkPlan",
+    "Splitter",
+    "plan_chunks",
+    "empty_chunks",
+    "all_empty",
+    "degenerate_chunks",
+    "bad_block_chunks",
+    "bad_chunks",
+    "HAS_PYMUPDF",
+    "PageGeometry",
+    "count_pdf_pages",
+    "split_pdf_pages",
+    "extract_page_geometry",
+]

orbitkit-0.9.22/orbitkit/pdf_chunking/chunk_fallback.py

@@ -0,0 +1,81 @@
+"""切块兜底的块级判定 —— 「哪些块要重投」的唯一实现（纯函数，无 I/O）。
+
+整篇路径的两条兜底（空解析 / 复读退化）都是「整篇一个数、整篇重投一次」。
+切块（> ``chunk_pages`` 页）的文档是 N 个块 ZIP 合成一份，整篇数字会被
+好块稀释，重投整篇又是主路径几倍的 GPU 时间。所以切块路径只重投**坏块**：
+
+- 空块：``total_in == 0``。0 block 的块没有分母，闸门看不见它，只能在这里判。
+- 退化块 / 坏块：只在**整篇合并后的对应率也超阀**时才找（保守版）——整篇不
+  超阀就当没事，避免块级分母变小（64 页 vs 整篇）让同一阈值在块上更敏感、兜底
+  触发率悄悄变高。整篇率 = Σerr / Σtotal ≤ max 块率，所以整篇超阀时至少一块超阀；
+  万一因序列 filter 跨块边界的口径差一块都没超，退回取率最高的那一块。
+  复读、坏块两个维度各自按上述规则选块，取并集（:func:`bad_chunks`）。
+
+``None`` 的块（middle.json 解析不了）一律不算坏块：让 transform 去报真正的
+错误码，跟 ``count_zip_blocks`` 的约定一致。
+"""
+
+from __future__ import annotations
+
+from typing import Callable, List, Optional, Sequence, Set
+
+from ..pdf_quality import VLM_ARTIFACT_FILTER
+from ..pdf_validator import FilterStats
+
+
+def empty_chunks(stats: Sequence[Optional[FilterStats]]) -> List[int]:
+    """0 个 block 的块下标（升序）。"""
+    return [k for k, s in enumerate(stats) if s is not None and s.total_in == 0]
+
+
+def all_empty(stats: Sequence[Optional[FilterStats]]) -> bool:
+    """每一块都判得出且都是 0 block（= 整篇空解析）。"""
+    return bool(stats) and all(s is not None and s.total_in == 0 for s in stats)
+
+
+def _over_threshold(
+    stats: Sequence[Optional[FilterStats]],
+    count: Callable[[FilterStats], int],
+    threshold: float,
+) -> List[int]:
+    rates = [
+        (k, count(s) / s.total_in)
+        for k, s in enumerate(stats)
+        if s is not None and s.total_in > 0
+    ]
+    over = [k for k, r in rates if r > threshold]
+    if over or not rates:
+        return over
+    return [max(rates, key=lambda kr: kr[1])[0]]
+
+
+def degenerate_chunks(
+    stats: Sequence[Optional[FilterStats]], *, threshold: float,
+) -> List[int]:
+    """复读率**严格大于** ``threshold`` 的块下标（升序）；一块都没有则退回
+    率最高的那一块（非空块里选）。全部判不出 / 全空 → 空列表。"""
+    return _over_threshold(stats, lambda s: s.degenerate, threshold)
+
+
+def bad_block_chunks(
+    stats: Sequence[Optional[FilterStats]], *, threshold: float,
+) -> List[int]:
+    """坏块率（``drop_vlm_artifacts`` 丢弃数 / 总块）超阀的块下标；规则同
+    :func:`degenerate_chunks`。"""
+    return _over_threshold(
+        stats, lambda s: s.dropped_by(VLM_ARTIFACT_FILTER), threshold,
+    )
+
+
+def bad_chunks(
+    stats: Sequence[Optional[FilterStats]], *,
+    degenerate: bool, rd_threshold: float,
+    bad_block: bool, bad_block_threshold: float,
+) -> List[int]:
+    """整篇哪些闸超了（``degenerate`` / ``bad_block``）就按那些维度选块，并集升序。"""
+    picked: Set[int] = set()
+    if degenerate:
+        picked.update(degenerate_chunks(stats, threshold=rd_threshold))
+    if bad_block:
+        picked.update(bad_block_chunks(stats, threshold=bad_block_threshold))
+    return sorted(picked)

orbitkit-0.9.22/orbitkit/pdf_chunking/chunk_plan.py

@@ -0,0 +1,91 @@
+"""切块计划 —— 把「切不切 / 切失败怎么办 / 块怎么命名 / 每块几页」收成一处。
+
+切块用的页数和合并（``pdf_transformer.mineru.transform_chunk_zips(chunk_pages=...)``
+做 page offset 累加）用的页数必须是同一个值，否则合并后的页码会静默错位。
+:class:`ChunkPlan` 把这个值随计划一起交给 transform，两者不可能不一致。
+
+## 为什么不是 frozen dataclass
+
+计划要携带切出来的字节。如果它一直持有这份引用，高并发下就等于每篇 PDF 多留
+一份在内存里。所以字节的所有权只能被 :meth:`ChunkPlan.take_parts` **取走一次**，
+取走后本对象不再持有；重复取或对整篇计划取都是大声失败（释放后访问不要静默）。
+计划本身的形状（``chunked`` / ``n_chunks``）不受取走影响。
+"""
+
+from __future__ import annotations
+
+from typing import Callable, List, Optional
+
+from .pdf_metadata import split_pdf_pages
+
+Splitter = Callable[[bytes, int], Optional[List[bytes]]]
+"""``(pdf_bytes, pages_per_chunk) -> 各块字节 | None``（None = 不切 / 切不成）。"""
+
+
+class ChunkPlan:
+    """一篇 PDF 的提交计划：整篇一次，或按页切成 N 块。"""
+
+    __slots__ = ("chunk_pages", "split_failed", "_parts", "_chunked", "_n_chunks")
+
+    def __init__(
+        self,
+        parts: Optional[List[bytes]],
+        *,
+        chunk_pages: int,
+        split_failed: bool = False,
+    ) -> None:
+        self._parts = parts
+        self._chunked = parts is not None
+        self._n_chunks = len(parts) if parts is not None else 1
+        self.chunk_pages = chunk_pages
+        self.split_failed = split_failed
+
+    @property
+    def chunked(self) -> bool:
+        """是否走切块路径（False = 整篇单次提交）。"""
+        return self._chunked
+
+    @property
+    def n_chunks(self) -> int:
+        return self._n_chunks
+
+    @property
+    def holds_parts(self) -> bool:
+        """本对象是否还持有各块字节（取走所有权后为 False）。"""
+        return self._parts is not None
+
+    def take_parts(self) -> List[bytes]:
+        """转移各块字节的所有权（只能取一次；取后本对象不再持有引用）。"""
+        if not self._chunked:
+            raise RuntimeError("ChunkPlan is whole-file; there are no parts")
+        if self._parts is None:
+            raise RuntimeError("ChunkPlan parts already taken")
+        parts, self._parts = self._parts, None
+        return parts
+
+    @staticmethod
+    def part_name(filename: str, index: int) -> str:
+        """第 ``index`` 块提交给 Router 的文件名（命名唯一实现）。"""
+        return f"{filename}.part{index:03d}.pdf"
+
+
+def plan_chunks(
+    pdf_bytes: bytes,
+    *,
+    chunk_pages: int,
+    should_chunk: bool,
+    splitter: Optional[Splitter] = None,
+) -> ChunkPlan:
+    """按页切块；不需要切或切不出来时，退化成整篇提交的计划。
+
+    默认 ``splitter`` 是 PyMuPDF 版 :func:`split_pdf_pages`，对「无需切块 / 加密 /
+    PyMuPDF 不可用 / 解析失败」一律返回 None（不抛异常），这里把它统一归成整篇
+    提交，并用 ``split_failed`` 区分「本来就不用切」和「想切但没切成」（后者调用
+    方要记一行 WARNING）。``splitter`` 可注入别的实现（其它 PDF 库 / 测试桩）。
+    """
+    if not should_chunk:
+        return ChunkPlan(None, chunk_pages=chunk_pages)
+    parts = (splitter or split_pdf_pages)(pdf_bytes, chunk_pages)
+    if not parts:
+        return ChunkPlan(None, chunk_pages=chunk_pages, split_failed=True)
+    return ChunkPlan(parts, chunk_pages=chunk_pages)

orbitkit-0.9.22/orbitkit/pdf_chunking/page_limit.py

@@ -0,0 +1,61 @@
+"""页数门槛判定 —— 纯函数，不碰 IO、不看 config 对象。
+
+页数极多的 PDF 会长时间独占 GPU / 拖垮 Router（大面积 30001 的根因），所以
+数出页数后要一次性回答三件事：
+
+    1. 是否硬拦截（不送 Router，判 10024）
+    2. 是否「超限但被 op_meta 的 ``allow_parse_over_limit`` 放行」（要记一行 INFO）
+    3. 是否切块（与 1、2 无关：放行的超限文档**仍然**切块）
+
+三条判据都取决于同一组输入，分开写就会出现「改了拦截忘了切块」这类静默不一致。
+收成一个 :class:`PageDecision`，各分支各一个单测。
+
+判据：
+    - ``max_pdf_pages <= 0`` → 禁用页数上限，从不拦截。
+    - ``allow_parse_over_limit`` → 不拦截（仍切块）。
+    - ``page_count is None``（加密 / 解析失败 / PyMuPDF 不可用）→ 放行，
+      按整篇提交处理；此时也**不切块**（页数未知，切不出来）。
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class PageDecision:
+    """页数门槛的完整结论。三个字段互相独立，调用方不再自己重算。"""
+
+    reject: bool
+    """硬拦截：不送 Router，判 ``pdf_quality.failure_codes.PAGE_COUNT_EXCEEDS_LIMIT`` (10024)。"""
+
+    over_limit_allowed: bool
+    """超过 ``max_pdf_pages`` 但被 op_meta 开关放行（仅用于记一行 INFO）。"""
+
+    should_chunk: bool
+    """按 ``chunk_pages`` 切块提交。"""
+
+
+def decide_pages(
+    page_count: Optional[int],
+    *,
+    max_pdf_pages: int,
+    chunk_pages: int,
+    allow_parse_over_limit: bool,
+) -> PageDecision:
+    """由页数 + 两个上限 + meta 开关，一次算出全部页数相关结论。"""
+    over_limit = (
+        max_pdf_pages > 0
+        and page_count is not None
+        and page_count > max_pdf_pages
+    )
+    return PageDecision(
+        reject=over_limit and not allow_parse_over_limit,
+        over_limit_allowed=over_limit and allow_parse_over_limit,
+        should_chunk=(
+            chunk_pages > 0
+            and page_count is not None
+            and page_count > chunk_pages
+        ),
+    )

orbitkit-0.9.22/orbitkit/pdf_chunking/pdf_metadata.py

@@ -0,0 +1,157 @@
+"""PDF 页级元信息：页数 / 按页切块 / 每页 mediabox + /Rotate（PyMuPDF，可选依赖）。
+
+三个函数都「失败返回 None、不抛异常」：解析失败 / 加密打不开 / PyMuPDF 未安装
+时调用方应放行（按整篇提交、跳过 bbox 纠正），不因为数不出页数就误杀文档。
+
+``extract_page_geometry`` 的结果直接喂给
+``pdf_transformer.mineru.transform_zip(page_geometry=...)`` 做 bbox 旋转纠正。
+"""
+
+import logging
+from typing import List, Optional
+
+from ..pdf_transformer.mineru.bbox_rotation import PageGeometry
+
+try:
+    import fitz  # PyMuPDF
+    HAS_PYMUPDF = True
+except ImportError:
+    HAS_PYMUPDF = False
+
+log = logging.getLogger(__name__)
+
+
+# ----------------------------------------------------------
+# Per-page geometry extraction
+# ----------------------------------------------------------
+#
+# 用于 result_transformer 的 bbox 旋转纠正：mineru 的 middle.json 里
+# `page_size` 可能是"应用了 /Rotate 之后的逻辑帧"，与 PDF 原 mediabox 不同。
+# 后处理时需要拿到原 mediabox 才能判定是否要把 bbox 反向旋转回 mediabox 帧。
+#
+# 这里特意 **只返回 raw mediabox 尺寸 + /Rotate 值**，不主动应用 /Rotate。
+# fitz 的 `page.rect` 默认是"应用了 /Rotate 之后"的可视尺寸；要拿原 mediabox
+# 必须从 `page.mediabox` 读，并显式取 width/height 元组。
+
+__all__ = [
+    "HAS_PYMUPDF",
+    "PageGeometry",
+    "count_pdf_pages",
+    "split_pdf_pages",
+    "extract_page_geometry",
+]
+
+
+def count_pdf_pages(pdf_bytes: bytes) -> Optional[int]:
+    """返回 PDF 页数；无法判定时返回 None（不抛异常）。
+
+    用于 submit 前的页数门槛：页数过多的 PDF 会拖垮 Router，直接拦截。
+    解析失败 / PyMuPDF 不可用 / 加密打不开 → 返回 None，调用方应放行
+    （不因为数不出页数就误杀），交给后续阶段按原逻辑处理。
+    """
+    if not HAS_PYMUPDF:
+        log.debug("count_pdf_pages: PyMuPDF unavailable")
+        return None
+    if not pdf_bytes:
+        return None
+
+    try:
+        with fitz.open(stream=pdf_bytes, filetype="pdf") as doc:
+            if doc.is_encrypted and not doc.authenticate(""):
+                log.debug("count_pdf_pages: encrypted PDF, skipping")
+                return None
+            return int(doc.page_count)
+    except Exception as e:
+        log.warning("count_pdf_pages failed: %s", e)
+        return None
+
+
+def split_pdf_pages(
+    pdf_bytes: bytes, pages_per_chunk: int
+) -> Optional[List[bytes]]:
+    """把 PDF 按 ``pages_per_chunk`` 页切成多块，每块返回独立的 PDF 字节。
+
+    用于大 PDF 切块 + 高优先级抢占：页数过多的 PDF 会长时间独占 GPU 槽位，
+    切成小块后每块单独提交 Router，块之间腾出槽位让高优先级任务插队。
+
+    Args:
+        pdf_bytes: 原始 PDF 字节。
+        pages_per_chunk: 每块页数（> 0）。
+
+    Returns:
+        - 若成功且需要切块（总页数 > pages_per_chunk）：返回按顺序排列的
+          每块 PDF 字节列表（长度 >= 2）。
+        - 若无需切块（总页数 <= pages_per_chunk）：返回 None（调用方应按整篇
+          单次提交处理，不做切块）。
+        - 若 PyMuPDF 不可用 / 加密打不开 / 解析失败 / 参数非法：返回 None
+          （不抛异常；调用方回退到整篇单次提交）。
+    """
+    if not HAS_PYMUPDF:
+        log.debug("split_pdf_pages: PyMuPDF unavailable")
+        return None
+    if not pdf_bytes or pages_per_chunk <= 0:
+        return None
+
+    try:
+        with fitz.open(stream=pdf_bytes, filetype="pdf") as doc:
+            if doc.is_encrypted and not doc.authenticate(""):
+                log.debug("split_pdf_pages: encrypted PDF, skipping")
+                return None
+            total = int(doc.page_count)
+            if total <= pages_per_chunk:
+                return None  # 无需切块
+
+            chunks: List[bytes] = []
+            for start in range(0, total, pages_per_chunk):
+                end = min(start + pages_per_chunk, total) - 1
+                sub = fitz.open()
+                try:
+                    sub.insert_pdf(doc, from_page=start, to_page=end)
+                    chunks.append(sub.tobytes())
+                finally:
+                    sub.close()
+            return chunks
+    except Exception as e:
+        log.warning("split_pdf_pages failed: %s", e)
+        return None
+
+
+def extract_page_geometry(pdf_bytes: bytes) -> Optional[List[PageGeometry]]:
+    """从 PDF 字节中提取每页 (mediabox_w, mediabox_h, /Rotate)。
+
+    用于后处理 bbox 旋转纠正：与 mineru.page_size 对比，发现维度交换时
+    根据 /Rotate 反向旋转 bbox。
+
+    Args:
+        pdf_bytes: PDF 文件字节
+
+    Returns:
+        每页一个 (W, H, rotate) 元组的列表；解析失败返回 None（不抛异常）。
+        None 时调用方应跳过纠正逻辑、按原 mineru 输出走。
+    """
+    if not HAS_PYMUPDF:
+        log.debug("extract_page_geometry: PyMuPDF unavailable")
+        return None
+    if not pdf_bytes:
+        return None
+
+    try:
+        with fitz.open(stream=pdf_bytes, filetype="pdf") as doc:
+            if doc.is_encrypted and not doc.authenticate(""):
+                log.debug("extract_page_geometry: encrypted PDF, skipping")
+                return None
+            geometry: List[PageGeometry] = []
+            for page in doc:
+                # mediabox 是 raw、未应用 /Rotate 的原始页面盒
+                # fitz.Rect: (x0, y0, x1, y1)
+                mb = page.mediabox
+                width = float(abs(mb.x1 - mb.x0))
+                height = float(abs(mb.y1 - mb.y0))
+                # `page.rotation` 是 /Rotate 字段值（0/90/180/270），不是
+                # 应用过旋转的渲染状态
+                rot = int(page.rotation) % 360
+                geometry.append((width, height, rot))
+            return geometry
+    except Exception as e:
+        log.warning("extract_page_geometry failed: %s", e)
+        return None

orbitkit-0.9.22/orbitkit/pdf_pipeline_io/__init__.py

@@ -0,0 +1,36 @@
+"""pdf_pipeline_io：PDF 处理流水线的 I/O 工具包。
+
+合并两块与外部系统交互的能力：
+
+- **CDN 对象存储**（:class:`CdnUploader`）：经自建 CDN 网关做对象下载 / 上传
+  （基于 ``requests``，不用 boto3），省 S3 出站费。
+- **PG 任务队列**（:class:`DbTaskSource`）：从生产 batch_worker 抽出的"更新
+  PG 业务流"，拉取 / 锁定 / 状态回写；schema / 队列 / 状态由
+  :class:`TaskStoreConfig` 参数化，默认值即 mineru 生产在用的一套。
+
+用法::
+
+    from orbitkit.pdf_pipeline_io import CdnUploader, DbTaskSource, TaskStoreConfig
+
+    with CdnUploader("https://cdn.example.com", upload_key=KEY) as cdn:
+        cdn.upload_files("my-bucket", "txt-vector/<key>", result.to_files())
+
+    db = DbTaskSource(dsn, config=TaskStoreConfig())
+    await db.connect()
+    tasks = await db.fetch_batch(limit=8)
+"""
+
+from .cdn import DEFAULT_CONTENT_TYPE, CdnUploader
+from .pg_task_store import (
+    AttachmentTask,
+    DbTaskSource,
+    TaskStoreConfig,
+)
+
+__all__ = [
+    "CdnUploader",
+    "DEFAULT_CONTENT_TYPE",
+    "DbTaskSource",
+    "AttachmentTask",
+    "TaskStoreConfig",
+]

orbitkit-0.9.12/orbitkit/cdn_uploader/uploader.py → orbitkit-0.9.22/orbitkit/pdf_pipeline_io/cdn.py

@@ -1,6 +1,6 @@
 """自建 CDN 网关客户端（省 S3 出站费），基于 ``requests``，不依赖 boto3。
 
-设了 CDN 网关（形如 ``https://oassets.orbitfin.ai``，路径 ``/{bucket}/{key}``）
+设了 CDN 网关（形如 ``https://cdn.example.com``，路径 ``/{bucket}/{key}``）
 后，把对象的下载 / 上传改走网关而不是直连 S3。收益：S3→CDN 回源免费 +
 CDN 出站费率低 / 有免费额度 → 省 egress。
 
@@ -47,7 +47,7 @@ class CdnUploader:
     """经自建 CDN 网关做对象的下载 / 上传（同步）。
 
     Args:
-        base_url: 网关根地址，如 ``https://oassets.orbitfin.ai``。
+        base_url: 网关根地址，如 ``https://cdn.example.com``。
         upload_key: 网关鉴权 key（``x-upload-key``）；下载时也一并带上（网关
             不需要会忽略）。**绝不硬编码**，由调用方从环境 / secret 传入。
         timeout_seconds: 单次请求超时。
@@ -148,4 +148,4 @@ class CdnUploader:
         return self
 
     def __exit__(self, *exc) -> None:
-        self.close()
+        self.close()