stbkit-core 0.1.0a9.dev1__py3-none-any.whl

stbkit/core/__init__.py

@@ -0,0 +1,12 @@
+# 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/.
+
+"""stbkitのコアモジュール
+
+※このモジュール内のAPIは暫定的なものであり、今後変更される可能性があります。
+  継続的に利用するコードから使う場合は、この点を了解したうえで、バージョンを固定して使用してください。
+  互換性に関する方針は、GitHubリポジトリのCOMPATIBILITY.mdを参照してください。
+"""

stbkit/core/_internal/constants.py

@@ -0,0 +1,42 @@
+# 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 importlib.metadata
+from typing import Final
+
+PACKAGE_NAME: Final = "stbkit-core"
+
+_tmp_version: str
+try:
+    _tmp_version = importlib.metadata.version(PACKAGE_NAME)
+except ImportError:
+    _tmp_version = "unknown"
+PACKAGE_VERSION: Final[str] = _tmp_version
+
+LATEST_STB_VERSION: Final = "2.1.1"
+"""stbkit-coreがサポートしているST-Bridgeの最新バージョン"""
+SUPPORTED_STB_VERSIONS: Final = ("2.0.0", "2.0.1", "2.0.2", "2.1.0", "2.1.1")
+"""stbkit-coreがサポートしているST-Bridgeのバージョン"""
+
+ENV_NAME_SCHEMA_PATH_STB_V2_0_0: Final = "STBKIT_SCHEMA_PATH_STB_V2_0_0"
+ENV_NAME_SCHEMA_PATH_STB_V2_0_1: Final = "STBKIT_SCHEMA_PATH_STB_V2_0_1"
+ENV_NAME_SCHEMA_PATH_STB_V2_0_2: Final = "STBKIT_SCHEMA_PATH_STB_V2_0_2"
+ENV_NAME_SCHEMA_PATH_STB_V2_1_0: Final = "STBKIT_SCHEMA_PATH_STB_V2_1_0"
+ENV_NAME_SCHEMA_PATH_STB_V2_1_1: Final = "STBKIT_SCHEMA_PATH_STB_V2_1_1"
+
+BYTES_PER_MB: Final[int] = 1024 * 1024
+
+DEFAULT_MAX_XML_SIZE: Final[int] = 128 * BYTES_PER_MB
+"""読み込めるXMLファイルのデフォルトのサイズ上限(byte)"""
+
+DEFAULT_MAX_XML_DEPTH: Final[int] = 15
+"""読み込めるXMLの要素の階層の上限。ST-Bridgeの階層は10程度だが、拡張要素もあるので少し余裕を持たせる"""
+
+XML_READ_CHUNK_SIZE: Final[int] = 64 * 1024
+"""XMLを逐次読み込みする際の1回あたりの文字数"""
+
+XML_READ_HEADER_CHUNK_SIZE: Final[int] = 8 * 1024
+"""XMLの前文を逐次読み込みする際の1回あたりの文字数"""

stbkit/core/_internal/extension_utils.py

