kompas-kernel 0.0.1__py3-none-any.whl

kompas_kernel/__init__.py

@@ -0,0 +1,3 @@
+"""Framework-neutral KOMPAS product kernel."""
+
+from __future__ import annotations

kompas_kernel/features/__init__.py

@@ -0,0 +1,9 @@
+"""Framework-free capability slices for live work with a KOMPAS document/assembly.
+
+Kernel owns the framework-free feature slices that talk to a live `KompasSession`
+(`document_session`, `geometry_3d`, `assembly_navigator`, `wrench_clearance`) and the
+`run_python` sandbox-policy slices (`ksapi_automation`, `part_authoring`, E17.04e): DTO,
+queries/commands, gate/namespace policy and their own `ksapi/` implementation, with no
+Pydantic AI and no Copilot import. Agent wiring, tool surface and model-facing text stay
+in Copilot (`kompas_copilot.core.capabilities`).
+"""

kompas_kernel/features/assembly_navigator/__init__.py

@@ -0,0 +1,8 @@
+"""Assembly navigator feature slice: read + show top-level КОМПАС-Сборка components.
+
+Framework-free (no Pydantic AI, no `kompas_copilot.bridge`): owns its DTO (`models.py`),
+raw KsAPI reader/resolver/presentation (`ksapi/`), public query/command API
+(`queries.py`/`commands.py`) over a `KompasSession`, and a thin service holder
+(`service.py`). Thin Pydantic AI registration lives in
+`core/capabilities/assembly_navigator.py`.
+"""

kompas_kernel/features/assembly_navigator/commands.py

@@ -0,0 +1,37 @@
+"""Framework-free public show/select command for the assembly navigator.
+
+No Pydantic AI, no `kompas_copilot.bridge` import — raw KsAPI select+zoom lives in
+`ksapi/presentation.py`; this module only validates the empty-list precondition and
+wires it through one session callback.
+"""
+
+from __future__ import annotations
+
+from kompas_kernel.features.assembly_navigator.ksapi.presentation import select_components_and_zoom
+from kompas_kernel.features.assembly_navigator.models import ComponentIdentifiers, ShowComponentsResult
+from kompas_kernel.kompas.errors import KompasError
+from kompas_kernel.kompas.session import KompasContext, KompasSession
+
+
+async def show_components(session: KompasSession, identifiers: ComponentIdentifiers) -> ShowComponentsResult:
+    """Выделить компоненты и зумнуть вид по общему выделению (И3).
+
+    `identifiers` — непустой список индексов из `read_assembly`
+    (поле `AssemblyComponent.identifier`). Для одного компонента передаётся
+    список из одного элемента.
+
+    Все найденные цели передаются одним списком в `ISelectionManager.Select`, после
+    чего `ksCMZoomSelected` вызывается ровно один раз. Невалидный индекс отражается
+    как `found=False` и не мешает показать остальные найденные компоненты.
+    """
+    if not identifiers:
+        raise KompasError("show_component: передан пустой список идентификаторов")
+    identifier_snapshot = list(identifiers)
+
+    def _select(context: KompasContext) -> ShowComponentsResult:
+        return select_components_and_zoom(context.modules, context.app, identifier_snapshot)
+
+    return await session.run(
+        operation_name="assembly_navigator.show_component",
+        operation=_select,
+    )

kompas_kernel/features/assembly_navigator/ksapi/__init__.py

@@ -0,0 +1,5 @@
+"""Raw KsAPI reads for the assembly navigator: reader, resolver, presentation, mapping.
+
+Everything that touches raw `IPart`/`ksapi.py` objects lives here, inside a
+`KompasSession.run(...)` callback — no raw handle leaves this package.
+"""

kompas_kernel/features/assembly_navigator/ksapi/mapping.py

