pilot.linkstec 0.0.32__py3-none-any.whl → 0.0.91__py3-none-any.whl

pilot/db/sql_loader.py

@@ -0,0 +1,233 @@
+# --------------------------------------------------------------
+# sql_loader.py – 通用的 SQL 加载 / 参数渲染工具
+# --------------------------------------------------------------
+import pathlib
+import re
+from typing import Any, Mapping, Tuple, Union, Iterable, List
+import importlib.resources as pkg_resources   # Python 3.7+
+
+# ------------------------------------------------------------------
+# 默认根目录：与本文件同级的 “sql” 目录（保持向后兼容）
+# ------------------------------------------------------------------
+DEFAULT_SQL_ROOT = pathlib.Path(__file__).parent
+
+
+def _read_from_filesystem(root: pathlib.Path, relative_path: str) -> str:
+    """
+    从磁盘文件系统读取 SQL。
+    参数
+    ----
+    root : pathlib.Path
+        sql 根目录（例如 Path('sql')）
+    relative_path : str
+        相对于根目录的路径，如 'ddl/create_user_table.sql'
+    """
+    file_path = root / relative_path
+    if not file_path.is_file():
+        raise FileNotFoundError(f"SQL file not found: {file_path}")
+    return file_path.read_text(encoding="utf-8")
+
+
+def _read_from_package(package: str, relative_path: str) -> str:
+    """
+    从 Python 包（资源）读取 SQL。
+    参数
+    ----
+    package : str
+        包名，例如 'dml'、'my_project.dml'
+    relative_path : str
+        包内部的相对路径，如 'ddl/create_user_table.sql'
+    """
+    # pkg_resources.open_text 会自动处理编码、BOM 等细节
+    try:
+        with pkg_resources.open_text(package, relative_path,
+                                     encoding="utf-8-sig") as f:
+            return f.read()
+    except FileNotFoundError as exc:
+        raise FileNotFoundError(
+            f"SQL resource not found: package={package!r}, file={relative_path}"
+        ) from exc
+
+
+def _read_sql_file(relative_path: str,
+                   base_path: Union[pathlib.Path, str] = DEFAULT_SQL_ROOT
+                   ) -> str:
+    """
+    统一入口：根据 ``base_path`` 类型决定读取方式。
+    * Path   → 从磁盘文件系统读取
+    * str    → 当作包名，使用 importlib.resources 读取资源文件
+    """
+    if isinstance(base_path, pathlib.Path):
+        return _read_from_filesystem(base_path, relative_path)
+    elif isinstance(base_path, str):
+        return _read_from_package(base_path, relative_path)
+    else:
+        raise TypeError(
+            "base_path 必须是 pathlib.Path（文件系统）或 str（包名），"
+            f"实际得到 {type(base_path)!r}"
+        )
+
+
+# ----------------------------------------------------------------------
+# 1️⃣ 正则：捕获 MyBatis‐style #{name} / ${name}
+# ----------------------------------------------------------------------
+_RE_PLACEHOLDER = re.compile(r'''
+    (?:\#|\$)          # 开头是 # 或 $
+    \{                 # 左花括号
+    \s*                # 可选空白
+    (?P<name>[^}]+?)   # 参数名（非贪婪）
+    \s*                # 可选空白
+    \}                 # 右花括号
+''', re.VERBOSE)
+
+
+def _replace_mybatis_placeholders(sql: str,
+                                 use_named: bool) -> Tuple[str, List[str]]:
+    """
+    把 ``#{name}`` / ``${name}`` 替换为 SQLite 占位符。
+
+    Parameters
+    ----------
+    sql : str
+        原始 SQL（可能包含 MyBatis 占位符）。
+    use_named : bool
+        * ``True``  → 使用命名占位符 ``:name``；
+        * ``False`` → 使用位置占位符 ``?``.
+
+    Returns
+    -------
+    Tuple[str, List[str]]
+        * 第 1 项：替换后的 SQL。
+        * 第 2 项：出现的参数名顺序列表（仅在 ``use_named=False`` 时有意义）。
+    """
+    if use_named:        # 直接把 #{xxx} 替换为 :xxx
+        new_sql = _RE_PLACEHOLDER.sub(lambda m: f":{m.group('name').strip()}", sql)
+        return new_sql, []                     # 参数顺序不需要
+
+    else:
+        # 把所有占位符统一为 “?”
+        names: List[str] = []
+
+        def repl(m: re.Match) -> str:
+            names.append(m.group('name').strip())
+            return "?"
+
+        new_sql = _RE_PLACEHOLDER.sub(repl, sql)
+        return new_sql, names
+
+
+# ----------------------------------------------------------------------
+# 2️⃣ 主函数
+# ----------------------------------------------------------------------
+def render_sql(
+    template: str,
+    params: Union[Mapping[str, Any], Iterable[Any], None] = None,
+) -> Tuple[
+    str,
+    Union[Mapping[str, Any], Tuple[Any, ...]]
+]:
+
+    # -------------------------------------------------
+    # ① 参数为 None → 只做占位符统一（全部转成 ?）
+    # -------------------------------------------------
+    if params is None:
+        new_sql, _ = _replace_mybatis_placeholders(template, use_named=False)
+        return new_sql, ()
+
+    # -------------------------------------------------
+    # ② 参数为 Mapping → 使用命名占位符
+    # -------------------------------------------------
+    if isinstance(params, Mapping):
+        new_sql, _ = _replace_mybatis_placeholders(template, use_named=True)
+        return new_sql, params
+
+    # -------------------------------------------------
+    # ③ 参数为 Iterable（但不是 Mapping） → 使用位置占位符
+    # -------------------------------------------------
+    if isinstance(params, Iterable):
+        # 先把模板里的 MyBatis 占位符全部换成 ?
+        new_sql, name_order = _replace_mybatis_placeholders(template,
+                                                          use_named=False)
+
+        # 1) 如果用户本来就传的是 list/tuple 等，直接转 tuple
+        # 2) 如果用户误把 dict 当成 Iterable（dict 本身是 Iterable），
+        #    那么我们把它当作 Mapping 处理，以免产生错误的顺序。
+        if isinstance(params, Mapping):
+            # 把 dict 按 name_order 取值，保持顺序一致
+            ordered_vals = tuple(params[name] for name in name_order)
+        else:
+            ordered_vals = tuple(params)
+
+        # 当模板里没有 MyBatis 占位符时 name_order 为 []，此时
+        # ordered_vals 仍然是用户提供的 tuple/list → 正常使用。
+        return new_sql, ordered_vals
+
+    # -------------------------------------------------
+    # ④ 其它类型（不应该出现） → 抛出友好错误
+    # -------------------------------------------------
+    raise TypeError(
+        "params 必须是 Mapping、Iterable 或 None，"
+        f"但收到的是 {type(params)!r}"
+    )
+
+
+# ------------------------------------------------------------------
+# 一站式加载 + 渲染
+# ------------------------------------------------------------------
+def load_sql(relative_path: str,
+             params: Union[Mapping[str, Any],
+                          Iterable[Any],
+                          None] = None,
+             base_path: Union[pathlib.Path, str] = DEFAULT_SQL_ROOT
+             ) -> Tuple[str,
+                        Union[Mapping[str, Any], Tuple[Any, ...]]]:
+    """
+    读取 SQL →（可选）渲染参数 → 返回 ``(sql, parameters)``。
+
+    参数
+    ----
+    relative_path : str
+        相对于根目录/包的路径，如 ``'ddl/create_user_table.sql'``。
+    params        : Mapping / Iterable / None
+        传给 ``sqlite3`` 的参数对象，渲染规则同 ``render_sql``。
+    base_path     : pathlib.Path | str
+        *Path* → 读取磁盘目录（默认 ``DEFAULT_SQL_ROOT``）<br>
+        *str*  → 当作 **包名**，使用 ``importlib.resources`` 从包中读取。
+    """
+    raw_sql = _read_sql_file(relative_path, base_path=base_path)
+    # -------------------------------------------------
+    # ① 若傳入的 params 含有 `values_str`（pattern‑2 用法）
+    # -------------------------------------------------
+    if isinstance(params, Mapping) and "values_str" in params:
+        # 把傳入的二元組列表渲染成 VALUES‑list
+        values_sql = _render_values_str(params["values_str"])
+        # 替換模板中預留的佔位符（我們約定使用 /*{values_str}*/）
+        raw_sql = raw_sql.replace("/*{values_str}*/", values_sql)
+
+        # 把 `values_str` 從 params 中剔除，避免後續被當成普通參數傳給 sqlite3
+        # （如果你想保留其他命名參數，仍然可以放在同一個 dict 中）
+        params = {k: v for k, v in params.items() if k != "values_str"}
+
+    return render_sql(raw_sql, params)
+
+# ----------------------------------------------------------------------
+# ② 把 values_str 渲染成 VALUES‑list ------------------------------------
+# ----------------------------------------------------------------------
+def _render_values_str(
+    values: Iterable[Tuple[Any, Any]]
+) -> str:
+    """
+    把 [(cls1, sub1), (cls2, sub2), …] 轉成
+
+        ('cls1','sub1'),('cls2','sub2'),...
+
+    只在 pattern‑2 中使用。會自動把單引號轉義為兩個單引號。
+    """
+    def esc(v: Any) -> str:
+        # 只處理字串型別，其他類型直接轉成 str
+        if isinstance(v, str):
+            return v.replace("'", "''")
+        return str(v)
+
+    rows = [f"('{esc(c)}', '{esc(s)}')" for c, s in values]
+    return ",\n".join(rows)

