capellambse.metamodel package¶

Metamodel definitions for Capella models.

Subpackages¶

Submodules¶

capellambse.metamodel.activity module¶

class capellambse.metamodel.activity.AbstractAction¶

Bases: ExecutableNode, AbstractNamedElement

context¶: The context of this AbstractAction.

inputs¶: The inputs of this AbstractAction.

local_postcondition¶: The local postcondition of this AbstractAction.

local_precondition¶: The local precondition of this AbstractAction.

outputs¶: The outputs of this AbstractAction.

class capellambse.metamodel.activity.AbstractActivity¶

Bases: AbstractBehavior, TraceableElement

edges¶: The edges of this AbstractActivity.

groups¶: The groups of this AbstractActivity.

is_read_only¶: A POD containing a boolean.

is_single_execution¶: A POD containing a boolean.

nodes¶: The nodes of this AbstractActivity.

class capellambse.metamodel.activity.AcceptEventAction¶

Bases: AbstractAction

is_unmarshall¶: A POD containing a boolean.

result¶: The result of this AcceptEventAction.

class capellambse.metamodel.activity.ActivityEdge¶

Bases: AbstractRelationship

guard¶: The guard of this ActivityEdge.

interrupts¶: The interrupts of this ActivityEdge.

probability¶: The probability of this ActivityEdge.

rate¶: The rate of this ActivityEdge.

rate_kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

source¶: The source of this ActivityEdge.

target¶: The target of this ActivityEdge.

weight¶: The weight of this ActivityEdge.

class capellambse.metamodel.activity.ActivityExchange¶: Bases: AbstractInformationFlow

class capellambse.metamodel.activity.ActivityGroup¶

Bases: ModelElement

edges¶: The edges of this ActivityGroup.

nodes¶: The nodes of this ActivityGroup.

sub_groups¶: The sub groups of this ActivityGroup.

super_group¶: The super group of this ActivityGroup.

class capellambse.metamodel.activity.ActivityNode¶: Bases: AbstractNamedElement

class capellambse.metamodel.activity.ActivityPartition¶

Bases: ActivityGroup, AbstractNamedElement

is_dimension¶: A POD containing a boolean.

is_external¶: A POD containing a boolean.

represented_element¶: The represented element of this ActivityPartition.

class capellambse.metamodel.activity.CallAction¶

Bases: InvocationAction

results¶: The results of this CallAction.

class capellambse.metamodel.activity.CallBehaviorAction¶

Bases: CallAction

behavior¶: The behavior of this CallBehaviorAction.

class capellambse.metamodel.activity.ControlFlow¶

Bases: ActivityEdge

An edge that starts an activity node after the previous one finished.

class capellambse.metamodel.activity.ExceptionHandler¶

Bases: ModelElement

exception_input¶: The exception input of this ExceptionHandler.

exception_types¶: The exception types of this ExceptionHandler.

handler_body¶: The handler body of this ExceptionHandler.

protected_node¶: The protected node of this ExceptionHandler.

class capellambse.metamodel.activity.ExecutableNode¶

Bases: ActivityNode

handlers¶: The handlers of this ExecutableNode.

class capellambse.metamodel.activity.InputPin¶

Bases: Pin

input_evaluation_action¶: The input evaluation action of this InputPin.

class capellambse.metamodel.activity.InterruptibleActivityRegion¶

Bases: ActivityGroup

interrupting_edges¶: The interrupting edges of this InterruptibleActivityRegion.

class capellambse.metamodel.activity.InvocationAction¶

Bases: AbstractAction

arguments¶: The arguments of this InvocationAction.

class capellambse.metamodel.activity.ObjectFlow¶

Bases: ActivityEdge

Models the flow of values to or from object nodes.

is_multicast¶: A POD containing a boolean.

is_multireceive¶: A POD containing a boolean.

selection¶: The selection of this ObjectFlow.

transformation¶: The transformation of this ObjectFlow.

class capellambse.metamodel.activity.ObjectNode¶

Bases: ActivityNode, AbstractTypedElement

in_state¶: The in state of this ObjectNode.

is_control_type¶: A POD containing a boolean.

node_kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

ordering¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

selection¶: The selection of this ObjectNode.

upper_bound¶: The upper bound of this ObjectNode.

class capellambse.metamodel.activity.ObjectNodeKind¶

Bases: Enum

The behavior type of the object node with respect to incoming data.

NO_BUFFER = 'NoBuffer'¶

Discard incoming tokens if they are refused.

When the “nobuffer” stereotype is applied to object nodes, tokens arriving at the node are discarded if they are refused by outgoing edges, or refused by actions for object nodes that are input pins.

OVERWRITE = 'Overwrite'¶

Incoming tokens may overwrite existing ones.

When the “overwrite” stereotype is applied to object nodes, a token arriving at a full object node replaces the ones already there. A full object node has as many tokens as allowed by its upper bound.

UNSPECIFIED = 'Unspecified'¶: Used when incoming object node management policy is not specified.

class capellambse.metamodel.activity.ObjectNodeOrderingKind¶

Bases: Enum

Indicates queuing order within a node.

FIFO = 'FIFO'¶: First In First Out ordering.

LIFO = 'LIFO'¶: Last In First Out ordering.

ORDERED = 'ordered'¶: Indicates that object node tokens are ordered.

UNORDERED = 'unordered'¶: Indicates that object node tokens are unordered.

class capellambse.metamodel.activity.OutputPin¶: Bases: Pin

class capellambse.metamodel.activity.Pin¶

Bases: ObjectNode

is_control¶: A POD containing a boolean.

class capellambse.metamodel.activity.SendSignalAction¶

Bases: InvocationAction

signal¶: The signal of this SendSignalAction.

target¶: The target of this SendSignalAction.

class capellambse.metamodel.activity.StructuredActivityNode¶: Bases: ActivityGroup, AbstractAction

class capellambse.metamodel.activity.ValuePin¶

Bases: InputPin

value¶: The value of this ValuePin.

capellambse.metamodel.behavior module¶

class capellambse.metamodel.behavior.AbstractBehavior¶

Bases: AbstractNamedElement

Abstract base class for behaviors.

is_control_operator¶: A POD containing a boolean.

parameter_sets¶: The parameter sets of this AbstractBehavior.

parameters¶: The parameters of this AbstractBehavior.

class capellambse.metamodel.behavior.AbstractEvent¶

Bases: AbstractType

Specification of an occurrence that may trigger effects.

class capellambse.metamodel.behavior.AbstractMessageEvent¶

Bases: AbstractEvent

The receipt by an object of either a call or a signal.

class capellambse.metamodel.behavior.AbstractSignal¶

Bases: AbstractType

Abstract base class for signals.

class capellambse.metamodel.behavior.AbstractSignalEvent¶

Bases: AbstractMessageEvent

The receipt of an asynchronous signal.

A signal event may cause a response, such as a state machine transition as specified in the classifier behavior of the classifier that specified the receiver object, if the signal referenced by the send request is mentioned in a reception owned or inherited by the classifier that specified the receiver object.

signal¶: The signal of this AbstractSignalEvent.

class capellambse.metamodel.behavior.AbstractTimeEvent¶

Bases: AbstractEvent

A point in time.

A time event specifies a point in time by an expression. The expression might be absolute or might be relative to some other point in time.

is_relative¶: A POD containing a boolean.

when¶: The when of this AbstractTimeEvent.

class capellambse.metamodel.behavior.TimeExpression¶

Bases: ValueSpecification

A specification of a point in time.

expression¶: The expression of this TimeExpression.

observations¶: The observations of this TimeExpression.

capellambse.metamodel.capellacommon module¶

class capellambse.metamodel.capellacommon.AbstractCapabilityPkg¶: Bases: Structure

class capellambse.metamodel.capellacommon.AbstractState¶

Bases: NamedElement, IState

incoming_transitions¶: The incoming transitions of this AbstractState.

outgoing_transitions¶: The outgoing transitions of this AbstractState.

realized_states¶: The realized states of this AbstractState.

realizing_states¶: The realizing states of this AbstractState.

property regions: ElementList[Region]¶

state_realizations¶: The state realizations of this AbstractState.

class capellambse.metamodel.capellacommon.AbstractStateRealization¶: Bases: Allocation

class capellambse.metamodel.capellacommon.CapabilityRealizationInvolvedElement¶: Bases: InvolvedElement

class capellambse.metamodel.capellacommon.CapabilityRealizationInvolvement¶: Bases: Involvement

class capellambse.metamodel.capellacommon.ChangeEvent¶

Bases: StateEvent

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

class capellambse.metamodel.capellacommon.ChangeEventKind¶

Bases: Enum

WHEN = 'WHEN'¶

class capellambse.metamodel.capellacommon.ChoicePseudoState¶: Bases: Pseudostate

class capellambse.metamodel.capellacommon.DeepHistoryPseudoState¶: Bases: Pseudostate

class capellambse.metamodel.capellacommon.EntryPointPseudoState¶: Bases: Pseudostate

class capellambse.metamodel.capellacommon.ExitPointPseudoState¶: Bases: Pseudostate

class capellambse.metamodel.capellacommon.FinalState¶

Bases: State

Special state signifying that the enclosing region is completed.

If the enclosing region is directly contained in a state machine and all other regions in the state machine also are completed, then it means that the entire state machine is completed.

class capellambse.metamodel.capellacommon.ForkPseudoState¶: Bases: Pseudostate

class capellambse.metamodel.capellacommon.GenericTrace¶

Bases: Trace

key_value_pairs¶: The key value pairs of this GenericTrace.

property name: str¶

class capellambse.metamodel.capellacommon.InitialPseudoState¶: Bases: Pseudostate

