osis-python 0.6.5__tar.gz → 0.7.0__tar.gz

{osis_python-0.6.5/src/osis_python.egg-info → osis_python-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osis-python
-Version: 0.6.5
+Version: 0.7.0
 Summary: A Python client library for Osis APDL
 Author-email: "CCCC Highway Consultant Co. Ltd." <support@osisbim.com>
 License-Expression: MIT

{osis_python-0.6.5 → osis_python-0.7.0/src/osis_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: osis-python
-Version: 0.6.5
+Version: 0.7.0
 Summary: A Python client library for Osis APDL
 Author-email: "CCCC Highway Consultant Co. Ltd." <support@osisbim.com>
 License-Expression: MIT

{osis_python-0.6.5 → osis_python-0.7.0}/src/osis_python.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/pyosis/core/__init__.py
 src/pyosis/core/all_func.py
 src/pyosis/core/apdl_sync.py
 src/pyosis/core/basic_manager.py
+src/pyosis/core/batch.py
 src/pyosis/core/build.py
 src/pyosis/core/client.py
 src/pyosis/core/command.py
@@ -111,5 +112,6 @@ src/pyosis/transfer/out_to_python.py
 src/pyosis/transfer/parser.py
 src/pyosis/transfer/routes.py
 src/pyosis/transfer/split.py
+tests/test_batch.py
 tests/test_delete_occupied.py
 tests/test_project_manager.py

{osis_python-0.6.5 → osis_python-0.7.0}/src/pyosis/__init__.py

@@ -7,10 +7,11 @@ A library for extending OSIS functionality.
 A library that allows users to use CAE with great flexibility.
 """
 
-__version__ = "0.6.5"
+__version__ = "0.7.0"
 __author__ = "CCCC Highway Consultant Co. Ltd." # 中交公路规划设计院 - 工程技术研究中心 - lzh - wjh - myf
 
 from .core.engine import OSISEngine
+from .core.batch import batch, flush, batch_state, BatchError
 # from .core import engine
 # from .ai.agents import BaseAgent
 # from .core import osis_run

{osis_python-0.6.5 → osis_python-0.7.0}/src/pyosis/boundary/manager.py

@@ -24,6 +24,8 @@ from enum import IntEnum
 
 from ..core.client import osis_client
 from ..core import get_references, raise_if_occupied
+from ..core.basic_manager import BasicManager
+from ..core.batch import batch_state
 from .interface import (
     osis_boundary_general,
     osis_boundary_elstcspt,
@@ -386,6 +388,8 @@ class BoundaryGroup:
 
     def refresh(self) -> BoundaryGroup:
         """刷新当前边界组对象并同步到对象属性"""
+        if batch_state.active:
+            return self
         resp = osis_client("GetBoundaryGroupInfoByNames", {"name": [self.name]})
         if not resp['success']:
             raise RuntimeError(f"刷新边界组 {self.name} 失败: {resp['error']}")
@@ -476,7 +480,7 @@ class BoundaryGroup:
 # ──────────────────────────────────────────────
 
 
-class BoundaryGroupManager:
+class BoundaryGroupManager(BasicManager):
     """边界组管理器
 
     统一管理边界组的创建、删除和查询。组成员操作在 BoundaryGroup 对象上进行。
@@ -492,6 +496,7 @@ class BoundaryGroupManager:
         >>> bg.remove(1)
         >>> bg.replace("3by4")   # 组内把边界 3 替换为 4
     """
+    _entity_class = BoundaryGroup
 
     def __init__(self) -> None:
         ...
@@ -581,6 +586,10 @@ class BoundaryGroupManager:
         if not isinstance(names, list):
             raise TypeError(f"不支持的名称类型: {type(name)}")
         
+        # batch 模式：返回延迟对象（零查询），访问真实属性时才物化
+        lazy = self._batch_lazy(names)
+        if lazy is not None:
+            return lazy
         resp = osis_client("GetBoundaryGroupInfoByNames", {"name": names})
         if not resp['success']:
             raise RuntimeError(f"{resp['error']}")
@@ -620,7 +629,7 @@ class BoundaryGroupManager:
 # ──────────────────────────────────────────────
 
 
-class BoundaryManager:
+class BoundaryManager(BasicManager):
     """边界管理器
 
     统一管理边界的创建、删除、修改和查询。
@@ -635,6 +644,8 @@ class BoundaryManager:
         >>> bg.add(1, 2)
         >>> bg = boundary_manager.group.get("桥台1")
     """
+    _entity_class = Boundary
+    _entity_key_attr = "no"
 
     def __init__(self) -> None:
         self._group_manager = BoundaryGroupManager()
@@ -1029,6 +1040,10 @@ class BoundaryManager:
         elif not isinstance(no, list):
             raise TypeError(f"不支持的编号类型: {type(no)}")
 
+        # batch 模式：返回延迟对象（零查询），访问真实属性时才物化
+        lazy = self._batch_lazy(no)
+        if lazy is not None:
+            return lazy
         resp = osis_client("GetBoundaryInfoByNos", {"no": no})
         if not resp['success']:
             raise RuntimeError(f"{resp['error']}")

{osis_python-0.6.5 → osis_python-0.7.0}/src/pyosis/core/__init__.py

@@ -10,5 +10,7 @@ OSISEngine中的函数，将会分发到各个模块，被再次封装，意图
 
 from .command import REGISTRY, osis_run, set_run_mode
 from .client import set_osis_port, set_osis_url
+from .batch import batch, flush, batch_state, BatchError
+from .basic_manager import BasicManager, LazyRef
 from .exceptions import DependencyError
 from .references import get_references, raise_if_occupied

osis_python-0.7.0/src/pyosis/core/basic_manager.py

@@ -0,0 +1,179 @@
+"""manager 基类：batch 模式的延迟对象（LazyRef）与编号记账基础设施
+
+batch 模式下的 get() 语义：
+- 返回 LazyRef 延迟对象，零服务器交互
+- 身份属性 name / no 直接返回主键（链式调用 engine.XXX.get(1).create_XXX
+  只需要身份，全程不查询）
+- 访问其他任意属性/方法时才"物化"：先自动冲刷缓冲，再查询服务器取回
+  真实对象，之后完全代理真实对象（每个 LazyRef 只物化一次）
+
+manager 接入方式（每个 manager 两处小改动，与具体命令无关）：
+    class NodeManager(BasicManager):
+        def _next_no(self) -> int:
+            return self._batched_next_no(          # 1) 自动编号批内记账
+                lambda: max((n.no for n in self._load()), default=0))
+
+        def get(self, no):
+            ...编号归一化与类型检查...
+            lazy = self._batch_lazy(no)            # 2) batch 模式返回 LazyRef
+            if lazy is not None:
+                return lazy
+            ...原有服务器查询逻辑...
+"""
+
+from __future__ import annotations
+
+import functools
+from contextlib import contextmanager
+from typing import Any
+
+from .batch import batch_state
+
+
+class LazyRef:
+    """batch 模式下 get() 的延迟对象
+
+    由 BasicManager._batch_lazy 创建，用户不应直接实例化。
+    - 身份属性（name/no）零查询直通
+    - 方法访问 → 绑定到"幽灵实例"（类型正确、仅注入身份字段），
+      调用即排队命令，零服务器交互——链式调用 get().create_xxx() 的关键
+    - 数据字段访问 → 物化（冲刷 + 服务器查询）后返回真实值
+    """
+
+    __slots__ = ("_manager", "_key", "_real", "_ghost")
+
+    def __init__(self, manager: "BasicManager", key: Any) -> None:
+        object.__setattr__(self, "_manager", manager)
+        object.__setattr__(self, "_key", key)
+        object.__setattr__(self, "_real", None)
+        object.__setattr__(self, "_ghost", None)
+
+    # ── 身份属性：零查询直通 ──────────────────
+
+    @property
+    def name(self) -> Any:
+        """对象名称（即 get 的主键），物化后返回真实值"""
+        return self._key if self._real is None else self._real.name
+
+    @property
+    def no(self) -> Any:
+        """对象编号（即 get 的主键），物化后返回真实值"""
+        return self._key if self._real is None else self._real.no
+
+    # ── 幽灵实例与物化 ────────────────────────
+
+    def _ghost_method(self, attr: str):
+        """方法访问：绑定到幽灵实例（真类型 + 身份字段），调用即排队"""
+        if self._ghost is None:
+            cls = self._ghost_class()
+            ghost = object.__new__(cls)          # 不走 __init__（缺服务器数据）
+            # 身份字段双保险（object.__setattr__ 兼容 frozen dataclass）
+            object.__setattr__(ghost, "name", self._key)
+            object.__setattr__(ghost, "no", self._key)
+            object.__setattr__(self, "_ghost", ghost)
+        return getattr(self._ghost, attr)
+
+    def _ghost_class(self) -> type:
+        m = self._manager
+        return getattr(type(m), "_entity_class", None) or type(m).get.__globals__.get(
+            type(m).__name__.replace("Manager", ""), object
+        )
+
+    def _materialize(self) -> Any:
+        """冲刷缓冲并从服务器取回真实对象（每个 LazyRef 只执行一次）"""
+        if self._real is None:
+            with self._manager._no_lazy():
+                real = self._manager.get(self._key)
+            if real is None:
+                raise RuntimeError(
+                    f"batch 延迟对象物化失败：{type(self._manager).__name__} 中不存在 {self._key!r}"
+                )
+            object.__setattr__(self, "_real", real)
+        return self._real
+
+    def __getattr__(self, attr: str) -> Any:
+        # 方法 → 幽灵实例（零查询，链式调用直接排队）
+        cls = getattr(type(self._manager), "_entity_class", None)
+        if cls is not None and callable(getattr(cls, attr, None)):
+            return self._ghost_method(attr)
+        # 数据字段 → 物化后取真实值
+        return getattr(self._materialize(), attr)
+
+    def __repr__(self) -> str:
+        if self._real is not None:
+            return repr(self._real)
+        return f"LazyRef({type(self._manager).__name__}, {self._key!r})"
+
+
+class BasicManager:
+    """所有 manager 的基类（batch 延迟对象 + 自动编号守卫）
+
+    子类可声明（用于 LazyRef 的链式调用优化，方法访问零查询直通排队）：
+    - _entity_class: 该 manager 管理的数据类（如 ElementGroup）
+    - _entity_key_attr: 身份字段名（"name" 或 "no"，默认 "name"）
+    """
+
+    _entity_class: type | None = None
+    _entity_key_attr: str = "name"
+    _no_lazy_flag: bool = False
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        super().__init_subclass__(**kwargs)
+        # 自动包装子类定义的 _next_no：batch 模式下直接报错（自动编号需要
+        # 拉全量查询，会打断批量；批内请显式传编号）。子类无需任何配合代码。
+        orig = cls.__dict__.get("_next_no")
+        if orig is not None and not getattr(orig, "_batch_guarded", False):
+            @functools.wraps(orig)
+            def _next_no(self, *args, **kw):
+                if batch_state.active:
+                    raise RuntimeError(
+                        "batch 模式下不支持自动编号（查询最大编号会打断批量）："
+                        "请显式传入编号，或退出 batch 后再使用自动编号"
+                    )
+                return orig(self, *args, **kw)
+
+            _next_no._batch_guarded = True
+            cls._next_no = _next_no
+
+    # ── 原有骨架保留（兼容旧引用） ─────────────
+
+    def create(self, *args, **kwargs):
+        pass
+
+    def get(self, *args, **kwargs):
+        pass
+
+    def all(self, *args, **kwargs):
+        pass
+
+    def delete(self, *args, **kwargs):
+        pass
+
+    def clear(self, *args, **kwargs):
+        pass
+
+    # ── 子类工具方法 ──────────────────────────
+
+    def _batch_lazy(self, keys: list) -> Any:
+        """batch 模式下为 get() 构造延迟对象
+
+        Args:
+            keys: 已归一化的主键列表（调用方完成类型检查与归一化后传入）
+
+        Returns:
+            单个 LazyRef（keys 长度为 1）或 LazyRef 列表；
+            非 batch 模式（或物化过程中）返回 None，调用方走原有查询逻辑
+        """
+        if not batch_state.active or self._no_lazy_flag or not keys:
+            return None
+        refs = [LazyRef(self, k) for k in keys]
+        return refs[0] if len(refs) == 1 else refs
+
+    @contextmanager
+    def _no_lazy(self):
+        """临时关闭延迟语义（LazyRef 物化时回查服务器用）"""
+        self._no_lazy_flag = True
+        try:
+            yield
+        finally:
+            self._no_lazy_flag = False

osis_python-0.7.0/src/pyosis/core/batch.py

@@ -0,0 +1,173 @@
+"""命令批量执行（batch）核心
+
+设计要点：
+- 任何经 REGISTRY 注册的命令函数在 batch 激活时都只进本地缓冲，退出 with 时
+  拼成一条命令流、一次 /OSIS_Run 发送（服务端 SplitOsisCommands + 单次 Execution）
+- 查询类调用（osis_client 的所有接口，含用户直接调用的 OSIS_Run）会先自动冲刷
+  缓冲，保证查询永远看到"已执行完毕"的状态
+- manager 通过影子工厂表（BasicManager._shadow_factories）在命令入缓冲时登记
+  影子对象，使 create 尾部的回查 get() 命中本地影子而不触发冲刷
+- 错误策略：冲刷失败抛 BatchError（附 OSIS 原文）；不重试、不退避、默认不二分
+  （isolate=True 可选二分定位坏命令，仅供调试，无 sleep）
+
+用法:
+    >>> import pyosis
+    >>> with pyosis.batch():
+    ...     for i in range(1000):
+    ...         engine.element.create_beam3d(None, i, i + 1, 1, 1, 1)
+    ...  # 退出 with 时 1000 条命令一次发送
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Any, Callable, Iterator
+
+from .client import osis_client
+
+
+class BatchError(RuntimeError):
+    """批量冲刷失败
+
+    Attributes:
+        error: OSIS 返回的错误原文
+        failed: 定位到的失败命令列表（isolate 模式下逐条列出，否则为空）
+        executed: 冲刷前缓冲中的命令总数
+    """
+
+    def __init__(self, error: str, failed: list[str] | None = None, executed: int = 0):
+        self.error = error
+        self.failed = failed or []
+        self.executed = executed
+        msg = f"批量冲刷失败（共 {executed} 条命令）: {error}"
+        if self.failed:
+            lines = "\n".join(f"  [FAIL] {c}" for c in self.failed)
+            msg += f"\n失败命令（{len(self.failed)} 条）:\n{lines}"
+        super().__init__(msg)
+
+
+class _BatchState:
+    """batch 全局状态（模块级单例 batch_state）"""
+
+    def __init__(self) -> None:
+        self.buffer: list[str] = []       # 已入队的命令流（每条自带分号终止符）
+        self.depth: int = 0               # batch 嵌套深度，>0 表示激活
+        self.flushing: bool = False       # 冲刷进行中（防止拦截器递归冲刷）
+
+    @property
+    def active(self) -> bool:
+        """batch 模式是否激活"""
+        return self.depth > 0
+
+
+batch_state = _BatchState()
+
+
+# ──────────────────────────────────────────────
+# 冲刷
+# ──────────────────────────────────────────────
+
+def flush(
+    isolate: bool = False,
+    timeout: float | None = None,
+    max_size: int | None = None,
+) -> int:
+    '''冲刷缓冲：把已入队的全部命令拼成一条流，一次 /OSIS_Run 发送
+
+    一般无需手动调用——退出 batch 上下文或任何查询调用都会自动冲刷。
+
+    Args:
+        isolate (bool): 冲刷失败时是否二分定位失败命令（仅供调试，
+            无重试无退避；二分重放假设失败命令本身无副作用残留）
+        timeout (float): HTTP 超时秒数，默认 600（大批量 Execution 耗时较长）
+        max_size (int): 单次请求最大命令条数，默认不限（一次全发）。
+            超大模型可设 5000 之类的安全阀，将分多次请求发送
+
+    Returns:
+        int: 本次冲刷发送的命令条数
+
+    Raises:
+        BatchError: OSIS 返回失败时抛出（isolate=True 时附失败命令清单）
+    '''
+    if batch_state.flushing or not batch_state.buffer:
+        return 0
+    cmds = batch_state.buffer[:]
+    batch_state.buffer.clear()
+    batch_state.flushing = True
+    try:
+        chunks = (
+            [cmds[i:i + max_size] for i in range(0, len(cmds), max_size)]
+            if max_size else [cmds]
+        )
+        failed: list[str] = []
+        for chunk in chunks:
+            failed += _send(chunk, isolate=isolate, timeout=timeout)
+        if failed:
+            raise BatchError(
+                failed_error(failed),
+                failed=[c.split("||", 1)[1] for c in failed],
+                executed=len(cmds),
+            )
+        return len(cmds)
+    finally:
+        batch_state.flushing = False
+
+
+def failed_error(failed: list[str]) -> str:
+    """汇总失败命令对应的 OSIS 错误信息（_send 记录在命令前缀）"""
+    errs = {c.split("||", 1)[0] for c in failed if "||" in c}
+    return "; ".join(errs) or "未知错误"
+
+
+def _send(cmds: list[str], isolate: bool = False, timeout: float | None = None) -> list[str]:
+    """发送一组命令，返回失败命令列表（"错误||命令" 格式；成功返回空表）"""
+    stream = "".join(cmds)
+    resp = osis_client(
+        "OSIS_Run",
+        {"strCmd": stream, "mode": "exec"},
+        timeout=timeout if timeout is not None else 600,
+    )
+    if resp.get("success"):
+        return []
+    err = resp.get("error", "")
+    if not isolate or len(cmds) == 1:
+        return [f"{err}||{cmds[0]}"] if len(cmds) == 1 else [f"{err}||(共{len(cmds)}条)"]
+    # 二分定位：无重试无退避，把坏命令找出来
+    mid = len(cmds) // 2
+    return _send(cmds[:mid], True, timeout) + _send(cmds[mid:], True, timeout)
+
+
+# ──────────────────────────────────────────────
+# batch 上下文
+# ──────────────────────────────────────────────
+
+@contextmanager
+def batch() -> Iterator[None]:
+    '''batch 模式上下文：内部所有命令只进缓冲，退出时一次性发送
+
+    >>> with pyosis.batch():
+    ...     engine.node.create(None, 0, 0, 0)
+    ...     engine.node.create(None, 1, 0, 0)
+    ...     element_manager.create_beam3d(None, 1, 2, 1, 1, 1)
+    ... # 退出时 3 条命令拼成一条流，一次 HTTP 请求
+
+    规则:
+        * 正常退出：自动 flush()，缓冲内全部命令一次执行
+        * 异常退出：丢弃本次进入后新增的缓冲命令并抛出原异常
+          （半截模型不落盘；需要保留请自行 try/finally + flush()）
+        * 支持嵌套：内层退出不冲刷，最外层退出才统一冲刷
+        * 期间任何查询（get/all/solve/用户直接 osis_run 等）会先自动
+          冲刷缓冲再执行，保证查询结果实时
+    '''
+    batch_state.depth += 1
+    added = len(batch_state.buffer)
+    try:
+        yield
+    except BaseException:
+        del batch_state.buffer[added:]
+        batch_state.depth -= 1
+        raise
+    else:
+        batch_state.depth -= 1
+        if batch_state.depth == 0:
+            flush()