capellambse.metamodel package

Subpackages

• capellambse.metamodel.information package
  • Association
    • Association.members
    • Association.navigable_members
    • Association.roles
  • Class
    • Class.generalizations
    • Class.is_abstract
    • Class.is_final
    • Class.is_primitive
    • Class.owned_properties
    • Class.properties
    • Class.realizations
    • Class.realized_by
    • Class.realized_classes
    • Class.state_machines
    • Class.sub
    • Class.super
    • Class.visibility
  • Collection
    • Collection.kind
    • Collection.sub
    • Collection.super
  • DataPkg
    • DataPkg.classes
    • DataPkg.collections
    • DataPkg.complex_values
    • DataPkg.datatypes
    • DataPkg.enumerations
    • DataPkg.owned_associations
    • DataPkg.packages
    • DataPkg.unions
  • ExchangeItem
    • ExchangeItem.elements
    • ExchangeItem.exchanges
    • ExchangeItem.instances
    • ExchangeItem.type
  • ExchangeItemElement
    • ExchangeItemElement.abstract_type
    • ExchangeItemElement.max_card
    • ExchangeItemElement.min_card
    • ExchangeItemElement.owner
  • ExchangeItemInstance
  • InformationRealization
  • PortAllocation
  • Property
    • Property.association
    • Property.default_value
    • Property.is_abstract
    • Property.is_derived
    • Property.is_ordered
    • Property.is_part_of_key
    • Property.is_read_only
    • Property.is_static
    • Property.is_unique
    • Property.kind
    • Property.max_card
    • Property.max_value
    • Property.min_card
    • Property.min_value
    • Property.null_value
    • Property.type
    • Property.visibility
  • Union
    • Union.kind
    • Union.sub
    • Union.super
  • Unit
  • cls
  • Submodules
  • capellambse.metamodel.information.datatype module
    • BooleanType
      • BooleanType.default
      • BooleanType.literals
    • DataType
      • DataType.is_discrete
      • DataType.max_inclusive
      • DataType.min_inclusive
      • DataType.pattern
      • DataType.visibility
    • Enumeration
      • Enumeration.domain_type
      • Enumeration.literals
      • Enumeration.owned_literals
      • Enumeration.sub
      • Enumeration.super
    • NumericType
      • NumericType.default_value
      • NumericType.kind
      • NumericType.max_value
      • NumericType.min_value
      • NumericType.null_value
    • PhysicalQuantity
      • PhysicalQuantity.unit
    • StringType
      • StringType.default_value
      • StringType.max_length
      • StringType.min_length
      • StringType.null_value
  • capellambse.metamodel.information.datavalue module
    • ComplexValue
      • ComplexValue.type
      • ComplexValue.value_parts
    • EnumerationLiteral
      • EnumerationLiteral.owner
      • EnumerationLiteral.value
    • EnumerationReference
      • EnumerationReference.type
      • EnumerationReference.value
    • LiteralBooleanValue
      • LiteralBooleanValue.value
    • LiteralNumericValue
      • LiteralNumericValue.unit
      • LiteralNumericValue.value
    • LiteralStringValue
    • LiteralValue
      • LiteralValue.is_abstract
      • LiteralValue.type
      • LiteralValue.value
    • ValuePart
      • ValuePart.referenced_property
      • ValuePart.value

Submodules

capellambse.metamodel.capellacommon module

Classes handling Mode/State-Machines and related content.

class capellambse.metamodel.capellacommon.AbstractStateMode

Bases: ModelElement

Common code for states and modes.

realized_states

The realized states of this AbstractStateMode.

regions

The regions of this AbstractStateMode.

class capellambse.metamodel.capellacommon.AbstractStateRealization

Bases: ModelElement

class capellambse.metamodel.capellacommon.CapabilityRealizationInvolvement

Bases: ModelElement

class capellambse.metamodel.capellacommon.DeepHistoryPseudoState

Bases: AbstractStateMode

A deep history pseudo state.

incoming_transitions

The incoming transitions of this DeepHistoryPseudoState.

outgoing_transitions

The outgoing transitions of this DeepHistoryPseudoState.

realizing_states

The realizing states of this DeepHistoryPseudoState.

class capellambse.metamodel.capellacommon.FinalState

Bases: AbstractStateMode

A final state.

incoming_transitions

The incoming transitions of this FinalState.

realizing_states

The realizing states of this FinalState.

class capellambse.metamodel.capellacommon.ForkPseudoState

Bases: AbstractStateMode

A fork pseudo state.

incoming_transitions

The incoming transitions of this ForkPseudoState.

outgoing_transitions

The outgoing transitions of this ForkPseudoState.

realizing_states

The realizing states of this ForkPseudoState.

class capellambse.metamodel.capellacommon.GenericTrace

Bases: TraceableElement

A trace between two elements.

property name: str

Return the name.

class capellambse.metamodel.capellacommon.InitialPseudoState

Bases: AbstractStateMode

An initial pseudo state.

outgoing_transitions

The outgoing transitions of this InitialPseudoState.

realizing_states

The realizing states of this InitialPseudoState.

class capellambse.metamodel.capellacommon.JoinPseudoState

Bases: AbstractStateMode

A join pseudo state.

incoming_transitions

The incoming transitions of this JoinPseudoState.

outgoing_transitions

The outgoing transitions of this JoinPseudoState.

realizing_states

The realizing states of this JoinPseudoState.

class capellambse.metamodel.capellacommon.Mode

Bases: AbstractStateMode

A mode.

incoming_transitions

The incoming transitions of this Mode.

outgoing_transitions

The outgoing transitions of this Mode.

realizing_states

The realizing states of this Mode.

class capellambse.metamodel.capellacommon.Region

Bases: ModelElement

A region inside a state machine or state/mode.

modes: Accessor

The modes of this Region.

states: Accessor

The states of this Region.

transitions: Accessor

The transitions of this Region.

class capellambse.metamodel.capellacommon.ShallowHistoryPseudoState

Bases: AbstractStateMode

A shallow history pseudo state.

incoming_transitions

The incoming transitions of this ShallowHistoryPseudoState.

outgoing_transitions

The outgoing transitions of this ShallowHistoryPseudoState.

realizing_states

The realizing states of this ShallowHistoryPseudoState.

class capellambse.metamodel.capellacommon.State

