capellambse package¶
The capellambse package.
- capellambse.load_model_extensions()
Load all model extensions.
This function loads all entry points in the group
capellambse.model_extensions
and executes them.It is automatically called when loading a model. Calling it more than once has no effect, so it is safe (although not necessary) to explicitly call this function before loading a model.
- Return type:
Subpackages¶
- capellambse.aird package
- capellambse.diagram package
- capellambse.extensions package
- Subpackages
- capellambse.extensions.metrics package
- capellambse.extensions.pvmt package
- capellambse.extensions.reqif package
AbstractRequirementsAttribute
AbstractRequirementsRelation
AbstractType
AttributeAccessor
AttributeDefinition
AttributeDefinitionEnumeration
BooleanValueAttribute
CapellaIncomingRelation
CapellaModule
CapellaOutgoingRelation
CapellaTypesFolder
DataTypeDefinition
DateValueAttribute
ElementRelationAccessor
EnumValue
EnumerationDataTypeDefinition
EnumerationValueAttribute
Folder
IntegerValueAttribute
InternalRelation
ModuleType
RealValueAttribute
RelationType
RelationsList
ReqIFElement
Requirement
RequirementType
RequirementsRelationAccessor
StringValueAttribute
- Submodules
- capellambse.extensions.reqif.exporter module
- capellambse.extensions.validation package
- Submodules
- capellambse.extensions.filtering module
- Subpackages
- capellambse.filehandler package
FileHandler
TransactionClosedError
get_filehandler()
- Submodules
- capellambse.filehandler.abc module
- capellambse.filehandler.git module
GitFileHandler
GitFileHandler.__init__()
GitFileHandler.cache_dir
GitFileHandler.get_model_info()
GitFileHandler.identity_file
GitFileHandler.iterdir()
GitFileHandler.known_hosts_file
GitFileHandler.open()
GitFileHandler.password
GitFileHandler.rootdir
GitFileHandler.shallow
GitFileHandler.username
GitFileHandler.write_transaction()
GitHandlerInfo
GitPath
- capellambse.filehandler.git_askpass module
- capellambse.filehandler.gitlab_artifacts module
- capellambse.filehandler.http module
- capellambse.filehandler.local module
- capellambse.filehandler.memory module
- capellambse.filehandler.zip module
- capellambse.loader package
- Submodules
- capellambse.loader.core module
CorruptModelError
FragmentType
MelodyLoader
MelodyLoader.__init__()
MelodyLoader.activate_viewpoint()
MelodyLoader.check_duplicate_uuids()
MelodyLoader.create_link()
MelodyLoader.filehandler
MelodyLoader.find_fragment()
MelodyLoader.follow_link()
MelodyLoader.follow_links()
MelodyLoader.generate_uuid()
MelodyLoader.get_model_info()
MelodyLoader.idcache_index()
MelodyLoader.idcache_rebuild()
MelodyLoader.idcache_remove()
MelodyLoader.iterall()
MelodyLoader.iterall_xt()
MelodyLoader.iterancestors()
MelodyLoader.iterchildren_xt()
MelodyLoader.iterdescendants()
MelodyLoader.iterdescendants_xt()
MelodyLoader.new_uuid()
MelodyLoader.referenced_viewpoints()
MelodyLoader.save()
MelodyLoader.update_namespaces()
MelodyLoader.write_tmp_project_dir()
MelodyLoader.xpath()
MelodyLoader.xpath2()
ModelFile
- capellambse.loader.exs module
- capellambse.loader.modelinfo module
- capellambse.metamodel package
- Subpackages
- Submodules
- capellambse.metamodel.capellacommon module
- capellambse.metamodel.capellacore module
- capellambse.metamodel.capellamodeller module
- capellambse.metamodel.cs module
Component
Component.exchanges
Component.is_abstract
Component.is_actor
Component.is_human
Component.owner
Component.parts
Component.physical_links
Component.physical_paths
Component.physical_ports
Component.ports
Component.realized_components
Component.realizing_components
Component.related_exchanges
Component.state_machines
ComponentArchitecture
ComponentArchitecture.all_classes
ComponentArchitecture.all_collections
ComponentArchitecture.all_complex_values
ComponentArchitecture.all_enumerations
ComponentArchitecture.all_interfaces
ComponentArchitecture.all_module_types
ComponentArchitecture.all_relation_types
ComponentArchitecture.all_requirement_types
ComponentArchitecture.all_requirements
ComponentArchitecture.all_unions
ComponentArchitecture.component_exchange_categories
ComponentArchitecture.data_package
ComponentArchitecture.interface_package
ComponentArchitecture.requirement_modules
ComponentArchitecture.requirement_types_folders
ComponentArchitecture.validation
ComponentRealization
ExchangeItemAllocation
Interface
InterfacePkg
Part
PhysicalLink
PhysicalPath
PhysicalPort
- capellambse.metamodel.fa module
AbstractExchange
AbstractFunction
ComponentExchange
ComponentExchange.allocated_exchange_items
ComponentExchange.allocated_functional_exchanges
ComponentExchange.allocating_physical_link
ComponentExchange.allocating_physical_paths
ComponentExchange.categories
ComponentExchange.exchange_items
ComponentExchange.kind
ComponentExchange.owner
ComponentExchange.realized_component_exchanges
ComponentExchange.realizing_component_exchanges
ComponentExchangeAllocation
ComponentExchangeCategory
ComponentExchangeFunctionalExchangeAllocation
ComponentFunctionalAllocation
ComponentPort
ControlNode
ExchangeCategory
Function
FunctionInputPort
FunctionOutputPort
FunctionPort
FunctionRealization
FunctionalChain
FunctionalChain.control_nodes
FunctionalChain.involved
FunctionalChain.involved_chains
FunctionalChain.involved_functions
FunctionalChain.involved_links
FunctionalChain.involvements
FunctionalChain.involving_chains
FunctionalChain.kind
FunctionalChain.postcondition
FunctionalChain.precondition
FunctionalChain.realized_chains
FunctionalChain.realizing_chains
FunctionalChainInvolvement
FunctionalChainInvolvementFunction
FunctionalChainInvolvementLink
FunctionalChainReference
FunctionalExchange
- capellambse.metamodel.interaction module
AbstractCapabilityExtend
AbstractCapabilityGeneralization
AbstractCapabilityInclude
AbstractCapabilityRealization
AbstractFunctionAbstractCapabilityInvolvement
AbstractInvolvement
CombinedFragment
Event
EventOperation
EventReceiptOperation
EventSentOperation
Exchange
Execution
ExecutionEnd
ExecutionEvent
FragmentEnd
FunctionalChainAbstractCapabilityInvolvement
InstanceRole
InteractionFragment
InteractionOperand
InteractionState
MessageEnd
Scenario
SequenceMessage
StateFragment
- capellambse.metamodel.la module
CapabilityRealization
CapabilityRealization.involved_chains
CapabilityRealization.involved_components
CapabilityRealization.involved_functions
CapabilityRealization.owned_chains
CapabilityRealization.packages
CapabilityRealization.postcondition
CapabilityRealization.precondition
CapabilityRealization.realized_capabilities
CapabilityRealization.scenarios
CapabilityRealization.states
CapabilityRealizationPkg
LogicalArchitecture
LogicalArchitecture.actor_exchanges
LogicalArchitecture.all_actors
LogicalArchitecture.all_capabilities
LogicalArchitecture.all_component_exchanges
LogicalArchitecture.all_components
LogicalArchitecture.all_function_exchanges
LogicalArchitecture.all_functional_chains
LogicalArchitecture.all_functions
LogicalArchitecture.capability_package
LogicalArchitecture.component_exchanges
LogicalArchitecture.component_package
LogicalArchitecture.diagrams
LogicalArchitecture.function_package
LogicalArchitecture.root_component
LogicalArchitecture.root_function
LogicalComponent
LogicalComponentPkg
LogicalFunction
LogicalFunctionPkg
- capellambse.metamodel.modellingcore module
- capellambse.metamodel.modeltypes module
AccessPolicy
AggregationKind
BinaryOperator
CatalogElementKind
ChangeEventKind
CollectionKind
CommunicationLinkKind
CommunicationLinkKind.ACCESS
CommunicationLinkKind.ACQUIRE
CommunicationLinkKind.CALL
CommunicationLinkKind.CONSUME
CommunicationLinkKind.EXECUTE
CommunicationLinkKind.PRODUCE
CommunicationLinkKind.RECEIVE
CommunicationLinkKind.SEND
CommunicationLinkKind.TRANSMIT
CommunicationLinkKind.UNSET
CommunicationLinkKind.WRITE
CommunicationLinkProtocol
ComponentExchangeKind
ComponentPortKind
ConfigurationItemKind
ControlNodeKind
ElementKind
ExchangeMechanism
FunctionKind
FunctionalChainKind
InteractionOperatorKind
InteractionOperatorKind.ALT
InteractionOperatorKind.ASSERT
InteractionOperatorKind.CONSIDER
InteractionOperatorKind.CRITICAL
InteractionOperatorKind.IGNORE
InteractionOperatorKind.LOOP
InteractionOperatorKind.NEG
InteractionOperatorKind.OPT
InteractionOperatorKind.PAR
InteractionOperatorKind.SEQ
InteractionOperatorKind.STRICT
InteractionOperatorKind.UNSET
MessageKind
NumericTypeKind
ObjectNodeKind
ObjectNodeOrderingKind
OrientationPortKind
ParameterDirection
ParameterEffectKind
PassingMode
PhysicalComponentKind
PhysicalComponentKind.DATA
PhysicalComponentKind.FACILITIES
PhysicalComponentKind.FIRMWARE
PhysicalComponentKind.HARDWARE
PhysicalComponentKind.HARDWARE_COMPUTER
PhysicalComponentKind.MATERIALS
PhysicalComponentKind.PERSON
PhysicalComponentKind.PROCESSES
PhysicalComponentKind.SERVICES
PhysicalComponentKind.SOFTWARE
PhysicalComponentKind.SOFTWARE_APPLICATION
PhysicalComponentKind.SOFTWARE_DEPLOYMENT_UNIT
PhysicalComponentKind.SOFTWARE_EXECUTION_UNIT
PhysicalComponentKind.UNSET
PhysicalComponentNature
RateKind
ScenarioKind
SynchronismKind
TimeEventKind
TransitionKind
UnaryOperator
UnionKind
VisibilityKind
_StringyEnumMixin
- capellambse.metamodel.oa module
AbstractEntity
CommunicationMean
Entity
EntityOperationalCapabilityInvolvement
EntityPkg
OperationalActivity
OperationalActivityPkg
OperationalAnalysis
OperationalAnalysis.activity_package
OperationalAnalysis.all_activities
OperationalAnalysis.all_activity_exchanges
OperationalAnalysis.all_actors
OperationalAnalysis.all_capabilities
OperationalAnalysis.all_entities
OperationalAnalysis.all_entity_exchanges
OperationalAnalysis.all_operational_processes
OperationalAnalysis.all_processes
OperationalAnalysis.capability_package
OperationalAnalysis.diagrams
OperationalAnalysis.entity_package
OperationalAnalysis.root_activity
OperationalAnalysis.root_entity
OperationalCapability
OperationalCapability.entity_involvements
OperationalCapability.extended_by
OperationalCapability.extends
OperationalCapability.generalized_by
OperationalCapability.generalizes
OperationalCapability.included_by
OperationalCapability.includes
OperationalCapability.involved_activities
OperationalCapability.involved_entities
OperationalCapability.involved_processes
OperationalCapability.owned_processes
OperationalCapability.packages
OperationalCapability.postcondition
OperationalCapability.precondition
OperationalCapability.realizing_capabilities
OperationalCapability.scenarios
OperationalCapability.states
OperationalCapabilityPkg
OperationalProcess
- capellambse.metamodel.pa module
PhysicalArchitecture
PhysicalArchitecture.all_actors
PhysicalArchitecture.all_capabilities
PhysicalArchitecture.all_component_exchanges
PhysicalArchitecture.all_components
PhysicalArchitecture.all_function_exchanges
PhysicalArchitecture.all_functional_chains
PhysicalArchitecture.all_functions
PhysicalArchitecture.all_physical_exchanges
PhysicalArchitecture.all_physical_links
PhysicalArchitecture.all_physical_paths
PhysicalArchitecture.capability_package
PhysicalArchitecture.component_package
PhysicalArchitecture.diagrams
PhysicalArchitecture.function_package
PhysicalArchitecture.root_component
PhysicalArchitecture.root_function
PhysicalComponent
PhysicalComponentPkg
PhysicalFunction
PhysicalFunctionPkg
- capellambse.metamodel.sa module
Capability
Capability.component_involvements
Capability.extended_by
Capability.extends
Capability.generalized_by
Capability.generalizes
Capability.included_by
Capability.includes
Capability.incoming_exploitations
Capability.involved_chains
Capability.involved_components
Capability.involved_functions
Capability.owned_chains
Capability.packages
Capability.postcondition
Capability.precondition
Capability.realized_capabilities
Capability.realizing_capabilities
Capability.scenarios
Capability.states
CapabilityExploitation
CapabilityInvolvement
CapabilityPkg
Mission
MissionInvolvement
MissionPkg
SystemAnalysis
SystemAnalysis.actor_exchanges
SystemAnalysis.all_actors
SystemAnalysis.all_capabilities
SystemAnalysis.all_capability_exploitations
SystemAnalysis.all_component_exchanges
SystemAnalysis.all_components
SystemAnalysis.all_function_exchanges
SystemAnalysis.all_functional_chains
SystemAnalysis.all_functions
SystemAnalysis.all_missions
SystemAnalysis.capability_package
SystemAnalysis.component_exchanges
SystemAnalysis.component_package
SystemAnalysis.diagrams
SystemAnalysis.function_package
SystemAnalysis.mission_package
SystemAnalysis.root_component
SystemAnalysis.root_function
SystemComponent
SystemComponentPkg
SystemFunction
SystemFunctionPkg
- capellambse.model package
Accessor
Alias
Allocation
AlternateAccessor
Association
AttributeMatcherAccessor
Backref
BasePOD
BoolPOD
CachedElementList
Containment
DatetimePOD
DeepProxyAccessor
DeprecatedAccessor
DirectProxyAccessor
E
ElementList
ElementListCouplingMixin
ElementListMapItemsView
ElementListMapKeyView
EnumPOD
FloatPOD
HTMLStringPOD
IndexAccessor
IntPOD
InvalidModificationError
MelodyModel
MelodyModel.__init__()
MelodyModel.activate_viewpoint()
MelodyModel.by_uuid()
MelodyModel.description_badge
MelodyModel.diagram_cache
MelodyModel.diagrams
MelodyModel.enumeration_property_types()
MelodyModel.filtering_model
MelodyModel.find_references()
MelodyModel.info
MelodyModel.la
MelodyModel.name
MelodyModel.oa
MelodyModel.pa
MelodyModel.project
MelodyModel.property_value_packages()
MelodyModel.pvmt
MelodyModel.referenced_viewpoints()
MelodyModel.resources
MelodyModel.sa
MelodyModel.save()
MelodyModel.search()
MelodyModel.update_diagram_cache()
MelodyModel.uuid
MelodyModel.validate
MelodyModel.validation
MixedElementList
ModelElement
ModelElement.__init__()
ModelElement._get_icon()
ModelElement._get_styleclass()
ModelElement.applied_property_value_groups
ModelElement.applied_property_values
ModelElement.constraints
ModelElement.description
ModelElement.diagrams
ModelElement.filtering_criteria
ModelElement.from_model()
ModelElement.layer
ModelElement.name
ModelElement.parent
ModelElement.progress_status
ModelElement.property_value_groups
ModelElement.property_value_packages
ModelElement.property_values
ModelElement.pvmt
ModelElement.requirements
ModelElement.sid
ModelElement.summary
ModelElement.traces
ModelElement.uuid
ModelElement.validate
ModelElement.validation
ModelElement.visible_on_diagrams
ModelElement.xtype
ModelInfo
ModelObject
NewObject
NonUniqueMemberError
ParentAccessor
PhysicalAccessor
PhysicalLinkEndsAccessor
S
SpecificationAccessor
StringPOD
T
T_co
TypecastAccessor
U
WritableAccessor
attr_equal()
build_xtype()
find_wrapper()
set_self_references()
stringy_enum()
xtype_handler()
- Submodules
- capellambse.model.diagram module
AbstractDiagram
ConfluenceSVGFormat
Diagram
Diagram.__init__()
Diagram._allow_render
Diagram._create_diagram()
Diagram.description
Diagram.filters
Diagram.from_model()
Diagram.invalidate_cache()
Diagram.name
Diagram.nodes
Diagram.representation_path
Diagram.semantic_nodes
Diagram.target
Diagram.type
Diagram.uuid
Diagram.viewpoint
Diagram.xtype
DiagramAccessor
DiagramFormat
DiagramType
DiagramType.CC
DiagramType.CDB
DiagramType.CDI
DiagramType.CEI
DiagramType.CIBD
DiagramType.CII
DiagramType.CM
DiagramType.COC
DiagramType.CRB
DiagramType.CRI
DiagramType.CRR
DiagramType.CSA
DiagramType.EAB
DiagramType.ES
DiagramType.FS
DiagramType.ID
DiagramType.IDB
DiagramType.IS
DiagramType.LAB
DiagramType.LCBD
DiagramType.LDFB
DiagramType.LFBD
DiagramType.LFCD
DiagramType.MB
DiagramType.MCB
DiagramType.MSM
DiagramType.OAB
DiagramType.OABD
DiagramType.OAIB
DiagramType.OAS
DiagramType.OCB
DiagramType.OEBD
DiagramType.OES
DiagramType.OPD
DiagramType.ORB
DiagramType.PAB
DiagramType.PCBD
DiagramType.PD
DiagramType.PDFB
DiagramType.PFBD
DiagramType.PFCD
DiagramType.PPD
DiagramType.SAB
DiagramType.SDFB
DiagramType.SFBD
DiagramType.SFCD
DiagramType.UNKNOWN
PNGFormat
PrettyDiagramFormat
REPR_DRAW
SVGDataURIFormat
SVGFormat
SVGInHTMLIMGFormat
TerminalGraphicsFormat
UnknownOutputFormat
convert_format()
convert_svgdiagram()
- capellambse.svg package
- Submodules
- capellambse.svg.decorations module
- capellambse.svg.drawing module
- capellambse.svg.generate module
- capellambse.svg.helpers module
- capellambse.svg.style module
- capellambse.svg.symbols module
Submodules¶
capellambse.cli_helpers module¶
Helpers for working with models in CLI scripts.
- capellambse.cli_helpers.ModelCLI(*__, **_)¶
Raise a dependency error.
- capellambse.cli_helpers.ModelInfoCLI(*__, **_)¶
Raise a dependency error.
- capellambse.cli_helpers.enumerate_known_models()¶
Enumerate the models that are found in the
known_models
folders.Two places are searched for models: The known_models folder in the user’s configuration directory, and the known_models folder in the installed
capellambse
package.Run the following command to print the location of the user’s known_models folder:
python -m capellambse.cli_helpers
In order to make a custom model known, place a JSON file in one of these known_models folders. It should contain a dictionary with the keyword arguments to
MelodyModel
- specifically it needs apath
, optionally anentrypoint
, and any additional arguments that the underlyingFileHandler
might need to gain access to the model.Files in the user’s configuration directory take precedence over files in the package directory. If a file with the same name exists in both places, the one in the user’s configuration directory will be used.
Be aware that relative paths in the JSON will be interpreted relative to the current working directory.
- Return type:
- capellambse.cli_helpers.loadcli(value)¶
Load a model from a file or JSON string.
This function works like
loadinfo()
, and also loads the model for convenience.- Parameters:
value (
str
|PathLike
[str
]) – As described forloadinfo()
.- Returns:
The loaded model, as described by the value.
- Return type:
Examples
def main(): model = capellambse.loadcli(sys.argv[1])
- capellambse.cli_helpers.loadinfo(value)¶
Load information about how to load a model as dict.
- Parameters:
One of the following:
A str or PathLike pointing to an
.aird
fileA str or PathLike pointing to a
.json
file, which contains the arguments to instantiate aMelodyModel
The contents of such a JSON file (as string)
- Returns:
A dict with information about how to load a
MelodyModel
.- Return type:
- Raises:
TypeError – If the value cannot be parsed as described above.
ValueError – If the value looks like a “known model” name, but the name is not defined.
Examples
def main(): modelinfo = capellambse.loadinfo(sys.argv[1]) # change any options, for example: modelinfo["diagram_cache"] = "/tmp/diagrams" model = MelodyModel(**modelinfo)
capellambse.decl module¶
Support for YAML-based declarative modelling.
A YAML-based approach to describing how to create and modify
capellambse
compatible models.
For an in-depth explanation, please refer to the full documentation about declarative modelling.
- class capellambse.decl.Metadata¶
Bases:
TypedDict
-
model:
ModelMetadata
¶
-
written_by:
WriterMetadata
¶
-
model:
- class capellambse.decl.UUIDReference¶
Bases:
object
References a model object by its UUID.
- __init__(uuid)¶
- Parameters:
uuid (UUIDString)
- Return type:
None
- exception capellambse.decl.UnfulfilledPromisesError¶
Bases:
RuntimeError
A promise could not be fulfilled.
This exception is raised when a promise is referenced via
!promise
, but it is never fulfilled by declaring an object with the samepromise_id
.
- class capellambse.decl.YDMDumper¶
Bases:
SafeDumper
A YAML dumper with extensions for declarative modelling.
- yaml_representers = {<class 'NoneType'>: <function SafeRepresenter.represent_none>, <class 'bool'>: <function SafeRepresenter.represent_bool>, <class 'bytes'>: <function SafeRepresenter.represent_binary>, <class 'capellambse.decl.FindBy'>: <function YDMDumper.represent_findby>, <class 'capellambse.decl.Promise'>: <function YDMDumper.represent_promise>, <class 'capellambse.decl.UUIDReference'>: <function YDMDumper.represent_uuidref>, <class 'capellambse.model._descriptors.NewObject'>: <function YDMDumper.represent_newobj>, <class 'datetime.date'>: <function SafeRepresenter.represent_date>, <class 'datetime.datetime'>: <function SafeRepresenter.represent_datetime>, <class 'dict'>: <function SafeRepresenter.represent_dict>, <class 'float'>: <function SafeRepresenter.represent_float>, <class 'int'>: <function SafeRepresenter.represent_int>, <class 'list'>: <function SafeRepresenter.represent_list>, <class 'set'>: <function SafeRepresenter.represent_set>, <class 'str'>: <function SafeRepresenter.represent_str>, <class 'tuple'>: <function SafeRepresenter.represent_list>, None: <function SafeRepresenter.represent_undefined>}¶
- class capellambse.decl.YDMLoader¶
Bases:
SafeLoader
A YAML loader with extensions for declarative modelling.
- construct_uuidref(node)¶
- Return type:
- Parameters:
node (Node)
- yaml_constructors = {'!find': <function YDMLoader.construct_findby>, '!new_object': <function YDMLoader.construct_newobj>, '!promise': <function YDMLoader.construct_promise>, '!uuid': <function YDMLoader.construct_uuidref>, 'tag:yaml.org,2002:binary': <function SafeConstructor.construct_yaml_binary>, 'tag:yaml.org,2002:bool': <function SafeConstructor.construct_yaml_bool>, 'tag:yaml.org,2002:float': <function SafeConstructor.construct_yaml_float>, 'tag:yaml.org,2002:int': <function SafeConstructor.construct_yaml_int>, 'tag:yaml.org,2002:map': <function SafeConstructor.construct_yaml_map>, 'tag:yaml.org,2002:null': <function SafeConstructor.construct_yaml_null>, 'tag:yaml.org,2002:omap': <function SafeConstructor.construct_yaml_omap>, 'tag:yaml.org,2002:pairs': <function SafeConstructor.construct_yaml_pairs>, 'tag:yaml.org,2002:seq': <function SafeConstructor.construct_yaml_seq>, 'tag:yaml.org,2002:set': <function SafeConstructor.construct_yaml_set>, 'tag:yaml.org,2002:str': <function SafeConstructor.construct_yaml_str>, 'tag:yaml.org,2002:timestamp': <function SafeConstructor.construct_yaml_timestamp>, None: <function SafeConstructor.construct_undefined>}¶
- capellambse.decl.apply(model, file, *, strict=False)¶
Apply a declarative modelling file to the given model.
- Parameters:
model (
MelodyModel
) – The model to apply the instructions to.file (
Union
[str
,PathLike
[Any
],IO
[str
]]) –An open file-like object to read YAML instructions from, or a path to such a file. Files will be read with UTF-8 encoding.
The full format of these files is documented in the section about declarative modelling.
strict (
bool
) – Verify metadata contained in the file against the used model, and raise an error if they don’t match.
- Return type:
Notes
This function is not transactional: If an exception occurs during this function, the model will be left partially modified, with no reliable way to know how much of the YAML input has been consumed. It is therefore advised to reload or discard the model immediately in these cases, to avoid working with an inconsistent state.
Even though the YAML layout suggests linear execution from top to bottom, the actual order in which modifications are executed is implementation defined. This is necessary to support promises with
!promise
, but reorderings are still possible even if no promises are used in an input document.
- capellambse.decl.dump(instructions, *, metadata=None, generator=None)¶
Dump an instruction stream to YAML.
Optionally dump metadata with the instruction stream to YAML.
- capellambse.decl.load(file)¶
Load an instruction stream from a YAML file.
- capellambse.decl.load_with_metadata(file)¶
Load an instruction stream and its metadata from a YAML file.
If the file does not have a metadata section, an empty dict will be returned.
- Parameters:
file (
Union
[str
,PathLike
[Any
],IO
[str
]]) – An open file-like object containing decl instructions, or a path or PathLike pointing to such a file. Files are expected to use UTF-8 encoding.- Return type:
- Returns:
dict[str, Any] – The metadata read from the file, or an empty dictionary if the file did not contain any metadata.
list[dict[str, Any]] – The instruction stream.
capellambse.diagram_cache module¶
CLI for the diagram cache updating feature.
capellambse.helpers module¶
Miscellaneous utility functions used throughout the modules.
- class capellambse.helpers.EverythingContainer¶
-
A container that contains everything.
- class capellambse.helpers.UUIDString¶
A string that represents a unique ID within the model.
alias of
str
- capellambse.helpers.escape_linked_text(loader, attr_text)¶
Transform simple HTML with object links into
LinkedText
.This is the inverse operation of
unescape_linked_text()
.- Return type:
- Parameters:
loader (MelodyLoader)
attr_text (str)
- capellambse.helpers.extent_func(text, fonttype='OpenSans-Regular.ttf', size=10)¶
Calculate the display size of the given text.
- capellambse.helpers.flatten_html_string(text)¶
Convert an HTML-string to plain text.
- capellambse.helpers.get_term_cell_size(stream=None)¶
Get the cell size of the terminal.
- Parameters:
stream – The stream that the terminal is connected to. If None, the stderr stream will be probed.
- Returns:
The width and height of a cell.
- Return type:
- Raises:
ValueError – Raised if the cell size could not be determined.
- capellambse.helpers.get_text_extent(text, width=inf, fonttype='OpenSans-Regular.ttf', fontsize=10)¶
Calculate the bounding box size of
text
after line wrapping.- Parameters:
- Return type:
- Returns:
width – The width of the text after word wrapping (px).
height – The height of the text after word wrapping (px).
- capellambse.helpers.get_transformation(class_, pos, size)¶
Calculate transformation for class.
The Scaling factor .725, translation constants (6, 5) are arbitrarily chosen to fit. Currently only ChoicePseudoState is tranformed.
- capellambse.helpers.is_uuid_string(string)¶
Validate that
string
is a valid UUID.
- capellambse.helpers.load_font(fonttype, size)¶
- Return type:
- Parameters:
- capellambse.helpers.make_short_html(clsname, uuid, name='', value='', *, icon='', iconsize=None)¶
Make HTML that briefly describes an element.
The layout of the generated HTML string is:
[icon and/or clsname] [name]: [value] ([uuid])
If an icon is used, the clsname is used for its alt and hover text.
All values passed except for icon will be HTML-escaped.
- Parameters:
clsname (
str
) – The name of the object’s class.uuid (
str
) – The object’s UUID.name (
str
) – The human-readable name of the object.value (
str
) – If the object contains a value of some sort, which is more interesting to the end user than the fact that the object exists, this parameter can be used to display the value.icon (
str
) – The icon to use, encoded as data: URI. Note that this value must already be HTML-safe.iconsize (
int
|None
) – Fix the width and height of the icon to this pixel value. Needed if the client application has dumb CSS rules.
- Return type:
- capellambse.helpers.normalize_pure_path(path, *, base='/')¶
Make a PurePosixPath relative to base and collapse
..
components.- Parameters:
path (
str
|PurePosixPath
) – The input path to normalize.base (
str
|PurePosixPath
) – The base directory to which relative paths should be interpreted. Ignored if the input path is not relative.
- Returns:
The normalized path.
- Return type:
- capellambse.helpers.ntuples(num, iterable, *, pad=False)¶
Yield N items of
iterable
at once.- Parameters:
- Yields:
items – A
num
long tuple of items fromiterable
.- Return type:
- capellambse.helpers.process_html_fragments(markup, node_callback)¶
Repair and modify HTML markup.
The original markup, which can be an HTML fragment (without a root element), is parsed and processed, and then reassembled into a Markup instance. If the original markup contained any errors or inconsistencies, these are repaired in the returned Markup instance.
- Parameters:
markup (
str
) – The markup string to modify.node_callback (
Callable
[[_Element
],None
]) –A callback function to process each node in the parsed markup. The function should accept a single
lxml.etree._Element
as argument; its return value is ignored.Note that, since the markup is parsed as fragments, more than the first element passed to the callback may have no parent.
The callback will not be invoked for leading text, if there is any, and thus it has no ability to influence it.
- Returns:
The processed markup.
- Return type:
- capellambse.helpers.relpath_pure(path, start)¶
Calculate the relative path between two pure paths.
Unlike
pathlib.PurePath.relative_to()
, this method can cope withpath
not being a subpath ofstart
. And unlike theos.path.relpath()
function, it does not involve any filesystem access.- Return type:
- Parameters:
path (PurePosixPath)
start (PurePosixPath)
- capellambse.helpers.repair_html(markup)¶
Try to repair broken HTML markup to prevent parse errors.
- Parameters:
markup (
str
) – The markup to try and repair.- Returns:
The repaired markup.
- Return type:
- capellambse.helpers.replace_hlinks(markup, model, make_href, *, broken_link_css='color: red; text-decoration: line-through;')¶
Replace hlink:// links with arbitrary other links.
- Parameters:
markup (
str
) – The markup to process.model (
MelodyModel
) – The model to use for resolving UUIDs.make_href (
Callable
[[ModelElement
],str
|None
]) – A function that maps objects to URLs. This function is called once for each link (possibly multiple times for the same object), and must return a URL to be inserted in place of the originalhlink://...
URL.broken_link_css (
str
) – Broken links (links to objects that have been deleted, and links where themake_href
callback returned None or an empty string) are indicated by a<span>
element with this CSS style applied to it.
- Return type:
- capellambse.helpers.resolve_namespace(tag)¶
Resolve a ‘:’-delimited symbolic namespace to its canonical form.
- capellambse.helpers.split_links(links)¶
Split a string containing intra- and inter-fragment links.
Intra-fragment links are simply “#UUID”, whereas inter-fragment links look like “xtype fragment#UUID”. Multiple such links are space-separated in a single long string to form a list. This function splits such a string back into its individual components (each being either an intra- or inter-fragment link), and yields them.
- capellambse.helpers.ssvparse(string, cast, *, parens=('', ''), sep=',', num=0)¶
Parse a string of
sep
-separated values wrapped inparens
.- Parameters:
string (
str
) – The input string.cast (
Callable
[[str
],TypeVar
(_T
)]) – A type to cast the values into.parens (
Sequence
[str
]) – The parentheses that must exist around the input. Either a two-character string or a 2-tuple of strings.sep (
str
) – The separator between values.num (
int
) – If non-zero, only accept exactly this many values.
- Returns:
A list of values cast into the given type.
- Return type:
list[_T]
- Raises:
ValueError – If the parentheses are missing around the input string, or if the expected number of values doesn’t match the actual number.
- capellambse.helpers.unescape_linked_text(loader, attr_text)¶
Transform the
linkedText
into regular HTML.- Return type:
- Parameters:
loader (MelodyLoader)
attr_text (str | None)
- capellambse.helpers.word_wrap(text, width)¶
Perform word wrapping for proportional fonts.
Whitespace at the beginning of input lines is preserved, but other whitespace is collapsed to single spaces. Words are kept as a whole, possibly leading to exceeding width bound.
- capellambse.helpers.xpath_fetch_unique(xpath, tree, elm_name, elm_uid=None, *, optional=False)¶
Fetch an XPath result from the tree, ensuring that it’s unique.
- Parameters:
xpath (
str
|XPath
) – Thelxml.etree.XPath
object to apply, or an XPath expression as str.tree (
_Element
) – The (sub-)tree to which the XPath will be applied.elm_name (
str
) – A human-readable element name for error messages.elm_uid (
str
|None
) – UID of the element which triggered this lookup. Will be included in the error message if an error occured.optional (
bool
) – True to return None in case the element is not found. Otherwise a ValueError will be raised.
- Returns:
The Element found by given
xpath
.- Return type:
lxml.etree._Element | None
- Raises:
ValueError – If more than one element was found matching the
xpath
, or ifoptional
isFalse
and no matching element was found.
- capellambse.helpers.xtype_of(elem)¶
Return the
xsi:type
of the element.If the element has an
xsi:type
attribute, its value is returned.If the element does not have an
xsi:type
, this function resolves the tag’s namespace to the symbolic name and reconstructs the type with thenamespace:tag
template.- Parameters:
elem (
_Element
) – Thelxml.etree._Element
object to return thexsi:type
for.- Raises:
capellambse.UnsupportedPluginError – If the plugin is unknown and therefore not supported.
capellambse.UnsupportedPluginVersionError – If the plugin’s version is not supported.
- Returns:
The
xsi:type
string of the provided element orNone
if the type could not be determined.- Return type:
str | None