pyArchimate

https://pyarchimate.readthedocs.io
Admin
pyArchimate provides comprehensive documentation covering its architecture, elements, relationships,...
Tokens:158,848
Snippets:1,321
Trust Score:9.6
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install pyArchimate

Source: https://pyarchimate.readthedocs.io/_sources/getting-started.rst.txt

Install the pyArchimate library using pip. This is the first step to using the library.

```bash
pip install pyArchimate
```

--------------------------------

### Practical Example: Decomposing a Service

Source: https://pyarchimate.readthedocs.io/_sources/guides/element-hierarchy.rst.txt

Demonstrates building a multi-level service decomposition by creating a top-level service element. This example sets up the initial element for a hierarchical structure.

```python
from pyArchimate import Model, ArchiType

model = Model(name="Service Decomposition")

# Create the top-level service
payment_service = model.add_element(
    name="Payment Service",

```

--------------------------------

### Get All Properties

Source: https://pyarchimate.readthedocs.io/element.html

Retrieves all element properties as a dictionary.

```python
property props -> dict
```

--------------------------------

### Get or Create Relationship

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Placeholder method for getting or creating a relationship. It takes relationship type, name, source, target, and optional parameters like access type and influence strength.

```python
def get_or_create_relationship(
        self,
        rel_type: str,
        name: str | None,
        source: Any,
        target: Any,
        create_rel: bool = False,  # noqa: E501
        access_type: str | None = None,
        influence_strength: str | None = None,

```

--------------------------------

### Get or Create View

Source: https://pyarchimate.readthedocs.io/model.html

Retrieves an existing view by name or creates a new view if it does not exist and `create_view` is set to True.

```python
get_or_create_view(_view_ , _create_view =False_)
```

--------------------------------

### Get Relationship Source

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Retrieves the source object of a relationship. This is the starting element of the relationship.

```python
relationship.source
```

--------------------------------

### Element Class Initialization and Usage Example

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/element.html

Demonstrates creating and styling ArchiMate elements, building hierarchy, and setting junction types. Requires importing ArchiType and Model from pyArchimate.

```python
from pyArchimate import ArchiType
from pyArchimate.model import Model
m = Model('example')

# Create elements
process = m.add(ArchiType.BusinessProcess, 'Order Processing')
func = m.add(ArchiType.BusinessFunction, 'Order Fulfillment')
junction = m.add(ArchiType.Junction, 'Decision Point')

# Build hierarchy
m.add_child(process.uuid, func.uuid)

# Style elements
process.set_fill_color('#ffeb3b')
process.set_transparency(0.9)

# Set junction semantics
junction.set_junction_type('and')

```

--------------------------------

### Get Ancestors of an Element

Source: https://pyarchimate.readthedocs.io/_sources/api/model.rst.txt

Retrieve a list of all ancestors for a given element, starting from the element itself up to the root. Useful for tracing an element's lineage.

```python
ancestors = model.get_ancestors(service.uuid)
# Returns: [service, func, process]
for ancestor in ancestors:
    print(f"Ancestor: {ancestor.name}")
```

--------------------------------

### Calculate Next Row Starting X Position

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/view.html

Determines the starting X coordinate for the next row of nodes based on the justification strategy.

```python
def _next_row_x(justify: str, row: int, elem_w: float, gap_x: float) -> int:
    if justify == "center":
        return 40 if row % 2 == 0 else 40 + int((elem_w + gap_x) / 2)
    return 40
```

--------------------------------

### Practical Example: Decomposing a Service

Source: https://pyarchimate.readthedocs.io/guides/element-hierarchy.html

Demonstrates building a multi-level service decomposition by creating a top-level service and adding sub-services as children using `add_element` and `add_child`.

```python
from pyArchimate import Model, ArchiType

model = Model(name="Service Decomposition")

# Create the top-level service
payment_service = model.add_element(
    name="Payment Service",
    element_type=ArchiType.ApplicationService
)

# Add sub-services (level 2)
payment_processing = model.add_element(
    name="Payment Processing",
    element_type=ArchiType.ApplicationService
)
fraud_detection = model.add_element(
    name="Fraud Detection",
    element_type=ArchiType.ApplicationService
)

model.add_child(parent=payment_service, child=payment_processing)
model.add_child(parent=payment_service, child=fraud_detection)

```

--------------------------------

### Create a Minimal pyArchimate Model

Source: https://pyarchimate.readthedocs.io/getting-started.html

This example demonstrates how to create a new ArchiMate model, add business and application elements, and establish a serving relationship between them. It then prints the number of elements in the model.

```python
from pyArchimate import Model, ArchiType

# Create a new model
model = Model(name="My First Model")

# Add elements (using model.add: element_type, name)
business = model.add(ArchiType.BusinessProcess, "Business Process")
app = model.add(ArchiType.ApplicationService, "Application Service")

# Create a relationship (rel_type as string, e.g. 'Serving')
model.add_relationship("Serving", source=business, target=app)

# Confirm the model has the expected elements
print(f"Model '{model.name}' has {len(model.elements)} elements")

```

```text
Model 'My First Model' has 2 elements

```

--------------------------------

### Custom Properties

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/view.html

Manage custom properties associated with a view. You can get all properties, get or set a specific property by key, or remove a property.

