<!-- # Author: Miguel Marina <karel.capek.robotics@gmail.com> # SPDX-License-Identifier: GPL-3.0-or-later # # Copyright (C) 2025 Capek System Safety & Robotic Solutions # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <https://www.gnu.org/licenses/>. -->

version: 0.2.267 Author: Miguel Marina karel.capek.robotics@gmail.com - LinkedIn

Reparent detached tabs across windows using native OS APIs so notebooks move widgets without cloning and avoid pending callback errors.

AutoML

AutoML is an automotive modeling and analysis tool built around a SysML-based metamodel. It lets you describe items, operating scenarios, functions, structure and interfaces in a single environment.

Project configuration is handled by the new ProjectPropertiesManager module, centralising probability tables and other project properties.

The metamodel blends concepts from key automotive standards—ISO 26262 (functional safety), ISO 21448 (SOTIF), ISO 21434 (cybersecurity) and ISO 8800 (safety and AI)—so one project can address safety, cybersecurity and assurance requirements side by side.

Diagram drawing is centralised in a dedicated :class:DiagramRendererService, providing a clear interface for generating and exporting diagrams.

Getting Started

1. Install dependencies

   pip install pillow openpyxl networkx matplotlib reportlab adjustText
   

2. Launch AutoML

   python automl.py
   

3. Create a new project
   • Choose File → New Project from the menu.
   • Use the diagrams and analysis tools to build your model.

These steps start the application with an empty project so you can explore the workflow described in later sections.

Table of Contents

• Getting Started
• Governance Diagrams
• Workflow Overview
• Pegasus Scenario Generation
• HAZOP Analysis
• Risk Assessment
• Causal Bayesian Network Analysis
• Requirements Creation and Management
• AutoML Diagrams and Safety Analyses
• Metamodel Overview
  • AutoML Safety Extensions
  • Core SysML Elements
  • Diagram Relationships
  • Detailed Safety, Reliability and Cybersecurity Metamodel
  • Extended AutoML Element Attributes
• BOM Integration with AutoML Diagrams
• Component Qualifications
• Mission Profiles and Probability Formulas
• SOTIF Analysis
  • SOTIF Traceability
• Cybersecurity Analysis
  • Safety and Cyber Governance
• Review Toolbox
• Additional Tools
  • Common Cause Toolbox
  • Risk & Assurance Gate Calculator
  • Product Goals Export
  • Safety Performance Indicators
  • Safety & Security Management Toolbox
• Email Setup
• Dependencies
• Diagram Styles
• License
• Building the Executable
• Version History

Governance Diagrams

Governance diagrams map the lifecycle of an item to the standards it must comply with so teams can see when each guideline applies. To build one in AutoML:

The Governance Core toolbox always lists all of its relationships and related elements, even when global relation filters are active or other diagram types have been opened.

1. List the standards that govern the item (e.g. ISO 26262, ISO 21448, ISO 21434, ISO 8800). Capture their key milestones, work products and review gates.
2. Define lifecycle states for the item such as concept, development, production and operation. For each state note the required evidence and decision points drawn from the standards.
3. Create a diagram that lays out the lifecycle states as nodes. Connect them with transitions that reflect progression or feedback. Use stereotypes or color coding to highlight which standard drives each state and to show shared activities across standards. Select process areas or work products from the governance panel and click in the diagram to place them where they belong.
4. Tailor the flow by adding optional branches or conditional steps when a standard allows alternative approaches. Document rationale for each tailoring so audits can trace the decision.
5. Iterate as the project evolves. Update the diagram when standards or lifecycle plans change so it remains a current view of governance.

These diagrams provide a single reference for planning work products, coordinating reviews and communicating how safety, cybersecurity and AI assurance fit together across the item’s lifecycle.

Governance diagrams can also produce derived requirements. Each task, flow and relationship—including any optional conditions or labels—is converted into a natural language statement so governance models can be exported as concise requirements lists.

When editing a governance diagram in the Safety & Security Management tool, use the Requirements button to generate these statements and view them in a new tab within the working area.

For example, the snippet below creates a tiny governance diagram and prints its derived requirements:

from analysis.governance import GovernanceDiagram

diagram = GovernanceDiagram()
diagram.add_task("Draft Plan")
diagram.add_task("Review Plan")
diagram.add_flow("Draft Plan", "Review Plan", condition="plan complete")
diagram.add_relationship(
    "Review Plan", "Draft Plan", condition="changes requested", label="rework"
)

for req in diagram.generate_requirements():
    print(req)

Running this script produces:

The system shall perform task 'Draft Plan'.
The system shall perform task 'Review Plan'.
When plan complete, task 'Draft Plan' shall precede task 'Review Plan'.
Task 'Review Plan' shall rework task 'Draft Plan' when changes requested.

To gather the requirements for every governance diagram within a specific lifecycle phase, use the Safety & Security Management tool's Phase Requirements menu or call the helper directly:

from analysis import SafetyManagementToolbox
from gui.safety_management_toolbox import SafetyManagementWindow

toolbox = SafetyManagementToolbox()
# diagrams would normally be created and assigned to a phase here
window = SafetyManagementWindow(None, app=None, toolbox=toolbox)
window.generate_phase_requirements("Concept")  # collects all Concept phase requirements

This opens a tab listing the combined requirements for the chosen phase, and now includes a dedicated column displaying the lifecycle phase for each requirement.

When importing governance diagrams from a SysML repository, every diagram object is treated as a task regardless of its type. Custom elements such as ANN or AI Database nodes therefore participate in requirement generation:

from mainappsrc.models.sysml.sysml_repository import SysMLRepository
from analysis.governance import GovernanceDiagram

repo = SysMLRepository()
diag = repo.create_diagram("Governance Diagram", name="Train")
ann = repo.create_element("ANN", name="ANN1")
gate = repo.create_element("Decision", name="Gate")
diag.objects = [
    {"obj_id": 1, "obj_type": "ANN", "element_id": ann.elem_id, "properties": {}},
    {"obj_id": 2, "obj_type": "Decision", "element_id": gate.elem_id, "properties": {}},
]
diag.connections = [
    {"src": 2, "dst": 1, "conn_type": "AI training", "name": "data ready", "properties": {}}
]

gov = GovernanceDiagram.from_repository(repo, diag.diag_id)
for req in gov.generate_requirements():
    print(req)

The output includes the relationship requirement:

The system shall perform task 'ANN1'.
The system shall perform task 'Gate'.
Task 'Gate' shall be related to task 'ANN1' when data ready.

To gather the requirements for every governance diagram within a specific lifecycle phase, use the Safety & Security Management tool's Phase Requirements menu or call the helper directly:

from analysis import SafetyManagementToolbox
from gui.safety_management_toolbox import SafetyManagementWindow

toolbox = SafetyManagementToolbox()
# diagrams would normally be created and assigned to a phase here
window = SafetyManagementWindow(None, app=None, toolbox=toolbox)
window.generate_phase_requirements("Concept")  # collects all Concept phase requirements

This opens a tab listing the combined requirements for the chosen phase.

When importing governance diagrams from a SysML repository, every diagram object is treated as a task regardless of its type. Custom elements such as ANN or AI Database nodes therefore participate in requirement generation:

from mainappsrc.models.sysml.sysml_repository import SysMLRepository
from analysis.governance import