orbitkit 0.8.78__tar.gz → 0.9.10__tar.gz

{orbitkit-0.8.78/orbitkit.egg-info → orbitkit-0.9.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbitkit
-Version: 0.8.78
+Version: 0.9.10
 Summary: This project is only for Orbit Tech internal use.
 Home-page: https://github.com/clown-0726/orbitkit
 Author: Lilu Cao

orbitkit-0.9.10/orbitkit/VERSION

@@ -0,0 +1 @@
+0.9.10

{orbitkit-0.8.78 → orbitkit-0.9.10}/orbitkit/airflow_handler/data_preprocessing.py

@@ -160,6 +160,7 @@ class DocumentProcessor:
                         "title": title,
                         "published": doc['x_reported_at_utc_date'],
                         "tickers": [],
+                        "tickers_map_arr": [],
                         "perm_id_list": doc['x_orbit_data']['perm_id_list'],
                         "report_type_id_list_str": doc['x_orbit_data']['report_type_id_list']
                     }

{orbitkit-0.8.78 → orbitkit-0.9.10}/orbitkit/airflow_handler/file_flow_entry_process.py

@@ -29,6 +29,7 @@ class FilingOfficialProcessor:
 
         self.mongo_client = pymongo.MongoClient(mongo_uri)
         self.data_xbrl_convert_collection = self.mongo_client['filing_reports']['data_xbrl_convert']
+        self.sm_orbit_entity_id_cache_collection = self.mongo_client['stat_cache']['sm_orbit_entity_id_cache']
 
         postgres_uri = os.environ.get('PG_URI_AIRFLOW12_USER_NEWSFEEDSITE') if not postgres_uri else postgres_uri
         if not postgres_uri:
@@ -139,13 +140,27 @@ class FilingOfficialProcessor:
 
                 if row.ticker is not None:
                     orbit_entity_id_ticker_map[row.orbit_entity_id].append(row.ticker)
+        # 批量查询 organization_name / primary_ticker（走查 doc 的同一个 mongo 连接）
+        orbit_entity_id_org_map = {}
+        cache_cursor = self.sm_orbit_entity_id_cache_collection.find(
+            {'orbit_entity_id': {'$in': perm_id_list}},
+            {'orbit_entity_id': 1, 'organization_name': 1, 'primary_ticker': 1}
+        ).batch_size(self.max_batch_size)
+        for row in cache_cursor:
+            orbit_entity_id_org_map[row['orbit_entity_id']] = (row.get('organization_name'), row.get('primary_ticker'))
+
         for step_info, records in file_flow_info.items():
             for record in records:
                 if 'extends' in record and record.get('extends') is not None:
                     tickers = set()
+                    tickers_map_arr = []
                     for i in record['extends']['perm_id_list']:
                         tickers.update(orbit_entity_id_ticker_map.get(i, []))
+                        org_info = orbit_entity_id_org_map.get(i)
+                        if org_info and org_info[0] is not None:
+                            tickers_map_arr.append({org_info[0]: org_info[1]})
                     record['extends']['tickers'] = list(tickers)
+                    record['extends']['tickers_map_arr'] = tickers_map_arr
 
                     record['extends']['report_type_id_list_str'] = [self.report_type_id_name_map.get(i) for i in record['extends']['report_type_id_list_str']]
 

orbitkit-0.9.10/orbitkit/cdn_uploader/__init__.py

@@ -0,0 +1,16 @@
+"""cdn_uploader：经自建 CDN 网关做对象下载 / 上传（基于 requests，不用 boto3）。
+
+用法::
+
+    from orbitkit.cdn_uploader import CdnUploader
+
+    with CdnUploader("https://oassets.orbitfin.ai", upload_key=KEY) as cdn:
+        cdn.upload_files("filing-reports", "txt-vector/<key>", result.to_files())
+"""
+
+from .uploader import DEFAULT_CONTENT_TYPE, CdnUploader
+
+__all__ = [
+    "CdnUploader",
+    "DEFAULT_CONTENT_TYPE",
+]