```APIDOC
## Custom Properties

### Description

Manage custom properties associated with a view. You can get all properties, get or set a specific property by key, or remove a property.

### Methods

- **props**: Returns a dictionary of all custom properties.
- **prop(key: str, value: object = None)**: Gets the value of a property by key. If a value is provided, it sets the property.
- **remove_prop(key: str)**: Removes a custom property by its key.

### Parameters

- **key** (str) - Required - The key of the property to get, set, or remove.
- **value** (object) - Optional - The value to set for the property. If not provided, the property's current value is returned.

### Response

- **props**: `dict[str, object]` - A dictionary containing all custom properties.
- **prop**: `object` - The value of the specified property, or the value that was set.
- **remove_prop**: `None`
```

--------------------------------

### Create and Build ArchiMate Model Hierarchy

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Demonstrates how to create business processes and functions, build a hierarchy between them, and apply visual styling using pyArchimate.

```python
from pyarchimate import model as m
from pyarchimate import architecturelayer as al
from pyarchimate import archtype as ArchiType

# Create elements
process = m.add(ArchiType.BusinessProcess, 'Order Management')
func1 = m.add(ArchiType.BusinessFunction, 'Order Entry')
func2 = m.add(ArchiType.BusinessFunction, 'Order Fulfillment')

# Build hierarchy
m.add_child(process.uuid, func1.uuid)
m.add_child(process.uuid, func2.uuid)

# Apply visual styling
process.set_fill_color('#e8f4f8')
func1.set_fill_color('#b3e5fc')
```

--------------------------------

### Create and Populate Archimate Model

Source: https://pyarchimate.readthedocs.io/model.html

Demonstrates creating a new Archimate model, adding business elements, establishing parent-child relationships, applying visual styling, and performing basic hierarchy queries.

```python
from pyArchimate import ArchiType
from pyArchimate.model import Model

m = Model('Enterprise Architecture')

# Create elements
process = m.add(ArchiType.BusinessProcess, 'Order Management')
func1 = m.add(ArchiType.BusinessFunction, 'Order Entry')
func2 = m.add(ArchiType.BusinessFunction, 'Order Fulfillment')

# Build hierarchy
m.add_child(process.uuid, func1.uuid)
m.add_child(process.uuid, func2.uuid)

# Apply visual styling
process.set_fill_color('#e8f4f8')
func1.set_fill_color('#b3e5fc')

# Query hierarchy
children = m.get_children(process.uuid)
siblings = m.get_siblings(func1.uuid)
ancestors = m.get_ancestors(func1.uuid)

# Find by path
results = m.find_by_hierarchy_path('/Order Management/Order Entry')
```

--------------------------------

### Get Profile ID

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/element.html

Gets the profile ID if the current profile is valid and exists in the associated model's profiles. Returns None if either there is no current profile or it does not exist.

```python
@property
def profile_id(self):
        """
        Gets the profile ID if the current profile is valid and exists in the associated
        model's profiles. Returns None if either there is no current profile or it does
        not exist.
        """
        # This part of the code was truncated in the source
```

--------------------------------

### Create and Style ArchiMate Elements

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Demonstrates how to add business processes, functions, and junctions to a model, build a hierarchy between them, and apply styling like fill color and transparency.

```python
# Create elements
process = m.add(ArchiType.BusinessProcess, 'Order Processing')
func = m.add(ArchiType.BusinessFunction, 'Order Fulfillment')
junction = m.add(ArchiType.Junction, 'Decision Point')

# Build hierarchy
m.add_child(process.uuid, func.uuid)

# Style elements
process.set_fill_color('#ffeb3b')
process.set_transparency(0.9)
```

--------------------------------

### Configure PyArchimate Logging

Source: https://pyarchimate.readthedocs.io/tutorial/tutorial.html

Demonstrates how to set the logging level for PyArchimate diagnostics using helper functions.

```python
from pyArchimate import log_set_level, log_to_stderr
import logging

# Show all debug messages
log_set_level(logging.DEBUG)


```

--------------------------------

### Get or Set Model Property in pyArchimate

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Allows getting an existing property value by its key or setting a new property value. If the key does not exist and a value is provided, it creates the property.

```python
def prop(self, key, value=None):
    """
    Method to get or set an element's property

    :param key:     Property key
    :type key: str
    :param value:   Property value
    :type value: str
    :return: an existing element property value if 'value' argument is None
    :rtype: str
    """
    if value is None:
        return self._properties[key] if key in self._properties else None
    else:
        self._properties[key] = value
        return value
```

--------------------------------

### Node.cx

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Gets the center x-coordinate of the node.

```APIDOC
## Node.cx

### Description
Center x coordinate.

### Method
property cx

### Returns
float
```

--------------------------------

### Writing Models in Different Formats

Source: https://pyarchimate.readthedocs.io/_sources/tutorial/tutorial.md.txt

Demonstrates how to write a model to different file formats including Archi tool format, OpenGroup XML, and CSV.

```python
from pyArchimate import Model, Writers

model = Model("export_demo")

# Default: Archi tool format
model.write("export_demo.archimate")

# OpenGroup XML exchange format
model.write("export_demo.xml", writer=Writers.archi)

# CSV (useful for spreadsheet analysis)
model.write("export_demo.csv", writer=Writers.csv)
```

--------------------------------

### uuid

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Gets the unique identifier for the model.

```APIDOC
## uuid

### Description
Get the Model Identifier.

### Method
uuid

### Parameters
None

### Response
#### Success Response (200)
* **str** - The model's identifier.

### Response Example
```python
model_id = model.uuid
```
```

--------------------------------

### Practical Example: Coloring Elements by Layer

Source: https://pyarchimate.readthedocs.io/guides/visual-styling.html

Applies different fill colors to elements based on their ArchiMate layer (business, application, technology) using a predefined color scheme.

