stbkit 0.1.0a9.dev1__py3-none-any.whl

stbkit/cli/_internal/diff.py

@@ -0,0 +1,213 @@
+# 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 __future__ import annotations
+
+import math
+import sys
+from argparse import ArgumentParser, Namespace, _SubParsersAction
+from pathlib import Path
+from typing import Any, Never
+
+from stbkit.core._internal.io_text import load_text
+from stbkit.core.stb_io._internal.loader import _detect_encoding
+from stbkit.core.stb_io._internal.stream_reader import check_no_doctype
+
+from stbkit.tools._internal.diff.diff_xml import (
+    XmlCompareOption,
+    compare_xml_str,
+)
+
+from . import common
+from .constants_exit_code import (
+    EXIT_EXECUTION_ERROR,
+    EXIT_INVALID_ARGUMENT,
+    EXIT_ISSUE_FOUND,
+    EXIT_OK,
+)
+from .global_parent import get_max_size, make_global_parent
+
+
+def register(subparsers: _SubParsersAction[Any]) -> None:
+    parser = subparsers.add_parser(
+        "diff",
+        parents=[make_global_parent()],
+        help="2つのモデルを比較します。",
+    )
+    diff_subparsers = parser.add_subparsers(
+        dest="diff_command",
+        title="比較方式",
+    )
+    _register_xml_command(diff_subparsers)
+
+    # ``stbkit diff`` 単独では比較せず、利用可能な方式を表示する。
+    parser.set_defaults(func=_show_diff_help, _parser=parser)
+
+
+def _register_xml_command(subparsers: _SubParsersAction[Any]) -> None:
+    parser = subparsers.add_parser(
+        "xml",
+        help="2つのST-Bridge XMLをXML構造として比較します。",
+    )
+    _use_common_arguments(parser)
+    parser.add_argument(
+        "--ignore-guid",
+        action="store_true",
+        help="guid属性を比較対象から除外します。",
+    )
+    parser.add_argument(
+        "--compare-by-order",
+        action="store_true",
+        help=("guidやidで対応付けず、同じタグの子要素をタグ内の出現順で比較します。"),
+    )
+    parser.add_argument(
+        "--compare-tag-order",
+        action="store_true",
+        help=("異なるタグを含む子要素のタグの並び順も差分として検出します。"),
+    )
+    parser.add_argument(
+        "--combine-attribute-diffs",
+        action="store_true",
+        help="同じ要素の複数の属性差分を1行にまとめます。",
+    )
+    parser.set_defaults(func=_run_xml)
+
+
+def _use_common_arguments(parser: ArgumentParser) -> None:
+    parser.add_argument(
+        "reference",
+        type=Path,
+        metavar="REFERENCE",
+        help="基準、期待値、または変更前のファイルです。",
+    )
+    parser.add_argument(
+        "candidate",
+        type=Path,
+        metavar="CANDIDATE",
+        help="比較対象、実測値、または変更後のファイルです。",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="-",
+        metavar="PATH",
+        help="比較レポートの出力先です。省略時は標準出力へ出力します。",
+    )
+    parser.add_argument(
+        "--exit-zero",
+        action="store_true",
+        help="差分が見つかった場合も終了コード0を返します。",
+    )
+
+
+def _show_diff_help(args: Namespace) -> Never:
+    parser: ArgumentParser = args._parser
+    parser.print_help()
+    raise SystemExit(EXIT_OK)
+
+
+def _run_xml(args: Namespace) -> None:
+    reference: Path = args.reference
+    candidate: Path = args.candidate
+
+    try:
+        max_size: int = get_max_size(args)
+        _validate_output_path(args.output, reference, candidate)
+        reference_xml = _read_xml(reference, max_size=max_size)
+        candidate_xml = _read_xml(candidate, max_size=max_size)
+        compare_option = XmlCompareOption()
+        if args.ignore_guid:
+            compare_option.filter_option.global_attribute_filter.exclude.append("guid")
+        compare_option.ignore_order_children = not bool(args.compare_by_order)
+        compare_option.compare_tag_order = bool(args.compare_tag_order)
+        result = compare_xml_str(reference_xml, candidate_xml, compare_option)
+        if args.combine_attribute_diffs:
+            result = result.combine_attribute_diffs()
+        report_text = result.to_reporting_result().to_text()
+        _write_report(report_text, args.output)
+    except FileNotFoundError as error:
+        # 指定されたパスが誤っている場合。比較を始められていないため、
+        # 比較中の失敗とは区別する。
+        _exit_with_invalid_argument(error)
+    except Exception as error:  # noqa: BLE001
+        _exit_with_error("XML比較に失敗しました", error)
+
+    _exit_for_result(equal=result.equal, exit_zero=bool(args.exit_zero))
+
+
+def _read_xml(path: Path, *, max_size: int) -> str:
+    if not path.is_file():
+        raise FileNotFoundError(f"入力ファイルが見つかりません: {path}")
+    xml: str = load_text(path, encoding=_detect_encoding(path), max_size=max_size)
+    check_no_doctype(xml)
+    return xml
+
+
+def _validate_geometry_inputs(reference: Path, candidate: Path) -> None:
+    for path in (reference, candidate):
+        if not path.is_file():
+            raise FileNotFoundError(f"入力ファイルが見つかりません: {path}")
+
+    suffixes = (reference.suffix.lower(), candidate.suffix.lower())
+    supported = {
+        (".stb", ".stb"),
+        (".stb", ".ifc"),
+        (".ifc", ".stb"),
+    }
+    if suffixes not in supported:
+        raise ValueError(
+            "対応している組合せはST-Bridge同士、またはST-BridgeとIFCです: "
+            f"{reference.suffix or '(拡張子なし)'} / "
+            f"{candidate.suffix or '(拡張子なし)'}"
+        )
+
+
+def _validate_distance_tolerance(value: float | None) -> float | None:
+    if value is None:
+        return None
+    if not math.isfinite(value) or value < 0.0:
+        raise ValueError("--distance-toleranceには0以上の有限値を指定してください。")
+    return value
+
+
+def _validate_output_path(output: str, reference: Path, candidate: Path) -> None:
+    try:
+        common.ensure_output_not_input(output, (reference, candidate))
+    except ValueError as error:
+        raise ValueError(f"比較レポートの{error}") from None
+
+
+def _write_report(report_text: str, output: str) -> None:
+    if output == "-":
+        if report_text:
+            sys.stdout.write(report_text)
+            if not report_text.endswith("\n"):
+                sys.stdout.write("\n")
+            sys.stdout.flush()
+        return
+
+    common.write_text_via_temporary_file(
+        output=output,
+        text=report_text,
+        encoding="utf-8",
+    )
+
+
+def _exit_for_result(*, equal: bool, exit_zero: bool) -> Never:
+    exit_code = EXIT_OK if equal or exit_zero else EXIT_ISSUE_FOUND
+    raise SystemExit(exit_code)
+
+
+def _exit_with_error(message: str, error: Exception) -> Never:
+    print(f"{message}: {error}", file=sys.stderr)
+    raise SystemExit(EXIT_EXECUTION_ERROR) from None
+
+
+def _exit_with_invalid_argument(error: Exception) -> Never:
+    print(str(error), file=sys.stderr)
+    raise SystemExit(EXIT_INVALID_ARGUMENT) from None
+
+