class capellambse.metamodel.capellacommon.JoinPseudoState¶: Bases: Pseudostate

class capellambse.metamodel.capellacommon.JustificationLink¶: Bases: GenericTrace

class capellambse.metamodel.capellacommon.Mode¶

Bases: State

Characterizes an expected behavior at a point in time.

A Mode characterizes an expected behaviour through the set of functions or elements available at a point in time.

class capellambse.metamodel.capellacommon.Pseudostate¶: Bases: AbstractState

class capellambse.metamodel.capellacommon.Region¶

Bases: NamedElement

involved_states¶: The involved states of this Region.

property modes: ElementList[Mode]¶

states¶: The states of this Region.

transitions¶: The transitions of this Region.

class capellambse.metamodel.capellacommon.ShallowHistoryPseudoState¶: Bases: Pseudostate

class capellambse.metamodel.capellacommon.State¶

Bases: AbstractState

A situation during which some invariant condition holds.

A condition of a system or element, as defined by some of its properties, which can enable system behaviors and/or structure to occur.

Note: The enabled behavior may include no actions, such as associated with a wait state. Also, the condition that defines the state may be dependent on one or more previous states.

connection_points¶: The connection points of this State.

do_activity¶: The do activity of this State.

entries¶: The entries of this State.

entry¶: The entry of this State.

exit¶: The exit of this State.

exits¶: The exits of this State.

functions¶: The functions of this State.

regions¶: The regions of this State.

state_invariant¶: The state invariant of this State.

class capellambse.metamodel.capellacommon.StateEvent¶

Bases: NamedElement, AbstractEvent

expression¶: The expression of this StateEvent.

realized_events¶: The realized events of this StateEvent.

state_event_realizations¶: The state event realizations of this StateEvent.

class capellambse.metamodel.capellacommon.StateEventRealization¶: Bases: Allocation

class capellambse.metamodel.capellacommon.StateMachine¶

Bases: CapellaElement, AbstractBehavior

connection_points¶: The connection points of this StateMachine.

regions¶: The regions of this StateMachine.

class capellambse.metamodel.capellacommon.StateTransition¶

Bases: NamedElement, Relationship

A directed relationship between a source and target vertex.

It may be part of a compound transition, which takes the state machine from one state configuration to another, representing the complete response of the state machine to an occurrence of an event of a particular type.

destination¶: The destination of this StateTransition.

effect¶: The effect of this StateTransition.

effects¶: The effects of this StateTransition.

guard¶: The guard of this StateTransition.

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

realized_transitions¶: The realized transitions of this StateTransition.

source¶: The source of this StateTransition.

state_transition_realizations¶: The state transition realizations of this StateTransition.

target¶: The target of this StateTransition.

trigger_description¶: A POD containing arbitrary string data.

triggers¶: The triggers of this StateTransition.

class capellambse.metamodel.capellacommon.StateTransitionRealization¶: Bases: Allocation

class capellambse.metamodel.capellacommon.TerminatePseudoState¶: Bases: Pseudostate

class capellambse.metamodel.capellacommon.TimeEvent¶

Bases: StateEvent

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

class capellambse.metamodel.capellacommon.TimeEventKind¶

Bases: Enum

AFTER = 'AFTER'¶

Trigger after a relative time duration has passed.

A relative time trigger is specified with the keyword ‘after’ followed by an expression that evaluates to a time value, such as ‘after (5 seconds)’.

AT = 'AT'¶

Trigger at a specific time.

An absolute time trigger is specified with the keyword ‘at’ followed by an expression that evaluates to a time value, such as ‘Jan. 1, 2000, Noon’.

class capellambse.metamodel.capellacommon.TransfoLink¶: Bases: GenericTrace

class capellambse.metamodel.capellacommon.TransitionKind¶

Bases: Enum

EXTERNAL = 'external'¶

INTERNAL = 'internal'¶

LOCAL = 'local'¶

capellambse.metamodel.capellacore module¶

class capellambse.metamodel.capellacore.AbstractAnnotation¶

Bases: CapellaElement

content¶: A POD containing arbitrary string data.

class capellambse.metamodel.capellacore.AbstractDependenciesPkg¶: Bases: Structure

class capellambse.metamodel.capellacore.AbstractExchangeItemPkg¶

Bases: Structure

exchange_items¶: The exchange items of this AbstractExchangeItemPkg.

class capellambse.metamodel.capellacore.AbstractModellingStructure¶

Bases: ReuserStructure

architecture_pkgs¶: The architecture pkgs of this AbstractModellingStructure.

architectures¶: The architectures of this AbstractModellingStructure.

class capellambse.metamodel.capellacore.AbstractPropertyValue¶

Bases: NamedElement

enumerations¶: The enumerations of this AbstractPropertyValue.

involved_elements¶: The involved elements of this AbstractPropertyValue.

class capellambse.metamodel.capellacore.Allocation¶: Bases: Relationship, AbstractTrace

class capellambse.metamodel.capellacore.BooleanPropertyValue¶

Bases: AbstractPropertyValue

A boolean property value.

value¶: A POD containing a boolean.

class capellambse.metamodel.capellacore.CapellaElement¶

Bases: TraceableElement, PublishableElement

applied_property_value_groups: _descriptors.Association[mm.capellacore.PropertyValueGroup]¶: The applied property value groups of this CapellaElement.

applied_property_values: _descriptors.Association[mm.capellacore.AbstractPropertyValue]¶: The applied property values of this CapellaElement.

description¶: Description of the Capella element.

enumeration_property_types¶: The enumeration property types of this CapellaElement.

features¶: The features of this CapellaElement.

property_value_groups: _descriptors.Containment[mm.capellacore.PropertyValueGroup]¶: The property value groups of this CapellaElement.

property_values: _descriptors.Containment[mm.capellacore.AbstractPropertyValue]¶: The property values of this CapellaElement.

review¶: Review description on the Capella element.

status¶: The status of this CapellaElement.

summary¶: Summary of the element.

class capellambse.metamodel.capellacore.Classifier¶

Bases: GeneralizableElement

owned_features¶: The owned features of this Classifier.

class capellambse.metamodel.capellacore.Constraint¶

Bases: NamedElement, AbstractConstraint

A condition or restriction.

The constraint is expressed in natural language text or in a machine readable language for the purpose of declaring some of the semantics of an element.

class capellambse.metamodel.capellacore.EnumerationPropertyLiteral¶

Bases: NamedElement

A Literal for EnumerationPropertyType.

class capellambse.metamodel.capellacore.EnumerationPropertyType¶

Bases: NamedElement

literals¶: The literals of this EnumerationPropertyType.

class capellambse.metamodel.capellacore.EnumerationPropertyValue¶

Bases: AbstractPropertyValue

type¶: The type of this EnumerationPropertyValue.

value¶: The value of this EnumerationPropertyValue.

class capellambse.metamodel.capellacore.Feature¶

Bases: NamedElement

is_abstract¶: A POD containing a boolean.

is_static¶: A POD containing a boolean.

visibility¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

class capellambse.metamodel.capellacore.FloatPropertyValue¶

Bases: AbstractPropertyValue

A floating point property value.

value¶

A POD containing a floating-point number.

In Capella’s Java land, these are often called “real numbers”.

class capellambse.metamodel.capellacore.GeneralClass¶

Bases: Classifier, FinalizableElement

nested_classes¶: The nested classes of this GeneralClass.

visibility¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

class capellambse.metamodel.capellacore.GeneralizableElement¶

Bases: Type

A type than can be generalized.

generalizations¶: The generalizations of this GeneralizableElement.

is_abstract¶: A POD containing a boolean.

sub¶: The sub of this GeneralizableElement.

super¶: The super of this GeneralizableElement.

class capellambse.metamodel.capellacore.Generalization¶

Bases: Relationship

sub¶: The sub of this Generalization.

super¶: The super of this Generalization.

class capellambse.metamodel.capellacore.IntegerPropertyValue¶

Bases: AbstractPropertyValue

An integer property value.

value¶: A POD containing an integer number.

class capellambse.metamodel.capellacore.InvolvedElement¶: Bases: CapellaElement

class capellambse.metamodel.capellacore.Involvement¶

Bases: Relationship

involved¶: The involved of this Involvement.

property name: str¶: Return the name.

source¶: The source of this Involvement.

target¶: The target of this Involvement.

class capellambse.metamodel.capellacore.InvolverElement¶: Bases: CapellaElement

class capellambse.metamodel.capellacore.KeyValue¶

Bases: CapellaElement

key¶: A POD containing arbitrary string data.

value¶: A POD containing arbitrary string data.

class capellambse.metamodel.capellacore.ModellingArchitecture¶

Bases: Structure

Supports the definition of the model structure at a design level.

class capellambse.metamodel.capellacore.ModellingArchitecturePkg¶

Bases: Structure

A container for modelling architectures.

class capellambse.metamodel.capellacore.ModellingBlock¶

Bases: Type

A modular unit that describes the structure of a system or element.

A class (or block) that cannot be directly instantiated. Contrast: concrete class.

class capellambse.metamodel.capellacore.NamedElement¶: Bases: AbstractNamedElement, CapellaElement

class capellambse.metamodel.capellacore.NamedRelationship¶

Bases: Relationship, NamedElement

naming_rules¶: The naming rules of this NamedRelationship.

class capellambse.metamodel.capellacore.Namespace¶

Bases: NamedElement

naming_rules¶: The naming rules of this Namespace.

traces¶: The traces of this Namespace.

class capellambse.metamodel.capellacore.NamingRule¶

Bases: AbstractAnnotation