orbitkit-0.9.10/orbitkit/cdn_uploader/uploader.py

@@ -0,0 +1,151 @@
+"""自建 CDN 网关客户端（省 S3 出站费），基于 ``requests``，不依赖 boto3。
+
+设了 CDN 网关（形如 ``https://oassets.orbitfin.ai``，路径 ``/{bucket}/{key}``）
+后，把对象的下载 / 上传改走网关而不是直连 S3。收益：S3→CDN 回源免费 +
+CDN 出站费率低 / 有免费额度 → 省 egress。
+
+用**独立的 requests.Session（trust_env=False，不读全局环境代理）**，是否走代理
+由 ``proxies`` 显式控制：
+    - 传了 ``proxies`` → CDN 请求经该代理出境（例如 xproxy 开启时跟着走 xproxy）；
+    - 不传 → 直连网关域名。
+
+接口（与生产网关约定一致）：
+    下载  GET  {base}/{bucket}/{key}
+          - 带 ``x-upload-key`` 头（网关不需要会忽略）
+          - 成功 2xx，body = 原始字节
+    上传  PUT  {base}/{bucket}/{key}
+          - ``x-upload-key``: 鉴权 key（**绝不硬编码**，由调用方传入）
+          - ``x-amz-content-sha256``: body 的 sha256 十六进制小写
+          - ``Content-Type``
+          - body = 文件内容
+          - 成功 2xx
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+from typing import Dict, Mapping, Optional
+from urllib.parse import quote
+
+import requests
+
+log = logging.getLogger(__name__)
+
+DEFAULT_CONTENT_TYPE = "application/octet-stream"
+
+
+def _proxies_arg(proxies: Optional[Mapping[str, str]], proxy_url: Optional[str]):
+    if proxies:
+        return dict(proxies)
+    if proxy_url:
+        return {"http": proxy_url, "https": proxy_url}
+    return None
+
+
+class CdnUploader:
+    """经自建 CDN 网关做对象的下载 / 上传（同步）。
+
+    Args:
+        base_url: 网关根地址，如 ``https://oassets.orbitfin.ai``。
+        upload_key: 网关鉴权 key（``x-upload-key``）；下载时也一并带上（网关
+            不需要会忽略）。**绝不硬编码**，由调用方从环境 / secret 传入。
+        timeout_seconds: 单次请求超时。
+        proxy_url: 简写：出境代理 URL（同时用于 http/https）。
+        proxies: requests 风格的 ``{"http": ..., "https": ...}``；给了则优先于
+            ``proxy_url``。两者都不给 = 直连。
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        upload_key: Optional[str] = None,
+        *,
+        timeout_seconds: int = 300,
+        proxy_url: Optional[str] = None,
+        proxies: Optional[Mapping[str, str]] = None,
+    ) -> None:
+        if not base_url:
+            raise ValueError("CdnUploader requires a non-empty base_url")
+        self._base = base_url.rstrip("/")
+        self._upload_key = upload_key
+        self._timeout = float(timeout_seconds)
+        self._proxies = _proxies_arg(proxies, proxy_url)
+        self._session = requests.Session()
+        # trust_env=False：不读全局 HTTP_PROXY/HTTPS_PROXY / netrc；代理只在
+        # 显式给了 proxies/proxy_url 时对这个 session 生效。
+        self._session.trust_env = False
+
+    def _url(self, bucket: str, key: str) -> str:
+        # key 里的 '/' 是路径分隔符要保留；其它特殊字符做 URL 编码。
+        safe_key = quote(key.lstrip("/"), safe="/")
+        return f"{self._base}/{bucket}/{safe_key}"
+
+    def download(self, bucket: str, key: str) -> bytes:
+        headers: Dict[str, str] = {}
+        if self._upload_key:
+            headers["x-upload-key"] = self._upload_key
+        resp = self._session.get(
+            self._url(bucket, key),
+            headers=headers,
+            proxies=self._proxies,
+            timeout=self._timeout,
+        )
+        resp.raise_for_status()
+        return resp.content
+
+    def upload(
+        self,
+        bucket: str,
+        key: str,
+        body: bytes,
+        content_type: str = DEFAULT_CONTENT_TYPE,
+    ) -> None:
+        headers = {
+            "x-amz-content-sha256": hashlib.sha256(body).hexdigest(),
+            "Content-Type": content_type,
+        }
+        if self._upload_key:
+            headers["x-upload-key"] = self._upload_key
+        resp = self._session.put(
+            self._url(bucket, key),
+            headers=headers,
+            data=body,
+            proxies=self._proxies,
+            timeout=self._timeout,
+        )
+        resp.raise_for_status()
+
+    def upload_files(
+        self,
+        bucket: str,
+        key_prefix: str,
+        files: Mapping[str, bytes],
+        *,
+        content_type_for: Optional[Mapping[str, str]] = None,
+    ) -> None:
+        """把 ``{相对路径: bytes}`` 批量上传到 ``{bucket}/{key_prefix}/{相对路径}``。
+
+        Args:
+            bucket: 目标 bucket。
+            key_prefix: key 前缀（会与相对路径以 ``/`` 拼接；空前缀直接用相对路径）。
+            files: 相对路径 → bytes，通常是 ``TransformResult.to_files()`` 的返回。
+            content_type_for: 可选，按相对路径覆盖 Content-Type；缺省用
+                ``application/octet-stream``。
+        """
+        prefix = key_prefix.strip("/")
+        for rel_path, body in files.items():
+            key = f"{prefix}/{rel_path}" if prefix else rel_path
+            ctype = DEFAULT_CONTENT_TYPE
+            if content_type_for and rel_path in content_type_for:
+                ctype = content_type_for[rel_path]
+            self.upload(bucket, key, body, ctype)
+
+    def close(self) -> None:
+        self._session.close()
+
+    def __enter__(self) -> "CdnUploader":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()