stbkit/cli/_internal/entry_points.py

@@ -0,0 +1,25 @@
+# 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 importlib import metadata
+from typing import Final
+
+COMMAND_GROUP: Final = "stbkit.commands"
+
+# pyproject.tomlの[project.entry-points."stbkit.commands"]に該当。
+# 将来的にpackageを分離した際にpyproject.tomlへ書けるように、この形式で登録する。
+BUILTIN_COMMANDS: Final[dict[str, str]] = {
+    "convert": "stbkit.cli.commands.convert:register",
+    "diff": "stbkit.cli.commands.diff:register",
+    "validate": "stbkit.cli.commands.validate:register",
+}
+
+
+def load_command_entry_points() -> metadata.EntryPoints:
+    return metadata.EntryPoints(
+        metadata.EntryPoint(name=name, value=value, group=COMMAND_GROUP)
+        for name, value in sorted(BUILTIN_COMMANDS.items())
+    )

stbkit/cli/_internal/global_parent.py

@@ -0,0 +1,70 @@
+# 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/.
+
+import argparse
+import logging
+from argparse import Namespace
+from logging import Logger
+
+from stbkit.core._internal.constants import BYTES_PER_MB, DEFAULT_MAX_XML_SIZE
+from stbkit.core._internal.stb_logger import get_logger as get_stb_logger
+
+DEFAULT_MAX_SIZE_MB: int = DEFAULT_MAX_XML_SIZE // BYTES_PER_MB
+
+
+def make_global_parent() -> argparse.ArgumentParser:
+    # 共通引数に既定値を持たせるとサブコマンドより前で指定した値がサブコマンドで上書きされてしまうため、
+    # 共通引数は既定値を持たせず、下のget_xxxを用いる。
+    parent = argparse.ArgumentParser(add_help=False)
+    parent.add_argument(
+        "-V",
+        "--version",
+        action="store_true",
+        default=argparse.SUPPRESS,
+        help="バージョン情報",
+    )
+    parent.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=argparse.SUPPRESS,
+        help="詳細ログを出力する場合に指定します (-v, -vv, -vvv)",
+    )
+    parent.add_argument(
+        "--max-size-mb",
+        type=int,
+        default=argparse.SUPPRESS,
+        help=f"読み込むXMLのサイズ上限(MB)。既定は{DEFAULT_MAX_SIZE_MB}です。",
+    )
+    parent.add_argument(
+        "--interactive",
+        action="store_true",
+        default=argparse.SUPPRESS,
+        help="対話モードで実行します。",
+    )
+
+    return parent
+
+
+def get_max_size(args: Namespace) -> int:
+    max_size_mb: int = getattr(args, "max_size_mb", DEFAULT_MAX_SIZE_MB)
+    return max_size_mb * BYTES_PER_MB
+
+
+def get_interactive(args: Namespace) -> bool:
+    interactive: bool = getattr(args, "interactive", False)
+    return interactive
+
+
+def get_logger(args: Namespace) -> Logger:
+    verbose: int = getattr(args, "verbose", 0)
+    if verbose >= 2:
+        logging_level = logging.DEBUG
+    elif verbose >= 1:
+        logging_level = logging.INFO
+    else:
+        logging_level = logging.WARNING
+    return get_stb_logger(level=logging_level)