Bases: AbstractStateMode

A state.

do_activity

The do activity of this State.

entries

The entries of this State.

exits

The exits of this State.

functions: Accessor

The functions of this State.

incoming_transitions

The incoming transitions of this State.

outgoing_transitions

The outgoing transitions of this State.

realizing_states

The realizing states of this State.

class capellambse.metamodel.capellacommon.StateMachine

Bases: ModelElement

A state machine.

regions

The regions of this StateMachine.

class capellambse.metamodel.capellacommon.StateTransition

Bases: ModelElement

A transition between States or Modes.

destination

The destination of this StateTransition.

effects

The effects of this StateTransition.

guard

The guard of this StateTransition.

source

The source of this StateTransition.

triggers

The triggers of this StateTransition.

class capellambse.metamodel.capellacommon.TerminatePseudoState

Bases: AbstractStateMode

A terminate pseudo state.

incoming_transitions

The incoming transitions of this TerminatePseudoState.

realizing_states

The realizing states of this TerminatePseudoState.

class capellambse.metamodel.capellacommon.TransfoLink

Bases: ModelElement

capellambse.metamodel.capellacommon.cls

alias of ShallowHistoryPseudoState

capellambse.metamodel.capellacore module

class capellambse.metamodel.capellacore.BooleanPropertyValue

Bases: PropertyValue

A boolean property value.

value: m.BasePOD | m.Association

A POD containing a boolean.

class capellambse.metamodel.capellacore.Constraint

Bases: ModelElement

A constraint.

constrained_elements

The constrained elements of this Constraint.

specification

The specification of this Constraint.

class capellambse.metamodel.capellacore.EnumerationPropertyLiteral

Bases: ModelElement

A Literal for EnumerationPropertyType.

class capellambse.metamodel.capellacore.EnumerationPropertyType

Bases: ModelElement

An EnumerationPropertyType.

literals

The literals of this EnumerationPropertyType.

class capellambse.metamodel.capellacore.EnumerationPropertyValue

Bases: PropertyValue

An enumeration property value.

type

The type of this EnumerationPropertyValue.

value: m.BasePOD | m.Association

The value of this EnumerationPropertyValue.

class capellambse.metamodel.capellacore.FloatPropertyValue

Bases: PropertyValue

A floating point property value.

value: m.BasePOD | m.Association

A POD containing a floating-point number.

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

class capellambse.metamodel.capellacore.Generalization

Bases: ModelElement

A Generalization.

super: m.Accessor

The super of this Generalization.

class capellambse.metamodel.capellacore.IntegerPropertyValue

Bases: PropertyValue

An integer property value.

value: m.BasePOD | m.Association

A POD containing an integer number.

class capellambse.metamodel.capellacore.PropertyValue

Bases: ModelElement

Abstract base class for PropertyValues.

enumerations

The enumerations of this PropertyValue.

value: m.BasePOD | m.Association

class capellambse.metamodel.capellacore.PropertyValueGroup

Bases: ModelElement

A group for PropertyValues.

values

The values of this PropertyValueGroup.

class capellambse.metamodel.capellacore.PropertyValuePkg

Bases: ModelElement

A Package for PropertyValues.

enumeration_property_types

The enumeration property types of this PropertyValuePkg.

groups

The groups of this PropertyValuePkg.

packages

The packages of this PropertyValuePkg.

values

The values of this PropertyValuePkg.

class capellambse.metamodel.capellacore.StringPropertyValue

Bases: PropertyValue

A string property value.

value: m.BasePOD | m.Association

A POD containing arbitrary string data.

capellambse.metamodel.capellamodeller module

class capellambse.metamodel.capellamodeller.Library

Bases: Project

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

class capellambse.metamodel.capellamodeller.Project

Bases: ModelElement

property model_root: SystemEngineering

model_roots

The model roots of this Project.

class capellambse.metamodel.capellamodeller.SystemEngineering

Bases: ModelElement

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]

architectures

The architectures of this SystemEngineering.

filtering_model

The filtering model of this SystemEngineering.

property la: LogicalArchitecture

property oa: OperationalAnalysis

property pa: PhysicalArchitecture

property sa: SystemAnalysis

capellambse.metamodel.cs module

Implementation of objects and relations for Functional Analysis.

Composite Structure objects inheritance tree (taxonomy):

Composite Structure object-relations map (ontology):

class capellambse.metamodel.cs.Component

Bases: ModelElement

A template class for components.

exchanges

The exchanges of this Component.

is_abstract

Boolean flag for an abstract Component.

is_actor

Boolean flag for an actor Component.

is_human

Boolean flag for a human Component.

owner

The owner of this Component.

parts

The parts 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.

state_machines

The state machines of this Component.

class capellambse.metamodel.cs.ComponentArchitecture

Bases: ModelElement

Formerly known as BaseArchitectureLayer.

all_classes

The all classes of this ComponentArchitecture.

all_collections

The all collections of this ComponentArchitecture.

all_complex_values

The all complex values of this ComponentArchitecture.

all_enumerations

The all enumerations of this ComponentArchitecture.

all_interfaces

The all interfaces of this ComponentArchitecture.

all_module_types

The all module types of this ComponentArchitecture.

all_relation_types

The all relation types of this ComponentArchitecture.

all_requirement_types

The all requirement types of this ComponentArchitecture.

all_requirements

The all requirements of this ComponentArchitecture.

all_unions

The all unions of this ComponentArchitecture.

component_exchange_categories

The component exchange categories of this ComponentArchitecture.

data_package

The data package of this ComponentArchitecture.

interface_package

The interface package of this ComponentArchitecture.

requirement_modules

The requirement modules of this ComponentArchitecture.

requirement_types_folders

The requirement types folders of this ComponentArchitecture.

validation

The validation of this ComponentArchitecture.

class capellambse.metamodel.cs.ComponentRealization

Bases: ModelElement

A realization that links to a component.

class capellambse.metamodel.cs.ExchangeItemAllocation

Bases: ModelElement

An allocation of an ExchangeItem to an Interface.

item

The item of this ExchangeItemAllocation.

class capellambse.metamodel.cs.Interface

Bases: ModelElement

An interface.

exchange_item_allocations

The exchange item allocations of this Interface.

class capellambse.metamodel.cs.InterfacePkg

Bases: ModelElement