target_type¶: Type to whose instances the naming rule has to be applied.

class capellambse.metamodel.capellacore.PropertyValueGroup¶

Bases: Namespace

A group for PropertyValues.

values¶: The values of this PropertyValueGroup.

class capellambse.metamodel.capellacore.PropertyValuePkg¶

Bases: Structure

A Package for PropertyValues.

groups¶: The groups of this PropertyValuePkg.

packages¶: The packages of this PropertyValuePkg.

values¶: The values of this PropertyValuePkg.

class capellambse.metamodel.capellacore.Relationship¶: Bases: AbstractRelationship, CapellaElement

class capellambse.metamodel.capellacore.ReuseLink¶

Bases: Relationship

reused¶: The reused of this ReuseLink.

reuser¶: The reuser of this ReuseLink.

class capellambse.metamodel.capellacore.ReuseableStructure¶

Bases: Structure

A structure intended to be reused across various architectures.

reuse_links¶: The reuse links of this ReuseableStructure.

class capellambse.metamodel.capellacore.ReuserStructure¶

Bases: Structure

owned_reuse_links¶: The owned reuse links of this ReuserStructure.

reuse_links¶: The reuse links of this ReuserStructure.

class capellambse.metamodel.capellacore.StringPropertyValue¶

Bases: AbstractPropertyValue

A string property value.

value¶: A POD containing arbitrary string data.

class capellambse.metamodel.capellacore.Structure¶

Bases: Namespace

property_value_packages¶: The property value packages of this Structure.

property_value_pkgs¶: The property value pkgs of this Structure.

class capellambse.metamodel.capellacore.Trace¶: Bases: Relationship, AbstractTrace

class capellambse.metamodel.capellacore.Type¶

Bases: AbstractType, Namespace

Represents a set of values.

A typed element that has this type is constrained to represent values within this set.

class capellambse.metamodel.capellacore.TypedElement¶

Bases: AbstractTypedElement, NamedElement

An element that has a type.

class capellambse.metamodel.capellacore.VisibilityKind¶

Bases: Enum

The possibilities regarding the visibility of a feature of a class.

PACKAGE = 'PACKAGE'¶: The feature is accessible from any element within the same package.

PRIVATE = 'PRIVATE'¶: The feature is only visible/accessible from the class itself.

PROTECTED = 'PROTECTED'¶: The feature offers visibility only to children of the class.

PUBLIC = 'PUBLIC'¶: The feature offers public access.

UNSET = 'UNSET'¶: Visibility is not specified.

capellambse.metamodel.capellamodeller module¶

class capellambse.metamodel.capellamodeller.Folder¶

Bases: Structure

folders¶: The folders of this Folder.

model_roots¶: The model roots of this Folder.

class capellambse.metamodel.capellamodeller.Library¶

Bases: Project

A project that is primarily intended as a library of components.

class capellambse.metamodel.capellamodeller.ModelRoot¶

Bases: CapellaElement

A system engineering element or a package of those.

class capellambse.metamodel.capellamodeller.Project¶

Bases: Structure

folders¶: The folders of this Project.

key_value_pairs¶: The key value pairs of this Project.

property model_root: ModelRoot¶

model_roots¶: The model roots of this Project.

class capellambse.metamodel.capellamodeller.SystemEngineering¶

Bases: AbstractModellingStructure, ModelRoot

A system engineering element.

System engineering is an interdisciplinary approach encompassing the entire technical effort to evolve and verify an integrated and life-cycle balanced set of system people, product, and process solutions that satisfy customer needs.

Systems engineering encompasses:

the technical efforts related to the development, manufacturing, verification, deployment, operations, support, disposal of, and user training for, systems products and processes;
the definition and management of the system configuration;
the translation of the system definition into work breakdown structures;
and development of information for management decision making.

[source:MIL-STD 499B standard]

property epbs: EPBSArchitecture¶

property la: LogicalArchitecture¶

property oa: OperationalAnalysis¶

property pa: PhysicalArchitecture¶

property sa: SystemAnalysis¶

class capellambse.metamodel.capellamodeller.SystemEngineeringPkg¶

Bases: Structure, ModelRoot

A package that contains system engineering elements.

system_engineerings¶: The system engineerings of this SystemEngineeringPkg.

capellambse.metamodel.cs module¶

Implementation of objects and relations for Functional Analysis.

class capellambse.metamodel.cs.AbstractDeploymentLink¶

Bases: Relationship

deployed_element¶: The deployed element of this AbstractDeploymentLink.

location¶: The location of this AbstractDeploymentLink.

class capellambse.metamodel.cs.AbstractPathInvolvedElement¶: Bases: InvolvedElement

class capellambse.metamodel.cs.AbstractPhysicalArtifact¶: Bases: CapellaElement

class capellambse.metamodel.cs.AbstractPhysicalLinkEnd¶: Bases: CapellaElement

class capellambse.metamodel.cs.AbstractPhysicalPathLink¶: Bases: ComponentExchangeAllocator

class capellambse.metamodel.cs.ArchitectureAllocation¶: Bases: Allocation

class capellambse.metamodel.cs.Block¶

Bases: AbstractFunctionalBlock, ModellingBlock

A modular unit that describes the structure of a system or element.

capability_pkg¶: The capability pkg of this Block.

data_package¶: The data package of this Block.

data_pkg¶: The data pkg of this Block.

interface_package¶: The interface package of this Block.

interface_pkg¶: The interface pkg of this Block.

state_machines¶: The state machines of this Block.

class capellambse.metamodel.cs.BlockArchitecture¶

Bases: AbstractFunctionalArchitecture

Parent class for deriving specific architectures for each design phase.

Formerly known as BaseArchitectureLayer.

property all_capabilities: ElementList[AbstractCapability]¶

property all_classes: ElementList[Class]¶

property all_collections: ElementList[Collection]¶

property all_complex_values: ElementList[AbstractComplexValue]¶

property all_enumerations: ElementList[Enumeration]¶

property all_interfaces: ElementList[Interface]¶

property all_unions: ElementList[Union]¶

capability_package¶: The capability package of this BlockArchitecture.

capability_pkg¶: The capability pkg of this BlockArchitecture.

data_package¶: The data package of this BlockArchitecture.

data_pkg¶: The data pkg of this BlockArchitecture.

interface_package¶: The interface package of this BlockArchitecture.

interface_pkg¶: The interface pkg of this BlockArchitecture.

class capellambse.metamodel.cs.BlockArchitecturePkg¶

Bases: ModellingArchitecturePkg

Container package for BlockArchitecture elements.

class capellambse.metamodel.cs.Component¶

Bases: Block, Classifier, InterfaceAllocator, CommunicationLinkExchanger

An entity, with discrete structure within the system.

Interacts with other Components of the system, thereby contributing at its lowest level to the system properties and characteristics.

component_realizations¶: The component realizations of this Component.

exchanges¶: The exchanges of this Component.

implemented_interfaces¶: The implemented interfaces of this Component.

interface_implementations¶: The interface implementations of this Component.

interface_uses¶: The interface uses of this Component.

is_actor¶: Indicates if the Component is an Actor.

is_human¶: Indicates whether the Component is a Human.

owner¶: The owner of this Component.

parts¶: The parts of this Component.

physical_link_categories¶: The physical link categories of this Component.

physical_links¶: The physical links of this Component.

physical_paths¶: The physical paths of this Component.

physical_ports¶: The physical ports of this Component.

ports¶: The ports of this Component.

realized_components¶: The realized components of this Component.

realizing_components¶: The realizing components of this Component.

related_exchanges¶: The related exchanges of this Component.

used_interfaces¶: The used interfaces of this Component.

class capellambse.metamodel.cs.ComponentArchitecture¶

Bases: BlockArchitecture

A specialized kind of BlockArchitecture.

Serves as a parent class for the various architecture levels, from System analysis down to EPBS architecture.

class capellambse.metamodel.cs.ComponentPkg¶

Bases: Structure

A package containing parts.

allocated_functions¶: The allocated functions of this ComponentPkg.

component_exchange_realizations¶: The component exchange realizations of this ComponentPkg.

exchange_categories¶: The exchange categories of this ComponentPkg.

exchanges¶: The exchanges of this ComponentPkg.

functional_allocations¶: The functional allocations of this ComponentPkg.

functional_links¶: The functional links of this ComponentPkg.

parts¶: The parts of this ComponentPkg.

physical_link_categories¶: The physical link categories of this ComponentPkg.

physical_links¶: The physical links of this ComponentPkg.

realized_component_exchanges¶: The realized component exchanges of this ComponentPkg.

state_machines¶: The state machines of this ComponentPkg.

class capellambse.metamodel.cs.ComponentRealization¶

Bases: Allocation

A realization that links to a component.

class capellambse.metamodel.cs.DeployableElement¶

Bases: NamedElement

A physical model element intended to be deployed.

class capellambse.metamodel.cs.DeploymentTarget¶

Bases: NamedElement

The physical target that will host a deployable element.

class capellambse.metamodel.cs.ExchangeItemAllocation¶

Bases: Relationship, AbstractEventOperation, FinalizableElement

An allocation of an ExchangeItem to an Interface.

allocated_item¶: The allocated item of this ExchangeItemAllocation.

item¶: The item of this ExchangeItemAllocation.

receive_protocol¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

send_protocol¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

class capellambse.metamodel.cs.Interface¶

Bases: GeneralClass, InterfaceAllocator

An interface.

An interface is a kind of classifier that represents a declaration of a set of coherent public features and obligations. An interface specifies a contract; any instance of a classifier that realizes the interface must fulfill that contract.