@@ -0,0 +1,122 @@
+"""Pure RawAssembly -> AssemblyView mapping without live KsAPI calls.
+
+Перенесено из `bridge/kompas_ksapi/pure/assembly.py` (E16.04) без изменения поведения.
+"""
+
+from __future__ import annotations
+
+from kompas_kernel.features.assembly_navigator.ksapi.raw import (
+    RawAssembly,
+    RawComponent,
+    RawStandardComponentInfo,
+    RawStandardReferenceObject,
+)
+from kompas_kernel.features.assembly_navigator.models import (
+    AssemblyComponent,
+    AssemblyView,
+    ComponentKind,
+    ComponentLoadState,
+    ComponentPlacement,
+    StandardComponentAxis,
+    StandardComponentInfo,
+    StandardComponentPlane,
+    StandardReferenceObject,
+)
+from kompas_kernel.kompas.models import BBox, Point3D
+from kompas_kernel.kompas.objects import Gabarit
+
+# Маппинг ksLoadStateEnum (ksConstants.h) -> ComponentLoadState.
+# Кодировка: -1 = недоступно/неизвестно, 0 = полная загрузка, 1 = выгружен,
+# 2 = только треугольники, 3 = частичная загрузка, 4 = только габарит.
+# Неизвестный код (не перечислен ниже) -> UNKNOWN.
+_LOAD_STATE_MAP: dict[int, ComponentLoadState] = {
+    -1: ComponentLoadState.UNKNOWN,
+    0: ComponentLoadState.FULL,
+    1: ComponentLoadState.UNLOADED,
+    2: ComponentLoadState.TRIANGLES,
+    3: ComponentLoadState.PARTIAL,
+    4: ComponentLoadState.GABARIT,
+}
+
+
+def build_assembly_view(raw: RawAssembly) -> AssemblyView:
+    """`RawAssembly` -> `AssemblyView`: маппит сырые поля в DTO без КОМПАС.
+
+    Не делает запросов к KsAPI - полностью детерминирован и тестируем без КОМПАС.
+    """
+    components = [_build_component(rc) for rc in raw.components]
+    return AssemblyView(
+        is_assembly=raw.is_assembly,
+        top_marking=raw.top_marking,
+        components=components,
+        component_count=len(components),
+    )
+
+
+def _build_component(rc: RawComponent) -> AssemblyComponent:
+    """Маппинг одного RawComponent -> AssemblyComponent (порт DTO)."""
+    bbox = None if rc.gabarit_mm is None else _bbox_from_gabarit(rc.gabarit_mm)
+    load_state = _LOAD_STATE_MAP.get(rc.load_state_code, ComponentLoadState.UNKNOWN)
+    kind = ComponentKind.PART if rc.is_detail else ComponentKind.SUBASSEMBLY
+    placement = ComponentPlacement(
+        origin_x=rc.origin_x,
+        origin_y=rc.origin_y,
+        origin_z=rc.origin_z,
+    )
+    return AssemblyComponent(
+        identifier=rc.identifier,
+        marking=rc.marking,
+        name=rc.name,
+        kind=kind,
+        is_standard=rc.is_standard,
+        placement=placement,
+        bbox=bbox,
+        standard=_build_standard_info(rc.standard),
+        load_state=load_state,
+        visible=rc.visible,
+        valid=rc.valid,
+        excluded=rc.excluded,
+    )
+
+
+def _build_standard_info(raw: RawStandardComponentInfo | None) -> StandardComponentInfo | None:
+    if raw is None:
+        return None
+    axis = None
+    if raw.axis_origin is not None and raw.axis_direction is not None:
+        axis = StandardComponentAxis(
+            origin=_point_from_tuple(raw.axis_origin),
+            direction=_point_from_tuple(raw.axis_direction),
+            reference=_build_standard_reference(raw.axis_reference),
+        )
+    plane = None
+    if raw.plane_origin is not None and raw.plane_normal is not None:
+        plane = StandardComponentPlane(
+            origin=_point_from_tuple(raw.plane_origin),
+            normal=_point_from_tuple(raw.plane_normal),
+            reference=_build_standard_reference(raw.plane_reference),
+        )
+    return StandardComponentInfo(file_name=raw.file_name, axis=axis, plane=plane)
+
+
+def _build_standard_reference(raw: RawStandardReferenceObject | None) -> StandardReferenceObject | None:
+    if raw is None:
+        return None
+    return StandardReferenceObject(name=raw.name, model_object_type=raw.model_object_type, source=raw.source)
+
+
+def _point_from_tuple(point: tuple[float, float, float]) -> Point3D:
+    return Point3D(x_mm=point[0], y_mm=point[1], z_mm=point[2])
+
+
+def _bbox_from_gabarit(gabarit: Gabarit) -> BBox:
+    """Кортеж (x1, y1, z1, x2, y2, z2) -> BBox с нормализованными min/max."""
+    x1, y1, z1, x2, y2, z2 = gabarit
+    return BBox(
+        min_x=min(x1, x2),
+        min_y=min(y1, y2),
+        min_z=min(z1, z2),
+        max_x=max(x1, x2),
+        max_y=max(y1, y2),
+        max_z=max(z1, z2),
+    )