```python
from pyArchimate import Model, ArchiType

model = Model(name="Layered Styling")

# Define color scheme by layer
layer_colors = {
    "business": "#FFE6CC",     # Light orange for Business
    "application": "#CCE5FF",  # Light blue for Application
    "technology": "#E6CCFF"    # Light purple for Technology
}

# Add elements with layer-based styling
business_process = model.add_element(
    name="Handle Order",
    element_type=ArchiType.BusinessProcess
)
business_process.set_fill_color(layer_colors["business"])

app_service = model.add_element(
    name="Order Service",
    element_type=ArchiType.ApplicationService
)
app_service.set_fill_color(layer_colors["application"])

tech_service = model.add_element(
    name="API Gateway",
    element_type=ArchiType.TechnologyService
)
tech_service.set_fill_color(layer_colors["technology"])

# Write styled model
model.write("layered.archimate")
```

--------------------------------

### Color Elements by Layer

Source: https://pyarchimate.readthedocs.io/_sources/guides/visual-styling.rst.txt

A practical example demonstrating how to apply different fill colors to elements based on their ArchiMate layer (business, application, technology).

```python
from pyArchimate import Model, ArchiType

model = Model(name="Layered Styling")

# Define color scheme by layer
layer_colors = {
    "business": "#FFE6CC",     # Light orange for Business
    "application": "#CCE5FF",  # Light blue for Application
    "technology": "#E6CCFF"    # Light purple for Technology
}

# Add elements with layer-based styling
business_process = model.add_element(
    name="Handle Order",
    element_type=ArchiType.BusinessProcess
)
business_process.set_fill_color(layer_colors["business"])

app_service = model.add_element(
    name="Order Service",
    element_type=ArchiType.ApplicationService
)
app_service.set_fill_color(layer_colors["application"])

tech_service = model.add_element(

```

--------------------------------

### property uuid

Source: https://pyarchimate.readthedocs.io/element.html

Get the identifier of this element.

```APIDOC
## property uuid

### Description
Get the identifier of this element.

### Method
N/A (Python property)

### Parameters
None

### Returns
* **uuid** (str) - The identifier of the element.
```

--------------------------------

### Configure Layout and Formatting Options

Source: https://pyarchimate.readthedocs.io/_sources/features/layout.rst.txt

Sets up detailed parameters for layout algorithms, element spacing, canvas margins, alignment, and routing styles.

```python
config = LayoutConfig(
    algorithm="force_directed",        # or "hierarchical"
    spacing=50,                        # Element spacing in pixels
    margin=20,                         # Canvas margin in pixels
    alignment="free",                  # or "grid" for grid snapping
    grid_size=10,                      # Grid cell size when alignment="grid"
    excluded_element_ids=[],           # Element IDs to exclude from repositioning
    routing_style="orthogonal",        # or "mixed_45" for diagonal segments
    layer_priority="mandatory",        # or "soft" for layer constraints
    node_size_constraints={}
)
```

--------------------------------

### View.prop

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Gets or sets a custom property for the view.

```APIDOC
## View.prop

### Description
Get or set a custom property.

### Method Signature
`prop(_key : str_, _value : object = None_) → object`
```

--------------------------------

### Creating and Styling Archimate Elements

Source: https://pyarchimate.readthedocs.io/element.html

Demonstrates how to create various Archimate elements, establish parent-child relationships, and apply custom visual styling like fill color and transparency. This is useful for building complex Archimate models programmatically.

```python
from pyArchimate import ArchiType
from pyArchimate.model import Model
m = Model('example')

# Create elements
process = m.add(ArchiType.BusinessProcess, 'Order Processing')
func = m.add(ArchiType.BusinessFunction, 'Order Fulfillment')
junction = m.add(ArchiType.Junction, 'Decision Point')

# Build hierarchy
m.add_child(process.uuid, func.uuid)

# Style elements
process.set_fill_color('#ffeb3b')
process.set_transparency(0.9)
```

--------------------------------

### type

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Gets the type of the model, which is always 'Model'.

```APIDOC
## type

### Description
Get the type of Model.

### Method
type

### Parameters
None

### Response
#### Success Response (200)
* **str** - The string 'Model'.

### Response Example
```python
model_type = model.type
```
```

--------------------------------

### Initialize a View

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/view.html

Initializes a diagram view with a name, description, and parent model. Raises an error if the parent is not a valid Model instance.

```python
def __init__(self, name=None, uuid=None, desc=None, folder=None, parent=None):
    """Initialize a diagram view with name, description, and parent model."""
    if not hasattr(parent, "views_dict"):
        raise ArchimateConceptTypeError("View class parent should be a class Model instance!")
    self.parent: Model = cast("Model", parent)
    self.model: Model = cast("Model", parent)
    self._uuid = set_id(uuid)
    self.name = name
    self.desc = desc
    self.unions: list[object] = []
    self.nodes_dict: dict[str, Node] = defaultdict(Node)
    self.conns_dict: dict[str, Connection] = defaultdict(Connection)
    self._properties: dict[str, object] = {}
    self.folder = folder
    self._primary_viewpoint: str | None = None
```

--------------------------------

### Get All Bendpoints

Source: https://pyarchimate.readthedocs.io/view.html

Retrieves all bendpoints associated with this connection.

```python
get_all_bendpoints() -> list[Point]
```

--------------------------------

### pyArchimate.get_or_create_connection

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Delegates connection creation to View helper methods.

```APIDOC
## pyArchimate.get_or_create_connection

### Description
Delegate connection creation to View helper methods.

### Method Signature
`get_or_create_connection(_owner_ , _* args_, _** kwargs_)`
```

--------------------------------

### Get or Create Connection Helper

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/helpers/diagram.html

