context

Extends the capellambse.model.diagram module with context diagrams.

Definitions of Custom Accessor- and Diagram-Classtypes based on Accessor and AbstractDiagram.

CollectorOutputData module-attribute

CollectorOutputData: TypeAlias = (
    ELKInputData | tuple[ELKInputData, ELKInputData | list[ELKInputEdge]]
)

The output of a collector or the input prepared for ELK.

CableTreeAccessor

CableTreeAccessor(dgcls: str, render_params: dict[str, Any] | None = None)

Bases: ContextAccessor

Provides access to the cable tree diagrams.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self, dgcls: str, render_params: dict[str, t.Any] | None = None
) -> None:
    super().__init__()
    self._dgcls = dgcls
    self._default_render_params = render_params or {}

__get__

__get__(
    obj: T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram

Make a CableTreeView for the given model object.

Source code in src/capellambse_context_diagrams/context.py

def __get__(  # type: ignore
    self,
    obj: m.T | None,
    objtype: type | None = None,
) -> m.Accessor | ContextDiagram:
    """Make a CableTreeView for the given model object."""
    del objtype
    if obj is None:  # pragma: no cover
        return self
    assert isinstance(obj, m.ModelElement)
    return self._get(obj, CableTreeViewDiagram)

CableTreeViewDiagram

CableTreeViewDiagram(
    class_: str,
    obj: ModelElement,
    *,
    render_styles: dict[str, Styler] | None = None,
    default_render_parameters: dict[str, Any]
)

Bases: ContextDiagram

An automatically generated CableTreeView.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    class_: str,
    obj: m.ModelElement,
    *,
    render_styles: dict[str, styling.Styler] | None = None,
    default_render_parameters: dict[str, t.Any],
) -> None:
    default_render_parameters = {
        "display_port_labels": True,
        "port_label_position": _elkjs.PORT_LABEL_POSITION.OUTSIDE,
        "include_external_context": True,
        "collect": cable_tree.collector,
        "edge_direction": enums.EDGE_DIRECTION.TREE,
    } | default_render_parameters
    super().__init__(
        class_,
        obj,
        render_styles=render_styles,
        default_render_parameters=default_render_parameters,
    )

uuid property

uuid: str

Returns the UUID of the diagram.

ClassTreeAccessor

ClassTreeAccessor(diagclass: str, render_params: dict[str, Any] | None = None)

Bases: ContextAccessor

Provides access to the tree view diagrams.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self, diagclass: str, render_params: dict[str, t.Any] | None = None
) -> None:
    self._dgcls = diagclass
    self._default_render_params = render_params or {}

__get__

__get__(
    obj: T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram

Make a ClassTreeDiagram for the given model object.

Source code in src/capellambse_context_diagrams/context.py

def __get__(  # type: ignore
    self,
    obj: m.T | None,
    objtype: type | None = None,
) -> m.Accessor | ContextDiagram:
    """Make a ClassTreeDiagram for the given model object."""
    del objtype
    if obj is None:  # pragma: no cover
        return self
    assert isinstance(obj, m.ModelElement)
    return self._get(obj, ClassTreeDiagram)

ClassTreeDiagram

ClassTreeDiagram(
    class_: str,
    obj: ModelElement,
    *,
    render_styles: dict[str, Styler] | None = None,
    default_render_parameters: dict[str, Any]
)

Bases: ContextDiagram

An automatically generated ClassTree Diagram.

This diagram is exclusively for Classes.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    class_: str,
    obj: m.ModelElement,
    *,
    render_styles: dict[str, styling.Styler] | None = None,
    default_render_parameters: dict[str, t.Any],
) -> None:
    default_render_parameters = {
        "display_symbols_as_boxes": True,
        "edgeRouting": "POLYLINE",
        "direction": "DOWN",
        "nodeSizeConstraints": "NODE_LABELS",
        "edgeLabelsSide": "SMART_DOWN",
        "partitioning": False,
        "depth": None,
        "super": "ROOT",
        "sub": "ROOT",
    } | default_render_parameters
    super().__init__(
        class_,
        obj,
        render_styles=render_styles,
        default_render_parameters=default_render_parameters,
    )
    self.builder = tree_view.collector  # type: ignore[assignment]

name property

name: str

Returns the name of the diagram.

uuid property

uuid: str