pilot/db/sql_service.py

@@ -0,0 +1,55 @@
+from typing import Dict, Any
+from db.db_util import exec_insert, exec_select, exec_update, exec_delete
+
+
+# insert文を呼出
+def insert_sql_info(key:str, params: Dict[str, Any]):
+    exec_insert(key, params)
+
+# select文を呼出
+def select_sql_info(key:str, params: Dict[str, Any]):
+    result_rows = exec_select(key, params)
+
+    if not result_rows:
+        return []
+    return [row_to_dict(r) for r in result_rows]
+
+# update文を呼出
+def update_sql_info(key:str, params: Dict[str, Any]):
+    exec_update(key, params)
+
+# delete文を呼出
+def delete_sql_info(key:str, params: Dict[str, Any]):
+    exec_delete(key, params)
+
+def row_to_dict(row: Any) -> Dict[str, Any]:
+    """
+    把数据库返回的“行对象”统一转换为普通 dict。
+    支持：
+      - sqlite3.Row               -> dict(row)
+      - SQLAlchemy RowProxy       -> dict(row._mapping)   (SQLA >=1.4)
+      - SQLAlchemy legacy RowProxy-> row._asdict()
+      - MyBatis‑Python ResultSet  -> dict(row)
+    如有其它库，只需在这里补充对应的转换方式。
+    """
+    # sqlite3.Row 直接可迭代 (key, value) 对
+    if isinstance(row, dict):
+        return row                     # 已经是 dict，直接返回
+
+    try:
+        # SQLAlchemy 1.4+ Row (has ._mapping)
+        return dict(row._mapping)      # type: ignore[attr-defined]
+    except AttributeError:
+        pass
+
+    try:
+        # SQLAlchemy 1.3‑ RowProxy (has ._asdict())
+        return row._asdict()           # type: ignore[attr-defined]
+    except AttributeError:
+        pass
+
+    try:
+        # 任何实现了 __iter__ 且返回 (key, value) 的对象（如 sqlite3.Row）
+        return dict(row)
+    except Exception as exc:
+        raise TypeError(f"Cannot convert row of type {type(row)} to dict") from exc