@@ -0,0 +1,238 @@
+# 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 ..data_model.common import StBridgeElement, StBridgeRoot, _FieldKind, _InvalidValue
+from ..stb_reporting import Code, Phase, Reporter
+from .name_converter import private_field_name
+
+
+@dataclass(kw_only=True, frozen=True)
+class AttributeInfo:
+    name: str
+    type: str
+
+
+@dataclass(kw_only=True)
+class ExtensionInfo:
+    """拡張情報により定義された、要素の拡張。
+
+    リポジトリで処理しやすいように、ST-Bridge上の表記と表現を変えているので注意。
+
+    - element_name: 対象の要素。
+    - attribute_infos: その要素が持ってよい属性一覧
+    - parent_name: 対象の要素が所属する親要素。既存要素は既に親が決まっており、親チェックが不要なため省略。
+    """
+
+    element_name: str
+    attribute_infos: set[AttributeInfo] = field(default_factory=set)
+    parent_name: str | None = None
+
+
+class ExtensionInfoRepository:
+    def __init__(self) -> None:
+        self._registry: dict[str, ExtensionInfo] = {}
+
+    def register(
+        self,
+        stb: StBridgeRoot,
+        *,
+        reporter: Reporter,
+        phase: Phase = Phase.VALIDATE,
+    ) -> None:
+        from stbkit.core.data_model import (
+            stb_v2_0_1,
+            stb_v2_0_2,
+            stb_v2_1_0,
+            stb_v2_1_1,
+        )
+
+        if isinstance(
+            stb,
+            (
+                stb_v2_0_1.StBridge,
+                stb_v2_0_2.StBridge,
+                stb_v2_1_0.StBridge,
+                stb_v2_1_1.StBridge,
+            ),
+        ):
+            if stb.stb_extensions_or_none is None:
+                return
+            for extension in stb.stb_extensions.stb_extension:
+                for ext_elm in extension.stb_ext_element:
+                    if ext_elm.object_name_or_none is None:
+                        continue
+                    element_name: str
+                    parent_name: str | None
+                    if ext_elm.element_name_or_none is None:
+                        element_name = ext_elm.object_name
+                        parent_name = None
+                    else:
+                        element_name = ext_elm.element_name
+                        parent_name = ext_elm.object_name
+                    ext_info: ExtensionInfo = self._register_element(
+                        element_name,
+                        parent_name,
+                        definition=ext_elm,
+                        reporter=reporter,
+                        phase=phase,
+                    )
+                    for ext_prop in ext_elm.stb_ext_property_def:
+                        if ext_prop.key_or_none is None:
+                            continue
+                        if ext_prop.type_or_none is None:
+                            continue
+                        attr_info = AttributeInfo(
+                            name=ext_prop.key,
+                            type=ext_prop.type,
+                        )
+                        if attr_info not in ext_info.attribute_infos:
+                            ext_info.attribute_infos.add(attr_info)
+
+    def _register_element(
+        self,
+        element_name: str,
+        parent_name: str | None,
+        *,
+        definition: StBridgeElement,
+        reporter: Reporter,
+        phase: Phase,
+    ) -> ExtensionInfo:
+        """対象要素の拡張定義登録。
+
+        同じ要素名に対して別の定義ある場合は、拡張定義として矛盾しているためエラー出力し、先にでてきた定義を優先します。
+        """
+        ext_info: ExtensionInfo | None = self._registry.get(element_name)
+        if ext_info is None:
+            ext_info = ExtensionInfo(
+                element_name=element_name,
+                attribute_infos=set(),
+                parent_name=parent_name,
+            )
+            self._registry[element_name] = ext_info
+            return ext_info
+        if ext_info.parent_name != parent_name:
+            reporter.error(
+                message=(
+                    f"要素[{element_name}]の拡張定義が重複しています。"
+                    "element_nameに記載する、拡張する子要素の名前は、拡張する子要素同志で重複しないことが求められます。"
+                    "処理では先に定義した内容を採用します"
+                ),
+                code=Code.EXTENSION_ERROR,
+                phase=phase,
+                stb_element=definition,
+                value=f"採用:element_name={ext_info.element_name},object_name={ext_info.parent_name},",
+                ref_value=f"無視:element_name={element_name},object_name={parent_name},",
+            )
+        return ext_info
+
+    def _allowed_attribute_names_by_element_name(self, element_name: str) -> set[str]:
+        ext_info: ExtensionInfo | None = self._registry.get(element_name)
+        if ext_info is None:
+            return set()
+        return {attr.name for attr in ext_info.attribute_infos}
+
+    def _allowed_attribute_names(self, stb_element: StBridgeElement) -> set[str]:
+        return self._allowed_attribute_names_by_element_name(stb_element._xml_name())
+
+    def _is_allowed_child_name(self, *, child_name: str, parent_name: str) -> bool:
+        ext_info: ExtensionInfo | None = self._registry.get(child_name)
+        if ext_info is None or ext_info.parent_name is None:
+            return False
+        return ext_info.parent_name == parent_name
+
+    def _is_allowed_child(
+        self, *, child: StBridgeElement, parent: StBridgeElement
+    ) -> bool:
+        return self._is_allowed_child_name(
+            child_name=child._xml_name(), parent_name=parent._xml_name()
+        )
+
+    def _attribute_infos(
+        self, stb_element: StBridgeElement
+    ) -> tuple[AttributeInfo, ...]:
+        ext_info: ExtensionInfo | None = self._registry.get(stb_element._xml_name())
+        if ext_info is None:
+            return ()
+        return tuple(sorted(ext_info.attribute_infos, key=lambda info: info.name))
+
+    def _child_element_names(self, parent: StBridgeElement) -> tuple[str, ...]:
+        parent_name: str = parent._xml_name()
+        return tuple(
+            ext_info.element_name
+            for ext_info in self._registry.values()
+            if ext_info.parent_name == parent_name
+        )
+
+    def repair_stb(
+        self,
+        stb_element: StBridgeElement,
+        reporter: Reporter,
+        phase: Phase = Phase.VALIDATE,
+    ) -> None:
+        ext = stb_element._extension
+        element_name: str = stb_element._xml_name()
+        # 拡張情報で説明できない属性・子要素は不正値として退避させる
+        allowed_attribute_names: set[str] = self._allowed_attribute_names(stb_element)
+        if ext is not None:
+            keys = list(ext._attributes.keys()) if ext._attributes else []
+            for key in keys:
+                if ext._attributes and key not in allowed_attribute_names:
+                    value = ext._attributes.pop(key)
+                    # 未知属性はモデルの_field_infoに存在しないため、XPathを直接生成する
+                    path_xml = f"{stb_element._path_xml()}/@{key}"
+                    reporter.error(
+                        message=(
+                            f"要素[{element_name}]の不明な拡張属性[{key}]を削除しました"
+                        ),
+                        code=Code.EXTENSION_ERROR,
+                        phase=phase,
+                        value=value,
+                        xpath=path_xml,
+                    )
+                    ext._set_invalid_value(
+                        _InvalidValue(
+                            kind=_FieldKind.ATTRIBUTE,
+                            value=value,
+                            path=path_xml,
+                            reason="拡張定義されていない拡張属性",
+                        )
+                    )
+            if ext._children:
+                for i in reversed(range(len(ext._children))):
+                    child = ext._children[i]
+                    child_name: str = child._xml_name()
+                    if not self._is_allowed_child(child=child, parent=stb_element):
+                        reporter.error(
+                            message=(
+                                f"要素[{element_name}]の不明な拡張要素[{child_name}]を削除しました"
+                            ),
+                            code=Code.EXTENSION_ERROR,
+                            phase=phase,
+                            xpath=child._path_xml(),
+                        )
+                        ext._set_invalid_value(
+                            _InvalidValue(
+                                kind=_FieldKind.ELEMENT,
+                                value=child,
+                                path=child._path_xml(),
+                                reason="拡張定義されていない拡張子要素",
+                            )
+                        )
+                        ext._children.pop(i)
+                for child in ext._children:
+                    self.repair_stb(child, reporter, phase)
+        for key, fi in stb_element._fields.items():
+            if fi.kind is _FieldKind.ELEMENT:
+                p_name: str = private_field_name(key)
+                value = getattr(stb_element, p_name)
+                if isinstance(value, StBridgeElement):
+                    self.repair_stb(value, reporter, phase)
+                elif isinstance(value, list):
+                    for v in value:
+                        if isinstance(v, StBridgeElement):
+                            self.repair_stb(v, reporter, phase)