Returns the UUID of the diagram.

ContextAccessor

ContextAccessor(dgcls: str, render_params: dict[str, Any] | None = None)

Bases: Accessor

Provides access to the custom context diagrams.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self, dgcls: str, render_params: dict[str, t.Any] | None = None
) -> None:
    super().__init__()
    self._dgcls = dgcls
    self._default_render_params = render_params or {}

__get__

__get__(obj: None, objtype: type[Any]) -> ContextAccessor

__get__(obj: T, objtype: type[T] | None = None) -> ContextDiagram

__get__(
    obj: T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram

Make a ContextDiagram for the given model object.

Source code in src/capellambse_context_diagrams/context.py

def __get__(
    self, obj: m.T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram:
    """Make a ContextDiagram for the given model object."""
    del objtype
    if obj is None:  # pragma: no cover
        return self
    assert isinstance(obj, m.ModelElement)
    return self._get(obj, ContextDiagram)

ContextDiagram

ContextDiagram(
    class_: str,
    obj: ModelElement | Diagram,
    *,
    render_styles: dict[str, Styler] | None = None,
    default_render_parameters: dict[str, Any]
)

Bases: AbstractDiagram

An automatically generated context diagram.

ATTRIBUTE	DESCRIPTION
target	The m.ModelElement from which the context is collected from. TYPE: ModelElement
styleclass	The diagram class (for e.g. [LAB]).
render_styles	Dictionary with the ElkChildType in str format as keys and styling.Styler functions as values. An example is given by: styling.BLUE_ACTOR_FNCS
serializer	The serializer builds a Diagram via serializers.DiagramSerializer.make_diagram by converting every _elkjs.ELKOutputChild into a Box, Edge or Circle.
filters	A list of filter names that are applied during collection of context. Currently this is only done in exchange_data_collector. TYPE: MutableSet[str]

Notes

The following render parameters are supported:

• display_symbols_as_boxes: Display objects that are normally displayed as symbol as a simple box instead, with the symbol being the box' icon. This avoids the object of interest to become one giant, oversized symbol in the middle of the diagram, and instead keeps the symbol small and only enlarges the surrounding box.
• display_parent_relation: Display objects with a parent relationship to the object of interest as the parent box.
• display_derived_interfaces: Display derived objects collected from additional collectors beside the main collector for building the context.
• slim_center_box: Minimal width for the center box, containing just the icon and the label. This is False if hierarchy was identified.
• display_port_labels: Display port labels on the diagram.
• port_label_position: Position of the port labels. See PORT_LABEL_POSITION.
• transparent_background: Make the background transparent.
• context_groups: Render context UUID groups in the class attribute of every context element when an SVG is rendered.
• display_unused_ports: Display ports that are not connected to an edge.
• edge_direction: Reroute direction of edges.
• mode: Context collection mode.
• display_actor_relation: Show the connections between the context actors.
• hide_context_owner: Hide the context owner in the diagram.
• include_children_context: Include the context of the target's children.
• include_external_context: Include all children of external actors in context.
• hide_functions: Hide functions from the diagram.
• display_functional_parent_relation: Display the parent relation of functions within the context.
• display_internal_relations: Show exchanges that connect to children of a box from the diagram. Only useful with BLACKBOX mode.
• display_cyclic_relations: Show cyclic exchanges that connect either the box of interest or a child with itself or a child. Only useful with BLACKBOX mode and display_cyclic_relations turned on.
• restrict_external_depth: In GREYBOX mode, restrict external components to the same depth as max_depth. This prevents showing deeply nested children from external components.
• pvmt_styling: Style the diagram according to the PVMT group applied to the diagram elements.
• child_shadow: Add a white background box (5px padding, 50% opacity) behind elements that have a parent box.

The following properties are used by the internal builders:

• collect: A callable that yields model elements from a given context diagram.
• is_portless: Boolean flag, if the diagram is portless.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    class_: str,
    obj: m.ModelElement | m.Diagram,
    *,
    render_styles: dict[str, styling.Styler] | None = None,
    default_render_parameters: dict[str, t.Any],
) -> None:
    super().__init__(obj._model)
    self.target = obj  # type: ignore[assignment]
    self.styleclass = class_

    self.render_styles = render_styles or {}
    self.serializer = serializers.DiagramSerializer(self)

    self._elk_input_data: CollectorOutputData | None = None
    self.__filters: cabc.MutableSet[str] = self.FilterSet(self)
    render_params = {
        "display_symbols_as_boxes": False,
        "display_parent_relation": False,
        "display_derived_interfaces": False,
        "slim_center_box": True,
        "display_port_labels": False,
        "port_label_position": _elkjs.PORT_LABEL_POSITION.OUTSIDE,
        "display_unused_ports": False,
        "transparent_background": False,
        "context_groups": False,
        "edge_direction": enums.EDGE_DIRECTION.SMART,
        "mode": enums.MODE.WHITEBOX,
        "display_actor_relation": False,
        "hide_context_owner": False,
        "include_children_context": True,
        "include_external_context": False,
        "include_interface": True,
        "hide_functions": False,
        "display_functional_parent_relation": False,
        "display_internal_relations": True,
        "display_cyclic_relations": False,
        "restrict_external_depth": True,
        "pvmt_styling": None,
        "child_shadow": False,
    }
    if not _generic.DIAGRAM_TYPE_TO_CONNECTOR_NAMES.get(self.type, ()):
        render_params |= {
            "collect": portless.collector,
            "is_portless": True,
        }
    else:
        render_params |= {
            "collect": default.collector,
            "is_portless": False,
        }
    self._default_render_parameters = (
        render_params | default_render_parameters
    )

    if standard_filter := STANDARD_FILTERS.get(class_):
        self.filters.add(standard_filter)
    if standard_styles := STANDARD_STYLES.get(class_):
        self.render_styles = standard_styles

    self.builder: cabc.Callable[
        [ContextDiagram, dict[str, t.Any]], CollectorOutputData
    ] = db.builder

name property

name: str

Returns the diagram name.

nodes property

nodes: ElementList

Return a list of all nodes visible in this diagram.

See Also

nodes

type property

type: DiagramType

Return the type of this diagram.

uuid property

uuid: str

Returns diagram UUID.

FilterSet

FilterSet(diagram: AbstractDiagram)

Bases: MutableSet

A set that stores filter_names and invalidates diagram cache.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    diagram: m.AbstractDiagram,
) -> None:
    self._set: set[str] = set()
    self._diagram = diagram