pilot/file_tool/create_prompt_file.py

@@ -0,0 +1,75 @@
+import pathlib
+import re
+from typing import Mapping, Optional
+
+
+def load_text(file_path: str | pathlib.Path) -> str:
+    """讀取檔案內容，返回 Unicode 字串。"""
+    path = pathlib.Path(file_path)
+    if not path.is_file():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    return path.read_text(encoding='utf-8')
+
+def replace_by_map(
+    text: str,
+    replace_map: Mapping[str, str],
+    *,
+    use_regex: bool = False,
+    case_sensitive: bool = True,
+) -> str:
+
+    if not replace_map:
+        return text
+
+    # 若使用正則，先把所有 pattern 編譯好，提高效能
+    if use_regex:
+        flags = 0 if case_sensitive else re.IGNORECASE
+        compiled = [(re.compile(p, flags), repl) for p, repl in replace_map.items()]
+        for pattern, repl in compiled:
+            text = pattern.sub(repl, text)
+    else:
+        # 直接使用 str.replace，速度最快
+        for old, new in replace_map.items():
+
+            text = text.replace(old, new)
+
+    return text
+
+def save_text(
+    file_path: str | pathlib.Path,
+    text: str,
+    *,
+    encoding: Optional[str] = None,
+) -> None:
+
+    path = pathlib.Path(file_path)
+    if not path.parent.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+
+    enc = encoding or "utf-8"
+    path.write_text(text, encoding=enc)
+
+def process_file(
+    src_path: str | pathlib.Path,
+    dst_path: Optional[str | pathlib.Path] = None,
+    replace_map: Optional[Mapping[str, str]] = None,
+    *,
+    use_regex: bool = False,
+    case_sensitive: bool = True,
+) -> None:
+
+    original = load_text(src_path)
+
+    if replace_map:
+        new_text = replace_by_map(
+            original,
+            replace_map,
+            use_regex=use_regex,
+            case_sensitive=case_sensitive,
+        )
+    else:
+        new_text = original
+
+    target = dst_path if dst_path is not None else src_path
+    save_text(target, new_text)