A package that can hold interfaces and exchange items.

exchange_items

The exchange items of this InterfacePkg.

interfaces

The interfaces of this InterfacePkg.

packages: Accessor

The packages of this InterfacePkg.

class capellambse.metamodel.cs.Part

Bases: ModelElement

A representation of a physical component.

deployed_parts: Accessor

The deployed parts of this Part.

type

The type of this Part.

class capellambse.metamodel.cs.PhysicalLink

Bases: PhysicalPort

A physical link.

ends

The ends of this PhysicalLink.

exchanges

The exchanges of this PhysicalLink.

physical_paths: Accessor

The physical paths of this PhysicalLink.

source

The source of this PhysicalLink.

target

The target of this PhysicalLink.

class capellambse.metamodel.cs.PhysicalPath

Bases: ModelElement

A physical path.

exchanges

The exchanges of this PhysicalPath.

involved_items

The involved items of this PhysicalPath.

property involved_links: ElementList[PhysicalLink]

class capellambse.metamodel.cs.PhysicalPort

Bases: ModelElement

A physical port.

links: Accessor

The links of this PhysicalPort.

owner

The owner of this PhysicalPort.

capellambse.metamodel.fa module

Implementation of objects and relations for Functional Analysis.

Functional Analysis objects inheritance tree (taxonomy):

Functional Analysis object-relations map (ontology):

class capellambse.metamodel.fa.AbstractExchange

Bases: ModelElement

Common code for Exchanges.

source

The source of this AbstractExchange.

target

The target of this AbstractExchange.

class capellambse.metamodel.fa.AbstractFunction

Bases: ModelElement

An AbstractFunction.

available_in_states

The available in states of this AbstractFunction.

scenarios

The scenarios of this AbstractFunction.

class capellambse.metamodel.fa.ComponentExchange

Bases: AbstractExchange

A functional component exchange.

allocated_exchange_items

The allocated exchange items of this ComponentExchange.

allocated_functional_exchanges

The allocated functional exchanges of this ComponentExchange.

allocating_physical_link

The allocating physical link of this ComponentExchange.

allocating_physical_paths

The allocating physical paths of this ComponentExchange.

categories

The categories of this ComponentExchange.

property exchange_items: ElementList[ExchangeItem]

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: ModelElement

class capellambse.metamodel.fa.ComponentExchangeCategory

Bases: ModelElement

exchanges: m.Association[ComponentExchange]

The accessor of this CoupledElementList.

class capellambse.metamodel.fa.ComponentExchangeFunctionalExchangeAllocation

Bases: ModelElement

class capellambse.metamodel.fa.ComponentFunctionalAllocation

Bases: ModelElement

class capellambse.metamodel.fa.ComponentPort

Bases: ModelElement

A component port.

direction

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.

exchanges: m.Accessor

The exchanges of this ComponentPort.

owner

The owner of this ComponentPort.

provided_interfaces

The provided interfaces of this ComponentPort.

required_interfaces

The required interfaces of this ComponentPort.

class capellambse.metamodel.fa.ControlNode

Bases: ModelElement

A node with a specific control-kind.

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.ExchangeCategory

Bases: ModelElement

exchanges: m.Association[FunctionalExchange]

The accessor of this CoupledElementList.

class capellambse.metamodel.fa.Function

Bases: AbstractFunction

Common Code for Function’s.

exchanges: m.Accessor[FunctionalExchange]

The exchanges of this Function.

functions: m.Accessor

inputs

The inputs of this Function.

property is_leaf

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.

outputs

The outputs of this Function.

packages: m.Accessor

realized_functions

The realized functions of this Function.

realizing_functions

The realizing functions of this Function.

related_exchanges: m.Accessor[FunctionalExchange]

The related exchanges of this Function.

class capellambse.metamodel.fa.FunctionInputPort

Bases: FunctionPort

A function input port.

exchange_items

The exchange items of this FunctionInputPort.

exchanges: m.Accessor

The exchanges of this FunctionInputPort.

class capellambse.metamodel.fa.FunctionOutputPort

Bases: FunctionPort

A function output port.

exchange_items

The exchange items of this FunctionOutputPort.

exchanges: m.Accessor

The exchanges of this FunctionOutputPort.

class capellambse.metamodel.fa.FunctionPort

Bases: ModelElement

A function port.

exchanges: m.Accessor

owner

The owner of this FunctionPort.

state_machines

The state machines of this FunctionPort.

class capellambse.metamodel.fa.FunctionRealization

Bases: ModelElement

A realization that links to a function.

class capellambse.metamodel.fa.FunctionalChain

Bases: ModelElement

A functional chain.

control_nodes

The control nodes of this FunctionalChain.

property involved: MixedElementList

involved_chains

The involved chains of this FunctionalChain.

involved_functions

The involved functions of this FunctionalChain.

involved_links

The involved links of this FunctionalChain.

involvements

The involvements of this FunctionalChain.

involving_chains: m.Accessor[FunctionalChain]

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: m.Accessor[FunctionalChain]

The realizing chains of this FunctionalChain.

class capellambse.metamodel.fa.FunctionalChainInvolvement

Bases: AbstractInvolvement

Abstract class for FunctionalChainInvolvementLink/Function.

class capellambse.metamodel.fa.FunctionalChainInvolvementFunction

Bases: FunctionalChainInvolvement

An element linking a FunctionalChain to a Function.

class capellambse.metamodel.fa.FunctionalChainInvolvementLink

Bases: FunctionalChainInvolvement

An element linking a FunctionalChain to an Exchange.

exchange_context

The exchange context of this FunctionalChainInvolvementLink.

exchanged_items

The exchanged items of this FunctionalChainInvolvementLink.

class capellambse.metamodel.fa.FunctionalChainReference

Bases: FunctionalChainInvolvement

An element linking two related functional chains together.

class capellambse.metamodel.fa.FunctionalExchange

Bases: AbstractExchange

A functional exchange.

allocating_component_exchange

The allocating component exchange of this FunctionalExchange.

categories

The categories of this FunctionalExchange.

exchange_items

The exchange items of this FunctionalExchange.

involving_functional_chains

The involving functional chains of this FunctionalExchange.

property owner: ComponentExchange | None

realized_functional_exchanges

The realized functional exchanges of this FunctionalExchange.