Interfaces are defined by functional and physical characteristics that exist at a common boundary with co-functioning items and allow systems, equipment, software, and system data to be compatible.

That design feature of one piece of equipment that affects a design feature of another piece of equipment. An interface can extend beyond the physical boundary between two items. (For example, the weight and center of gravity of one item can affect the interfacing item; however, the center of gravity is rarely located at the physical boundary. An electrical interface generally extends to the first isolating element rather than terminating at a series of connector pins.)

Usage guideline¶

In Capella, Interfaces are created to declare the nature of interactions between the System and external actors.

allocated_exchange_items¶: The allocated exchange items of this Interface.

exchange_item_allocations¶: The exchange item allocations of this Interface.

is_structural¶: A POD containing a boolean.

mechanism¶: A POD containing arbitrary string data.

class capellambse.metamodel.cs.InterfaceAllocation¶: Bases: Allocation

class capellambse.metamodel.cs.InterfaceAllocator¶

Bases: CapellaElement

allocated_interfaces¶: The allocated interfaces of this InterfaceAllocator.

interface_allocations¶: The interface allocations of this InterfaceAllocator.

class capellambse.metamodel.cs.InterfaceImplementation¶

Bases: Relationship

implemented_interface¶: The implemented interface of this InterfaceImplementation.

class capellambse.metamodel.cs.InterfacePkg¶

Bases: MessageReferencePkg, AbstractDependenciesPkg, AbstractExchangeItemPkg

A container for Interface elements.

interfaces¶: The interfaces of this InterfacePkg.

packages¶: The packages of this InterfacePkg.

class capellambse.metamodel.cs.InterfaceUse¶

Bases: Relationship

used_interface¶: The used interface of this InterfaceUse.

class capellambse.metamodel.cs.Part¶

Bases: AbstractInstance, InformationsExchanger, DeployableElement, DeploymentTarget, AbstractPathInvolvedElement

A representation of a physical component.

In SysML, a Part is an owned property of a Block.

deployed_parts¶: The deployed parts of this Part.

deployment_links¶: The deployment links of this Part.

owned_type¶: The owned type of this Part.

class capellambse.metamodel.cs.PhysicalLink¶

Bases: AbstractPhysicalPathLink, AbstractPhysicalArtifact, AbstractPathInvolvedElement

allocated_functional_exchanges¶: The allocated functional exchanges of this PhysicalLink.

ends¶: The ends of this PhysicalLink.

exchanges¶: The exchanges of this PhysicalLink.

functional_exchange_allocations¶: The functional exchange allocations of this PhysicalLink.

links()¶

Return type:: ElementList[ModelElement]

owner¶: The owner of this PhysicalLink.

physical_link_ends¶: The physical link ends of this PhysicalLink.

physical_link_realizations¶: The physical link realizations of this PhysicalLink.

physical_paths¶: The physical paths of this PhysicalLink.

realized_physical_links¶: The realized physical links of this PhysicalLink.

property source: AbstractPhysicalLinkEnd¶

property target: AbstractPhysicalLinkEnd¶

class capellambse.metamodel.cs.PhysicalLinkCategory¶

Bases: NamedElement

links¶: The links of this PhysicalLinkCategory.

class capellambse.metamodel.cs.PhysicalLinkEnd¶

Bases: AbstractPhysicalLinkEnd

part¶: The part of this PhysicalLinkEnd.

port¶: The port of this PhysicalLinkEnd.

class capellambse.metamodel.cs.PhysicalLinkRealization¶: Bases: Allocation

class capellambse.metamodel.cs.PhysicalPath¶

Bases: ComponentExchangeAllocator, AbstractPathInvolvedElement, InvolverElement, NamedElement

A physical path.

exchanges¶: The exchanges of this PhysicalPath.

involved_items¶: The involved items of this PhysicalPath.

involved_links¶: The involved links of this PhysicalPath.

physical_path_involvements¶: The physical path involvements of this PhysicalPath.

physical_path_realizations¶: The physical path realizations of this PhysicalPath.

realized_paths¶: The realized paths of this PhysicalPath.

class capellambse.metamodel.cs.PhysicalPathInvolvement¶

Bases: Involvement

next_involvements¶: The next involvements of this PhysicalPathInvolvement.

class capellambse.metamodel.cs.PhysicalPathRealization¶: Bases: Allocation

class capellambse.metamodel.cs.PhysicalPathReference¶: Bases: PhysicalPathInvolvement

class capellambse.metamodel.cs.PhysicalPort¶

Bases: Port, AbstractPhysicalArtifact, InformationsExchanger, AbstractPhysicalLinkEnd, Property

A port on a physical component.

allocated_component_ports¶: The allocated component ports of this PhysicalPort.

component_port_allocations¶: The component port allocations of this PhysicalPort.

links¶: The links of this PhysicalPort.

owner¶: The owner of this PhysicalPort.

physical_port_realizations¶: The physical port realizations of this PhysicalPort.

realized_ports¶: The realized ports of this PhysicalPort.

class capellambse.metamodel.cs.PhysicalPortRealization¶: Bases: Allocation

class capellambse.metamodel.cs.ProvidedInterfaceLink¶

Bases: Relationship

interface¶: The interface of this ProvidedInterfaceLink.

class capellambse.metamodel.cs.RequiredInterfaceLink¶

Bases: Relationship

interface¶: The interface of this RequiredInterfaceLink.

capellambse.metamodel.epbs module¶

Tools for the EPBS layer.

class capellambse.metamodel.epbs.ConfigurationItem¶

Bases: CapabilityRealizationInvolvedElement, Component

configuration_item_pkgs¶: The configuration item pkgs of this ConfigurationItem.

configuration_items¶: The configuration items of this ConfigurationItem.

identifier¶: A POD containing arbitrary string data.

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

physical_artifact_realizations¶: The physical artifact realizations of this ConfigurationItem.

realized_physical_artifacts¶: The realized physical artifacts of this ConfigurationItem.

class capellambse.metamodel.epbs.ConfigurationItemKind¶

Bases: Enum

COTSCI = 'COTSCI'¶: Commercial Off The Shelves Configuration Item.

CSCI = 'CSCI'¶: Computer Software Configuration Item.

HWCI = 'HWCI'¶: Hardware Configuration Item.

INTERFACE_CI = 'InterfaceCI'¶: Interface Configuration Item.

NDICI = 'NDICI'¶: Non Developmental Configuration Item.

PRIME_ITEM_CI = 'PrimeItemCI'¶: Prime Item Configuration Item.

SYSTEM_CI = 'SystemCI'¶: System Configuration Item.

UNSET = 'Unset'¶

class capellambse.metamodel.epbs.ConfigurationItemPkg¶

Bases: ComponentPkg

configuration_item_pkgs¶: The configuration item pkgs of this ConfigurationItemPkg.

configuration_items¶: The configuration items of this ConfigurationItemPkg.

class capellambse.metamodel.epbs.EPBSArchitecture¶

Bases: ComponentArchitecture

configuration_item_pkg¶: The configuration item pkg of this EPBSArchitecture.

physical_architecture_realizations¶: The physical architecture realizations of this EPBSArchitecture.

realized_physical_architecture¶: The realized physical architecture of this EPBSArchitecture.

class capellambse.metamodel.epbs.EPBSArchitecturePkg¶

Bases: BlockArchitecturePkg

architectures¶: The architectures of this EPBSArchitecturePkg.

class capellambse.metamodel.epbs.PhysicalArchitectureRealization¶: Bases: ArchitectureAllocation

class capellambse.metamodel.epbs.PhysicalArtifactRealization¶: Bases: Allocation

capellambse.metamodel.fa module¶

class capellambse.metamodel.fa.AbstractFunction¶

Bases: Namespace, InvolvedElement, AbstractInstance, AbstractFunctionalChainContainer, CallBehaviorAction, AbstractEvent

An abstract function.

available_in_states¶: The available in states of this AbstractFunction.

condition¶: A POD containing arbitrary string data.

exchanges¶: The exchanges of this AbstractFunction.

function_realizations¶: The function realizations of this AbstractFunction.

functions¶: The functions of this AbstractFunction.

property is_leaf: bool¶

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

realized_functions¶: The realized functions of this AbstractFunction.

realizing_functions¶: The realizing functions of this AbstractFunction.

related_exchanges¶: The related exchanges of this AbstractFunction.

scenarios¶: The scenarios of this AbstractFunction.

class capellambse.metamodel.fa.AbstractFunctionAllocation¶: Bases: Allocation

class capellambse.metamodel.fa.AbstractFunctionalArchitecture¶

Bases: ModellingArchitecture

property all_function_exchanges: ElementList[FunctionalExchange]¶

property all_functional_chains: ElementList[FunctionalChain]¶

property all_functions: ElementList[AbstractFunction]¶

component_exchange_categories¶: The component exchange categories of this AbstractFunctionalArchitecture.

component_exchange_realizations¶: The component exchange realizations of this AbstractFunctionalArchitecture.

component_exchanges¶: The component exchanges of this AbstractFunctionalArchitecture.

function_package¶: The function package of this AbstractFunctionalArchitecture.

function_pkg¶: The function pkg of this AbstractFunctionalArchitecture.

functional_allocations¶: The functional allocations of this AbstractFunctionalArchitecture.

functional_links¶: The functional links of this AbstractFunctionalArchitecture.

property root_function: AbstractFunction¶: Returns the first function in the function_pkg.

class capellambse.metamodel.fa.AbstractFunctionalBlock¶

Bases: ModellingBlock

allocated_functions¶: The allocated functions of this AbstractFunctionalBlock.

component_exchange_categories¶: The component exchange categories of this AbstractFunctionalBlock.