Delegates connection creation to the owner's view helper methods. Use this to ensure a connection exists or create it if it doesn't.

```python
def get_or_create_connection(owner, *args, **kwargs):
    """Delegate connection creation to View helper methods."""
    return owner.get_or_create_connection(*args, **kwargs)
```

--------------------------------

### Get Model Type

Source: https://pyarchimate.readthedocs.io/model.html

Retrieves the type of the Archimate model.

```python
property type
```

--------------------------------

### property type

Source: https://pyarchimate.readthedocs.io/element.html

Get the Archimate concept type of this element.

```APIDOC
## property type

### Description
Get the Archimate concept type of this element.

### Method
N/A (Python property)

### Parameters
None

### Returns
* **type** (str) - The Archimate concept type.
```

--------------------------------

### Node Initialization

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/view.html

Initializes a visual node with position, size, and an optional element reference. The parent must be a View or Node instance.

```python
def __init__(self, ref=None, x=0, y=0, w=120, h=55, uuid=None, node_type="Element", label=None, parent=None):
    """Initialize a visual node with position, size, and element reference."""
    # parent type check is done after View is defined; accept duck-typed objects
    if parent is None or not (hasattr(parent, "view") and hasattr(parent, "model")):
        raise ValueError("Node class parent should be a class View or Node instance!")

    self.parent: View | Node = parent
    self._view: View = cast("View", parent.view)
    self._model: Model = cast("Model", parent.model)

    self._ref = self._resolve_ref(ref)
    self._validate_ref(node_type, self._ref)

    self._uuid = set_id(uuid)
    self._x = int(x)
    self._y = int(y)
    self._w = int(w)
    self._h = int(h)
    self._cx = self._x + self._w / 2
    self._cy = self._y + self._h / 2
    self._area = self._w * self._h
    self.flags = 0
    self.cat = node_type
    self.label = label
    self.nodes_dict: dict[str, Node] = {}
    self._fill_color: str | None = None
    self.line_color: str | None = None
    self.opacity: int | float = 100
    self.lc_opacity: int | float = 100
    self.font_color: str | None = None
    self.font_name = "Segoe UI"
    self.font_size: int | float = 9
    self.text_alignment: str | None = None
    self.text_position = None
    self.label_expression: str | None = None
    self.border_type: str | None = None
    self.icon_color = None
    self.gradient = None
    self.image_path: str | None = None
    self.image_position: int | None = None
    self.image_type: int | None = None
    self.image_source: bool = False
```

--------------------------------

### Get Model Relationships

Source: https://pyarchimate.readthedocs.io/model.html

Retrieves a list of all relationships present in the model.

```python
property relationships
```

--------------------------------

### Get or Create Connection (Helper)

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Helper function to delegate connection creation to the View's helper methods. Accepts owner and arbitrary arguments/keyword arguments.

```python
get_or_create_connection(_owner_ , _* args_, _** kwargs_)[source]
    
    Delegate connection creation to View helper methods.
```

--------------------------------

### Get Model Nodes

Source: https://pyarchimate.readthedocs.io/model.html

Retrieves a list of all nodes within the model.

```python
property nodes
```

--------------------------------

### Create Archimate View

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Initializes a new Archimate view (diagram) with optional name, UUID, description, folder, and parent model. Views contain nodes and connections.

```python
view = View(name='MyView', uuid='some-uuid', desc='A sample view', folder=None, parent=None)
```

--------------------------------

### Render Package Diagram

Source: https://pyarchimate.readthedocs.io/_sources/diagrams/README.md.txt

Use the plantuml command-line tool to render the package.puml diagram to an image file. Ensure PlantUML is installed.

```bash
plantuml docs/diagrams/package.puml
```

--------------------------------

### Get Model Type

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Returns the type of the model, which is always 'Model'.

```python
    @property
    def type(self):
        """
        Get the type of Model
        :return: type
        :rtype: str
        """
        return "Model"

```

--------------------------------

### Distribute Connection Endpoints

Source: https://pyarchimate.readthedocs.io/_sources/tutorial/tutorial.md.txt

Demonstrates how to use `node.distribute_connections()` to evenly spread connection endpoints along a node's edges, reducing visual clutter when many connections exist.

```python
from pyArchimate import Model, ArchiType

model = Model("distribute demo")
hub  = model.add(ArchiType.ApplicationComponent, "API Gateway")
svc1 = model.add(ArchiType.ApplicationService,  "Auth")
svc2 = model.add(ArchiType.ApplicationService,  "Search")
svc3 = model.add(ArchiType.ApplicationService,  "Orders")

rel1 = model.add_relationship(ArchiType.Serving, source=hub, target=svc1)
rel2 = model.add_relationship(ArchiType.Serving, source=hub, target=svc2)
rel3 = model.add_relationship(ArchiType.Serving, source=hub, target=svc3)

view     = model.add(ArchiType.View, "Gateway View")
node_hub = view.add(hub,  x=160, y=100, w=120, h=55)
ns1      = view.add(svc1, x=0,   y=250, w=120, h=55)
ns2      = view.add(svc2, x=160, y=250, w=120, h=55)
ns3      = view.add(svc3, x=320, y=250, w=120, h=55)
view.add_connection(rel1, source=node_hub, target=ns1)
view.add_connection(rel2, source=node_hub, target=ns2)
view.add_connection(rel3, source=node_hub, target=ns3)

# Spread connection endpoints evenly along the hub node's edges
node_hub.distribute_connections()
print(f"Number of outgoing connections from hub: {len(node_hub.out_conns())}")  # 3
```

--------------------------------