stbkit/cli/_internal/show_versions.py

@@ -0,0 +1,36 @@
+# 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 importlib import metadata
+
+
+def print_versions(dist_name: str) -> None:
+    try:
+        version = metadata.version(dist_name)
+        print(f"{dist_name}: {version}")
+    except metadata.PackageNotFoundError:
+        print(f"{dist_name}: unknown")
+
+
+def show_versions(entry_points: metadata.EntryPoints) -> None:
+    print_versions("stbkit")
+    stbkit_set: set[str] = set()
+    for dist in metadata.distributions():
+        name = dist.metadata.get("Name")
+        if not isinstance(name, str):
+            continue
+        dist_name: str = name.strip()
+        if dist_name.replace("_", "-").lower().startswith("stbkit-"):
+            stbkit_set.add(dist_name)
+    for package in sorted(stbkit_set):
+        print_versions(package)
+    stbkit_set.add("stbkit")
+    for ep in entry_points:
+        if ep.dist:
+            dist_name = ep.dist.name
+            if dist_name not in stbkit_set:
+                stbkit_set.add(dist_name)
+                print_versions(dist_name)

stbkit/cli/_internal/validate.py

@@ -0,0 +1,310 @@
+# 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 __future__ import annotations
+
+import sys
+from argparse import Namespace, _SubParsersAction
+from pathlib import Path
+from typing import Any, Never
+from xml.etree.ElementTree import ParseError
+
+from stbkit.core._internal.io_text import load_text
+from stbkit.core.stb_exceptions import DeveloperError, StbError
+from stbkit.core.stb_io._internal.loader import _detect_encoding
+from stbkit.core.stb_reporting import (
+    Code,
+    CollectingReporter,
+    Phase,
+    Severity,
+)
+from stbkit.core.validation._internal.validator import validate_schema
+
+from . import common
+from .constants_exit_code import (
+    EXIT_EXECUTION_ERROR,
+    EXIT_INVALID_ARGUMENT,
+    EXIT_ISSUE_FOUND,
+    EXIT_OK,
+    EXIT_OPTIONAL_DEPENDENCY_MISSING,
+)
+from .global_parent import get_interactive, get_max_size, make_global_parent
+
+
+def _check_optional_dependency(reporter: CollectingReporter) -> bool:
+    return any(
+        item.code == Code.OPTIONAL_DEPENDENCY_MISSING.value for item in reporter.report
+    )
+
+
+def _try_validate_report(
+    input_path: str,
+    *,
+    schema_path: str | None,
+    max_size: int,
+    require_xsd: bool,
+    exclude_legal_extensions: bool,
+) -> tuple[CollectingReporter | None, str]:
+    # XMLとして読み込めなかった場合は、チェック結果ではなく実行の失敗なので(None, エラーメッセージ)を返す。
+    # ST-Bridgeとしての不正はチェック結果であるため、エラーとしない。
+    try:
+        reporter: CollectingReporter = _validate_report(
+            input_path,
+            schema_path=schema_path,
+            max_size=max_size,
+            require_xsd=require_xsd,
+            exclude_legal_extensions=exclude_legal_extensions,
+        )
+    except DeveloperError:
+        raise
+    except (StbError, ParseError, UnicodeDecodeError) as error:
+        return None, f"入力ファイルを処理できません: {error}"
+    return reporter, ""
+
+
+def _has_error(reporter: CollectingReporter) -> bool:
+    # 任意依存の不足以外
+    return any(
+        item.severity >= Severity.WARNING.value
+        and item.code != Code.OPTIONAL_DEPENDENCY_MISSING.value
+        for item in reporter.report
+    )
+
+
+def register(subparsers: _SubParsersAction[Any]) -> None:
+    parser = subparsers.add_parser(
+        "validate",
+        parents=[make_global_parent()],
+        help=(
+            "ST-Bridgeのバリデーションを行います。\n"
+            "--schemaを指定すると、指定されたXSDスキーマでの検査を行います。\n"
+            "XSDスキーマの指定は環境変数でも可能です\n"
+            "XSDスキーマの指定を行わない場合は、stbkit-coreのデータモデルが持つ情報でチェックを行います。"
+        ),
+    )
+    common.use_input(parser)
+    common.use_output(parser)
+    common.use_yes(parser)
+    parser.add_argument(
+        "--schema",
+        help="チェックに利用するXSDスキーマファイルのパス",
+    )
+    parser.add_argument(
+        "--require-xsd",
+        action="store_true",
+        help="XSDスキーマによる検査を必須にします",
+    )
+    parser.add_argument(
+        "--exclude-legal-extensions",
+        action="store_true",
+        help="StbExtensionsで定義された拡張に由来するXSDスキーマチェック時のエラーをXSD結果から除外します。\n"
+        "XSDを利用しない場合はこのオプションは不要です。",
+    )
+    common.use_quiet(parser)
+
+    parser.set_defaults(func=_run, _parser=parser)
+
+
+def _run(args: Namespace) -> None:
+    input_path_str: str = common.get_input(args)
+    output_path: str = common.get_output(args)
+    yes: bool = common.get_yes(args)
+    quiet: bool = common.get_quiet(args)
+    interactive: bool = get_interactive(args)
+    schema: str | None = args.schema
+    require_xsd: bool = bool(args.require_xsd)
+    exclude_legal_extensions: bool = bool(args.exclude_legal_extensions)
+    max_size: int = get_max_size(args)
+
+    if schema:
+        schema_path = Path(schema)
+        if not schema_path.is_file():
+            _exit_with_error(
+                f"指定されたXSDスキーマファイルが存在しません: {schema_path}"
+            )
+
+    is_valid: bool = True
+    from_stdin: bool = input_path_str == "-"
+    input_path: Path = Path(input_path_str)
+
+    if not from_stdin:
+        try:
+            common.ensure_output_not_input(output_path, (input_path,))
+        except ValueError as error:
+            _exit_with_error(f"バリデーション結果の{error}")
+
+    if not common.confirm_overwrite(
+        output=output_path,
+        yes=yes,
+        interactive=interactive,
+    ):
+        _exit_with_error(
+            "出力先ファイルが既に存在します。上書きするには-y/--yesを指定してください。"
+        )
+
+    result: list[str] = []
+    lacks_optional_dependency = False
+    has_target_issue = False
+    has_unreadable_input = False
+
+    if from_stdin or input_path.is_file():
+        result.append("入力： 標準入力" if from_stdin else f"ファイル： {input_path}")
+        reporter, read_error = _try_validate_report(
+            input_path_str,
+            schema_path=schema,
+            max_size=max_size,
+            require_xsd=require_xsd,
+            exclude_legal_extensions=exclude_legal_extensions,
+        )
+        if reporter is None:
+            print(read_error, file=sys.stderr)
+            sys.exit(EXIT_EXECUTION_ERROR)
+        result.extend(_output_report(reporter, quiet=quiet))
+        is_valid = reporter.is_valid()
+        lacks_optional_dependency = _check_optional_dependency(reporter)
+        has_target_issue = _has_error(reporter)
+    elif input_path.is_dir():
+        result.append(f"ディレクトリ: {input_path}")
+        result.append("ディレクトリ内のST-Bridgeファイルを再帰的に検査します。")
+        xml_files: list[Path] = list(input_path.rglob("*.stb"))
+        try:
+            common.ensure_output_not_input(output_path, xml_files)
+        except ValueError as error:
+            _exit_with_error(f"バリデーション結果の{error}")
+        if not xml_files:
+            result.append("ディレクトリ内にST-Bridgeファイルが見つかりませんでした。")
+            is_valid = False
+        else:
+            result_files: list[str] = []
+            error_file_count: list[tuple[str, int]] = []
+            for xml_file in xml_files:
+                reporter, read_error = _try_validate_report(
+                    str(xml_file),
+                    schema_path=schema,
+                    max_size=max_size,
+                    require_xsd=require_xsd,
+                    exclude_legal_extensions=exclude_legal_extensions,
+                )
+                if reporter is None:
+                    # 1つのファイルが読めなくても残りのバリデーションは続ける
+                    result_files.append("-" * 3)
+                    result_files.append(f"ファイル: {xml_file}")
+                    result_files.append(read_error)
+                    has_unreadable_input = True
+                    is_valid = False
+                    continue
+                file_result = _output_report(reporter, quiet=quiet)
+                result_files.append("-" * 3)
+                result_files.append(f"ファイル: {xml_file}")
+                result_files.extend(file_result)
+                if _check_optional_dependency(reporter):
+                    lacks_optional_dependency = True
+                if _has_error(reporter):
+                    has_target_issue = True
+                if not reporter.is_valid():
+                    error_file_count.append((str(xml_file), len(reporter.report)))
+                    is_valid = False
+            result.append(f"{len(xml_files)}ファイルが見つかりました。")
+            if is_valid:
+                result.append("すべてのファイルがOKです。")
+            else:
+                result.append(
+                    f"{len(error_file_count)}ファイルにエラーが見つかりました。"
+                )
+                for file, count in error_file_count:
+                    result.append(f"  {file}: {count}件のエラー")
+                result.extend(result_files)
+    else:
+        _exit_with_error(
+            f"入力パスはファイルまたはディレクトリである必要があります: {input_path}"
+        )
+
+    if is_valid:
+        if not quiet:
+            if output_path == "-":
+                print("\n".join(result))
+            else:
+                common.write_text_via_temporary_file(
+                    output=output_path,
+                    text="\n".join(result),
+                    encoding="utf-8",
+                )
+        sys.exit(EXIT_OK)
+    else:
+        error_text: str = "\n".join(result)
+        if output_path == "-":
+            print(error_text, file=sys.stderr)
+        else:
+            common.write_text_via_temporary_file(
+                output=output_path,
+                text=error_text,
+                encoding="utf-8",
+            )
+            print(error_text, file=sys.stderr)
+        # 検査が実行できた場合は、検査のエラーを優先する。
+        # 検査で問題を見つけられなかった場合は、実行できなかった原因を返す。
+        if not has_target_issue:
+            if has_unreadable_input:
+                sys.exit(EXIT_EXECUTION_ERROR)
+            if lacks_optional_dependency:
+                sys.exit(EXIT_OPTIONAL_DEPENDENCY_MISSING)
+        sys.exit(EXIT_ISSUE_FOUND)
+
+
+def _output_report(reporter: CollectingReporter, quiet: bool) -> list[str]:
+    result: list[str] = []
+    if reporter.is_valid():
+        result.append("結果: OK")
+    else:
+        result.append("結果: NG")
+        result.append("エラー数: " + str(len(reporter.report)))
+        result.append("エラー詳細:")
+        result.append(reporter.report.to_text())
+    return result
+
+
+def _validate_report(
+    input_path: str,
+    schema_path: str | None,
+    *,
+    max_size: int,
+    require_xsd: bool,
+    exclude_legal_extensions: bool,
+) -> CollectingReporter:
+    xsd_path: Path | None = Path(schema_path) if schema_path else None
+
+    reporter: CollectingReporter = CollectingReporter(
+        default_code=Code.SCHEMA_ERROR, default_phase=Phase.VALIDATE
+    )
+
+    if xsd_path is not None and not xsd_path.is_file():
+        reporter.error(f"指定されたXSDスキーマファイルが存在しません: {xsd_path}")
+        return reporter
+
+    xml_text: str
+    if input_path == "-":
+        xml_text = common.read_stdin_xml(max_size=max_size)
+    else:
+        xml_path: Path = Path(input_path)
+        if not xml_path.is_file():
+            reporter.error(f"指定されたST-Bridgeファイルが存在しません: {xml_path}")
+            return reporter
+        encoding: str = _detect_encoding(xml_path)
+        xml_text = load_text(xml_path, encoding=encoding, max_size=max_size)
+
+    validate_schema(
+        xml_text,
+        reporter=reporter,
+        xsd_path=xsd_path,
+        require_xsd=require_xsd,
+        exclude_legal_extensions=exclude_legal_extensions,
+    )
+    return reporter
+
+
+def _exit_with_error(message: str) -> Never:
+    print(message, file=sys.stderr)
+    sys.exit(EXIT_INVALID_ARGUMENT)

stbkit/cli/commands/convert.py

@@ -0,0 +1,16 @@
+# 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 __future__ import annotations
+
+from argparse import _SubParsersAction
+from typing import Any
+
+from .._internal import converter
+
+
+def register(subparsers: _SubParsersAction[Any]) -> None:
+    converter.register(subparsers)

stbkit/cli/commands/diff.py

@@ -0,0 +1,16 @@
+# 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 __future__ import annotations
+
+from argparse import _SubParsersAction
+from typing import Any
+
+from .._internal import diff
+
+
+def register(subparsers: _SubParsersAction[Any]) -> None:
+    diff.register(subparsers)