component_exchanges¶: The component exchanges of this AbstractFunctionalBlock.

functional_allocations¶: The functional allocations of this AbstractFunctionalBlock.

in_exchange_links¶: The in exchange links of this AbstractFunctionalBlock.

out_exchange_links¶: The out exchange links of this AbstractFunctionalBlock.

class capellambse.metamodel.fa.AbstractFunctionalChainContainer¶

Bases: CapellaElement

functional_chains¶: The functional chains of this AbstractFunctionalChainContainer.

class capellambse.metamodel.fa.ComponentExchange¶

Bases: AbstractEvent, AbstractEventOperation, ExchangeSpecification, NamedElement, _AbstractExchange

allocated_exchange_items¶: The allocated exchange items of this ComponentExchange.

allocated_functional_exchanges¶: The allocated functional exchanges of this ComponentExchange.

property allocating_physical_link: PhysicalLink | None¶

allocating_physical_links¶: The allocating physical links of this ComponentExchange.

allocating_physical_paths¶: The allocating physical paths of this ComponentExchange.

categories¶: The categories of this ComponentExchange.

component_exchange_realizations¶: The component exchange realizations of this ComponentExchange.

ends¶: The ends of this ComponentExchange.

property exchange_items: ElementList[AbstractExchangeItem]¶

functional_exchange_allocations¶: The functional exchange allocations of this ComponentExchange.

is_oriented¶: A POD containing a boolean.

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

property owner: PhysicalLink | None¶

realized_component_exchanges¶: The realized component exchanges of this ComponentExchange.

realizing_component_exchanges¶: The realizing component exchanges of this ComponentExchange.

class capellambse.metamodel.fa.ComponentExchangeAllocation¶: Bases: Allocation

class capellambse.metamodel.fa.ComponentExchangeAllocator¶

Bases: NamedElement

allocated_component_exchanges¶: The allocated component exchanges of this ComponentExchangeAllocator.

component_exchange_allocations¶: The component exchange allocations of this ComponentExchangeAllocator.

class capellambse.metamodel.fa.ComponentExchangeCategory¶

Bases: NamedElement

exchanges¶: The exchanges of this ComponentExchangeCategory.

class capellambse.metamodel.fa.ComponentExchangeEnd¶

Bases: InformationsExchanger, CapellaElement

part¶: The part of this ComponentExchangeEnd.

port¶: The port of this ComponentExchangeEnd.

class capellambse.metamodel.fa.ComponentExchangeFunctionalExchangeAllocation¶: Bases: AbstractFunctionAllocation

class capellambse.metamodel.fa.ComponentExchangeKind¶

Bases: Enum

The kind of a ComponentExchange.

ASSEMBLY = 'ASSEMBLY'¶: Indicates that the connector is an assembly connector.

DELEGATION = 'DELEGATION'¶: Indicates that the connector is a delegation connector.

FLOW = 'FLOW'¶: Describes a flow communication.

UNSET = 'UNSET'¶: Communication kind is not set.

class capellambse.metamodel.fa.ComponentExchangeRealization¶: Bases: ExchangeSpecificationRealization

class capellambse.metamodel.fa.ComponentFunctionalAllocation¶: Bases: AbstractFunctionAllocation

class capellambse.metamodel.fa.ComponentPort¶

Bases: Port, InformationsExchanger, Property

A component port.

direction¶: The direction of this ComponentPort.

exchanges¶: The exchanges of this ComponentPort.

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

orientation¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

owner¶: The owner of this ComponentPort.

class capellambse.metamodel.fa.ComponentPortAllocation¶

Bases: Allocation

ends¶: The ends of this ComponentPortAllocation.

class capellambse.metamodel.fa.ComponentPortAllocationEnd¶

Bases: CapellaElement

part¶: The part of this ComponentPortAllocationEnd.

port¶: The port of this ComponentPortAllocationEnd.

class capellambse.metamodel.fa.ComponentPortKind¶

Bases: Enum

FLOW = 'FLOW'¶

Describes a flow port.

A flow port is an interaction point through which input and/or output of items such as data, material, or energy may flow.

STANDARD = 'STANDARD'¶

Describes a standard port.

A port is an interaction point between a Block or sub-Block and its environment that supports Exchanges with other ports.

class capellambse.metamodel.fa.ControlNode¶

Bases: SequenceLinkEnd

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

class capellambse.metamodel.fa.ControlNodeKind¶

Bases: Enum

AND = 'AND'¶

ITERATE = 'ITERATE'¶

OR = 'OR'¶

class capellambse.metamodel.fa.ExchangeCategory¶

Bases: NamedElement

exchanges¶: The exchanges of this ExchangeCategory.

class capellambse.metamodel.fa.ExchangeContainment¶

Bases: Relationship

exchange¶: The exchange of this ExchangeContainment.

link¶: The link of this ExchangeContainment.

class capellambse.metamodel.fa.ExchangeLink¶

Bases: NamedRelationship

destinations¶: The destinations of this ExchangeLink.

exchange_containment_links¶: The exchange containment links of this ExchangeLink.

exchange_containments¶: The exchange containments of this ExchangeLink.

sources¶: The sources of this ExchangeLink.

class capellambse.metamodel.fa.ExchangeSpecification¶

Bases: NamedElement, ActivityExchange

link¶: The link of this ExchangeSpecification.

class capellambse.metamodel.fa.ExchangeSpecificationRealization¶: Bases: Allocation

class capellambse.metamodel.fa.FunctionInputPort¶

Bases: FunctionPort, InputPin

A function input port.

exchange_items¶: The exchange items of this FunctionInputPort.

class capellambse.metamodel.fa.FunctionKind¶

Bases: Enum

The kind of a Function.

DUPLICATE = 'DUPLICATE'¶

FUNCTION = 'FUNCTION'¶

GATHER = 'GATHER'¶

ROUTE = 'ROUTE'¶

SELECT = 'SELECT'¶

SPLIT = 'SPLIT'¶

class capellambse.metamodel.fa.FunctionOutputPort¶

Bases: FunctionPort, OutputPin

A function output port.

exchange_items¶: The exchange items of this FunctionOutputPort.

class capellambse.metamodel.fa.FunctionPkg¶

Bases: Structure

categories¶: The categories of this FunctionPkg.

exchange_specification_realizations¶: The exchange specification realizations of this FunctionPkg.

exchanges¶: The exchanges of this FunctionPkg.

function_specifications¶: The function specifications of this FunctionPkg.

functional_links¶: The functional links of this FunctionPkg.

realized_exchange_specifications¶: The realized exchange specifications of this FunctionPkg.

class capellambse.metamodel.fa.FunctionPort¶

Bases: Port, TypedElement, AbstractEvent

allocated_ports¶: The allocated ports of this FunctionPort.

exchanges¶: The exchanges of this FunctionPort.

owner¶: The owner of this FunctionPort.

realized_ports¶: The realized ports of this FunctionPort.

represented_component_port¶: The represented component port of this FunctionPort.

class capellambse.metamodel.fa.FunctionRealization¶

Bases: AbstractFunctionAllocation

A realization that links to a function.

class capellambse.metamodel.fa.FunctionSpecification¶

Bases: Namespace, AbstractActivity

in_exchange_links¶: The in exchange links of this FunctionSpecification.

out_exchange_links¶: The out exchange links of this FunctionSpecification.

ports¶: The ports of this FunctionSpecification.

class capellambse.metamodel.fa.FunctionalChain¶

Bases: NamedElement, InvolverElement, InvolvedElement

available_in_states¶: The available in states of this FunctionalChain.

control_nodes¶: The control nodes of this FunctionalChain.

functional_chain_realizations¶: The functional chain realizations of this FunctionalChain.

property involved: ElementList[AbstractFunction | FunctionalExchange]¶

property involved_chains: ElementList[FunctionalChain]¶

property involved_functions: ElementList[AbstractFunction]¶

property involved_links: ElementList[FunctionalExchange]¶

involvements¶: The involvements of this FunctionalChain.

involving_chains¶: The involving chains of this FunctionalChain.

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

postcondition¶: The postcondition of this FunctionalChain.

precondition¶: The precondition of this FunctionalChain.

realized_chains¶: The realized chains of this FunctionalChain.

realizing_chains¶: The realizing chains of this FunctionalChain.

sequence_links¶: The sequence links of this FunctionalChain.

sequence_nodes¶: The sequence nodes of this FunctionalChain.

class capellambse.metamodel.fa.FunctionalChainInvolvement¶: Bases: Involvement

class capellambse.metamodel.fa.FunctionalChainInvolvementFunction¶: Bases: FunctionalChainInvolvement, SequenceLinkEnd

class capellambse.metamodel.fa.FunctionalChainInvolvementLink¶

Bases: FunctionalChainInvolvement, ReferenceHierarchyContext

context¶: The context of this FunctionalChainInvolvementLink.

exchange_context¶: The exchange context of this FunctionalChainInvolvementLink.

exchanged_items¶: The exchanged items of this FunctionalChainInvolvementLink.

source¶: The source of this FunctionalChainInvolvementLink.

target¶: The target of this FunctionalChainInvolvementLink.

class capellambse.metamodel.fa.FunctionalChainKind¶

Bases: Enum

The kind of a Functional Chain.

COMPOSITE = 'COMPOSITE'¶

FRAGMENT = 'FRAGMENT'¶

SIMPLE = 'SIMPLE'¶

class capellambse.metamodel.fa.FunctionalChainRealization¶: Bases: Allocation

class capellambse.metamodel.fa.FunctionalChainReference¶

Bases: FunctionalChainInvolvement

involved¶: The involved of this FunctionalChainReference.