realizing_functional_exchanges: m.Accessor[FunctionalExchange]

The realizing functional exchanges of this FunctionalExchange.

capellambse.metamodel.interaction module

class capellambse.metamodel.interaction.AbstractCapabilityExtend

Bases: Exchange

An AbstractCapabilityExtend.

source

The source of this AbstractCapabilityExtend.

target

The target of this AbstractCapabilityExtend.

class capellambse.metamodel.interaction.AbstractCapabilityGeneralization

Bases: Exchange

An AbstractCapabilityGeneralization.

source

The source of this AbstractCapabilityGeneralization.

target

The target of this AbstractCapabilityGeneralization.

class capellambse.metamodel.interaction.AbstractCapabilityInclude

Bases: Exchange

An AbstractCapabilityInclude.

source

The source of this AbstractCapabilityInclude.

target

The target of this AbstractCapabilityInclude.

class capellambse.metamodel.interaction.AbstractCapabilityRealization

Bases: ModelElement

class capellambse.metamodel.interaction.AbstractFunctionAbstractCapabilityInvolvement

Bases: AbstractInvolvement

An abstract CapabilityInvolvement linking to SystemFunctions.

class capellambse.metamodel.interaction.AbstractInvolvement

Bases: ModelElement

An abstract Involvement.

involved

The involved of this AbstractInvolvement.

property name: str

Return the name.

source

The source of this AbstractInvolvement.

target

The target of this AbstractInvolvement.

class capellambse.metamodel.interaction.CombinedFragment

Bases: Execution

A combined fragment.

operands

The operands of this CombinedFragment.

operator

A POD containing arbitrary string data.

class capellambse.metamodel.interaction.Event

Bases: ModelElement

Abstract super class of all events in a Scenario.

class capellambse.metamodel.interaction.EventOperation

Bases: Event

Abstract super class for events about operations.

operation

The operation of this EventOperation.

class capellambse.metamodel.interaction.EventReceiptOperation

Bases: EventOperation

An event-receipt operation.

class capellambse.metamodel.interaction.EventSentOperation

Bases: EventOperation

An event-sent operation.

class capellambse.metamodel.interaction.Exchange

Bases: ModelElement

An abstract Exchange.

source

The source of this Exchange.

class capellambse.metamodel.interaction.Execution

Bases: ModelElement

An execution.

finish

The finish of this Execution.

start

The start of this Execution.

class capellambse.metamodel.interaction.ExecutionEnd

Bases: InteractionFragment

An end for an execution.

event

The event of this ExecutionEnd.

class capellambse.metamodel.interaction.ExecutionEvent

Bases: Event

An execution event.

class capellambse.metamodel.interaction.FragmentEnd

Bases: InteractionFragment

An end for a fragment.

class capellambse.metamodel.interaction.FunctionalChainAbstractCapabilityInvolvement

Bases: ModelElement

class capellambse.metamodel.interaction.InstanceRole

Bases: ModelElement

An instance role.

instance

The instance of this InstanceRole.

class capellambse.metamodel.interaction.InteractionFragment

Bases: ModelElement

Abstract super class of all interaction fragments in a Scenario.

covered

The covered of this InteractionFragment.

class capellambse.metamodel.interaction.InteractionOperand

Bases: InteractionFragment

An interaction-operand.

guard

The guard of this InteractionOperand.

class capellambse.metamodel.interaction.InteractionState

Bases: InteractionFragment

An interaction-state.

function

The function of this InteractionState.

state

The state of this InteractionState.

class capellambse.metamodel.interaction.MessageEnd

Bases: InteractionFragment

A message-end.

event

The event of this MessageEnd.

class capellambse.metamodel.interaction.Scenario

Bases: ModelElement

A scenario that holds instance roles.

events

The events of this Scenario.

fragments

The fragments of this Scenario.

instance_roles

The instance roles of this Scenario.

messages

The messages of this Scenario.

postcondition

The postcondition of this Scenario.

precondition

The precondition of this Scenario.

property related_functions: ElementList[AbstractFunction]

time_lapses

The time lapses of this Scenario.

class capellambse.metamodel.interaction.SequenceMessage

Bases: ModelElement

A sequence message.

source

The source of this SequenceMessage.

target

The target of this SequenceMessage.

class capellambse.metamodel.interaction.StateFragment

Bases: Execution

A state fragment.

function

The function of this StateFragment.

capellambse.metamodel.la module

Tools for the Logical Architecture layer.

class capellambse.metamodel.la.CapabilityRealization

Bases: ModelElement

A capability.

involved_chains

The involved chains of this CapabilityRealization.

involved_components

The involved components of this CapabilityRealization.

involved_functions

The involved functions of this CapabilityRealization.

owned_chains

The owned chains of this CapabilityRealization.

packages: m.Accessor

postcondition

The postcondition of this CapabilityRealization.

precondition

The precondition of this CapabilityRealization.

realized_capabilities

The realized capabilities of this CapabilityRealization.

scenarios

The scenarios of this CapabilityRealization.

states

The states of this CapabilityRealization.

class capellambse.metamodel.la.CapabilityRealizationPkg

Bases: ModelElement

A capability package that can hold capabilities.

capabilities

The capabilities of this CapabilityRealizationPkg.

packages: m.Accessor

class capellambse.metamodel.la.LogicalArchitecture

Bases: ComponentArchitecture

Provides access to the LogicalArchitecture layer of the model.

actor_exchanges

The actor exchanges of this LogicalArchitecture.

property all_actors

all_capabilities

The all capabilities of this LogicalArchitecture.

all_component_exchanges

The all component exchanges of this LogicalArchitecture.

all_components

The all components of this LogicalArchitecture.

all_function_exchanges

The all function exchanges of this LogicalArchitecture.

property all_functional_chains

all_functions

The all functions of this LogicalArchitecture.

capability_package

The capability package of this LogicalArchitecture.

component_exchanges

The component exchanges of this LogicalArchitecture.

component_package

The component package of this LogicalArchitecture.

diagrams: _descriptors.Accessor[capellambse.model.diagram.Diagram]

The diagrams of this LogicalArchitecture.

function_package

The function package of this LogicalArchitecture.

root_component

The root component of this LogicalArchitecture.

root_function

The root function of this LogicalArchitecture.

class capellambse.metamodel.la.LogicalComponent