kompas_kernel/features/assembly_navigator/ksapi/presentation.py

@@ -0,0 +1,107 @@
+"""Live KsAPI select+zoom for one or more assembly components.
+
+Перенесено дословно из `KompasKsApiAdapter._select_components_and_zoom`
+(`bridge/kompas_ksapi/adapter.py:497-578`, E16.04): один `Select` на все найденные цели,
+один `ksCMZoomSelected` c `async=True`, тот же лог-эвент
+`bridge.ksapi_show_component.completed`. Индекс резолвится тем же `resolver.py`, что и
+`reader.py` — устраняет прежнее раздвоение numbering/parsing между чтением и показом.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from kompas_kernel.features.assembly_navigator.ksapi.resolver import list_components, resolve_index
+from kompas_kernel.features.assembly_navigator.models import ComponentShowResult, ShowComponentsResult
+from kompas_kernel.kompas.errors import KompasError
+from kompas_kernel.kompas.objects import as_document_3d, constants_class
+from kompas_kernel.kompas.runtime import KsApiModules
+from kompas_kernel.observability.logger import get_logger
+from kompas_kernel.observability.taxonomy import LogDomain, LogEventType, event_name
+
+logger = get_logger(__name__)
+
+
+def select_components_and_zoom(modules: KsApiModules, app: Any, identifiers: list[str]) -> ShowComponentsResult:
+    """Выделить найденные компоненты одним `Select`, затем зумнуть одной командой.
+
+    Невалидный индекс отражается как `found=False` у соответствующего результата и не
+    мешает показать остальные найденные компоненты.
+    """
+    doc3d = as_document_3d(modules, app.GetActiveDocument())
+    if doc3d is None:
+        raise KompasError("show_component: активный документ не 3D")
+    constants = constants_class(modules)
+    top = doc3d.GetTopPart()
+    components = list_components(modules, top)
+
+    resolutions: list[tuple[str, int | None]] = []
+    target_indices: list[int] = []
+    seen_indices: set[int] = set()
+    for requested_identifier in identifiers:
+        resolved_index = resolve_index(components, requested_identifier)
+        resolutions.append((requested_identifier, resolved_index))
+        if resolved_index is not None and resolved_index not in seen_indices:
+            seen_indices.add(resolved_index)
+            target_indices.append(resolved_index)
+
+    if not target_indices:
+        logger.info(
+            event_name(LogDomain.BRIDGE, "ksapi_show_component", LogEventType.COMPLETED),
+            identifiers=identifiers,
+            requested_count=len(identifiers),
+            found_count=0,
+            selected_count=0,
+            zoomed=False,
+        )
+        return ShowComponentsResult(
+            components=tuple(
+                ComponentShowResult(identifier=value, found=False, selected=False, marking="")
+                for value, _index in resolutions
+            ),
+            zoomed=False,
+        )
+
+    targets = [components[index] for index in target_indices]
+    sm = doc3d.GetSelectionManager()
+    sm.UnselectAll()
+    sm.Select(targets)
+    selected_by_index = {
+        index: bool(sm.IsSelected(target)) for index, target in zip(target_indices, targets, strict=True)
+    }
+    all_found_selected = all(selected_by_index.values())
+    # Зум по выделению: ExecuteKompasCommand требует async=True — sync с worker-потока
+    # не отрабатывает (ksCMZoomSelected = 32416). См. docs/recipes/ksapi-link.md.
+    zoomed = all_found_selected and bool(app.ExecuteKompasCommand(int(constants.ksCMZoomSelected), True))
+
+    results: list[ComponentShowResult] = []
+    for requested_identifier, index in resolutions:
+        if index is None:
+            results.append(
+                ComponentShowResult(
+                    identifier=requested_identifier,
+                    found=False,
+                    selected=False,
+                    marking="",
+                )
+            )
+            continue
+        marking_raw = components[index].GetMarking()
+        results.append(
+            ComponentShowResult(
+                identifier=requested_identifier,
+                found=True,
+                selected=selected_by_index[index],
+                marking=str(marking_raw) if marking_raw is not None else "",
+            )
+        )
+
+    logger.info(
+        event_name(LogDomain.BRIDGE, "ksapi_show_component", LogEventType.COMPLETED),
+        identifiers=identifiers,
+        requested_count=len(identifiers),
+        found_count=sum(index is not None for _identifier, index in resolutions),
+        selected_count=sum(selected_by_index[index] for _identifier, index in resolutions if index is not None),
+        zoomed=zoomed,
+    )
+    return ShowComponentsResult(components=tuple(results), zoomed=zoomed)

kompas_kernel/features/assembly_navigator/ksapi/raw.py

@@ -0,0 +1,74 @@
+"""Raw assembly facts read from KsAPI before mapping to public DTOs.
+
+Перенесено из `bridge/kompas_ksapi/raw/assembly.py` (E16.04). `Gabarit` теперь живёт в
+`kompas_kernel.kompas.objects` (общий примитив, используется и вне assembly navigator).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from kompas_kernel.features.assembly_navigator.models import StandardReferenceSource
+from kompas_kernel.kompas.objects import Gabarit
+
+
+@dataclass(frozen=True)
+class RawStandardReferenceObject:
+    """Сырой факт о найденном опорном объекте стандартного компонента."""
+
+    name: str
+    model_object_type: int
+    source: StandardReferenceSource
+
+
+@dataclass(frozen=True)
+class RawStandardComponentInfo:
+    """Сырые дополнительные поля для `IPart.IsStandard()==True`."""
+
+    file_name: str | None
+    axis_origin: tuple[float, float, float] | None
+    axis_direction: tuple[float, float, float] | None
+    axis_reference: RawStandardReferenceObject | None
+    plane_origin: tuple[float, float, float] | None
+    plane_normal: tuple[float, float, float] | None
+    plane_reference: RawStandardReferenceObject | None
+
+
+@dataclass(frozen=True)
+class RawComponent:
+    """Сырые поля одного компонента (IPart) из GetPartsArray - до маппинга в DTO.
+
+    `identifier` - строковый индекс в массиве GetPartsArray, стабилен в сессии.
+    `name` - None, если GetName() вернул пустую строку (нормализуется reader'ом).
+    `gabarit_mm` - (x1, y1, z1, x2, y2, z2) в мм; None если нет тела/габарита.
+    `load_state_code` - сырое целое из GetLoadState() (ksLoadStateEnum).
+    """
+
+    identifier: str
+    marking: str
+    name: str | None
+    is_standard: bool
+    standard: RawStandardComponentInfo | None
+    is_detail: bool
+    origin_x: float
+    origin_y: float
+    origin_z: float
+    gabarit_mm: Gabarit | None
+    load_state_code: int
+    visible: bool
+    valid: bool
+    excluded: bool
+
+
+@dataclass(frozen=True)
+class RawAssembly:
+    """Сырой снимок верхнего уровня сборки/детали - до маппинга в AssemblyView.
+
+    `is_assembly` - True если GetDocumentType() == ksDocumentAssembly (5).
+    `top_marking` - обозначение головного Part из GetMarking().
+    `components` - список сырых компонентов верхнего уровня (все вставки, дубли сохранены).
+    """
+
+    is_assembly: bool
+    top_marking: str
+    components: list[RawComponent]