### Get Model UUID

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Retrieves the unique identifier for the ArchiMate model.

```python
    @property
    def uuid(self):
        """
        Get the Model Identifier

        :return: Identifer
        :rtype: str
        """
        return self._uuid

```

--------------------------------

### Styling Nodes with Default Theme and Overrides

Source: https://pyarchimate.readthedocs.io/_sources/tutorial/tutorial.md.txt

Shows how to apply a default color theme to all nodes in a view and then override individual node colors. Node colors are specified as hex strings.

```python
from pyArchimate import Model, ArchiType

model = Model("styling demo")
app = model.add(ArchiType.ApplicationComponent, "Payment Service")
svc = model.add(ArchiType.ApplicationService, "Charge Card")
rel = model.add_relationship(ArchiType.Serving, source=app, target=svc)

view = model.add(ArchiType.View, "App Layer")
node_app = view.add(app, x=0,   y=0, w=140, h=60)
node_svc = view.add(svc, x=200, y=0, w=140, h=60)
view.add_connection(rel, source=node_app, target=node_svc)

# Apply the built-in ArchiMate color theme to all nodes
model.default_theme("archi")
print(f"Default fill color for ApplicationComponent: {node_app.fill_color}")

# Override a single node's color
node_svc.fill_color = "#cce5ff"
print(f"Custom fill color: {node_svc.fill_color}")  # #cce5ff
```

--------------------------------

### Get Element Type

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/element.html

Retrieves the Archimate concept type of the element.

```python
@property
def type(self) -> str | None:  # noqa: A003  # 'type' is the canonical ArchiMate attribute name; renaming would break public API
        """
        Get the Archimate concept type of this element

        :return:    type str
        :rtype: str
        """
        return self._type
```

--------------------------------

### Create a Minimal ArchiMate Model

Source: https://pyarchimate.readthedocs.io/_sources/getting-started.rst.txt

Create a new ArchiMate model, add a business process and an application service, and establish a 'Serving' relationship between them. This snippet demonstrates basic model creation and element/relationship addition.

```python
from pyArchimate import Model, ArchiType

# Create a new model
model = Model(name="My First Model")

# Add elements (using model.add: element_type, name)
business = model.add(ArchiType.BusinessProcess, "Business Process")
app = model.add(ArchiType.ApplicationService, "Application Service")

# Create a relationship (rel_type as string, e.g. 'Serving')
model.add_relationship("Serving", source=business, target=app)

# Confirm the model has the expected elements
print(f"Model '{model.name}' has {len(model.elements)} elements")
```

--------------------------------

### Get pyArchimate Relationship UUID

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/relationship.html

Retrieves the unique identifier for the relationship.

```python
@property
def uuid(self):
        """
        Get this relationship identifier

        :return: Identifier
        :rtype: str

        """
        return self._uuid
```

--------------------------------

### Use a Custom Writer

Source: https://pyarchimate.readthedocs.io/_sources/guides/extending.rst.txt

Instantiate your custom writer and call its `write` method, passing the model and the desired filepath. This example demonstrates writing a model to 'output.json' using `JSONWriter`.

```python
model = Model(name="My Model")
# ... add elements ...

writer = JSONWriter()
writer.write(model, "output.json")
```

--------------------------------

### get_ancestors

Source: https://pyarchimate.readthedocs.io/_sources/api/model.rst.txt

Retrieves a list of all ancestors for a given element, starting from the element itself up to the root.

```APIDOC
## get_ancestors

### Description
Get all ancestors of an element from the element itself to the root.

### Method
`get_ancestors(elem_uuid: str) -> list[Element]`

### Parameters
#### Path Parameters
- **elem_uuid** (str) - Required - Element UUID

### Returns
- List of Elements [elem, parent, grandparent, ..., root]

### Example
```python
ancestors = model.get_ancestors(service.uuid)
# Returns: [service, func, process]
for ancestor in ancestors:
    print(f"Ancestor: {ancestor.name}")
```
```

--------------------------------

### pyArchimate.default_color

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Gets the default color of a Node based on its type and a specified theme.

```APIDOC
## pyArchimate.default_color

### Description
Get the default color of a Node, according to its type.

### Parameters
* **elem_type** (_str_) – Archimate element type.
* **theme** (_Any_) – ‘archi’ or ‘aris’ color theme - default = ‘archi’.

### Returns
#Hex color str

### Method Signature
`default_color(_elem_type : str_, _theme : Any = 'archi'_) → str`
```

--------------------------------

### Initialize pyArchimate Logger

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/logger.html

Initializes the pyArchimate logger with a default warning level and sets up a formatter. This is the base configuration for all logging operations.

```python
import logging
from logging.handlers import RotatingFileHandler

log = logging.getLogger()
log.setLevel(logging.WARNING)
formatter = logging.Formatter("%(asctime)s | %(name)s | %(levelname)s | %(message)s")
```

--------------------------------

### Get Model Connections

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Retrieves a list of all connections present in the Archimate model.

```python
property conns
    
    Get the list of all connections from the model :return: Connections :rtype: list(Connection)
```

--------------------------------

### Example of XOR Junction for Payment Method Choice

Source: https://pyarchimate.readthedocs.io/guides/junction-types.html

Demonstrates how to use an XOR junction to represent a choice between two mutually exclusive payment methods (credit card or bank transfer). Exactly one path should be taken.