elk_input_data

elk_input_data(params: dict[str, Any]) -> CollectorOutputData

Return the collected ELK input data.

Source code in src/capellambse_context_diagrams/context.py

def elk_input_data(self, params: dict[str, t.Any]) -> CollectorOutputData:
    """Return the collected ELK input data."""
    params = self._default_render_parameters | params
    if "pvmt_styling" in params:
        params["pvmt_styling"] = styling.normalize_pvmt_styling(
            params["pvmt_styling"]  # type: ignore[arg-type]
        )

    for param_name in self._default_render_parameters:
        setattr(self, f"_{param_name}", params.pop(param_name))

    data: CollectorOutputData
    if data := params.get("elkdata", None):  # type: ignore[assignment]
        self._elk_input_data = data

    if self._elk_input_data is None:
        self._elk_input_data = self.builder(self, params)

    return self._elk_input_data

CustomDiagramType

Bases: Enum

Custom Diagram types.

DataFlowAccessor

DataFlowAccessor(diagclass: str, render_params: dict[str, Any] | None = None)

Bases: ContextAccessor

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self, diagclass: str, render_params: dict[str, t.Any] | None = None
) -> None:
    self._dgcls = diagclass
    self._default_render_params = render_params or {}

__get__

__get__(
    obj: T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram

Make a DataFlowViewDiagram for the given model object.

Source code in src/capellambse_context_diagrams/context.py

def __get__(  # type: ignore
    self,
    obj: m.T | None,
    objtype: type | None = None,
) -> m.Accessor | ContextDiagram:
    """Make a DataFlowViewDiagram for the given model object."""
    del objtype
    if obj is None:  # pragma: no cover
        return self
    assert isinstance(obj, m.ModelElement)
    return self._get(obj, DataFlowViewDiagram)

DataFlowViewDiagram

DataFlowViewDiagram(
    class_: str,
    obj: ModelElement,
    *,
    render_styles: dict[str, Styler] | None = None,
    default_render_parameters: dict[str, Any]
)

Bases: ContextDiagram

An automatically generated DataFlowViewDiagram.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    class_: str,
    obj: m.ModelElement,
    *,
    render_styles: dict[str, styling.Styler] | None = None,
    default_render_parameters: dict[str, t.Any],
) -> None:
    default_render_parameters = {
        "display_symbols_as_boxes": True,
        "display_parent_relation": True,
        "edge_direction": enums.EDGE_DIRECTION.NONE,
        "mode": enums.MODE.WHITEBOX,
        "collect": dataflow_view.collector,
    } | default_render_parameters
    super().__init__(
        class_,
        obj,
        render_styles=render_styles,
        default_render_parameters=default_render_parameters,
    )
    self.builder = dataflow.builder