orbitkit-0.9.10/orbitkit/pdf_transformer/__init__.py

@@ -0,0 +1,16 @@
+"""pdf_transformer：各模型专属的 raw 结果 → 统一 blocks / pages 转换器集合。
+
+每个模型一个子包，产出同一套与模型无关的 blocks / pages 结构，交给
+:mod:`orbitkit.pdf_validator` 做减法过滤、:mod:`orbitkit.cdn_uploader` 上传：
+
+- :mod:`orbitkit.pdf_transformer.mineru` —— MinerU Router ZIP 转换器（现有）。
+- 后续：``datalab`` 等其它模型。
+
+用法::
+
+    from orbitkit.pdf_transformer.mineru import transform_zip, transform_chunk_zips
+"""
+
+from . import mineru
+
+__all__ = ["mineru"]

orbitkit-0.9.10/orbitkit/pdf_transformer/mineru/__init__.py

@@ -0,0 +1,41 @@
+"""MinerU 结果转换：raw ZIP → 结构化 blocks / pages（已旋转纠正 + 已 Y 翻转）+ 透传文件。
+
+本子包只负责 **模型专属的解析 + 几何归一**，产出与模型无关的 blocks / pages
+结构（:class:`TransformResult`）。**内容过滤**（减法）交给
+:mod:`orbitkit.pdf_validator`；**上传**交给 :mod:`orbitkit.cdn_uploader`。
+
+MinerU 是 :mod:`orbitkit.pdf_transformer` 下的其中一个模型实现（后续会有
+``datalab`` 等），各模型都产出同一套 blocks / pages 结构以复用 pdf_validator。
+
+典型用法::
+
+    from orbitkit.pdf_transformer.mineru import transform_zip
+    from orbitkit.pdf_validator import apply_block_filters, resolve_filters, parse_filter_names
+
+    result = transform_zip(zip_bytes, page_geometry=geom, bbox_rotate_correction=True)
+    result.blocks, result.pages = apply_block_filters(
+        result.blocks, result.pages,
+        resolve_filters(parse_filter_names("drop_non_text,drop_vlm_artifacts")),
+    )
+    files = result.to_files()   # Dict[相对路径, bytes]，可直接上传
+"""
+
+from .bbox_rotation import (
+    PageGeometry,
+    bbox_inverse_rotate,
+    correct_middle_bbox_rotation,
+)
+from .result_transformer import (
+    TransformResult,
+    transform_chunk_zips,
+    transform_zip,
+)
+
+__all__ = [
+    "TransformResult",
+    "transform_zip",
+    "transform_chunk_zips",
+    "PageGeometry",
+    "bbox_inverse_rotate",
+    "correct_middle_bbox_rotation",
+]