```python
credit_card_path = model.add_element(
    name="Credit Card Payment",
    element_type=ArchiType.ApplicationService
)
bank_transfer_path = model.add_element(
    name="Bank Transfer",
    element_type=ArchiType.ApplicationService
)

payment_choice = model.add_element(
    name="Choose Payment Method",
    element_type=ArchiType.XorJunctionElement
)
payment_choice.set_junction_type(JunctionType.XOR)

process_payment = model.add_element(
    name="Process Payment",
    element_type=ArchiType.ApplicationService
)

# Exactly one payment method is chosen
model.add_relationship(
    source=credit_card_path,
    target=payment_choice,
    relationship_type=RelationType.Influences
)
model.add_relationship(
    source=bank_transfer_path,
    target=payment_choice,
    relationship_type=RelationType.Influences
)
model.add_relationship(
    source=payment_choice,
    target=process_payment,
    relationship_type=RelationType.Influences
)
```

--------------------------------

### Get All Viewpoints

Source: https://pyarchimate.readthedocs.io/model.html

Returns a list of all 13 standard ArchiMate 3.x viewpoints.

```python
get_viewpoints()
```

--------------------------------

### Configure PyArchimate Logging

Source: https://pyarchimate.readthedocs.io/_sources/tutorial/tutorial.md.txt

Shows how to adjust PyArchimate's logging verbosity and output destination using helper functions. This avoids direct configuration of Python's standard `logging` module.

```python
from pyArchimate import log_set_level, log_to_stderr
import logging

# Show all debug messages
log_set_level(logging.DEBUG)

# Redirect logs to stderr
log_to_stderr()
```

--------------------------------

### Get Profile by Name

Source: https://pyarchimate.readthedocs.io/model.html

Retrieves an Archimate profile object based on its name.

```python
get_profile(_name : str_) → Profile | None
```

--------------------------------

### Get Ancestors Elements

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Retrieves a list of all ancestor elements for a given element.

```python
def get_ancestors(self, elem_uuid: str) -> list[Element]:
```

--------------------------------

### Walk Organizations

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/readers/archimateReader.html

Recursively walks through organizational items in the XML, assigning folder paths and updating view descriptions and folders.

```python
def _walk_orgs(item: Any, ns: str, model: Any, folder: str = "") -> None:
    items = item.findall(ns + "item")
    label = item.find(ns + "label")
    if label is not None:
        folder += "/" + label.text
    doc = item.find(ns + "documentation")
    if doc is not None:
        ref_id = item.find(ns + "item").get("identifierRef")
        _v = model.views_dict[ref_id]
        _v.desc = doc.text
        _v.folder = folder
        return
    for sub_item in items:
        ref_id = sub_item.get("identifierRef")
        if ref_id is not None:
            _assign_folder_by_ref(ref_id, folder, model)
        else:
            _walk_orgs(sub_item, ns, model, folder)
```

--------------------------------

### Get Connections in pyArchimate Model

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Returns a list of all connections within the model.

```python
@property
def conns(self):
    """
    Get the list of all connections from the model
    :return: Connections
    :rtype: list(Connection)
    """
    return list(self.conns_dict.values())
```

--------------------------------

### Apply and Verify Element Styling

Source: https://pyarchimate.readthedocs.io/_sources/examples/styling_examples.rst.txt

This snippet shows how to set fill color, line color, line width, and transparency for a Business Process element. It then saves the model, reads it back, and asserts that the styling properties were preserved. Finally, it modifies the styling and verifies the second round-trip.

```python
from pyarchimate import Model, ArchiType

# Create a new model
model = Model()

# Add a Business Process element with initial styling
elem = model.add_element(
    name="Styled Element",
    element_type=ArchiType.BusinessProcess
)
elem.set_fill_color("#FF6B6B")
elem.set_line_color("#C92A2A")
elem.set_line_width(2)
elem.set_transparency(0.2)

# Save the model
model.write("original.archimate")
print("Saved original model with styling")

# Read it back
model2 = Model.read("original.archimate")
elem2 = model2.get_element(elem.id)

# Verify styling was preserved
assert elem2.get_fill_color() == "#FF6B6B", "Fill color not preserved!"
assert elem2.get_line_color() == "#C92A2A", "Line color not preserved!"
assert elem2.get_line_width() == 2, "Line width not preserved!"
assert elem2.get_transparency() == 0.2, "Transparency not preserved!"

print("✓ All styling preserved in round-trip!")

# Modify and save again
elem2.set_fill_color("#4ECDC4")  # Teal
model2.write("modified.archimate")

# Read again to verify second round-trip
model3 = Model.read("modified.archimate")
elem3 = model3.get_element(elem.id)

assert elem3.get_fill_color() == "#4ECDC4", "Updated color not preserved!"
print("✓ Updated styling preserved in second round-trip!")
```

--------------------------------

### Building an Application Service Hierarchy

Source: https://pyarchimate.readthedocs.io/_sources/guides/element-hierarchy.rst.txt

This snippet shows how to create a nested structure of Application Services within a model. It demonstrates adding elements and defining their relationships using add_element and add_child methods. The example concludes by querying the number of direct children and total descendants, and saving the model.

```python
from pyarchimate import model
from pyarchimate.model import ArchiType

# Create a new model
model = model.Model()

# Add top-level service
payment_service = model.add_element(
    name="Payment Service",
    element_type=ArchiType.ApplicationService
)

# Add sub-services (level 2)
payment_processing = model.add_element(
    name="Payment Processing",
    element_type=ArchiType.ApplicationService
)
fraud_detection = model.add_element(
    name="Fraud Detection",
    element_type=ArchiType.ApplicationService
)

model.add_child(parent=payment_service, child=payment_processing)
model.add_child(parent=payment_service, child=fraud_detection)

# Add sub-sub-services (level 3)
card_auth = model.add_element(
    name="Card Authorization",
    element_type=ArchiType.ApplicationService
)
model.add_child(parent=payment_processing, child=card_auth)

# Query the hierarchy
print(f"Payment Service has {len(payment_service.get_children())} direct children")
print(f"Payment Service has {len(payment_service.get_descendants())} total descendants")

# Write to file (hierarchy preserved)
model.write("service_hierarchy.archimate")
```