name property

name: str

Returns the name of the diagram.

uuid property

uuid: str

Returns the UUID of the diagram.

DiagramLayoutAccessor

DiagramLayoutAccessor(
    dgls_to_render_params: dict[DiagramType, dict[str, Any]] | None = None,
)

Bases: Accessor

Provides access to an ELK layout of a diagram.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    dgls_to_render_params: (
        dict[m.DiagramType, dict[str, t.Any]] | None
    ) = None,
) -> None:
    super().__init__()
    self._dgls_to_render_params = dgls_to_render_params or {}

ELKDiagram

ELKDiagram(
    class_: str,
    obj: Diagram,
    *,
    render_styles: dict[str, Styler] | None = None,
    default_render_parameters: dict[str, Any]
)

Bases: ContextDiagram

A former diagram layouted by ELKJS.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    class_: str,
    obj: m.Diagram,
    *,
    render_styles: dict[str, styling.Styler] | None = None,
    default_render_parameters: dict[str, t.Any],
) -> None:
    default_render_parameters = {
        "include_port_allocations": True,
        "hide_elements": set(),
        "pvmt_styling": None,
        "display_port_labels": False,
        "display_symbols_as_boxes": False,
    } | default_render_parameters
    super().__init__(
        class_,
        obj,
        render_styles=render_styles,
        default_render_parameters=default_render_parameters,
    )

    self.builder = diagram_view.build_from_diagram  # type: ignore[assignment]
    self.target: m.Diagram = obj  # type: ignore[assignment]

    self.__nodes: m.ElementList | None = None

name property

name: str

Returns the diagram name.

nodes property

nodes: ElementList

Return a list of all nodes visible in this diagram.

uuid property

uuid: str

Returns diagram UUID.

FunctionalChainContextAccessor

FunctionalChainContextAccessor(
    diagclass: dict[type[ModelElement], str],
    render_params: dict[str, Any] | None = None,
)

Bases: InterfaceContextAccessor

Provides access to the functional chain view diagrams.

Source code in src/capellambse_context_diagrams/context.py

def __init__(  # pylint: disable=super-init-not-called
    self,
    diagclass: dict[type[m.ModelElement], str],
    render_params: dict[str, t.Any] | None = None,
) -> None:
    self._dgclasses = diagclass
    self._default_render_params = render_params or {}

__get__