class capellambse.metamodel.fa.FunctionalExchange¶

Bases: Relationship, InvolvedElement, ObjectFlow, AbstractEvent, AbstractEventOperation, NamedElement, _AbstractExchange

allocating_component_exchange¶: The allocating component exchange of this FunctionalExchange.

categories¶: The categories of this FunctionalExchange.

exchange_items¶: The exchange items of this FunctionalExchange.

exchange_specifications¶: The exchange specifications of this FunctionalExchange.

exchanged_items¶: The exchanged items of this FunctionalExchange.

functional_exchange_realizations¶: The functional exchange realizations of this FunctionalExchange.

involving_functional_chains¶: The involving functional chains of this FunctionalExchange.

owner¶: The owner of this FunctionalExchange.

realized_functional_exchanges¶: The realized functional exchanges of this FunctionalExchange.

realizing_functional_exchanges¶: The realizing functional exchanges of this FunctionalExchange.

class capellambse.metamodel.fa.FunctionalExchangeRealization¶: Bases: Allocation

class capellambse.metamodel.fa.FunctionalExchangeSpecification¶: Bases: ExchangeSpecification

class capellambse.metamodel.fa.OrientationPortKind¶

Bases: Enum

Direction of component ports.

IN = 'IN'¶: The port represents an input of the component it is used in.

INOUT = 'INOUT'¶: The port represents both an input and on output of the component.

OUT = 'OUT'¶: The port represents an output of the component it is used in.

UNSET = 'UNSET'¶: The port orientation is undefined.

class capellambse.metamodel.fa.ReferenceHierarchyContext¶

Bases: ModelElement

source_reference_hierarchy¶: The source reference hierarchy of this ReferenceHierarchyContext.

target_reference_hierarchy¶: The target reference hierarchy of this ReferenceHierarchyContext.

class capellambse.metamodel.fa.SequenceLink¶

Bases: CapellaElement, ReferenceHierarchyContext

condition¶: The condition of this SequenceLink.

links¶: The links of this SequenceLink.

source¶: The source of this SequenceLink.

target¶: The target of this SequenceLink.

class capellambse.metamodel.fa.SequenceLinkEnd¶: Bases: CapellaElement

capellambse.metamodel.interaction module¶

class capellambse.metamodel.interaction.AbstractCapability¶

Bases: Structure, InvolverElement, AbstractFunctionalChainContainer

available_in_states¶: The available in states of this AbstractCapability.

capability_realizations¶: The capability realizations of this AbstractCapability.

chain_involvements¶: The chain involvements of this AbstractCapability.

extended_by¶: The extended by of this AbstractCapability.

extends¶: The extends of this AbstractCapability.

extension_points¶: The extension points of this AbstractCapability.

function_involvements¶: The function involvements of this AbstractCapability.

generalizations¶: The generalizations of this AbstractCapability.

generalized_by¶: The generalized by of this AbstractCapability.

generalizes¶: The generalizes of this AbstractCapability.

included_by¶: The included by of this AbstractCapability.

includes¶: The includes of this AbstractCapability.

involved_chains¶: The involved chains of this AbstractCapability.

involved_functions¶: The involved functions of this AbstractCapability.

postcondition¶: The postcondition of this AbstractCapability.

precondition¶: The precondition of this AbstractCapability.

realized_capabilities¶: The realized capabilities of this AbstractCapability.

realizing_capabilities¶: The realizing capabilities of this AbstractCapability.

scenarios¶: The scenarios of this AbstractCapability.

states¶: The states of this AbstractCapability.

class capellambse.metamodel.interaction.AbstractCapabilityExtend¶

Bases: _CapabilityRelation

extended¶: The extended of this AbstractCapabilityExtend.

extension_location¶: The extension location of this AbstractCapabilityExtend.

target¶: The target of this AbstractCapabilityExtend.

class capellambse.metamodel.interaction.AbstractCapabilityExtensionPoint¶

Bases: NamedRelationship

extend_links¶: The extend links of this AbstractCapabilityExtensionPoint.

class capellambse.metamodel.interaction.AbstractCapabilityGeneralization¶

Bases: _CapabilityRelation

super¶: The super of this AbstractCapabilityGeneralization.

target¶: The target of this AbstractCapabilityGeneralization.

class capellambse.metamodel.interaction.AbstractCapabilityInclude¶

Bases: _CapabilityRelation

included¶: The included of this AbstractCapabilityInclude.

target¶: The target of this AbstractCapabilityInclude.

class capellambse.metamodel.interaction.AbstractCapabilityRealization¶: Bases: Allocation

class capellambse.metamodel.interaction.AbstractEnd¶

Bases: InteractionFragment

event¶: The event of this AbstractEnd.

class capellambse.metamodel.interaction.AbstractFragment¶

Bases: TimeLapse

gates¶: The gates of this AbstractFragment.

class capellambse.metamodel.interaction.AbstractFunctionAbstractCapabilityInvolvement¶: Bases: Involvement

class capellambse.metamodel.interaction.ArmTimerEvent¶: Bases: Event

class capellambse.metamodel.interaction.CancelTimerEvent¶: Bases: Event

class capellambse.metamodel.interaction.CombinedFragment¶

Bases: AbstractFragment

operands¶: The operands of this CombinedFragment.

operator¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

class capellambse.metamodel.interaction.ConstraintDuration¶

Bases: NamedElement

duration¶: A POD containing arbitrary string data.

finish¶: The finish of this ConstraintDuration.

start¶: The start of this ConstraintDuration.

class capellambse.metamodel.interaction.CreationEvent¶: Bases: Event

class capellambse.metamodel.interaction.DestructionEvent¶: Bases: Event

class capellambse.metamodel.interaction.Event¶: Bases: NamedElement, AbstractEvent

class capellambse.metamodel.interaction.EventReceiptOperation¶

Bases: _EventOperation

operation¶: The operation of this EventReceiptOperation.

class capellambse.metamodel.interaction.EventSentOperation¶

Bases: _EventOperation

operation¶: The operation of this EventSentOperation.

class capellambse.metamodel.interaction.Execution¶: Bases: TimeLapse

class capellambse.metamodel.interaction.ExecutionEnd¶: Bases: AbstractEnd

class capellambse.metamodel.interaction.ExecutionEvent¶: Bases: Event

class capellambse.metamodel.interaction.FragmentEnd¶: Bases: InteractionFragment

class capellambse.metamodel.interaction.FunctionalChainAbstractCapabilityInvolvement¶: Bases: Involvement

class capellambse.metamodel.interaction.Gate¶: Bases: MessageEnd

class capellambse.metamodel.interaction.InstanceRole¶

Bases: NamedElement

instance¶: The instance of this InstanceRole.

represented_instance¶: The represented instance of this InstanceRole.

class capellambse.metamodel.interaction.InteractionFragment¶

Bases: NamedElement

covered¶: The covered of this InteractionFragment.

covered_instance_roles¶: The covered instance roles of this InteractionFragment.

class capellambse.metamodel.interaction.InteractionOperand¶

Bases: InteractionFragment

fragments¶: The fragments of this InteractionOperand.

guard¶: The guard of this InteractionOperand.

class capellambse.metamodel.interaction.InteractionOperatorKind¶

Bases: Enum

ALT = 'ALT'¶

ASSERT = 'ASSERT'¶

CONSIDER = 'CONSIDER'¶

CRITICAL = 'CRITICAL'¶

IGNORE = 'IGNORE'¶

LOOP = 'LOOP'¶

NEG = 'NEG'¶

OPT = 'OPT'¶

PAR = 'PAR'¶

SEQ = 'SEQ'¶

STRICT = 'STRICT'¶

UNSET = 'UNSET'¶

class capellambse.metamodel.interaction.InteractionState¶

Bases: InteractionFragment

function¶: The function of this InteractionState.

state¶: The state of this InteractionState.

class capellambse.metamodel.interaction.InteractionUse¶

Bases: AbstractFragment

referenced_scenario¶: The referenced scenario of this InteractionUse.

class capellambse.metamodel.interaction.MergeLink¶: Bases: Trace

class capellambse.metamodel.interaction.MessageEnd¶: Bases: AbstractEnd

class capellambse.metamodel.interaction.MessageKind¶

Bases: Enum

Identifies the type of message.

This concept is similar to UML MessageSort.

ASYNCHRONOUS_CALL = 'ASYNCHRONOUS_CALL'¶

The message was generated by an asynchronous call to an operation.

Equivalent to UML MessageSort::asynchCall.

CREATE = 'CREATE'¶: The message designates the creation of an instance role.

DELETE = 'DELETE'¶

The message designates the termination of another lifeline.

Equivalent to UML MessageSort::deleteMessage.

REPLY = 'REPLY'¶

The message is a reply message to an operation call.

Equivalent to UML MessageSort::reply.

SYNCHRONOUS_CALL = 'SYNCHRONOUS_CALL'¶

The message was generated by a synchronous call to an operation.

Equivalent to UML MessageSort::synchCall.

TIMER = 'TIMER'¶

UNSET = 'UNSET'¶: The message kind is not specified.

class capellambse.metamodel.interaction.RefinementLink¶: Bases: Trace

class capellambse.metamodel.interaction.Scenario¶

Bases: Namespace, AbstractBehavior

constraint_durations¶: The constraint durations of this Scenario.

events¶: The events of this Scenario.

formal_gates¶: The formal gates of this Scenario.

fragments¶: The fragments of this Scenario.

instance_roles¶: The instance roles of this Scenario.

is_merged¶: A POD containing a boolean.

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

messages¶: The messages of this Scenario.

postcondition¶: The postcondition of this Scenario.