Bases: Component

A logical component on the Logical Architecture layer.

allocated_functions

The allocated functions of this LogicalComponent.

components: m.Accessor

The components 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: ModelElement

A logical component package.

components

The components of this LogicalComponentPkg.

exchange_categories

The exchange categories of this LogicalComponentPkg.

exchanges

The exchanges of this LogicalComponentPkg.

packages: m.Accessor

The packages of this LogicalComponentPkg.

state_machines

The state machines of this LogicalComponentPkg.

class capellambse.metamodel.la.LogicalFunction

Bases: Function

A logical function on the Logical Architecture layer.

functions: m.Accessor

The functions of this LogicalFunction.

involved_in

The involved in of this LogicalFunction.

owner: m.Accessor[LogicalComponent]

The owner of this LogicalFunction.

packages: m.Accessor

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: ModelElement

A logical function package.

categories

The categories of this LogicalFunctionPkg.

functions

The functions of this LogicalFunctionPkg.

packages: m.Accessor

The packages of this LogicalFunctionPkg.

capellambse.metamodel.modellingcore module

Abstract classes acting as templates for concrete classes.

These base classes are used between different layers.

class capellambse.metamodel.modellingcore.TraceableElement

Bases: ModelElement

A template for traceable ModelObjects.

source

The source of this TraceableElement.

target

The target of this TraceableElement.

capellambse.metamodel.modeltypes module

Enumeration types used by the MelodyModel.

class capellambse.metamodel.modeltypes.AccessPolicy

Bases: _StringyEnumMixin, Enum

READ_AND_WRITE = 'readAndWrite'

READ_ONLY = 'readOnly'

class capellambse.metamodel.modeltypes.AggregationKind

Bases: _StringyEnumMixin, Enum

Defines the specific kind of a relationship, as per UML definitions.

AGGREGATION = 'AGGREGATION'

A semantic relationship between a part and a whole.

The part has a lifecycle of its own, and is potentially shared among several aggregators.

ASSOCIATION = 'ASSOCIATION'

A semantic relationship between typed instances.

It has at least two ends represented by properties, each of which is connected to the type of the end. More than one end of the association may have the same type.

Indicates that the property has no aggregation.

COMPOSITION = 'COMPOSITION'

A semantic relationship between whole and its parts.

The parts lifecycles are tied to that of the whole, and they are not shared with any other aggregator.

UNSET = 'UNSET'

Used when value is not defined by the user.

class capellambse.metamodel.modeltypes.BinaryOperator

Bases: _StringyEnumMixin, Enum

Specifies the kind of this binary operator.

ADD = 'ADD'

The binary operator refers to an addition.

AND = 'AND'

The binary operator refers to a logical AND operation.

DIV = 'DIV'

The binary operator refers to a division.

EQU = 'EQU'

The binary operator refers to an equal operation.

IOR = 'IOR'

The binary operator refers to a logical inclusive OR operation.

MAX = 'MAX'

The binary operator refers to a max operation.

MIN = 'MIN'

The binary operator refers to a min operation.

MUL = 'MUL'

The binary operator refers to a multiplication.

POW = 'POW'

The binary operator refers to a power operation.

SUB = 'SUB'

The binary operator refers to a substraction.

UNSET = 'UNSET'

The binary operator is not initialized.

XOR = 'XOR'

The binary operator refers to a logical exclusive OR operation.

class capellambse.metamodel.modeltypes.CatalogElementKind

Bases: _StringyEnumMixin, Enum

GROUPING = 'GROUPING'

REC = 'REC'

REC_RPL = 'REC_RPL'

RPL = 'RPL'

class capellambse.metamodel.modeltypes.ChangeEventKind

Bases: _StringyEnumMixin, Enum

WHEN = 'WHEN'

class capellambse.metamodel.modeltypes.CollectionKind

Bases: _StringyEnumMixin, Enum

Defines the specific kind of a Collection structure.

ARRAY = 'ARRAY'

The collection is to be considered an array of elements.

SEQUENCE = 'SEQUENCE'

The collection is to be considered as a sequence (list) of elements.

class capellambse.metamodel.modeltypes.CommunicationLinkKind

Bases: _StringyEnumMixin, Enum

Enumeration listing the various possibilities of communication links.

ACCESS = 'ACCESS'

The CommunicationLink describes an access to the ExchangeItem.

ACQUIRE = 'ACQUIRE'

The CommunicationLink describes an acquisition of ExchangeItem.

CALL = 'CALL'

The CommunicationLink describes a call of ExchangeItem.

CONSUME = 'CONSUME'

The CommunicationLink describes a comsumption of ExchangeItem.

EXECUTE = 'EXECUTE'

The CommunicationLink describes an execution of ExchangeItem.

PRODUCE = 'PRODUCE'

The CommunicationLink describes a production of ExchangeItem.

RECEIVE = 'RECEIVE'

The CommunicationLink describes a reception of ExchangeItem.

SEND = 'SEND'

The CommunicationLink describes a sending of ExchangeItem.

TRANSMIT = 'TRANSMIT'

The CommunicationLink describes a transmission of ExchangeItem.

UNSET = 'UNSET'

The CommunicationLink protocol is not yet set.

WRITE = 'WRITE'

The CommunicationLink describes a writing of ExchangeItem.

class capellambse.metamodel.modeltypes.CommunicationLinkProtocol

Bases: _StringyEnumMixin, Enum

The various possibilities for the protocol of the communication link.

ACCEPT = 'ACCEPT'

Describes access to the ExchangeItem by accepting it.

ASYNCHRONOUS = 'ASYNCHRONOUS'

Describes a call of the ExchangeItem using the asynchronous protocol.

BROADCAST = 'BROADCAST'

Describes sending an ExchangeItem using the broadcast protocol.

MULTICAST = 'MULTICAST'

Describes sending an ExchangeItem using the multicast protocol.

READ = 'READ'

Describes access to the ExchangeItem by reading it.

SYNCHRONOUS = 'SYNCHRONOUS'

Describes a call of the ExchangeItem using the synchronous protocol.

UNICAST = 'UNICAST'

Describes sending an ExchangeItem using the unicast protocol.

UNSET = 'UNSET'

The CommunicationLink protocol is not yet set.

class capellambse.metamodel.modeltypes.ComponentExchangeKind