__get__(
    obj: T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram

Make a ContextDiagram for the given model object.

Source code in src/capellambse_context_diagrams/context.py

def __get__(  # type: ignore
    self, obj: m.T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram:
    """Make a ContextDiagram for the given model object."""
    del objtype
    if obj is None:  # pragma: no cover
        return self
    assert isinstance(obj, m.ModelElement)
    assert isinstance(obj.layer, m.ModelElement)
    self._dgcls = self._dgclasses[obj.layer.__class__]
    return self._get(obj, FunctionalChainContextDiagram)

FunctionalChainContextDiagram

FunctionalChainContextDiagram(
    class_: str,
    obj: ModelElement,
    *,
    render_styles: dict[str, Styler] | None = None,
    default_render_parameters: dict[str, Any]
)

Bases: ContextDiagram

A custom Context Diagram exclusively for FunctionalChains.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    class_: str,
    obj: m.ModelElement,
    *,
    render_styles: dict[str, styling.Styler] | None = None,
    default_render_parameters: dict[str, t.Any],
) -> None:
    default_render_parameters = {
        "display_symbols_as_boxes": True,
        "display_parent_relation": True,
        "edge_direction": enums.EDGE_DIRECTION.SMART,
        "mode": enums.MODE.WHITEBOX,
        "collect": default.functional_chain_collector,
    } | default_render_parameters

    super().__init__(
        class_,
        obj,
        render_styles=render_styles,
        default_render_parameters=default_render_parameters,
    )

    self.builder = fchain.builder

InterfaceContextAccessor

InterfaceContextAccessor(
    diagclass: dict[type[ModelElement], str],
    render_params: dict[str, Any] | None = None,
)

Bases: ContextAccessor

Provides access to the interface context diagrams.

Source code in src/capellambse_context_diagrams/context.py

def __init__(  # pylint: disable=super-init-not-called
    self,
    diagclass: dict[type[m.ModelElement], str],
    render_params: dict[str, t.Any] | None = None,
) -> None:
    self._dgclasses = diagclass
    self._default_render_params = render_params or {}

__get__

__get__(
    obj: T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram

Make a ContextDiagram for the given model object.

Source code in src/capellambse_context_diagrams/context.py

def __get__(  # type: ignore
    self, obj: m.T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram:
    """Make a ContextDiagram for the given model object."""
    del objtype
    if obj is None:  # pragma: no cover
        return self
    assert isinstance(obj, m.ModelElement)
    assert isinstance(obj.parent, m.ModelElement)
    self._dgcls = self._dgclasses[obj.parent.__class__]
    return self._get(obj, InterfaceContextDiagram)

InterfaceContextDiagram

InterfaceContextDiagram(
    class_: str,
    obj: ModelElement,
    *,
    render_styles: dict[str, Styler] | None = None,
    default_render_parameters: dict[str, Any]
)

Bases: ContextDiagram

A Context Diagram exclusively for ComponentExchanges.

ATTRIBUTE	DESCRIPTION
dangling_functional_exchanges	A list of dangling functional exchanges for which either the source or target function were not allocated to a Component, part of the context. TYPE: list[AbstractExchange]

Notes

The following render parameters are available:

• include_interface: Boolean flag to enable inclusion of the context diagram target: The interface ComponentExchange.
• include_port_allocations: Boolean flag to enable rendering of port allocations.
• hide_functions: Boolean flag to enable white box view: Only displaying Components or Entities.

In addition to all other render parameters of ContextDiagram.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    class_: str,
    obj: m.ModelElement,
    *,
    render_styles: dict[str, styling.Styler] | None = None,
    default_render_parameters: dict[str, t.Any],
) -> None:
    default_render_parameters = {
        "include_interface": False,
        "include_port_allocations": False,
        "hide_functions": False,
        "display_symbols_as_boxes": True,
        "display_port_labels": False,
        "port_label_position": _elkjs.PORT_LABEL_POSITION.OUTSIDE,
        "display_parent_relation": True,
        "collect": exchanges.interface_context_collector,
        "hide_context_owner": True,
        "edge_direction": enums.EDGE_DIRECTION.RIGHT,
        "display_functional_parent_relation": True,
    } | default_render_parameters
    super().__init__(
        class_,
        obj,
        render_styles=render_styles,
        default_render_parameters=default_render_parameters,
    )
    self.builder = interface.builder

PhysicalPortContextAccessor

PhysicalPortContextAccessor(
    dgcls: str, render_params: dict[str, Any] | None = None
)

Bases: ContextAccessor

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self, dgcls: str, render_params: dict[str, t.Any] | None = None
) -> None:
    super().__init__()
    self._dgcls = dgcls
    self._default_render_params = render_params or {}

__get__

__get__(
    obj: T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram

Make a ContextDiagram for the given model object.

Source code in src/capellambse_context_diagrams/context.py

def __get__(  # type: ignore
    self,
    obj: m.T | None,
    objtype: type | None = None,
) -> m.Accessor | ContextDiagram:
    """Make a ContextDiagram for the given model object."""
    del objtype
    if obj is None:  # pragma: no cover
        return self
    assert isinstance(obj, m.ModelElement)
    return self._get(obj, PhysicalPortContextDiagram)

PhysicalPortContextDiagram

PhysicalPortContextDiagram(
    class_: str,
    obj: ModelElement,
    *,
    render_styles: dict[str, Styler] | None = None,
    default_render_parameters: dict[str, Any]
)

Bases: ContextDiagram

A custom Context Diagram exclusively for PhysicalPorts.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    class_: str,
    obj: m.ModelElement,
    *,
    render_styles: dict[str, styling.Styler] | None = None,
    default_render_parameters: dict[str, t.Any],
) -> None:
    default_render_parameters = {
        "collect": default.physical_port_context_collector,
        "display_parent_relation": True,
        "edge_direction": enums.EDGE_DIRECTION.TREE,
        "display_port_labels": True,
        "port_label_position": _elkjs.PORT_LABEL_POSITION.OUTSIDE,
    } | default_render_parameters

    super().__init__(
        class_,
        obj,
        render_styles=render_styles,
        default_render_parameters=default_render_parameters,
    )

RealizationViewContextAccessor

RealizationViewContextAccessor(
    diagclass: str, render_params: dict[str, Any] | None = None
)

Bases: ContextAccessor

Provides access to the realization view diagrams.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self, diagclass: str, render_params: dict[str, t.Any] | None = None
) -> None:
    self._dgcls = diagclass
    self._default_render_params = render_params or {}