precondition¶: The precondition of this Scenario.

realized_scenarios¶: The realized scenarios of this Scenario.

realizing_scenarios¶: The realizing scenarios of this Scenario.

property related_functions: ElementList[AbstractFunction]¶

scenario_realizations¶: The scenario realizations of this Scenario.

time_lapses¶: The time lapses of this Scenario.

class capellambse.metamodel.interaction.ScenarioKind¶

Bases: Enum

DATA_FLOW = 'DATA_FLOW'¶

FUNCTIONAL = 'FUNCTIONAL'¶

INTERACTION = 'INTERACTION'¶

INTERFACE = 'INTERFACE'¶

UNSET = 'UNSET'¶

class capellambse.metamodel.interaction.ScenarioRealization¶: Bases: Allocation

class capellambse.metamodel.interaction.SequenceMessage¶

Bases: NamedElement

A sequence message.

exchange_context¶: The exchange context of this SequenceMessage.

exchanged_items¶: The exchanged items of this SequenceMessage.

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

receiving_end¶: The receiving end of this SequenceMessage.

sending_end¶: The sending end of this SequenceMessage.

source¶: The source of this SequenceMessage.

target¶: The target of this SequenceMessage.

valuations¶: The valuations of this SequenceMessage.

class capellambse.metamodel.interaction.SequenceMessageValuation¶

Bases: CapellaElement

element¶: The element of this SequenceMessageValuation.

value¶: The value of this SequenceMessageValuation.

class capellambse.metamodel.interaction.StateFragment¶

Bases: TimeLapse

function¶: The function of this StateFragment.

state¶: The state of this StateFragment.

class capellambse.metamodel.interaction.TimeLapse¶

Bases: NamedElement

finish¶: The finish of this TimeLapse.

start¶: The start of this TimeLapse.

capellambse.metamodel.la module¶

Tools for the Logical Architecture layer.

class capellambse.metamodel.la.CapabilityRealization¶

Bases: AbstractCapability

capability_realization_involvements¶: The capability realization involvements of this CapabilityRealization.

involved_components¶: The involved components of this CapabilityRealization.

involved_elements¶: The involved elements of this CapabilityRealization.

involved_functions¶: The involved functions of this CapabilityRealization.

owned_chains¶: The owned chains of this CapabilityRealization.

class capellambse.metamodel.la.CapabilityRealizationPkg¶

Bases: AbstractCapabilityPkg

A capability package that can hold capabilities.

capabilities¶: The capabilities of this CapabilityRealizationPkg.

packages¶: The packages of this CapabilityRealizationPkg.

class capellambse.metamodel.la.ContextInterfaceRealization¶: Bases: InterfaceAllocation

class capellambse.metamodel.la.LogicalArchitecture¶

Bases: ComponentArchitecture

actor_exchanges¶: The actor exchanges of this LogicalArchitecture.

property all_actor_exchanges: ElementList[ComponentExchange]¶

property all_actors: ElementList[LogicalComponent]¶

property all_component_exchanges: ElementList[ComponentExchange]¶

property all_components: ElementList[LogicalComponent]¶

property component_exchanges: ElementList[ComponentExchange]¶: The component exchanges of this AbstractFunctionalArchitecture.

component_package¶: The component package of this LogicalArchitecture.

component_pkg¶: The component pkg of this LogicalArchitecture.

diagrams: _descriptors.Accessor[ElementList[capellambse.model.diagram.Diagram]]¶: The diagrams of this LogicalArchitecture.

realized_system_analysis¶: The realized system analysis of this LogicalArchitecture.

property root_component: LogicalComponent¶

system_analysis_realizations¶: The system analysis realizations of this LogicalArchitecture.

class capellambse.metamodel.la.LogicalArchitecturePkg¶

Bases: BlockArchitecturePkg

architectures¶: The architectures of this LogicalArchitecturePkg.

class capellambse.metamodel.la.LogicalComponent¶

Bases: Component, CapabilityRealizationInvolvedElement

architectures¶: The architectures of this LogicalComponent.

components¶: The components of this LogicalComponent.

packages¶: The packages of this LogicalComponent.

realized_system_components¶: The realized system components of this LogicalComponent.

realizing_physical_components¶: The realizing physical components of this LogicalComponent.

class capellambse.metamodel.la.LogicalComponentPkg¶

Bases: ComponentPkg

components¶: The components of this LogicalComponentPkg.

packages¶: The packages of this LogicalComponentPkg.

class capellambse.metamodel.la.LogicalFunction¶

Bases: AbstractFunction

functions¶: The functions of this LogicalFunction.

involved_in¶: The involved in of this LogicalFunction.

owner¶: The owner of this LogicalFunction.

packages¶: The packages of this LogicalFunction.

realized_system_functions¶: The realized system functions of this LogicalFunction.

realizing_physical_functions¶: The realizing physical functions of this LogicalFunction.

class capellambse.metamodel.la.LogicalFunctionPkg¶

Bases: FunctionPkg

functions¶: The functions of this LogicalFunctionPkg.

packages¶: The packages of this LogicalFunctionPkg.

class capellambse.metamodel.la.SystemAnalysisRealization¶: Bases: ArchitectureAllocation

capellambse.metamodel.libraries module¶

class capellambse.metamodel.libraries.AccessPolicy¶

Bases: Enum

READ_AND_WRITE = 'readAndWrite'¶

READ_ONLY = 'readOnly'¶

class capellambse.metamodel.libraries.LibraryAbstractElement¶: Bases: ModelElement

class capellambse.metamodel.libraries.LibraryReference¶

Bases: LibraryAbstractElement

access_policy¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

library¶: The library of this LibraryReference.

version¶: The version of this LibraryReference.

class capellambse.metamodel.libraries.ModelInformation¶

Bases: LibraryAbstractElement

references¶: The references of this ModelInformation.

version¶: The version of this ModelInformation.

class capellambse.metamodel.libraries.ModelVersion¶

Bases: LibraryAbstractElement

last_modified_file_stamp¶: A POD containing an integer number.

major_version_number¶: A POD containing an integer number.

minor_version_number¶: A POD containing an integer number.

capellambse.metamodel.modellingcore module¶

class capellambse.metamodel.modellingcore.AbstractConstraint¶

Bases: ModelElement

A constraint that applies to a given set of model elements.

constrained_elements¶: The constrained elements of this AbstractConstraint.

specification¶: A condition that must evaluate to true to satisfy the constraint.

class capellambse.metamodel.modellingcore.AbstractExchangeItem¶

Bases: AbstractType

Set of exchanged element exchanged between ports.

class capellambse.metamodel.modellingcore.AbstractInformationFlow¶

Bases: AbstractNamedElement, AbstractRelationship

convoyed_informations¶: The convoyed informations of this AbstractInformationFlow.

realizations¶: The realizations of this AbstractInformationFlow.

source¶: The source of this AbstractInformationFlow.

target¶: The target of this AbstractInformationFlow.

class capellambse.metamodel.modellingcore.AbstractNamedElement¶

Bases: ModelElement

An element that may have a name.

The name is used for identification of the named element within the namespace in which it is defined. A named element also has a qualified name that allows it to be unambiguously identified within a hierarchy of nested namespaces.

name¶: A POD containing arbitrary string data.

class capellambse.metamodel.modellingcore.AbstractParameter¶

Bases: AbstractTypedElement

Specification of an argument to a behavioral feature.

Parameters are used to pass information into or out of an invocation of a behavioral feature.

effect¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

is_exception¶: A POD containing a boolean.

is_optional¶: A POD containing a boolean.

is_stream¶: A POD containing a boolean.

kind_of_rate¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.

parameter_set¶: The parameter set of this AbstractParameter.

probability¶: The probability of this AbstractParameter.

rate¶: The rate of this AbstractParameter.

class capellambse.metamodel.modellingcore.AbstractParameterSet¶

Bases: AbstractNamedElement

An alternative set of inputs or outputs that a behavior may use.

conditions¶: The conditions of this AbstractParameterSet.

parameters¶: The parameters of this AbstractParameterSet.

probability¶: The probability of this AbstractParameterSet.

class capellambse.metamodel.modellingcore.AbstractRelationship¶

Bases: ModelElement

realized_flow¶: The realized flow of this AbstractRelationship.

class capellambse.metamodel.modellingcore.AbstractTrace¶

Bases: TraceableElement

source¶: The source of this AbstractTrace.

target¶: The target of this AbstractTrace.

class capellambse.metamodel.modellingcore.AbstractType¶

Bases: AbstractNamedElement

Base abstract class supporting the definition of data types.

class capellambse.metamodel.modellingcore.AbstractTypedElement¶

Bases: AbstractNamedElement

A (named) model element to which a specific type is associated.

type¶: The type of this AbstractTypedElement.

class capellambse.metamodel.modellingcore.FinalizableElement¶

Bases: ModelElement

is_final¶: A POD containing a boolean.

class capellambse.metamodel.modellingcore.IState¶

Bases: AbstractNamedElement

A vertex is an abstraction of a node in a state machine graph.

In general, it can be the source or destination of any number of transitions.

exploited_states¶: The exploited states of this IState.

referenced_states¶: The referenced states of this IState.

class capellambse.metamodel.modellingcore.InformationsExchanger¶

Bases: ModelElement

An element that may exchange information with other elements.

class capellambse.metamodel.modellingcore.ParameterEffectKind¶

Bases: Enum

A behavior’s effect on values passed in or out of its parameters.

CREATE = 'create'¶: The parameter value is being created upon behavior execution.

DELETE = 'delete'¶: The parameter value is being deleted upon behavior execution.