stbkit/core/_internal/io_text.py

@@ -0,0 +1,48 @@
+# 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 os
+from typing import IO
+
+from ..stb_exceptions import XmlLimitExceededError, XmlLimitKind
+from ..stb_typing import TextSource
+from .constants import DEFAULT_MAX_XML_SIZE, XML_READ_CHUNK_SIZE
+
+
+def load_text(
+    src: TextSource, *, encoding: str, max_size: int = DEFAULT_MAX_XML_SIZE
+) -> str:
+    """テキストの読み込み
+
+    メモリ保護のため、サイズの上限を設ける。
+    """
+    # ファイルオブジェクトの場合は上限より1文字多く読み、超過したら例外を投げる
+    if not isinstance(src, (str, os.PathLike)):
+        return _read_limited(src, max_size=max_size)
+    # ファイルパスの場合はファイルサイズを確認し、上限を超えるファイルは例外を投げる
+    size: int = os.stat(src).st_size
+    if size > max_size:
+        raise XmlLimitExceededError(kind=XmlLimitKind.SIZE, limit=max_size, actual=size)
+    with open(src, encoding=encoding) as f:
+        return _read_limited(f, max_size=max_size)
+
+
+def _read_limited(src: IO[str], *, max_size: int) -> str:
+    """上限より1文字多く読み、超過したら例外を投げる"""
+    # readにmax_sizeをそのまま渡すと、実際のデータ量と無関係にその大きさのバッファを確保するため、分割して読みこむ。
+    chunks: list[str] = []
+    remaining: int = max_size + 1
+    while remaining > 0:
+        chunk: str = src.read(min(remaining, XML_READ_CHUNK_SIZE))
+        if not chunk:
+            break
+        chunks.append(chunk)
+        remaining -= len(chunk)
+
+    result: str = "".join(chunks)
+    if len(result) > max_size:
+        raise XmlLimitExceededError(kind=XmlLimitKind.SIZE, limit=max_size)
+    return result