Bases: _StringyEnumMixin, 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.modeltypes.ComponentPortKind

Bases: _StringyEnumMixin, 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.modeltypes.ConfigurationItemKind

Bases: _StringyEnumMixin, 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.modeltypes.ControlNodeKind

Bases: _StringyEnumMixin, Enum

AND = 'AND'

ITERATE = 'ITERATE'

OR = 'OR'

class capellambse.metamodel.modeltypes.ElementKind

Bases: _StringyEnumMixin, Enum

The visibility options for features of a class.

MEMBER = 'MEMBER'

The ExchangeItemElement is a member for its ExchangeItem.

TYPE = 'TYPE'

The ExchangeItemElement is a type for its ExchangeItem.

class capellambse.metamodel.modeltypes.ExchangeMechanism

Bases: _StringyEnumMixin, Enum

Enumeration of the different exchange mechanisms.

EVENT = 'EVENT'

Asynchronous information that is taken into account rapidly.

FLOW = 'FLOW'

Continuous supply of data.

OPERATION = 'OPERATION'

Sporadic supply of data with returned data.

SHARED_DATA = 'SHARED_DATA'

UNSET = 'UNSET'

The exchange mechanism is not defined.

class capellambse.metamodel.modeltypes.FunctionKind

Bases: _StringyEnumMixin, Enum

The kind of a Function.

DUPLICATE = 'DUPLICATE'

FUNCTION = 'FUNCTION'

GATHER = 'GATHER'

ROUTE = 'ROUTE'

SELECT = 'SELECT'

SPLIT = 'SPLIT'

class capellambse.metamodel.modeltypes.FunctionalChainKind

Bases: _StringyEnumMixin, Enum

The kind of a Functional Chain.

COMPOSITE = 'COMPOSITE'

FRAGMENT = 'FRAGMENT'

SIMPLE = 'SIMPLE'

class capellambse.metamodel.modeltypes.InteractionOperatorKind

Bases: _StringyEnumMixin, 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.modeltypes.MessageKind

Bases: _StringyEnumMixin, 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.modeltypes.NumericTypeKind

Bases: _StringyEnumMixin, Enum

The kind of this numeric data type.

FLOAT = 'FLOAT'

INTEGER = 'INTEGER'

class capellambse.metamodel.modeltypes.ObjectNodeKind

Bases: _StringyEnumMixin, 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.modeltypes.ObjectNodeOrderingKind

Bases: _StringyEnumMixin, 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.modeltypes.OrientationPortKind

Bases: _StringyEnumMixin, 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.modeltypes.ParameterDirection

Bases: _StringyEnumMixin, Enum

The direction in which data is passed along through a parameter.

EXCEPTION = 'EXCEPTION'

The parameter is like an exception.

IN = 'IN'

The parameter represents an input of the operation it is used in.

INOUT = 'INOUT'

The parameter represents both an input and output of the operation.

OUT = 'OUT'

The parameter represents an output of the operation it is used in.

RETURN = 'RETURN'

The parameter represents the return value of the operation.

UNSET = 'UNSET'

The CommunicationLink protocol is not yet set.

class capellambse.metamodel.modeltypes.ParameterEffectKind

Bases: _StringyEnumMixin, 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.modeltypes.PassingMode

Bases: _StringyEnumMixin, Enum

The data passing mechanism for parameters of an operation.

BY_REF = 'BY_REF'

The data is being passed by reference to the operation.

BY_VALUE = 'BY_VALUE'

The data is being passed by value to the operation.

UNSET = 'UNSET'

The data passing mechanism is not precised.

class capellambse.metamodel.modeltypes.PhysicalComponentKind

Bases: _StringyEnumMixin, Enum

Categories of physical components.

Allows to categorize a physical component, with respect to real life physical entities.

DATA = 'DATA'

The physical component represents a set of data.

FACILITIES = 'FACILITIES'

The physical component refers to Facilities.

FIRMWARE = 'FIRMWARE'

The physical component is a firmware part.

HARDWARE = 'HARDWARE'

The physical component is a hardware resource.

HARDWARE_COMPUTER = 'HARDWARE_COMPUTER'

The physical component is a computing resource.

MATERIALS = 'MATERIALS'

The physical component represents a bunch of materials.

PERSON = 'PERSON'

The physical component is a person.

PROCESSES = 'PROCESSES'

The physical component represents a set of processes.

SERVICES = 'SERVICES'

The physical component represents a set of services.

SOFTWARE = 'SOFTWARE'

The physical component is a software entity.

SOFTWARE_APPLICATION = 'SOFTWARE_APPLICATION'

The physical component is a software application.

SOFTWARE_DEPLOYMENT_UNIT = 'SOFTWARE_DEPLOYMENT_UNIT'

The physical component is a software deployment unit.

SOFTWARE_EXECUTION_UNIT = 'SOFTWARE_EXECUTION_UNIT'

The physical component is a software execution unit.

UNSET = 'UNSET'

The physical component kind is not specified.

class capellambse.metamodel.modeltypes.PhysicalComponentNature

Bases: _StringyEnumMixin, Enum

The nature of a physical component.

BEHAVIOR = 'BEHAVIOR'

The physical component nature is behavioral.

This typically means a piece of software.

NODE = 'NODE'

The physical component is a host for behavioral components.

This typically means a computing resource.

UNSET = 'UNSET'

The physical component nature is not specified.

class capellambse.metamodel.modeltypes.RateKind

Bases: _StringyEnumMixin, 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.modeltypes.ScenarioKind

Bases: _StringyEnumMixin, Enum

DATA_FLOW = 'DATA_FLOW'

FUNCTIONAL = 'FUNCTIONAL'

INTERACTION = 'INTERACTION'

INTERFACE = 'INTERFACE'

UNSET = 'UNSET'

class capellambse.metamodel.modeltypes.SynchronismKind

Bases: _StringyEnumMixin, Enum

The synchronicity of an operation invocation.

ASYNCHRONOUS = 'ASYNCHRONOUS'

SYNCHRONOUS = 'SYNCHRONOUS'

UNSET = 'UNSET'

class capellambse.metamodel.modeltypes.TimeEventKind

Bases: _StringyEnumMixin, 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.modeltypes.TransitionKind

Bases: _StringyEnumMixin, Enum