orbitkit-0.9.10/orbitkit/pdf_transformer/mineru/bbox_rotation.py

@@ -0,0 +1,218 @@
+"""bbox 旋转纠正：把 mineru middle.json 里 display 帧的 bbox 转回 MediaBox 帧。
+
+# 现象（mineru 上游 bug）
+
+1. mineru 用 pdfium 渲染时调用 ``page.render()``，pdfium **会自动应用
+   /Rotate**，所以渲染出来的图像在 "/Rotate 后的视觉帧"（display frame）。
+   VLM 看到的、输出 bbox 的图像就是这个 display frame。
+2. mineru 把 bbox 写进 middle.json 时，**没有**把图像旋转过的事实补回去
+   → middle.json 里的 bbox 留在 display frame。
+3. 但 middle.json 的 ``page_size`` 字段是用 ``page.get_size()`` 拿的
+   **未旋转 MediaBox** 尺寸，**没有** W↔H 互换。
+
+⇒ 同一个 middle.json 里 ``page_size`` 与 bbox 坐标系不一致：
+   - page_size = (mediabox_W, mediabox_H)
+   - bbox     ∈ display frame = (mediabox_H, mediabox_W) for /Rotate∈{90,270}
+
+下游若拿这份 bbox 去叠在原 PDF 渲染图（mediabox 帧）上 → 偏移 / 越界。
+
+# 修复
+
+把 bbox 反向旋转回 MediaBox 帧。
+
+## 检测条件
+
+* /Rotate ∈ {90, 270} → 进入纠正分支。
+* **不**依赖 "page_size 维度互换" —— mineru 永远报未旋转 MediaBox，
+  这个条件**永远不成立**，不能作为信号。
+* 仅做防御性 sanity：若 page_size 与 MediaBox 不一致（mineru 行为变了
+  或上游修了 bug），warn 一下、继续按旋转纠正走，需要人工看日志。
+
+不处理 180°：mediabox 维度不变 → 检测不到；即使强制处理，也需要内容
+方向探测（OCR）才知道要不要转。punt。
+
+## 旋转公式
+
+image 坐标系，top-left 原点 Y 向下：
+- /Rotate=90  反向：``[x0,y0,x1,y1]`` → ``[y0, H_m - x1, y1, H_m - x0]``
+- /Rotate=270 反向：``[x0,y0,x1,y1]`` → ``[W_m - y1, x0, W_m - y0, x1]``
+
+推导见 :func:`bbox_inverse_rotate` 函数内注释。
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, List, Optional, Tuple
+
+log = logging.getLogger(__name__)
+
+# 每页几何信息：(mediabox_w, mediabox_h, /Rotate value 0/90/180/270)
+PageGeometry = Tuple[float, float, int]
+
+# 检测维度交换时的容差（像素）。mineru 的 page_size 偶尔有 ±1 浮点抖动。
+DIM_SWAP_EPS = 2.0
+
+
+def bbox_inverse_rotate(
+    bbox: List[float],
+    rotate: int,
+    media_w: float,
+    media_h: float,
+) -> List[float]:
+    """把 mineru 输出的 bbox（display 帧）反向旋转回 mediabox 帧。
+
+    bbox 输入约定：top-left 原点、Y 向下，且 ``x0 <= x1, y0 <= y1``。
+    输出同约定，在 (media_w, media_h) 帧里。
+
+    Args:
+        bbox: 4 元素 ``[x0, y0, x1, y1]``（display frame）
+        rotate: PDF /Rotate 字段值，仅 90/270 会真正旋转；其它值原样返回
+        media_w: MediaBox 宽
+        media_h: MediaBox 高
+
+    Returns:
+        转回 mediabox 帧的 4 元素 bbox。
+    """
+    x0, y0, x1, y1 = bbox
+    # 防御性：调用方应保证 x0<=x1 / y0<=y1，但 middle.json 里偶有反向
+    if x0 > x1:
+        x0, x1 = x1, x0
+    if y0 > y1:
+        y0, y1 = y1, y0
+
+    if rotate == 90:
+        # 推导：mediabox→display 是 +90° CW，即 (x_m, y_m) → (H_m - y_m, x_m)。
+        # 反向是 -90° CW = +270° CW，即 display(x_d, y_d) → (y_d, H_m - x_d)。
+        # bbox 4 角全部映射后取 min/max：
+        return [y0, media_h - x1, y1, media_h - x0]
+    if rotate == 270:
+        # 推导：mediabox→display 是 +270° CW，即 (x_m, y_m) → (y_m, W_m - x_m)。
+        # 反向是 +90° CW，即 display(x_d, y_d) → (W_m - y_d, x_d)。
+        return [media_w - y1, x0, media_w - y0, x1]
+    # 其它情况（0 或 180 或非法值）不应到达此函数；保持不变以防错改
+    return [x0, y0, x1, y1]
+
+
+def walk_and_fix_bboxes(
+    node: Any,
+    fix: Callable[[List[float]], List[float]],
+    counter: List[int],
+) -> None:
+    """递归遍历 page 子树（para_blocks/discarded_blocks/blocks/lines/spans），
+    对所有 ``bbox`` 字段应用 ``fix``。
+
+    ``counter[0]`` 累加修改次数，便于日志统计。仅修改 ``list[float|int]``
+    形式且长度 ≥ 4 的 bbox；其它形态保持不变。
+    """
+    if isinstance(node, dict):
+        bbox = node.get("bbox")
+        if (
+            isinstance(bbox, list)
+            and len(bbox) >= 4
+            and all(isinstance(v, (int, float)) for v in bbox[:4])
+        ):
+            new_bbox = fix(list(map(float, bbox[:4])))
+            # 保留 bbox 列表后续元素（如有）
+            node["bbox"] = new_bbox + list(bbox[4:])
+            counter[0] += 1
+        for child_key in ("para_blocks", "discarded_blocks", "blocks", "lines", "spans"):
+            child = node.get(child_key)
+            if isinstance(child, list):
+                for item in child:
+                    walk_and_fix_bboxes(item, fix, counter)
+    elif isinstance(node, list):
+        for item in node:
+            walk_and_fix_bboxes(item, fix, counter)
+
+
+def correct_middle_bbox_rotation(
+    middle: dict,
+    page_geometry: List[PageGeometry],
+    *,
+    attach_id: Optional[int] = None,
+) -> None:
+    """对 middle.json 的每页应用 bbox 旋转纠正。**就地修改** ``middle``。
+
+    检测：``/Rotate ∈ {90, 270}``。其它情况（0° / 180° / 非法值 / geometry
+    越界 / page_size 缺失）→ 跳过。
+
+    Sanity 校验：mineru 当前行为是 ``page_size`` = 未旋转 MediaBox。若实际
+    page_size 与 MediaBox 维度不匹配（说明 mineru 行为变了、可能已经在上游
+    修了 bug），打 warn 但仍按旋转纠正走 —— 防止"我们以为修了，结果 mineru
+    自己又把 bbox 旋转回去导致双重旋转"，需要人工看日志。
+
+    Args:
+        middle: middle.json 顶层 dict（应有 ``pdf_info`` 列表）
+        page_geometry: 每页 ``(mediabox_w, mediabox_h, /Rotate)``，索引按
+            页面 ``page_idx`` 对齐
+        attach_id: 仅用于日志关联，不影响行为
+    """
+    pdf_info = middle.get("pdf_info") or []
+    for page in pdf_info:
+        if not isinstance(page, dict):
+            continue
+        page_idx = page.get("page_idx", -1)
+        if not isinstance(page_idx, int) or page_idx < 0 or page_idx >= len(page_geometry):
+            continue
+        media_w, media_h, rotate = page_geometry[page_idx]
+
+        if rotate not in (90, 270):
+            # 0° / 180° / 非法 → 不动
+            continue
+
+        mineru_size = page.get("page_size") or [0, 0]
+        if len(mineru_size) < 2:
+            continue
+        try:
+            mineru_w = float(mineru_size[0])
+            mineru_h = float(mineru_size[1])
+        except (TypeError, ValueError):
+            continue
+
+        # Sanity: mineru 期望行为 = page_size 与 MediaBox 维度一致（未旋转）
+        size_matches_mediabox = (
+            abs(mineru_w - media_w) < DIM_SWAP_EPS
+            and abs(mineru_h - media_h) < DIM_SWAP_EPS
+        )
+        size_is_swapped = (
+            abs(mineru_w - media_h) < DIM_SWAP_EPS
+            and abs(mineru_h - media_w) < DIM_SWAP_EPS
+        )
+        if not size_matches_mediabox:
+            if size_is_swapped:
+                # mineru 行为可能变了：page_size 用旋转后帧。这种情况下 bbox
+                # 是已经在 mediabox 帧（mineru 自己修了 bug），还是在 display
+                # 帧（mineru 改了 page_size 但忘了改 bbox），从 JSON 看不出。
+                # 保守仍按旋转纠正走，加 warn 让人工观察。
+                log.warning(
+                    "bbox-correct: page_size W↔H swap vs MediaBox detected "
+                    "(mineru=%.0fx%.0f mediabox=%.0fx%.0f /Rotate=%d). mineru "
+                    "behavior may have changed — verify staging output before "
+                    "trusting this correction (attach=%s page_idx=%d)",
+                    mineru_w, mineru_h, media_w, media_h, rotate, attach_id, page_idx,
+                )
+            else:
+                # 完全不一致（既不匹配 MediaBox 也不是 W↔H swap）→ 异常，
+                # warn 但仍按旋转纠正走
+                log.warning(
+                    "bbox-correct: page_size %.0fx%.0f mismatches both "
+                    "MediaBox %.0fx%.0f and its swap; proceeding with rotation "
+                    "anyway (attach=%s page_idx=%d /Rotate=%d)",
+                    mineru_w, mineru_h, media_w, media_h, attach_id, page_idx, rotate,
+                )
+
+        def _fix(bbox: List[float]) -> List[float]:
+            return bbox_inverse_rotate(bbox, rotate, media_w, media_h)
+
+        counter = [0]
+        walk_and_fix_bboxes(page, _fix, counter)
+        # 把 page_size 改为 mediabox 帧；下游 _parse_middle 用 page_size[1]
+        # 做 Y 翻转时才能用对的 H_m。即使 mineru 已经写了 mediabox 也无副作用。
+        page["page_size"] = [media_w, media_h]
+        log.info(
+            "bbox-correct: rotated %d bbox(es) by inverse of /Rotate=%d "
+            "(attach=%s page_idx=%d, mineru=%.0fx%.0f → mediabox=%.0fx%.0f)",
+            counter[0], rotate, attach_id, page_idx,
+            mineru_w, mineru_h, media_w, media_h,
+        )