stbkit/core/_internal/name_converter.py

@@ -0,0 +1,170 @@
+# 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 re
+from typing import Final
+
+RESERVED_WORDS: Final[set[str]] = {"as", "ensure"}
+"""Pythonの予約語及び、基底クラスで利用している属性名。かぶったら末尾にアンダーバーを付ける。"""
+
+
+def pascal_case_to_snake_case(input_string: str) -> str:
+    """
+    PascalCase -> snake_case。camelCase -> snake_caseにも対応。
+    """
+    if not input_string:
+        return input_string
+
+    # ColumnSSame -> ColumnS_Same などの対策
+    result = re.sub(
+        r"([A-Z]+)([A-Z][a-z])",
+        r"\1_\2",
+        input_string,
+    )
+
+    result = re.sub(
+        r"([a-z0-9])([A-Z])",
+        r"\1_\2",
+        result,
+    )
+
+    return result.lower()
+
+
+def snake_case_to_large_snake_case(input_string: str) -> str:
+    return input_string.upper()
+
+
+def snake_case_to_lower_camel_case(input_string: str) -> str:
+    if not input_string:
+        return input_string
+    first, *rest = input_string.split("_")
+    return first + "".join(part[:1].upper() + part[1:] for part in rest if part)
+
+
+def xml_element_name_to_pascal_case(xml_element_name: str) -> str:
+    result: str = (
+        xml_element_name.replace("-", "_")
+        .replace("_member", "_Member")
+        .replace("_RC_", "Rc")
+        .replace("_S_", "S")
+        .replace("_SRC_", "Src")
+        .replace("_CFT_", "Cft")
+        .replace("ST_BRIDGE", "StBridge")
+        .replace("NRBProperty", "NrbProperty")
+        .replace("HDRProperty", "HdrProperty")
+        .replace("LRBProperty", "LrbProperty")
+        .replace("TRBProperty", "TrbProperty")
+        .replace("SDRBProperty", "SdrbProperty")
+        .replace("ESBProperty", "EsbProperty")
+        .replace("RSBProperty", "RsbProperty")
+        .replace("CSBProperty", "CsbProperty")
+        .replace("CSLBProperty", "CslbProperty")
+        .replace("CLBProperty", "ClbProperty")
+        .replace("EGring", "Egring")
+        .replace("FRring", "Frring")
+        .replace("OSring", "Osring")
+        .replace("Lip2C", "Lip2c")
+    )
+    suffix_map = [
+        ("_2C", "2c"),
+        ("_2L", "2l"),
+        ("_BOX", "Box"),
+        ("_C", "C"),
+        ("_CFT", "Cft"),
+        ("CMQ", "Cmq"),
+        ("_CPRC", "Cprc"),
+        ("_H", "H"),
+        ("_HAssymmetric", "HAssymmetric"),
+        ("_HAsymmetric", "HAsymmetric"),
+        ("_L", "L"),
+        ("_PHC", "Phc"),
+        ("_PRC", "Prc"),
+        ("_RC", "Rc"),
+        ("_S", "S"),
+        ("_SC", "Sc"),
+        ("_SRC", "Src"),
+        ("_ST", "St"),
+        ("_T", "T"),
+        ("NRB", "Nrb"),
+        ("SP", "Sp"),
+        ("HDR", "Hdr"),
+        ("LRB", "Lrb"),
+        ("TRB", "Trb"),
+        ("SDRB", "Sdrb"),
+        ("ESB", "Esb"),
+        ("RSB", "Rsb"),
+        ("CSB", "Csb"),
+        ("CLSB", "Clsb"),
+        ("CLB", "Clb"),
+        ("LB", "Lb"),
+        ("RB", "Rb"),
+    ]
+    for suffix, replacement in suffix_map:
+        if result.endswith(suffix):
+            result = result[: -len(suffix)] + replacement
+            break
+    return result
+
+
+def xml_element_name_to_snake_case(xml_element_name: str) -> str:
+    result: str = (
+        pascal_case_to_snake_case(xml_element_name_to_pascal_case(xml_element_name))
+        .replace("rc2_way", "rc_2_way")
+        .replace("rc1_way", "rc_1_way")
+        .replace("roll2c", "roll_2c")
+        .replace("roll2l", "roll_2l")
+        .replace("lip2c", "lip_2c")
+    )
+    return result
+
+
+def xml_element_name_to_large_snake_case(xml_element_name: str) -> str:
+    return snake_case_to_large_snake_case(
+        xml_element_name_to_snake_case(xml_element_name)
+    )
+
+
+def xml_element_name_to_python_class_name(xml_element_name: str) -> str:
+    return xml_element_name_to_pascal_case(xml_element_name)
+
+
+def xml_attribute_name_to_snake_case(xml_attribute_name: str) -> str:
+    return pascal_case_to_snake_case(xml_attribute_name)
+
+
+def snake_case_to_python_attribute_name(name: str) -> str:
+    if name in RESERVED_WORDS:
+        name = f"{name}_"
+    return name
+
+
+def xml_element_name_to_key(element_name: str) -> str:
+    return xml_attribute_name_to_python_attribute_name(
+        xml_element_name_to_snake_case(element_name)
+    )
+
+
+def xml_attribute_name_to_python_attribute_name(attribute_name: str) -> str:
+    return snake_case_to_python_attribute_name(
+        xml_attribute_name_to_snake_case(attribute_name.replace("@", ""))
+    )
+
+
+def content_py_attr_name() -> str:
+    return "content"
+
+
+def private_field_name(key: str) -> str:
+    return f"_{key}"
+
+
+def property_name(key: str) -> str:
+    return key
+
+
+def or_none_property_name(key: str) -> str:
+    return f"{key}_or_none"