--------------------------------

### Get Nodes in pyArchimate Model

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Retrieves a list of all nodes present in the model.

```python
@property
def nodes(self):
    """
    Get the list of all nodes from the model
    :return: Nodes
    :rtype: list(Node)
    """
    return list(self.nodes_dict.values())
```

--------------------------------

### Render Class Diagram

Source: https://pyarchimate.readthedocs.io/_sources/diagrams/README.md.txt

Use the plantuml command-line tool to render the class.puml diagram to an image file. Ensure PlantUML is installed.

```bash
plantuml docs/diagrams/class.puml
```

--------------------------------

### Get Views in pyArchimate Model

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Returns a list of all views present in the model.

```python
@property
def views(self):
    """
    Get the list of views in this model

    :return: [View]
    :rtype: list
    """
    return list(self.views_dict.values())
```

--------------------------------

### Get Bendpoint by Index

Source: https://pyarchimate.readthedocs.io/view.html

Retrieves a specific bendpoint from the connection at the given index.

```python
get_bendpoint(_index: int_) -> Point | None
```

--------------------------------

### Create Three-Level Process Hierarchy

Source: https://pyarchimate.readthedocs.io/_sources/examples/hierarchy_examples.rst.txt

Demonstrates how to build a nested structure of business processes, from a top-level management process down to sub-processes and their sub-tasks. Use this to model complex workflows.

```python
from pyArchimate import Model, ArchiType

model = Model(name="Order Processing Hierarchy")

# Level 1: Top-level process
order_mgmt = model.add_element(
    name="Order Management",
    element_type=ArchiType.BusinessProcess
)

# Level 2: Sub-processes
receive_order = model.add_element(
    name="Receive Order",
    element_type=ArchiType.BusinessProcess
)
validate_order = model.add_element(
    name="Validate Order",
    element_type=ArchiType.BusinessProcess
)
fulfill_order = model.add_element(
    name="Fulfill Order",
    element_type=ArchiType.BusinessProcess
)

# Create parent-child relationships (level 2)
model.add_child(parent=order_mgmt, child=receive_order)
model.add_child(parent=order_mgmt, child=validate_order)
model.add_child(parent=order_mgmt, child=fulfill_order)

# Level 3: Sub-sub-processes
check_payment = model.add_element(
    name="Check Payment",
    element_type=ArchiType.BusinessProcess
)
check_stock = model.add_element(
    name="Check Stock",
    element_type=ArchiType.BusinessProcess
)

# Create parent-child relationships (level 3)
model.add_child(parent=validate_order, child=check_payment)
model.add_child(parent=validate_order, child=check_stock)

# Verify structure
print(f"Order Management has {len(order_mgmt.get_children())} direct children")
print(f"Order Management has {len(order_mgmt.get_descendants())} total descendants")
print(f"Validate Order has depth {validate_order.get_depth()}")

# Save the model
model.write("order_hierarchy.archimate")
```

--------------------------------

### Get All Element Properties

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/element.html

Returns a dictionary containing all properties associated with the element.

```python
return self._properties
```

--------------------------------

### Prepare XML Reader

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Prepares an XML reader by loading file contents, parsing the XML, and matching a reader entry based on the root tag. Returns the reader, root element, and entry, or None values if preparation fails.

```python
def _prepare_reader(self, file_path, operation):
    entry = None
    data = self._load_file_contents(file_path, operation)

    if data != "":
        parser = et.XMLParser(recover=True)
        root = et.fromstring(data.encode(), parser=parser)
        entry = self._match_reader_entry(root.tag)

    if entry is None:
        log.error(OPERATION_ERROR_MESSAGES.get(operation, OPERATION_ERROR_MESSAGES["read"]))
        return None, None, None
    reader = entry.loader()
    return reader, root, entry
```

--------------------------------

### Get Element UUID

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/element.html

Retrieves the unique identifier (UUID) of the Archimate element.

```python
@property
def uuid(self) -> str:
        """
        Get the identifier of this element

        :return:    Identifier str
        :rtype: str
        """
        return self._uuid
```

--------------------------------

### Get or Create Node Helper

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/helpers/diagram.html

Delegates node creation to the owner's model or view helper methods. Use this to ensure a node exists or create it if it doesn't.

```python
def get_or_create_node(owner, *args, **kwargs):
    """Delegate node creation to Model/View helper methods."""
    return owner.get_or_create_node(*args, **kwargs)
```

--------------------------------

### get_ancestors()

Source: https://pyarchimate.readthedocs.io/api/model.html

Retrieves a list of all ancestors for a given element, starting from the element itself up to the root of its hierarchy.

```APIDOC
## get_ancestors()

### Description
Get all ancestors of an element from the element itself to the root.

### Method
```python
get_ancestors(_elem_uuid : str_) → list[Element]
```

### Parameters
#### Path Parameters
- **elem_uuid** (str) - Required - Element UUID

### Returns
List of Elements [elem, parent, grandparent, …, root]

### Return type
list[Element]

### Example
```python
ancestors = model.get_ancestors(service.uuid)
```
```

--------------------------------

### pyArchimate.pyArchimate.get_or_create_node

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Delegate node creation to Model/View helper methods.