pilot/file_tool/json_file_tool.py

@@ -0,0 +1,103 @@
+import json
+from pathlib import Path
+from typing import List, Dict, Any, Sequence
+
+
+# -------------------------------------------------
+# 读取映射 JSON（返回 list[dict]）
+# -------------------------------------------------
+def load_mapping(json_path: Path) -> List[Dict[str, str]]:
+    """
+    参数
+    ----
+    json_path : Path
+        包含 {"table_name": "...", "table_name_jp": "..."} 记录的 JSON 文件
+
+    返回
+    ----
+    List[Dict[str, str]]
+        直接返回 JSON 中的数组对象，后面会用它做查找
+    """
+    if not json_path.is_file():
+        raise FileNotFoundError(f"映射文件不存在: {json_path}")
+    return json.loads(json_path.read_text(encoding="utf-8"))
+
+def get_json_items(
+    source_keys: List[str],
+    json_file_path: str,
+    *,
+    src_field: str = "key",
+    dst_fields: Sequence[str] = ("value",),
+    default: Any = None,
+    extra_fields: Sequence[str] = (),
+    result_key_prefix: str = "",
+) -> List[Dict[str, Any]]:
+    """
+    通用映射函数（支持一次提取多个目标字段）。
+
+    参数
+    ----
+    source_keys : List[str]
+        待映射的键列表（如表名、代码等）。
+    mapping_array : List[Dict[str, Any]]
+        从 JSON 读取的映射记录，每条记录必须至少包含 ``src_field`` 与
+        所有在 ``dst_fields`` 中列出的字段。
+    src_field : str, default "key"
+        用来匹配 ``source_keys`` 的字段名。
+    dst_fields : Sequence[str], default ("value",)
+        需要一次性提取的 **一个或多个** 目标字段名。
+    default : Any, default None
+        当 ``source_keys`` 在映射中找不到时使用的默认值。
+    extra_fields : Sequence[str], default ()
+        需要把映射记录里额外字段原样复制到结果中的键名列表。
+    result_key_prefix : str, default ""
+        给返回的字段名前加统一前缀（例如 ``"tbl_"``），防止键冲突。
+
+    返回
+    ----
+    List[Dict[str, Any]]
+        每条记录形如：
+        {
+            "<prefix><src_field>"   : "...",      # 原始键
+            "<prefix><dst1>"        : "...",
+            "<prefix><dst2>"        : "...",
+            ... extra_fields ...
+        }
+    """
+    # -------------------------------------------------
+    # 1️⃣ 把映射数组转成 dict，便于 O(1) 查找
+    # -------------------------------------------------
+
+    mapping_array = load_mapping(Path(json_file_path))
+
+    lookup: Dict[Any, Dict[str, Any]] = {}
+    for rec in mapping_array:
+        key = rec.get(src_field)
+        if key is not None:               # 跳过缺失 src_field 的脏数据
+            lookup[key] = rec
+
+    # -------------------------------------------------
+    # 2️⃣ 构造结果列表
+    # -------------------------------------------------
+    result: List[Dict[str, Any]] = []
+    for k in source_keys:
+        rec = lookup.get(k)               # 可能为 None
+
+        # 基础字段（原始键）
+        item: Dict[str, Any] = {
+            f"{result_key_prefix}{src_field}": k,
+        }
+
+        # 目标字段们
+        for dst in dst_fields:
+            value = rec.get(dst, default) if rec else default
+            item[f"{result_key_prefix}{dst}"] = value
+
+        # 额外字段（若有对应记录则复制，否则填 default）
+        for extra in extra_fields:
+            item[f"{result_key_prefix}{extra}"] = (
+                rec.get(extra, default) if rec else default
+            )
+        result.append(item)
+
+    return result

pilot/job/base/convert/encodingTransformerJob.py

@@ -0,0 +1,16 @@
+import threading
+
+from pilot.job.impl.base_job import BaseJob
+
+from pilot.conver.converfileEncodding import nkf_convert
+
+
+class EncodingTransformerJob(BaseJob):
+    _begin_file_lock = threading.Lock()
+    def run(self):
+        with self._begin_file_lock:
+            if not self.change_current_trg_to_begin():
+                return
+        nkf_args = ['-w', '--overwrite']
+        nkf_convert(self.file_path, nkf_args)
+        super().run()

