stbkit 0.1.0a9.dev1__py3-none-any.whl

stbkit/tools/converters/_internal/pipeline/stb_pipeline.py

@@ -0,0 +1,226 @@
+# Copyright 2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal, cast
+
+from stbkit.core import stb_io
+from stbkit.core._internal.constants import (
+    DEFAULT_MAX_XML_SIZE,
+    LATEST_STB_VERSION,
+)
+from stbkit.core.data_model.common import StBridgeRoot
+from stbkit.core.stb_exceptions import UnsupportedStbVersionError
+from stbkit.core.stb_reporting import NullReporter
+from stbkit.core.stb_typing import StbVersion
+
+from ...._internal.stb_repair._stb_repair import repair_stb
+from ....upgrade._internal.upgrade import upgrade_to
+from .data import (
+    _DataFormat,
+    _FileData,
+    _FileFormat,
+    _ObjectData,
+    _StbVersion,
+    _TextData,
+)
+from .step import _ExecutableStep, _ExecutionContext, _ExecutionResult
+
+
+def _get_pipeline_stb_version(stb: StBridgeRoot) -> _StbVersion:
+    try:
+        return _StbVersion(stb.version)
+    except ValueError:
+        return _StbVersion.UNSPECIFIED
+
+
+def _get_load_stb_version(version: _StbVersion) -> StbVersion | None:
+    if version == _StbVersion.UNSPECIFIED:
+        return None
+    if version == _StbVersion.LATEST:
+        return LATEST_STB_VERSION
+    return cast(StbVersion, version.value)
+
+
+class StbFileData(_FileData):
+    def __init__(
+        self,
+        path: Path,
+        *,
+        stb_version: _StbVersion = _StbVersion.UNSPECIFIED,
+        encoding: str | None = None,
+    ) -> None:
+        super().__init__(
+            format=_DataFormat.STB,
+            path=path,
+            file_format=_FileFormat.XML,
+            stb_version=stb_version,
+            encoding=encoding,
+        )
+
+
+class StbTextData(_TextData):
+    def __init__(
+        self,
+        text: str,
+        *,
+        stb_version: _StbVersion = _StbVersion.UNSPECIFIED,
+        has_xml_declaration: bool = True,
+    ) -> None:
+        self.has_xml_declaration: bool = has_xml_declaration
+        super().__init__(
+            format=_DataFormat.STB,
+            text=text,
+            file_format=_FileFormat.XML,
+            stb_version=stb_version,
+        )
+
+
+class StbData[TStb: StBridgeRoot](_ObjectData[TStb]):
+    def __init__(self, value: TStb, stb_version: _StbVersion) -> None:
+        super().__init__(format=_DataFormat.STB, value=value, stb_version=stb_version)
+
+
+class StbUnspecifiedData(StbData[StBridgeRoot]):
+    def __init__(self, value: StBridgeRoot) -> None:
+        super().__init__(value=value, stb_version=_StbVersion.UNSPECIFIED)
+
+
+class StbLoadStep(_ExecutableStep[StbFileData | StbTextData, StbData[StBridgeRoot]]):
+    name = "STB Load"
+
+    def execute(
+        self,
+        data: StbFileData | StbTextData,
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[StbData[StBridgeRoot]]:
+        stb: StBridgeRoot
+        version = _get_load_stb_version(data.stb_version or _StbVersion.UNSPECIFIED)
+        max_size: int = (
+            context.max_size if context.max_size is not None else DEFAULT_MAX_XML_SIZE
+        )
+        if isinstance(data, StbTextData):
+            stb = stb_io.loads(
+                data.text,
+                version=version,
+                max_size=max_size,
+                reporter=context.reporter,
+            )
+        else:
+            stb = stb_io.load(
+                data.path,
+                version=version,
+                encoding=data.encoding,
+                max_size=max_size,
+                reporter=context.reporter,
+            )
+        return _ExecutionResult(output=StbData(stb, _get_pipeline_stb_version(stb)))
+
+
+class StbDumpsStep[TStb: StBridgeRoot](_ExecutableStep[StbData[TStb], StbTextData]):
+    name = "STB Dump"
+
+    def execute(
+        self,
+        data: StbData[TStb],
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[StbTextData]:
+        text = stb_io.dumps(data.value, reporter=context.reporter)
+        return _ExecutionResult(
+            output=StbTextData(
+                text,
+                stb_version=data.stb_version or _StbVersion.UNSPECIFIED,
+            )
+        )
+
+
+@dataclass(frozen=True)
+class StbToVersionStep(_ExecutableStep[StbData[StBridgeRoot], StbData[StBridgeRoot]]):
+    """ST-Bridgeを指定されたバージョンへ更新するステップ。"""
+
+    target_version: _StbVersion
+    name: str = field(init=False)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "name", f"STB -> {self.target_version.value}")
+
+    def execute(
+        self,
+        data: StbData[StBridgeRoot],
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[StbData[StBridgeRoot]]:
+        if self.target_version in (
+            _StbVersion.LATEST,
+            _StbVersion.UNSPECIFIED,
+        ):
+            raise ValueError(
+                "StbToVersionStepには具体的なST-Bridgeバージョンを指定してください"
+            )
+
+        actual_version = _get_pipeline_stb_version(data.value)
+        if actual_version == self.target_version:
+            return _ExecutionResult(output=StbData(data.value, self.target_version))
+
+        target_version: Literal["2.0.1", "2.0.2", "2.1.0", "2.1.1"]
+        match self.target_version:
+            case _StbVersion.V2_0_1:
+                target_version = "2.0.1"
+            case _StbVersion.V2_0_2:
+                target_version = "2.0.2"
+            case _StbVersion.V2_1_0:
+                target_version = "2.1.0"
+            case _StbVersion.V2_1_1:
+                target_version = "2.1.1"
+            case _StbVersion.V2_0_0:
+                raise UnsupportedStbVersionError("2.0.0への変換")
+            case _:
+                raise ValueError(
+                    "StbToVersionStepには具体的なST-Bridgeバージョンを指定してください"
+                )
+
+        converted: StBridgeRoot = upgrade_to(
+            data.value,
+            to_version=target_version,
+            reporter=context.reporter,
+        )
+
+        return _ExecutionResult(output=StbData(converted, self.target_version))
+
+
+class StbAssignGuidsStep[TStb: StBridgeRoot](
+    _ExecutableStep[StbData[TStb], StbData[TStb]]
+):
+    """ST-Bridge内のguid未設定要素へguidを割り当てるステップ"""
+
+    name = "STB Assign GUIDs"
+
+    def execute(
+        self,
+        data: StbData[TStb],
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[StbData[TStb]]:
+        from stbkit.core._internal.transform.guid_tools import assign_guid_all
+
+        assign_guid_all(data.value)
+        return _ExecutionResult(output=data)
+
+
+class StbRepairStep[TStb: StBridgeRoot](_ExecutableStep[StbData[TStb], StbData[TStb]]):
+    name = "STB Repair"
+
+    def execute(
+        self,
+        data: StbData[TStb],
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[StbData[TStb]]:
+        repair_stb(data.value, reporter=context.reporter or NullReporter())
+        return _ExecutionResult(output=data)

stbkit/tools/converters/_internal/pipeline/stb_pipeline_latest.py

@@ -0,0 +1,39 @@
+# Copyright 2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.core.data_model.common import StBridgeRoot
+
+from stbkit.api import stb_latest
+
+from ....upgrade._internal.upgrade import upgrade_to_latest
+from .data import _StbVersion
+from .stb_pipeline import StbData
+from .step import _ExecutableStep, _ExecutionContext, _ExecutionResult
+
+
+class StbLatestData(StbData[stb_latest.StBridge]):
+    def __init__(self, value: stb_latest.StBridge) -> None:
+        super().__init__(value=value, stb_version=_StbVersion.LATEST)
+
+
+class StbToLatestStep[TStb: StBridgeRoot](
+    _ExecutableStep[StbData[TStb], StbLatestData]
+):
+    name = "STB -> STB Latest"
+
+    def execute(
+        self,
+        data: StbData[TStb],
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[StbLatestData]:
+        stb: StBridgeRoot = data.value
+        if isinstance(stb, stb_latest.StBridge):
+            return _ExecutionResult(output=StbLatestData(stb))
+        if isinstance(stb, StBridgeRoot):
+            stb_latest_value = upgrade_to_latest(stb, reporter=context.reporter)
+            return _ExecutionResult(output=StbLatestData(stb_latest_value))
+        raise TypeError(f"ST-Bridgeデータではありません: {type(stb)}")

stbkit/tools/converters/_internal/pipeline/step.py

@@ -0,0 +1,139 @@
+# Copyright 2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Protocol, cast
+
+from stbkit.core.stb_reporting import NullReporter, Reporter
+
+from .data import _Data
+
+
+@dataclass
+class _ExecutionContext:
+    work_dir: Path | None = None
+    keep_temporary_files: bool = False
+    reporter: Reporter = field(default_factory=NullReporter)
+    max_size: int | None = None
+    """max_sizeは読み込む ST-Bridgeのサイズ上限(バイト)。
+    Noneの場合は読み込み側の既定値を使用する。"""
+    on_step_completed: Callable[[str, _Data], None] | None = None
+    """複合ステップ内を含む各単一ステップの完了時に呼び出される。
+    CLIの中間ファイル保存など、変換処理そのものとは独立した処理の実装のために使用する。"""
+    ifc_round_digits: int | None = None
+    ifc_round_digits_mm: int | None = None
+
+
+@dataclass(frozen=True)
+class _ExecutionResult[OutData: _Data]:
+    output: OutData
+    cleanup_paths: tuple[Path, ...] = ()
+    """結果を利用し終わった後に削除してよい一時パス。
+    複合ステップでは直ちに削除せず、最上位の呼び出し側へ集約して返す。"""
+
+
+class _ExecutableStep[InData: _Data, OutData: _Data](Protocol):
+    name: str
+
+    def execute(
+        self,
+        data: InData,
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[OutData]: ...
+
+
+@dataclass(frozen=True)
+class _FunctionExecutableStep[InData: _Data, OutData: _Data]:
+    name: str
+    func: Callable[[InData, _ExecutionContext], _ExecutionResult[OutData]]
+
+    def execute(
+        self,
+        data: InData,
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[OutData]:
+        return self.func(data, context)
+
+
+@dataclass(frozen=True)
+class _CompositeExecutableStep[InData: _Data, OutData: _Data](
+    _ExecutableStep[InData, OutData]
+):
+    name: str
+    runners: Sequence[_ExecutableStep[Any, Any]]
+
+    def execute(
+        self,
+        data: InData,
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[OutData]:
+        tmp_data: _Data = data
+        cleanup_paths: list[Path] = []
+        for runner in self.runners:
+            result = _execute_step(runner, tmp_data, context=context)
+            tmp_data = result.output
+            cleanup_paths.extend(result.cleanup_paths)
+        return _ExecutionResult(
+            output=cast(OutData, tmp_data),
+            cleanup_paths=tuple(cleanup_paths),
+        )
+
+
+class _NoOpStep[InData: _Data](_ExecutableStep[InData, InData]):
+    name = "No-Op"
+
+    def execute(
+        self,
+        data: InData,
+        *,
+        context: _ExecutionContext,
+    ) -> _ExecutionResult[InData]:
+        return _ExecutionResult(output=data)
+
+
+def _execute_step[InData: _Data, OutData: _Data](
+    step: _ExecutableStep[InData, OutData],
+    data: InData,
+    *,
+    context: _ExecutionContext,
+) -> _ExecutionResult[OutData]:
+    """ステップを実行し、単一ステップであれば完了通知も行う"""
+    result = step.execute(data, context=context)
+    if context.on_step_completed is not None and not isinstance(
+        step, _CompositeExecutableStep
+    ):
+        context.on_step_completed(step.name, result.output)
+    return result
+
+
+def _compose_steps(
+    name: str,
+    steps: Sequence[_ExecutableStep[Any, Any]],
+) -> _ExecutableStep[Any, Any]:
+    """
+    ステップを平坦化し、不要なNo-Opを除いて最小の実行単位を返す。
+
+    変換ルートを組み立てる側が複合ステップの入れ子や、単一ステップだけの複合オブジェクトを意識せずに済むようにする。
+    """
+    flattened: list[_ExecutableStep[Any, Any]] = []
+    for step in steps:
+        if isinstance(step, _CompositeExecutableStep):
+            flattened.extend(step.runners)
+        elif isinstance(step, _NoOpStep):
+            continue
+        else:
+            flattened.append(step)
+
+    if not flattened:
+        return _NoOpStep()
+    if len(flattened) == 1:
+        return flattened[0]
+    return _CompositeExecutableStep(name=name, runners=tuple(flattened))

stbkit/tools/converters/_internal/stb_latest_to_element_data/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from ._stb_latest_to_element_data import (
+    node_coords_from_stb_nodes,
+    node_infos_from_stb_nodes,
+    stb_to_element_data,
+)
+
+__all__ = [
+    "node_coords_from_stb_nodes",
+    "node_infos_from_stb_nodes",
+    "stb_to_element_data",
+]

stbkit/tools/converters/_internal/stb_latest_to_element_data/_stb_latest_to_element_data.py

@@ -0,0 +1,186 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.core.repository import get_repository
+from stbkit.core.stb_exceptions import NoneAccessError
+from stbkit.core.stb_reporting import Code, Phase, Reporter
+
+from stbkit.api.experimental.repository import RepositoryLatest
+from stbkit.api.stb_latest import (
+    StbBeam,
+    StbBrace,
+    StbColumn,
+    StbFoundationColumn,
+    StbGirder,
+    StbMembers,
+    StbModel,
+    StbNodes,
+    StbParapet,
+    StbPile,
+    StbPost,
+    StBridge,
+    StbStripFooting,
+)
+
+from ...._internal.data_model.element_data import (
+    ElementData,
+    ElementPlane,
+    Node,
+)
+from ...._internal.vectors import Vector3d
+from . import open
+from .member.member_footing import stb_footing_to_line_element
+from .member.member_line import stb_element_to_element_line
+from .member.member_plane import (
+    stb_slab_to_ifc_data,
+    stb_wall_to_ifc_data,
+)
+
+
+def node_coords_from_stb_nodes(stb_nodes: StbNodes) -> dict[int, Vector3d]:
+    return {node.id: Vector3d.from_stb_node(node) for node in stb_nodes.stb_node}
+
+
+def node_infos_from_stb_nodes(stb_nodes: StbNodes) -> dict[int, Node]:
+    return {
+        node.id: Node(
+            position=Vector3d.from_stb_node(node),
+            xpath=node._path_xml(),
+            guid=node.guid_or_none,
+        )
+        for node in stb_nodes.stb_node
+    }
+
+
+def stb_to_element_data(
+    stb: StBridge,
+    *,
+    reporter: Reporter,
+) -> ElementData:
+    reporter.info(
+        "---ST-Bridge->ジオメトリデータ変換処理開始---",
+        code=Code.PROGRESS_INFO,
+        phase=Phase.CONVERT_GEOMETRY,
+    )
+    result: ElementData = ElementData()
+    repo: RepositoryLatest = get_repository(stb)
+    try:
+        stb_model: StbModel = stb.stb_model
+        stb_members: StbMembers = stb_model.stb_members
+    except NoneAccessError:
+        reporter.error(
+            "部材情報がありません",
+            code=Code.MEMBER_NOT_FOUND,
+            phase=Phase.CONVERT_GEOMETRY,
+        )
+        return result
+    try:
+        stb_nodes: StbNodes = stb.stb_model.stb_nodes
+    except NoneAccessError:
+        reporter.error(
+            "節点情報がありません",
+            code=Code.MEMBER_NOT_FOUND,
+            phase=Phase.CONVERT_GEOMETRY,
+        )
+        return result
+    node_coords: dict[int, Vector3d] = node_coords_from_stb_nodes(stb_nodes)
+    try:
+        _ = stb.stb_model.stb_sections
+    except NoneAccessError:
+        reporter.error(
+            "断面情報がありません",
+            code=Code.MEMBER_NOT_FOUND,
+            phase=Phase.CONVERT_GEOMETRY,
+        )
+        return result
+    stb_member_lines: list[
+        StbColumn
+        | StbPost
+        | StbGirder
+        | StbBeam
+        | StbBrace
+        | StbPile
+        | StbStripFooting
+        | StbFoundationColumn
+        | StbParapet
+    ] = []
+    try:
+        stb_member_lines.extend(stb_members.stb_columns.stb_column)
+    except NoneAccessError:
+        pass
+    try:
+        stb_member_lines.extend(stb_members.stb_posts.stb_post)
+    except NoneAccessError:
+        pass
+    try:
+        stb_member_lines.extend(stb_members.stb_girders.stb_girder)
+    except NoneAccessError:
+        pass
+    try:
+        stb_member_lines.extend(stb_members.stb_beams.stb_beam)
+    except NoneAccessError:
+        pass
+    try:
+        stb_member_lines.extend(stb_members.stb_braces.stb_brace)
+    except NoneAccessError:
+        pass
+    try:
+        stb_member_lines.extend(stb_members.stb_strip_footings.stb_strip_footing)
+    except NoneAccessError:
+        pass
+    try:
+        stb_member_lines.extend(stb_members.stb_piles.stb_pile)
+    except NoneAccessError:
+        pass
+    try:
+        stb_member_lines.extend(
+            stb_members.stb_foundation_columns.stb_foundation_column
+        )
+    except NoneAccessError:
+        pass
+    try:
+        stb_member_lines.extend(stb_members.stb_parapets.stb_parapet)
+    except NoneAccessError:
+        pass
+
+    result.extend(
+        [
+            stb_element_to_element_line(repo, ele, node_coords, reporter)
+            for ele in stb_member_lines
+        ]
+    )
+    stb_id_to_planes: dict[int, ElementPlane] = {}
+    if stb_members.stb_slabs_or_none:
+        for stb_slab in stb_members.stb_slabs.stb_slab:
+            result.append(
+                stb_slab_to_ifc_data(
+                    stb_slab,
+                    node_coords,
+                    repo,
+                    stb_id_to_planes,
+                    reporter,
+                )
+            )
+    if stb_members.stb_walls_or_none:
+        for stb_wall in stb_members.stb_walls.stb_wall:
+            result.append(
+                stb_wall_to_ifc_data(
+                    stb_wall,
+                    node_coords,
+                    repo,
+                    stb_id_to_planes,
+                    reporter,
+                )
+            )
+    if stb_members.stb_open_arrangements_or_none:
+        open.add_open(stb_model, stb_id_to_planes, reporter=reporter)
+
+    if stb_members.stb_footings_or_none and stb_members.stb_footings.stb_footing:
+        for stb_footing in stb_members.stb_footings.stb_footing:
+            result.append(
+                stb_footing_to_line_element(repo, stb_footing, node_coords, reporter)
+            )
+    return result

stbkit/tools/converters/_internal/stb_latest_to_element_data/member/member_footing.py

@@ -0,0 +1,49 @@
+# Copyright 2025-2026 TAISEI CORPORATION
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from stbkit.core.stb_reporting import Reporter
+
+from stbkit.api.experimental.repository import RepositoryLatest
+from stbkit.api.stb_latest import StbFooting, StbSecFoundationRc
+
+from ....._internal.data_model.element_data import ElementLine, ElementType
+from ....._internal.data_model.shape_data import ShapePosition
+from ....._internal.vectors import Vector3d
+from ..section.sec_foundation import stb_sec_foundation_rc_to_shapes_and_depth
+
+
+def stb_footing_to_line_element(
+    repo: RepositoryLatest,
+    stb_footing: StbFooting,
+    node_coords: dict[int, Vector3d],
+    reporter: Reporter,
+) -> ElementLine:
+    point: Vector3d = node_coords[stb_footing.id_node]
+    offset: Vector3d = Vector3d(
+        stb_footing.offset_x if stb_footing.offset_x_or_none else 0.0,
+        stb_footing.offset_y if stb_footing.offset_y_or_none else 0.0,
+        stb_footing.level_bottom if stb_footing.level_bottom_or_none else 0.0,
+    )
+    angle: float = stb_footing.rotate if stb_footing.rotate_or_none else 0.0
+    point_bottom: Vector3d = point + offset
+    stb_sec_foundation_rc: StbSecFoundationRc = repo.deref(stb_footing).id_section
+    shapes, lengths = stb_sec_foundation_rc_to_shapes_and_depth(
+        stb_sec_foundation_rc, reporter
+    )
+    point_top: Vector3d = point_bottom + sum(lengths) * Vector3d.unit_z()
+    return ElementLine(
+        element_type=ElementType.FOOTING,
+        name=stb_footing.name_or_none,
+        guid=stb_footing.guid_or_none,
+        lengths=lengths,
+        point_start=point_bottom,
+        point_end=point_top,
+        angle=angle,
+        shapes=shapes,
+        axis_position=ShapePosition.DIAGRAM_CORE,
+        path=stb_footing._path_xml(),
+        node_ids=[stb_footing.id_node],
+    )