stbkit/core/_internal/optional_dependencies/xmlschema_validator.py

@@ -0,0 +1,163 @@
+# 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/.
+
+import re
+from collections.abc import Mapping
+from functools import cache
+from pathlib import Path
+from typing import Any
+
+from ...stb_reporting import Code, NullReporter, Phase
+from ...validation._internal.common import ValidationContext
+from ..extension_utils import ExtensionInfoRepository
+
+
+def _print_import_error() -> None:
+    import sys
+
+    print(
+        "xmlschemaがインストールされていません。下記コマンドでインストールしてください。\n"
+        "pip install xmlschema\n"
+        "または\n"
+        "pip install stbkit[xsd]\n",
+        file=sys.stderr,
+    )
+
+
+@cache
+def _load_xmlschema(xsd_path: Path) -> Any:
+    import xmlschema
+
+    xsd_str: str = xsd_path.read_text(encoding="utf-8")
+    # 公式スキーマのファイル頭に余計な文字が入っているのを取り除く処理
+    while xsd_str and xsd_str[0] != "<":
+        xsd_str = xsd_str[1:]
+
+    return xmlschema.XMLSchema(xsd_str)
+
+
+# 定義に無い属性のエラーメッセージを検出する正規表現。
+_ATTRIBUTE_NOT_ALLOWED_RE = re.compile(
+    r"^'(?P<name>[^']+)' attribute not allowed for element$"
+)
+
+
+def _is_legal_extension_error(error: Any, *, ext_repo: ExtensionInfoRepository) -> bool:
+    """XSDのエラーが、ST-Bridge仕様で認められる拡張かを返す
+
+    判断できないエラーはFalse
+    """
+    from xmlschema.validators import XMLSchemaChildrenValidationError
+
+    from ...stb_io._internal.stream_reader import _delete_namespace
+
+    elem: Any = getattr(error, "elem", None)
+    if elem is None:
+        return False
+    element_name: str = _delete_namespace(str(elem.tag))
+
+    if isinstance(error, XMLSchemaChildrenValidationError):
+        if error.invalid_tag is None:
+            return False
+        return ext_repo._is_allowed_child_name(
+            child_name=_delete_namespace(str(error.invalid_tag)),
+            parent_name=element_name,
+        )
+
+    matched = _ATTRIBUTE_NOT_ALLOWED_RE.match(str(getattr(error, "reason", None) or ""))
+    if matched is None:
+        return False
+    attribute_name: str = matched.group("name")
+    # 解釈が適切か、要素が実際にその属性を持つかで確認する
+    attributes: Any = getattr(error, "obj", None)
+    if not isinstance(attributes, Mapping) or attribute_name not in attributes:
+        return False
+    return attribute_name in ext_repo._allowed_attribute_names_by_element_name(
+        element_name
+    )
+
+
+def validate_by_xsd(
+    xsd_path: Path | None,
+    ctx: ValidationContext,
+    *,
+    require_xsd: bool = False,
+    use_cache: bool = True,
+    exclude_legal_extensions: bool = False,
+) -> bool:
+    try:
+        if xsd_path is None:
+            ctx.reporter.error(
+                message="xsd:XSDファイルのパスが指定されていません。XSDによるスキーマチェックはスキップします。",
+                code=Code.SCHEMA_ERROR,
+                phase=Phase.VALIDATE,
+            )
+            return not require_xsd
+        import xmlschema
+        from xmlschema import XMLSchemaException
+
+        try:
+            resolved_xsd_path: Path = xsd_path.resolve()
+            if use_cache:
+                schema = _load_xmlschema(resolved_xsd_path)
+            else:
+                schema = xmlschema.XMLSchema(resolved_xsd_path)
+        except XMLSchemaException as e:
+            ctx.reporter.error(
+                message=f"xsd:XSDファイルの読み込みに失敗しました: {e}。詳細スキーマチェックはスキップします。",
+                code=Code.UNEXPECTED_ERROR,
+                phase=Phase.VALIDATE,
+            )
+            return not require_xsd
+        ext_repo: ExtensionInfoRepository | None = None
+        if exclude_legal_extensions:
+            ext_repo = ExtensionInfoRepository()
+            # 拡張定義のエラーメッセージはload時に出力しているため、ここでは出力しない
+            ext_repo.register(ctx.obj(), reporter=NullReporter())
+        errors = []
+        xpaths = []
+        for error in schema.iter_errors(ctx.xml()):
+            if ext_repo is not None and _is_legal_extension_error(
+                error, ext_repo=ext_repo
+            ):
+                continue
+            line = getattr(error, "line", None)
+            xpath = error.path
+            raw_msg = (
+                getattr(error, "reason", None)
+                or getattr(error, "message", None)
+                or str(error)
+            )
+            msg = str(raw_msg).strip()
+            info = []
+            if line is not None:
+                info.append(f"line-{line}")
+            info_str = " / ".join(info)
+            if info_str:
+                errors.append(f"{info_str}: {msg}")
+            else:
+                errors.append(f"{msg}")
+            xpaths.append(xpath)
+
+        if not errors:
+            return True
+        else:
+            for err, xpath in zip(errors, xpaths):
+                ctx.reporter.error(
+                    message=f"xsd:{err}",
+                    code=Code.SCHEMA_ERROR,
+                    phase=Phase.VALIDATE,
+                    xpath=xpath,
+                )
+            return False
+    except ImportError:
+        ctx.reporter.warning(
+            message="xmlschemaパッケージがインストールされていません。XSDによるスキーマチェックはスキップします。",
+            code=Code.OPTIONAL_DEPENDENCY_MISSING,
+            phase=Phase.VALIDATE,
+        )
+        _print_import_error()
+        return not require_xsd