__get__

__get__(
    obj: T | None, objtype: type | None = None
) -> m.Accessor | ContextDiagram

Make a RealizationViewDiagram for the given model object.

Source code in src/capellambse_context_diagrams/context.py

def __get__(  # type: ignore
    self,
    obj: m.T | None,
    objtype: type | None = None,
) -> m.Accessor | ContextDiagram:
    """Make a RealizationViewDiagram for the given model object."""
    del objtype
    if obj is None:  # pragma: no cover
        return self
    assert isinstance(obj, m.ModelElement)
    return self._get(obj, RealizationViewDiagram)

RealizationViewDiagram

RealizationViewDiagram(
    class_: str,
    obj: ModelElement,
    *,
    render_styles: dict[str, Styler] | None = None,
    default_render_parameters: dict[str, Any]
)

Bases: ContextDiagram

An automatically generated realization view diagram.

This diagram is exclusively for Activity, Functions, Entity and Components of all layers.

Source code in src/capellambse_context_diagrams/context.py

def __init__(
    self,
    class_: str,
    obj: m.ModelElement,
    *,
    render_styles: dict[str, styling.Styler] | None = None,
    default_render_parameters: dict[str, t.Any],
) -> None:
    default_render_parameters = {
        "display_symbols_as_boxes": True,
        "depth": 1,
        "search_direction": "ALL",
        "show_owners": True,
        "layer_sizing": "WIDTH",
    } | default_render_parameters
    super().__init__(
        class_,
        obj,
        render_styles=render_styles,
        default_render_parameters=default_render_parameters,
    )
    self.builder = realization_view.collector  # type: ignore[assignment]

name property

name: str

Returns the name of the diagram.

type property

type: CustomDiagramType

Return the type of this diagram.

uuid property

uuid: str

Returns the UUID of the diagram.

add_context

add_context(data: ELKOutputData, is_legend: bool = False) -> None

Add all connected nodes as context to all elements.

Source code in src/capellambse_context_diagrams/context.py

def add_context(data: _elkjs.ELKOutputData, is_legend: bool = False) -> None:
    """Add all connected nodes as context to all elements."""
    if is_legend:
        for child in data.children:
            if child.type == "node":
                child.context = [child.id]
        return

    ids: set[str] = set()

    def get_ids(
        obj: (
            _elkjs.ELKOutputNode
            | _elkjs.ELKOutputPort
            | _elkjs.ELKOutputJunction
            | _elkjs.ELKOutputEdge
        ),
    ) -> None:
        if obj.id and not obj.id.startswith("g_"):
            ids.add(obj.id)
        for child in getattr(obj, "children", []):
            if child.type in {"node", "port", "junction", "edge"}:
                assert child.type != "label"
                get_ids(child)

    def set_ids(
        obj: _elkjs.ELKOutputChild,
        ids: set[str],
    ) -> None:
        obj.context = list(ids)
        for child in getattr(obj, "children", []):
            set_ids(child, ids)

    for child in data.children:
        if child.type in {"node", "port", "junction", "edge"}:
            assert child.type != "label"
            get_ids(child)

    for child in data.children:
        set_ids(child, ids)

adjust_layer_sizing

adjust_layer_sizing(
    data: ELKInputData,
    layout: ELKOutputData,
    layer_sizing: Literal["UNION", "WIDTH", "HEIGHT", "INDIVIDUAL"],
) -> None

Set nodeSize.minimum config in the layoutOptions.