kompas_kernel/features/assembly_navigator/ksapi/reader.py

@@ -0,0 +1,287 @@
+"""Live KsAPI reader for top-level assembly components and standard-component facts.
+
+Перенесено из `bridge/kompas_ksapi/api/assembly_reader.py` + `api/standard_parts.py`
+(E16.04, слиты в один файл — `standard_parts.py` был единственным потребителем
+`read_raw_standard_component`). Компонентная нумерация и резолв индекса теперь общие
+с `presentation.py` через `resolver.py` (устраняет прежнее раздвоение `enumerate` vs
+`_parse_index`), поведение и семантика не изменились.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from kompas_kernel.features.assembly_navigator.ksapi.raw import (
+    RawAssembly,
+    RawComponent,
+    RawStandardComponentInfo,
+    RawStandardReferenceObject,
+)
+from kompas_kernel.features.assembly_navigator.ksapi.resolver import component_identifier, list_components
+from kompas_kernel.features.assembly_navigator.models import StandardReferenceSource
+from kompas_kernel.kompas.errors import KompasError
+from kompas_kernel.kompas.objects import as_document_3d, constants3d_class, constants_class, part_gabarit
+from kompas_kernel.kompas.runtime import KsApiModules
+from kompas_kernel.observability.logger import get_logger
+from kompas_kernel.observability.taxonomy import LogDomain, LogEventType, event_name
+
+logger = get_logger(__name__)
+
+_GET_VECTOR_VALUE_COUNT = 4
+_STANDARD_AXIS_NAMES = ("Axis",)
+_STANDARD_PLANE_NAMES = ("Plane", "Plain")
+_UNNAMED_REFERENCE_NAME = "<unnamed>"
+
+
+def read_raw_assembly(modules: KsApiModules, app: Any) -> RawAssembly:
+    doc = app.GetActiveDocument()
+    doc3d = as_document_3d(modules, doc)
+    if doc3d is None:
+        raise KompasError("read_assembly: активный документ не 3D")
+    constants = constants_class(modules)
+    constants3d = constants3d_class(modules)
+    is_assembly: bool = bool(doc.GetDocumentType() == constants.ksDocumentAssembly)
+    top = doc3d.GetTopPart()
+    parts_list = list_components(modules, top)
+    components = [_read_raw_component(constants3d=constants3d, part=p, index=i) for i, p in enumerate(parts_list)]
+    top_marking_raw = top.GetMarking()
+    top_marking = str(top_marking_raw) if top_marking_raw is not None else ""
+    return RawAssembly(
+        is_assembly=is_assembly,
+        top_marking=top_marking,
+        components=components,
+    )
+
+
+def _read_raw_component(*, constants3d: Any, part: Any, index: int) -> RawComponent:
+    """Прочитать поля одного компонента (IPart) с worker-потока -> RawComponent."""
+    identifier = component_identifier(index)
+    marking = str(part.GetMarking() or "")
+    raw_name = str(part.GetName() or "")
+    name: str | None = raw_name or None
+    is_standard = bool(part.IsStandard())
+    is_detail = bool(part.IsDetail())
+
+    ox: float = 0.0
+    oy: float = 0.0
+    oz: float = 0.0
+    axis_direction: tuple[float, float, float] | None = None
+    try:
+        pl = part.GetPlacement()
+        # GetOrigin - out-параметры: возвращает (ok, x, y, z), а не голую тройку.
+        origin = pl.GetOrigin(0.0, 0.0, 0.0)
+        ox = float(origin[1])
+        oy = float(origin[2])
+        oz = float(origin[3])
+        # GetMatrix3D() (16 float, 4x4) не читаем: её не потреблял никто, кроме выдачи
+        # модели, а там она стоила ~450 байт на компонент. Ориентация стандартного
+        # изделия берётся ниже из GetVector(o3d_axisOZ) - точнее и дешевле.
+    except Exception as exc:
+        logger.warning(
+            event_name(LogDomain.BRIDGE, "ksapi_read_component_placement", LogEventType.FAILED),
+            identifier=identifier,
+            error=str(exc),
+        )
+    else:
+        axis_direction = _placement_axis_direction(
+            placement=pl,
+            constants3d=constants3d,
+            identifier=identifier,
+        )
+
+    gabarit_mm = part_gabarit(part, body_count=1)
+    load_state_code = int(part.GetLoadState())
+    visible = bool(part.IsStaffVisible())
+    valid = bool(part.IsValid())
+    excluded = bool(part.IsInheritExclude())
+    standard = (
+        read_raw_standard_component(
+            constants3d=constants3d,
+            part=part,
+            identifier=identifier,
+            origin=(ox, oy, oz),
+            axis_direction=axis_direction,
+        )
+        if is_standard
+        else None
+    )
+
+    return RawComponent(
+        identifier=identifier,
+        marking=marking,
+        name=name,
+        is_standard=is_standard,
+        standard=standard,
+        is_detail=is_detail,
+        origin_x=ox,
+        origin_y=oy,
+        origin_z=oz,
+        gabarit_mm=gabarit_mm,
+        load_state_code=load_state_code,
+        visible=visible,
+        valid=valid,
+        excluded=excluded,
+    )
+
+
+def _placement_axis_direction(
+    *,
+    placement: Any,
+    constants3d: Any,
+    identifier: str,
+) -> tuple[float, float, float] | None:
+    try:
+        vector = placement.GetVector(int(constants3d.o3d_axisOZ), 0.0, 0.0, 0.0)
+    except Exception as exc:
+        logger.warning(
+            event_name(LogDomain.BRIDGE, "ksapi_read_component_axis", LogEventType.FAILED),
+            identifier=identifier,
+            error=str(exc),
+        )
+        return None
+    if vector is None:
+        return None
+    try:
+        values = tuple(vector)
+    except TypeError:
+        logger.warning(
+            event_name(LogDomain.BRIDGE, "ksapi_read_component_axis", LogEventType.FAILED),
+            identifier=identifier,
+            error=f"unexpected GetVector result: {vector!r}",
+        )
+        return None
+    if len(values) < _GET_VECTOR_VALUE_COUNT or not bool(values[0]):
+        return None
+    return (float(values[1]), float(values[2]), float(values[3]))
+
+
+def read_raw_standard_component(
+    *,
+    constants3d: Any,
+    part: Any,
+    identifier: str,
+    origin: tuple[float, float, float],
+    axis_direction: tuple[float, float, float] | None,
+) -> RawStandardComponentInfo:
+    file_name = _read_optional_string(
+        part.GetFileName,
+        identifier=identifier,
+        field="file_name",
+    )
+    axis_reference = _read_standard_reference(
+        constants3d=constants3d,
+        part=part,
+        identifier=identifier,
+        role="axis",
+        named_candidates=_STANDARD_AXIS_NAMES,
+        default_object_type=int(constants3d.o3d_axisOZ),
+    )
+    plane_reference = _read_standard_reference(
+        constants3d=constants3d,
+        part=part,
+        identifier=identifier,
+        role="plane",
+        named_candidates=_STANDARD_PLANE_NAMES,
+        default_object_type=int(constants3d.o3d_planeXOY),
+    )
+    return RawStandardComponentInfo(
+        file_name=file_name,
+        axis_origin=origin if axis_direction is not None else None,
+        axis_direction=axis_direction,
+        axis_reference=axis_reference,
+        plane_origin=origin if axis_direction is not None else None,
+        plane_normal=axis_direction,
+        plane_reference=plane_reference,
+    )
+
+
+def _read_optional_string(read: Callable[[], object], *, identifier: str, field: str) -> str | None:
+    try:
+        raw = read()
+    except Exception as exc:
+        logger.warning(
+            event_name(LogDomain.BRIDGE, "ksapi_read_component_field", LogEventType.FAILED),
+            identifier=identifier,
+            field=field,
+            error=str(exc),
+        )
+        return None
+    value = str(raw or "")
+    return value or None
+
+
+def _read_standard_reference(
+    *,
+    constants3d: Any,
+    part: Any,
+    identifier: str,
+    role: str,
+    named_candidates: tuple[str, ...],
+    default_object_type: int,
+) -> RawStandardReferenceObject | None:
+    unknown_type = int(constants3d.o3d_unknown)
+    for name in named_candidates:
+        try:
+            obj = part.GetObjectByName(name, unknown_type, True, True)
+        except Exception as exc:
+            logger.warning(
+                event_name(LogDomain.BRIDGE, "ksapi_read_standard_reference", LogEventType.FAILED),
+                identifier=identifier,
+                role=role,
+                source=StandardReferenceSource.NAMED.value,
+                name=name,
+                error=str(exc),
+            )
+            continue
+        try:
+            reference = _standard_reference_from_object(obj, StandardReferenceSource.NAMED)
+        except Exception as exc:
+            logger.warning(
+                event_name(LogDomain.BRIDGE, "ksapi_read_standard_reference", LogEventType.FAILED),
+                identifier=identifier,
+                role=role,
+                source=StandardReferenceSource.NAMED.value,
+                name=name,
+                error=str(exc),
+            )
+            continue
+        if reference is not None:
+            return reference
+    try:
+        obj = part.GetDefaultObject(default_object_type)
+    except Exception as exc:
+        logger.warning(
+            event_name(LogDomain.BRIDGE, "ksapi_read_standard_reference", LogEventType.FAILED),
+            identifier=identifier,
+            role=role,
+            source=StandardReferenceSource.DEFAULT.value,
+            error=str(exc),
+        )
+        return None
+    try:
+        return _standard_reference_from_object(obj, StandardReferenceSource.DEFAULT)
+    except Exception as exc:
+        logger.warning(
+            event_name(LogDomain.BRIDGE, "ksapi_read_standard_reference", LogEventType.FAILED),
+            identifier=identifier,
+            role=role,
+            source=StandardReferenceSource.DEFAULT.value,
+            error=str(exc),
+        )
+        return None
+
+
+def _standard_reference_from_object(
+    obj: Any | None,
+    source: StandardReferenceSource,
+) -> RawStandardReferenceObject | None:
+    if obj is None:
+        return None
+    raw_name = str(obj.GetName() or "")
+    name = raw_name or _UNNAMED_REFERENCE_NAME
+    return RawStandardReferenceObject(
+        name=name,
+        model_object_type=int(obj.GetModelObjectType()),
+        source=source,
+    )