EXTERNAL = 'external'

INTERNAL = 'internal'

LOCAL = 'local'

class capellambse.metamodel.modeltypes.UnaryOperator

Bases: _StringyEnumMixin, Enum

The operator of a unary expression.

NOT = 'NOT'

The unary operator refers to a NOT operation.

POS = 'POS'

The unary operator refers to a position operation.

PRE = 'PRE'

The unary operator refers to a predecessor operation.

SUC = 'SUC'

The unary operator refers to a successor operation.

UNSET = 'UNSET'

The unary operator is not initialized.

VAL = 'VAL'

The unary operator refers to a value operation.

class capellambse.metamodel.modeltypes.UnionKind

Bases: _StringyEnumMixin, Enum

UNION = 'UNION'

VARIANT = 'VARIANT'

class capellambse.metamodel.modeltypes.VisibilityKind

Bases: _StringyEnumMixin, 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.

class capellambse.metamodel.modeltypes._StringyEnumMixin

Bases: object

Mixin for enums that makes members compare equal to their key name.

name: Any

capellambse.metamodel.oa module

Tools for the Operational Analysis layer.

class capellambse.metamodel.oa.AbstractEntity

Bases: Component

Common code for Entities.

activities

The activities of this AbstractEntity.

capabilities

The capabilities of this AbstractEntity.

class capellambse.metamodel.oa.CommunicationMean

Bases: AbstractExchange

An operational entity exchange.

allocated_exchange_items

The allocated exchange items of this CommunicationMean.

allocated_interactions

The allocated interactions of this CommunicationMean.

property exchange_items: ElementList[ExchangeItem]

class capellambse.metamodel.oa.Entity

Bases: AbstractEntity

An Entity in the OperationalAnalysis layer.

entities: m.Accessor

The entities of this Entity.

exchanges

The exchanges of this Entity.

property inputs: ElementList[CommunicationMean]

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: AbstractInvolvement

An EntityOperationalCapabilityInvolvement.

class capellambse.metamodel.oa.EntityPkg

Bases: ModelElement

A package that holds operational entities.

entities

The entities of this EntityPkg.

exchanges

The exchanges of this EntityPkg.

packages: m.Accessor

The packages of this EntityPkg.

state_machines

The state machines of this EntityPkg.

class capellambse.metamodel.oa.OperationalActivity

Bases: AbstractFunction

An operational activity.

activities

The activities of this OperationalActivity.

exchanges

The exchanges of this OperationalActivity.

inputs

The inputs of this OperationalActivity.

outputs

The outputs of this OperationalActivity.

owner: m.Accessor[Entity]

The owner of this OperationalActivity.

packages

The packages of this OperationalActivity.

realizing_system_functions

The realizing system functions of this OperationalActivity.

property related_exchanges: ElementList[FunctionalExchange]

class capellambse.metamodel.oa.OperationalActivityPkg

Bases: ModelElement

A package that holds operational entities.

activities

The activities of this OperationalActivityPkg.

packages: m.Accessor

The packages of this OperationalActivityPkg.

class capellambse.metamodel.oa.OperationalAnalysis

Bases: ComponentArchitecture

Provides access to the OperationalAnalysis layer of the model.

activity_package

The activity package of this OperationalAnalysis.

all_activities

The all activities of this OperationalAnalysis.

all_activity_exchanges

The all activity exchanges of this OperationalAnalysis.

property all_actors

all_capabilities

The all capabilities of this OperationalAnalysis.

all_entities

The all entities of this OperationalAnalysis.

all_entity_exchanges

The all entity exchanges of this OperationalAnalysis.

property all_operational_processes

all_processes

The all processes of this OperationalAnalysis.

capability_package

The capability package of this OperationalAnalysis.

diagrams: _descriptors.Accessor[capellambse.model.diagram.Diagram]

The diagrams of this OperationalAnalysis.

entity_package

The entity package of this OperationalAnalysis.

root_activity

The root activity of this OperationalAnalysis.

root_entity

The root entity of this OperationalAnalysis.

class capellambse.metamodel.oa.OperationalCapability

Bases: ModelElement

A capability in the OperationalAnalysis layer.

entity_involvements

The entity involvements of this OperationalCapability.

extended_by

The extended by of this OperationalCapability.

extends

The extends of this OperationalCapability.

generalized_by

The generalized by of this OperationalCapability.

generalizes

The generalizes of this OperationalCapability.

included_by

The included by of this OperationalCapability.

includes

The includes 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.

packages: m.Accessor

postcondition

The postcondition of this OperationalCapability.

precondition

The precondition of this OperationalCapability.

realizing_capabilities

The realizing capabilities of this OperationalCapability.

scenarios

The scenarios of this OperationalCapability.

states

The states of this OperationalCapability.

class capellambse.metamodel.oa.OperationalCapabilityPkg

Bases: ModelElement

A package that holds operational capabilities.

capabilities

The capabilities of this OperationalCapabilityPkg.

packages: m.Accessor

The packages of this OperationalCapabilityPkg.

class capellambse.metamodel.oa.OperationalProcess

Bases: FunctionalChain

An operational process.

capellambse.metamodel.pa module

Tools for the Physical Architecture layer.

class capellambse.metamodel.pa.PhysicalArchitecture

Bases: ComponentArchitecture

Provides access to the Physical Architecture layer of the model.

property all_actors

all_capabilities

The all capabilities of this PhysicalArchitecture.

all_component_exchanges

The all component exchanges of this PhysicalArchitecture.

all_components

The all components of this PhysicalArchitecture.

all_function_exchanges

The all function exchanges of this PhysicalArchitecture.

property all_functional_chains

all_functions

The all functions of this PhysicalArchitecture.

all_physical_exchanges

The all physical exchanges of this PhysicalArchitecture.

all_physical_links

The all physical links of this PhysicalArchitecture.

all_physical_paths

The all physical paths of this PhysicalArchitecture.

capability_package

The capability package of this PhysicalArchitecture.

component_package

The component package of this PhysicalArchitecture.

diagrams: _descriptors.Accessor[capellambse.model.diagram.Diagram]

The diagrams of this PhysicalArchitecture.

function_package

The function package of this PhysicalArchitecture.

root_component

The root component of this PhysicalArchitecture.

root_function

The root function of this PhysicalArchitecture.