Source code in src/capellambse_context_diagrams/context.py

def adjust_layer_sizing(
    data: _elkjs.ELKInputData,
    layout: _elkjs.ELKOutputData,
    layer_sizing: t.Literal["UNION", "WIDTH", "HEIGHT", "INDIVIDUAL"],
) -> None:
    """Set `nodeSize.minimum` config in the layoutOptions."""

    def calculate_min(key: t.Literal["width", "height"] = "width") -> float:
        return max(getattr(child.size, key) for child in layout.children)  # type: ignore[union-attr]

    if layer_sizing not in {"UNION", "WIDTH", "HEIGHT", "INDIVIDUAL"}:
        raise NotImplementedError(
            "For ``layer_sizing`` only UNION, WIDTH, HEIGHT or INDIVIDUAL is supported"
        )

    min_w = calculate_min() + 15.0 if layer_sizing in {"UNION", "WIDTH"} else 0
    min_h = (
        calculate_min("height") if layer_sizing in {"UNION", "HEIGHT"} else 0
    )
    for layer in data.children:
        layer.layoutOptions["nodeSize.minimum"] = f"({min_w},{min_h})"

calculate_label_position

calculate_label_position(
    x: float, y: float, width: float, height: float, padding: float = 10.0
) -> tuple[float, float, float]

Calculate the position of the label and tspan.

The function calculates the center of the rectangle and uses the rectangle's width and height to adjust its position within it. The text is assumed to be horizontally and vertically centered within the rectangle. The tspan y coordinate is for positioning the label right under the left side of the rectangle.

PARAMETER	DESCRIPTION
x	The x coordinate of the label position. TYPE: float
y	The y coordinate of the label position. TYPE: float
width	Width of the label. TYPE: float
height	Height of the label TYPE: float
padding	The padding for the label. TYPE: float DEFAULT: 10.0

RETURNS	DESCRIPTION
position	A tuple containing the x- and y-coordinate for the text element and the adjusted y-coordinate for the tspan element.

Source code in src/capellambse_context_diagrams/context.py

def calculate_label_position(
    x: float,
    y: float,
    width: float,
    height: float,
    padding: float = 10.0,
) -> tuple[float, float, float]:
    """Calculate the position of the label and tspan.

    The function calculates the center of the rectangle and uses the
    rectangle's width and height to adjust its position within it. The
    text is assumed to be horizontally and vertically centered within
    the rectangle. The tspan y coordinate is for positioning the label
    right under the left side of the rectangle.

    Parameters
    ----------
    x
        The x coordinate of the label position.
    y
        The y coordinate of the label position.
    width
        Width of the label.
    height
        Height of the label
    padding
        The padding for the label.

    Returns
    -------
    position
        A tuple containing the x- and y-coordinate for the text element
        and the adjusted y-coordinate for the tspan element.
    """
    center_y = y + height / 2
    tspan_y = center_y - width / 2 + padding
    return (x + width / 2, center_y, tspan_y)

stack_diagrams

stack_diagrams(
    first: Diagram, second: Diagram, axis: Literal["x", "y"] = "x"
) -> None

Add the diagram elements from right to left inline.

Source code in src/capellambse_context_diagrams/context.py

def stack_diagrams(
    first: cdiagram.Diagram,
    second: cdiagram.Diagram,
    axis: t.Literal["x", "y"] = "x",
) -> None:
    """Add the diagram elements from ``right`` to left inline."""
    if first.viewport:
        offset = first.viewport.pos + first.viewport.size
        offset @= (1, 0) if axis == "x" else (0, 1)
        for element in second:
            new = copy.deepcopy(element)
            new.move(offset)
            first += new
    else:
        for element in second:
            new = copy.deepcopy(element)
            first += new

try_to_layout

try_to_layout(data: ELKInputData) -> _elkjs.ELKOutputData

Try calling elkjs, raise a JSONDecodeError if it fails.

Source code in src/capellambse_context_diagrams/context.py

def try_to_layout(data: _elkjs.ELKInputData) -> _elkjs.ELKOutputData:
    """Try calling elkjs, raise a JSONDecodeError if it fails."""
    try:
        return _elkjs.elk_manager.call_elkjs(data)
    except json.JSONDecodeError as error:
        logger.error(json.dumps(data, indent=4))
        raise error