```APIDOC
## pyArchimate.pyArchimate.get_or_create_node

### Description
Delegate node creation to Model/View helper methods.

### Method
Not specified (likely a Python function call)

### Endpoint
Not applicable (Python function)

### Parameters
Not explicitly detailed in the source for this function signature.

### Request Example
Not applicable

### Response
Not explicitly detailed in the source for this function signature.
```

--------------------------------

### Create and Style ArchiMate Model Elements

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Demonstrates creating business process and function elements, establishing parent-child relationships, applying custom fill colors, and querying the model hierarchy. Exports the model to an ArchiMate file.

```python
from pyArchimate import ArchiType
from pyArchimate.model import Model

m = Model('Enterprise Architecture')

# Create elements
process = m.add(ArchiType.BusinessProcess, 'Order Management')
func1 = m.add(ArchiType.BusinessFunction, 'Order Entry')
func2 = m.add(ArchiType.BusinessFunction, 'Order Fulfillment')

# Build hierarchy
m.add_child(process.uuid, func1.uuid)
m.add_child(process.uuid, func2.uuid)

# Apply visual styling
process.set_fill_color('#e8f4f8')
func1.set_fill_color('#b3e5fc')

# Query hierarchy
children = m.get_children(process.uuid)
siblings = m.get_siblings(func1.uuid)
ancestors = m.get_ancestors(func1.uuid)

# Find by path
results = m.find_by_hierarchy_path('/Order Management/Order Entry')

# Export (preserves all hierarchy and visual properties)
m.write('model.archimate')
```

--------------------------------

### Get Relationship Target

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Retrieves the target object of a relationship. This is the ending element of the relationship.

```python
relationship.target
```

--------------------------------

### Route Connections with Bendpoints

Source: https://pyarchimate.readthedocs.io/_sources/tutorial/tutorial.md.txt

Shows how to route connections between nodes using bendpoints to avoid obstacles. Includes examples of automatic L-shape and S-shape routing, as well as manual bendpoint addition.

```python
from pyArchimate import Model, ArchiType
from pyArchimate.view import Point

model = Model("bendpoint demo")
app = model.add(ArchiType.ApplicationComponent, "Order Service")
db  = model.add(ArchiType.ApplicationComponent, "Database")
rel = model.add_relationship(ArchiType.Association, source=app, target=db)

view     = model.add(ArchiType.View, "Routing Demo")
node_app = view.add(app, x=0,   y=0,   w=120, h=55)
node_db  = view.add(db,  x=300, y=200, w=120, h=55)
conn     = view.add_connection(rel, source=node_app, target=node_db)

# Route as an L-shape (one bendpoint)
conn.l_shape()
print(f"Number of bendpoints (L-shape): {len(conn.get_all_bendpoints())}")  # 1

# Route as an S-shape (two bendpoints)
conn.s_shape()
print(f"Number of bendpoints (S-shape): {len(conn.get_all_bendpoints())}")  # 2

# Manual bendpoint
conn.remove_all_bendpoints()
conn.add_bendpoint(Point(150, 50))
print(f"First bendpoint x-coordinate: {conn.get_bendpoint(0).x}")  # 150
```

--------------------------------

### Get Node Connections

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Returns connections to or from this node, optionally filtered by relationship type.

```python
conns(_rel_type =None_)
```

--------------------------------

### type

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Property to get the ArchiMate relationship type. This indicates the semantic nature of the relationship.

```APIDOC
## type

### Description
ArchiMate relationship type.

### Returns
- str: The type of the ArchiMate relationship.
```

--------------------------------

### Apply Connection Styling from XML

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/readers/archimateReader.html

Applies line color, font properties, and line width to a connection object based on XML style data.

```Python
def _apply_conn_style(conn, style_xml, ns):
    if style_xml is None:
        return
    lc = style_xml.find(ns + "lineColor")
    if lc is not None:
        conn.line_color = RGBA(lc.get("r"), lc.get("g"), lc.get("b")).color
    ft = style_xml.find(ns + "font")
    if ft is not None:
        conn.font_name = ft.get("name")
        conn.font_size = ft.get("size")
        ftc = ft.find(ns + "color")
        conn.font_color = RGBA(ftc.get("r"), ftc.get("g"), ftc.get("b")).color
    conn.line_width = style_xml.get("lineWidth")
```

--------------------------------

### name

Source: https://pyarchimate.readthedocs.io/pyArchimate.html

Property to get or set the name of the relationship. The name is a key identifier for the relationship.

```APIDOC
## name

### Description
Relationship name.

### Returns
- str | None: The name of the relationship.
```

--------------------------------

### Get Model Views

Source: https://pyarchimate.readthedocs.io/model.html

Retrieves a list of all views contained within the Archimate model.

```python
property views
```

--------------------------------

### Get or Create View

Source: https://pyarchimate.readthedocs.io/_modules/pyArchimate/model.html

Retrieves an existing view by name or creates a new one if the `create_view` flag is set to True. Accepts either a view name (string) or a view object.

```python
def get_or_create_view(self, view, create_view=False):
        """
        Method to get or create a view by name

        :param view:        View name
        :type view: str
        :param create_view: if True, create a view if not found
        :type create_view: bool
        :return:            View object
        :rtype: View
        """
        if isinstance(view, str):
            v = self.find_views(view)
            if len(v) > 0:
                v = v[0]
            elif create_view:
                v = self.add(ArchiType.View, view)
            else:
                v = None
        else:
            v = view
        return v

```

--------------------------------

### Get Model Properties

Source: https://pyarchimate.readthedocs.io/model.html

Accesses a dictionary of the model's properties. This is a read-only property.

```python
property props
```
Tokens:
Raw