class capellambse.metamodel.pa.PhysicalComponent

Bases: Component

A physical component on the Physical Architecture layer.

allocated_functions

The allocated functions of this PhysicalComponent.

property components: ElementList[PhysicalComponent]

property deployed_components: ElementList[PhysicalComponent]

deploying_components: m.Accessor

The deploying components of this PhysicalComponent.

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.

nature

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.

owned_components: m.Accessor

The owned components of this PhysicalComponent.

realized_logical_components

The realized logical components of this PhysicalComponent.

class capellambse.metamodel.pa.PhysicalComponentPkg

Bases: ModelElement

A logical component package.

components

The components of this PhysicalComponentPkg.

exchange_categories

The exchange categories of this PhysicalComponentPkg.

exchanges

The exchanges of this PhysicalComponentPkg.

packages: m.Accessor

The packages of this PhysicalComponentPkg.

state_machines

The state machines of this PhysicalComponentPkg.

class capellambse.metamodel.pa.PhysicalFunction

Bases: Function

A physical function on the Physical Architecture layer.

functions: m.Accessor

The functions of this PhysicalFunction.

owner: m.Accessor[PhysicalComponent]

The owner of this PhysicalFunction.

packages: m.Accessor

The packages of this PhysicalFunction.

realized_logical_functions

The realized logical functions of this PhysicalFunction.

class capellambse.metamodel.pa.PhysicalFunctionPkg

Bases: ModelElement

A logical component package.

categories

The categories of this PhysicalFunctionPkg.

functions

The functions of this PhysicalFunctionPkg.

packages: m.Accessor

The packages of this PhysicalFunctionPkg.

capellambse.metamodel.sa module

Tools for the System Analysis layer.

This is normally the place to declare data used in the model for e.g. functions, actors etc. which is best presented in a glossary document.

class capellambse.metamodel.sa.Capability

Bases: ModelElement

A capability.

component_involvements

The component involvements of this Capability.

extended_by

The extended by of this Capability.

extends

The extends of this Capability.

generalized_by

The generalized by of this Capability.

generalizes

The generalizes of this Capability.

included_by

The included by of this Capability.

includes

The includes of this Capability.

incoming_exploitations

The incoming exploitations of this Capability.

involved_chains

The involved chains of this Capability.

involved_components

The involved components of this Capability.

involved_functions

The involved functions of this Capability.

owned_chains

The owned chains of this Capability.

packages: Accessor

postcondition

The postcondition of this Capability.

precondition

The precondition of this Capability.

realized_capabilities

The realized capabilities of this Capability.

realizing_capabilities

The realizing capabilities of this Capability.

scenarios

The scenarios of this Capability.

states

The states of this Capability.

class capellambse.metamodel.sa.CapabilityExploitation

Bases: ModelElement

A CapabilityExploitation.

capability

The capability of this CapabilityExploitation.

property name: str

Return the name.

class capellambse.metamodel.sa.CapabilityInvolvement

Bases: AbstractInvolvement

A CapabilityInvolvement.

class capellambse.metamodel.sa.CapabilityPkg

Bases: ModelElement

A capability package that can hold capabilities.

capabilities

The capabilities of this CapabilityPkg.

packages: Accessor

class capellambse.metamodel.sa.Mission

Bases: ModelElement

A mission.

exploitations

The exploitations of this Mission.

exploits

The exploits of this Mission.

incoming_involvements

The incoming involvements of this Mission.

involvements

The involvements of this Mission.

class capellambse.metamodel.sa.MissionInvolvement

Bases: AbstractInvolvement

A MissionInvolvement.

class capellambse.metamodel.sa.MissionPkg

Bases: ModelElement

A system mission package that can hold missions.

missions

The missions of this MissionPkg.

packages: Accessor

The packages of this MissionPkg.

class capellambse.metamodel.sa.SystemAnalysis

Bases: ComponentArchitecture

Provides access to the SystemAnalysis layer of the model.

actor_exchanges

The actor exchanges of this SystemAnalysis.

property all_actors

all_capabilities

The all capabilities of this SystemAnalysis.

all_capability_exploitations

The all capability exploitations of this SystemAnalysis.

all_component_exchanges

The all component exchanges of this SystemAnalysis.

all_components

The all components of this SystemAnalysis.

all_function_exchanges

The all function exchanges of this SystemAnalysis.

property all_functional_chains

all_functions

The all functions of this SystemAnalysis.

all_missions

The all missions of this SystemAnalysis.

capability_package

The capability package of this SystemAnalysis.

component_exchanges

The component exchanges of this SystemAnalysis.

component_package

The component package of this SystemAnalysis.

diagrams: _descriptors.Accessor[capellambse.model.diagram.Diagram]

The diagrams of this SystemAnalysis.

function_package

The function package of this SystemAnalysis.

mission_package

The mission package of this SystemAnalysis.

root_component

The root component of this SystemAnalysis.

root_function

The root function of this SystemAnalysis.

class capellambse.metamodel.sa.SystemComponent

Bases: Component

A system component.

allocated_functions

The allocated functions of this SystemComponent.

components

The components of this SystemComponent.

realized_entities

The realized entities of this SystemComponent.

realized_operational_entities

The realized operational entities of this SystemComponent.

realizing_logical_components

The realizing logical components of this SystemComponent.

class capellambse.metamodel.sa.SystemComponentPkg

Bases: ModelElement

A system component package.

components

The components of this SystemComponentPkg.

exchange_categories

The exchange categories of this SystemComponentPkg.

packages: Accessor

The packages of this SystemComponentPkg.

state_machines

The state machines of this SystemComponentPkg.

class capellambse.metamodel.sa.SystemFunction

Bases: Function

A system function.

functions: m.Accessor

The functions of this SystemFunction.

involved_in

The involved in of this SystemFunction.

owner: Accessor

The owner of this SystemFunction.

packages: m.Accessor

The packages of this SystemFunction.

realized_operational_activities

The realized operational activities of this SystemFunction.

realizing_logical_functions

The realizing logical functions of this SystemFunction.

class capellambse.metamodel.sa.SystemFunctionPkg

Bases: ModelElement

A function package that can hold functions.

categories

The categories of this SystemFunctionPkg.

functions

The functions of this SystemFunctionPkg.

packages: Accessor

The packages of this SystemFunctionPkg.