READ = 'read'¶: The parameter value is only being read upon behavior execution.

UPDATE = 'update'¶: The parameter value is being updated upon behavior execution.

class capellambse.metamodel.modellingcore.PublishableElement¶

Bases: ModelElement

is_visible_in_doc¶: A POD containing a boolean.

is_visible_in_lm¶: A POD containing a boolean.

class capellambse.metamodel.modellingcore.RateKind¶

Bases: Enum

The possible caracterizations for the rate of a streaming parameter.

CONTINUOUS = 'Continuous'¶: The rate characterizes a continuous flow.

DISCRETE = 'Discrete'¶: The rate characterizes a discrete flow.

UNSPECIFIED = 'Unspecified'¶: The rate kind is not specified.

class capellambse.metamodel.modellingcore.TraceableElement¶

Bases: ModelElement

An element that may be traced to other elements.

class capellambse.metamodel.modellingcore.ValueSpecification¶

Bases: AbstractTypedElement

The specification of a set of instances.

The set includes both objects and data values, and may be empty.

capellambse.metamodel.modeltypes module¶

Enumeration types used by the MelodyModel.

capellambse.metamodel.namespaces module¶

Common namespace definitions for the Capella metamodel.

capellambse.metamodel.oa module¶

Tools for the Operational Analysis layer.

class capellambse.metamodel.oa.AbstractConceptItem¶

Bases: Component

composing_links¶: The composing links of this AbstractConceptItem.

class capellambse.metamodel.oa.ActivityAllocation¶: Bases: Allocation

class capellambse.metamodel.oa.CapabilityConfiguration¶

Bases: AbstractConceptItem

configured_capability¶: The configured capability of this CapabilityConfiguration.

class capellambse.metamodel.oa.CommunicationMean¶

Bases: ComponentExchange

An operational entity exchange.

allocated_interactions¶: The allocated interactions of this CommunicationMean.

naming_rules¶: The naming rules of this CommunicationMean.

class capellambse.metamodel.oa.CommunityOfInterest¶

Bases: NamedElement

community_of_interest_compositions¶: The community of interest compositions of this CommunityOfInterest.

class capellambse.metamodel.oa.CommunityOfInterestComposition¶

Bases: NamedElement

community_of_interest¶: The community of interest of this CommunityOfInterestComposition.

interested_organisational_unit¶: The interested organisational unit of this CommunityOfInterestComposition.

class capellambse.metamodel.oa.Concept¶

Bases: NamedElement

compliances¶: The compliances of this Concept.

composite_links¶: The composite links of this Concept.

class capellambse.metamodel.oa.ConceptCompliance¶

Bases: Relationship

compliant_capability¶: The compliant capability of this ConceptCompliance.

comply_with_concept¶: The comply with concept of this ConceptCompliance.

class capellambse.metamodel.oa.ConceptPkg¶

Bases: Structure

concepts¶: The concepts of this ConceptPkg.

packages¶: The packages of this ConceptPkg.

class capellambse.metamodel.oa.Entity¶

Bases: AbstractConceptItem, InformationsExchanger, InvolvedElement

An Entity in the OperationalAnalysis layer.

activities¶: The activities of this Entity.

actual_location¶: The actual location of this Entity.

capabilities¶: The capabilities of this Entity.

communication_means¶: The communication means of this Entity.

entities¶: The entities of this Entity.

exchanges¶: The exchanges of this Entity.

property inputs: ElementList[CommunicationMean]¶

organisational_unit_memberships¶: The organisational unit memberships of this Entity.

property outputs: ElementList[CommunicationMean]¶

realizing_system_components¶: The realizing system components of this Entity.

related_exchanges¶: The related exchanges of this Entity.

class capellambse.metamodel.oa.EntityOperationalCapabilityInvolvement¶: Bases: Involvement

class capellambse.metamodel.oa.EntityPkg¶

Bases: ComponentPkg

communication_means¶: The communication means of this EntityPkg.

entities¶: The entities of this EntityPkg.

locations¶: The locations of this EntityPkg.

packages¶: The packages of this EntityPkg.

class capellambse.metamodel.oa.ItemInConcept¶

Bases: NamedElement

concept¶: The concept of this ItemInConcept.

item¶: The item of this ItemInConcept.

class capellambse.metamodel.oa.Location¶

Bases: AbstractConceptItem

located_entities¶: The located entities of this Location.

location_description¶: A POD containing arbitrary string data.

class capellambse.metamodel.oa.OperationalActivity¶

Bases: AbstractFunction

activities¶: The activities of this OperationalActivity.

inputs¶: The inputs of this OperationalActivity.

outputs¶: The outputs of this OperationalActivity.

owner¶: The owner of this OperationalActivity.

packages¶: The packages of this OperationalActivity.

realizing_system_functions¶: The realizing system functions of this OperationalActivity.

related_exchanges¶: The related exchanges of this OperationalActivity.

class capellambse.metamodel.oa.OperationalActivityPkg¶

Bases: FunctionPkg

activities¶: The activities of this OperationalActivityPkg.

owner¶: The owner of this OperationalActivityPkg.

packages¶: The packages of this OperationalActivityPkg.

class capellambse.metamodel.oa.OperationalAnalysis¶

Bases: BlockArchitecture

Provides access to the OperationalAnalysis layer of the model.

activity_package¶: The activity package of this OperationalAnalysis.

activity_pkg¶: The activity pkg of this OperationalAnalysis.

property all_activities: ElementList[OperationalActivity]¶

property all_activity_exchanges: ElementList[FunctionalExchange]¶

property all_actors: ElementList[Entity]¶

property all_entities: ElementList[Entity]¶

property all_entity_exchanges: ElementList[CommunicationMean]¶

property all_operational_processes: ElementList[OperationalProcess]¶

property all_processes: ElementList[OperationalProcess]¶

capability_package¶: The capability package of this OperationalAnalysis.

concept_pkg¶: The concept pkg of this OperationalAnalysis.

diagrams: _descriptors.Accessor[ElementList[capellambse.model.diagram.Diagram]]¶: The diagrams of this OperationalAnalysis.

entity_package¶: The entity package of this OperationalAnalysis.

entity_pkg¶: The entity pkg of this OperationalAnalysis.

role_pkg¶: The role pkg of this OperationalAnalysis.

property root_activity: OperationalActivity¶

property root_entity: Entity¶

class capellambse.metamodel.oa.OperationalCapability¶

Bases: AbstractCapability, Namespace

A capability in the OperationalAnalysis layer.

compliances¶: The compliances of this OperationalCapability.

configurations¶: The configurations of this OperationalCapability.

entity_involvements¶: The entity involvements of this OperationalCapability.

involved_activities¶: The involved activities of this OperationalCapability.

involved_entities¶: The involved entities of this OperationalCapability.

involved_processes¶: The involved processes of this OperationalCapability.

owned_processes¶: The owned processes of this OperationalCapability.

class capellambse.metamodel.oa.OperationalCapabilityPkg¶

Bases: AbstractCapabilityPkg

capabilities¶: The capabilities of this OperationalCapabilityPkg.

capability_configurations¶: The capability configurations of this OperationalCapabilityPkg.

complies_with_concepts¶: The complies with concepts of this OperationalCapabilityPkg.

concept_compliances¶: The concept compliances of this OperationalCapabilityPkg.

packages¶: The packages of this OperationalCapabilityPkg.

class capellambse.metamodel.oa.OperationalProcess¶: Bases: FunctionalChain

class capellambse.metamodel.oa.OperationalScenario¶

Bases: NamedElement

context¶: A POD containing arbitrary string data.

objective¶: A POD containing arbitrary string data.

class capellambse.metamodel.oa.OrganisationalUnit¶

Bases: NamedElement

community_of_interest_memberships¶: The community of interest memberships of this OrganisationalUnit.

organisational_unit_compositions¶: The organisational unit compositions of this OrganisationalUnit.

class capellambse.metamodel.oa.OrganisationalUnitComposition¶

Bases: NamedElement

organisational_unit¶: The organisational unit of this OrganisationalUnitComposition.

participating_entity¶: The participating entity of this OrganisationalUnitComposition.

class capellambse.metamodel.oa.Role¶

Bases: AbstractInstance

activity_allocations¶: The activity allocations of this Role.

assembly_usages¶: The assembly usages of this Role.

class capellambse.metamodel.oa.RoleAllocation¶: Bases: Allocation

class capellambse.metamodel.oa.RoleAssemblyUsage¶

Bases: NamedElement

child¶: The child of this RoleAssemblyUsage.

class capellambse.metamodel.oa.RolePkg¶

Bases: Structure

packages¶: The packages of this RolePkg.

roles¶: The roles of this RolePkg.

class capellambse.metamodel.oa.Swimlane¶: Bases: NamedElement, ActivityPartition

capellambse.metamodel.re module¶

class capellambse.metamodel.re.CatalogElement¶

Bases: ReDescriptionElement, ReElementContainer

author¶: A POD containing arbitrary string data.

current_compliancy¶: The current compliancy of this CatalogElement.

default_replica_compliancy¶: The default replica compliancy of this CatalogElement.

environment¶: A POD containing arbitrary string data.

is_read_only¶: A POD containing a boolean.

kind¶

A POD that can have one of a pretermined set of values.

This works in much the same way as the StringPOD, except that the returned and consumed values are not simple strings, but members of the Enum that was passed into the constructor.

When assigning, this property also accepts the string name of one of the enum members. In either case, the corresponding enum member’s value will be placed in the underlying XML element.

The default constructor argument determines which member will be used if the attribute is missing from the XML. If no default is passed exlicitly, the first declared enum member will be used.