pilot/job/base/convert/tabReplaceJob.py

@@ -0,0 +1,27 @@
+import threading
+from pathlib import Path
+
+from pilot.job.impl.base_job import BaseJob
+
+class TabReplaceJob(BaseJob):
+    _begin_file_lock = threading.Lock()
+    def run(self):
+        with self._begin_file_lock:
+            if not self.change_current_trg_to_begin():
+                return
+        self.replace_tabs_with_spaces()
+        super().run()
+
+    def replace_tabs_with_spaces(self, tab_width: int = 4):
+        replaced_text =[]
+        src_path = Path(self.file_path)
+        spaces = ' ' * tab_width
+        with open(self.file_path, 'r', encoding='utf-8', newline='') as rf:
+            for line in rf:
+                replaced_text.append(line.replace('\t', spaces))
+
+        tmp_path = src_path.parent / (src_path.name + '.tmp')
+        with open(tmp_path, 'w', encoding='utf-8', newline='') as wf:
+            wf.writelines(replaced_text)
+
+        tmp_path.replace(src_path)

pilot/job/base/generate/generateJsonBaseJob.py

@@ -0,0 +1,42 @@
+import json
+import os
+import threading
+import time
+
+from pilot.job.impl.base_job import BaseJob
+
+from pilot.generater.vertexai import VertexAISingleton
+
+class generateJsonBaseJob(BaseJob):
+
+    prompt_content: str
+    result_content: str
+    result_file_path: str
+
+    def run(self):
+        #with self._begin_file_lock:
+        #    if not self.change_current_trg_to_begin():
+        #        return
+        #prompt = self.get_file_content()
+        prompt = self.prompt_content
+        # トークン数チェック
+        vertexai = VertexAISingleton.get_instance()
+        token_count = vertexai.count_tokens(prompt)
+        if token_count == 0:
+            super().run()
+            return
+        if token_count > 900000:
+            print(f"警告: promptのトークン数が900000を超えています ({token_count} tokens)")
+            super().run()
+            return
+        # VertexAI で生成
+        start = time.time()
+        result = vertexai.generate_content(prompt)
+        end = time.time()
+        print(f"Ai 処理時間 {self.file_path}: {end - start:.2f}秒")
+
+        result_content = result.get('response', '')
+        data = json.loads(result_content)
+        with open(self.result_file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        super().run()

pilot/job/base/generate/generateTextBaseJob.py

@@ -0,0 +1,40 @@
+import json
+import os
+import threading
+import time
+
+from pilot.job.impl.base_job import BaseJob
+
+from pilot.generater.vertexai import VertexAISingleton
+
+class textBaseJob(BaseJob):
+
+    prompt_content: str
+    result_content: str
+    result_file_path: str
+
+    def run(self):
+        #with self._begin_file_lock:
+        #    if not self.change_current_trg_to_begin():
+        #        return
+        #prompt = self.get_file_content()
+        prompt = self.prompt_content
+        # トークン数チェック
+        vertexai = VertexAISingleton.get_instance()
+        token_count = vertexai.count_tokens(prompt)
+        if token_count == 0:
+            super().run()
+            return
+        if token_count > 900000:
+            print(f"警告: promptのトークン数が900000を超えています ({token_count} tokens)")
+            super().run()
+            return
+        # VertexAI で生成
+        start = time.time()
+        result = vertexai.generate_content(prompt)
+        end = time.time()
+        print(f"AI 処理時間 {self.file_path}: {end - start:.2f}秒")
+        result_content = result.get('response', '')
+        with open(self.result_file_path, 'w', encoding='utf-8') as f:
+            f.write(result_content)
+        super().run()

pilot/job/impl/base_job.py

@@ -67,7 +67,11 @@ class BaseJob(JobInterface):
         self._trg_file_path = value
 
 
+    def prerun(self):
+        pass
 
+    def postrun(self):
+        self.change_current_trg_to_end()
 
     def run(self):
         pass

pilot/unit/impl/base_unit.py

@@ -31,6 +31,7 @@ class BaseUnit(UnitInterface):
                 job.file_path = file_path
                 if self.job_need_run(job, filename, index):
                     job.run()
+                    job.postrun()
 
     def job_need_run(self, job:BaseJob,filename: str,index):
         return True

{pilot_linkstec-0.0.32.dist-info → pilot_linkstec-0.0.91.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pilot.linkstec
-Version: 0.0.32
+Version: 0.0.91
 Summary: pilot of the ship, a tool for managing and deploying Python projects.
 Author-email: wanglr <wanglr1980@gmail.com>
 License-Expression: MIT