# danielt/autosar-data-py architecture

> Architecture diagram of the GitHub repository danielt/autosar-data-py, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-07-07). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/danielt/autosar-data-py
- Repository: https://github.com/danielt/autosar-data-py

## Overview

1. **Repository purpose**
   This project provides Python bindings for the Rust `autosar-data` library. The core job is to load, inspect, validate, modify, and write AUTOSAR ARXML models from Python while keeping the heavy model logic in Rust via PyO3.

2. **Two-layer architecture**
   The repository is split into a **Rust implementation layer** under `src/` and a **Python packaging/API layer** under `python/autosar_data/`. The Python side is mostly a thin, typed facade; the Rust side owns the model, parsing, validation, and serialization behavior.

3. **Core model layer**
   The foundational Rust modules are `model.rs`, `arxmlfile.rs`, `element.rs`, `specification.rs`, and `version.rs`. Together they define the in-memory AUTOSAR document model, element tree behavior, file membership, version awareness, and schema/specification handling.

4. **Generic ARXML tree operations**
   `element.rs` and related abstractions support common operations seen in the README: create sub-elements, set attributes, resolve references, navigate by path, and manage which elements belong to which file. This is the central boundary between generic XML-like structure and AUTOSAR-specific semantics.

5. **AUTOSAR abstraction layer**
   Most domain logic sits under `src/abstraction/`. This layer maps the generic element model onto AUTOSAR concepts such as packages, signals, PDUs, ports, interfaces, ECU configuration, and systems. It is organized by domain rather than by file format concerns.

6. **Communication subsystem**
   `src/abstraction/communication/` is the largest domain area and models AUTOSAR communication artifacts. It is subdivided into:
   - **clusters**: CAN, Ethernet, FlexRay, LIN
   - **controllers**: bus controller definitions per network type
   - **frames** and **PDUs**
   - **transport layers**: CAN TP, DoIP TP, FlexRay TP/AR TP
   - **network management**
   - **physical channels** and Ethernet-specific variants such as SOME/IP, socket addresses, and network endpoints  
   This domain is where most cross-references and protocol-specific relationships live.

7. **Datatype subsystem**
   `src/abstraction/datatype/` models AUTOSAR application data types, base types, implementation types, compu methods, mappings, and value representations. This is the type system that underpins signal and interface data descriptions elsewhere in the model.

8. **Software component subsystem**
   `src/abstraction/software_component/` captures AUTOSAR software components, ports, connectors, interfaces, internal behavior, and mode-related concepts. It is the boundary for application-level composition and RTE-facing modeling.

9. **ECU configuration and system mapping**
   `src/abstraction/ecu_configuration/` handles ECU configuration definitions and values, while `src/abstraction/system/` contains system mapping. These modules represent the configuration side of AUTOSAR: parameter definitions, references, instantiated values, and mappings between system and component/communication structures.

10. **Python API surface**
    The Python package in `python/autosar_data/` mirrors the Rust API in a distributable form. It includes `.pyi` stub files and `py.typed`, so consumers get type-aware IDE support. The public Python entry point exposes the AUTOSAR model operations shown in the README.

11. **Validation and versioning**
    Validation is built into the load and mutation flow, with strict vs non-strict loading behavior described in the README. Version support is explicit and spans AUTOSAR 4.0.1 and newer, which influences parsing, allowed attributes, and element availability.

12. **Data flow**
    The main runtime flow is: Python code calls into the Rust-backed model → ARXML is loaded or created → abstraction modules materialize AUTOSAR concepts on top of generic elements → references and constraints are validated → the model is serialized or written back to one or more ARXML files.

13. **Tests and quality gates**
    The `test/` directory contains Python integration-style tests for each major abstraction area, plus core model/file/specification tests. CI is handled by GitHub Actions workflows for test execution and pages/docs publication, which suggests the API docs are part of the project’s deliverable surface.

14. **Documentation boundary**
    `docs/` and `mkdocs.yml` form the architecture-level reference for the public API, with separate docs for abstraction, communication, datatype, ECU configuration, and software component APIs. This mirrors the source tree and reinforces the module boundaries exposed to users.

Main entry points: [`src/abstraction/mod.rs`](https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/mod.rs) (Abstraction), [`src/lib.rs`](https://github.com/danielt/autosar-data-py/blob/main/src/lib.rs) (PyO3 lib), [`src/model.rs`](https://github.com/danielt/autosar-data-py/blob/main/src/model.rs) (Model), [`src/abstraction/software_component/mod.rs`](https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/software_component/mod.rs) (Software components)

## Diagram (Mermaid)

```mermaid
flowchart TD

subgraph group_group_python["Python API"]
  node_node_python_init["autosar_data<br/>[__init__.py]"]
  node_node_python_abstraction["Abstraction API<br/>[__init__.py]"]
  node_node_python_comm["Comm API<br/>[__init__.py]"]
  node_node_python_datatype["Datatype API<br/>[__init__.py]"]
  node_node_python_ecu["ECU API<br/>[__init__.py]"]
  node_node_python_swc["SWC API<br/>[__init__.py]"]
end

subgraph group_group_rust_core["Rust Core"]
  node_node_lib["PyO3 lib<br/>rust crate<br/>[lib.rs]"]
  node_node_model["Model<br/>[model.rs]"]
  node_node_element["Elements<br/>tree core<br/>[element.rs]"]
  node_node_arxmlfile["ARXML files<br/>file ownership<br/>[arxmlfile.rs]"]
  node_node_spec_version["Spec & version<br/>schema/version<br/>[specification.rs]"]
end

subgraph group_group_abstraction["AUTOSAR Abstractions"]
  node_node_abstraction_root["Abstraction<br/>domain layer<br/>[mod.rs]"]
  node_node_comm["Communication<br/>domain<br/>[mod.rs]"]
  node_node_datatype["Datatypes<br/>domain<br/>[mod.rs]"]
  node_node_swc["Software components<br/>domain<br/>[mod.rs]"]
  node_node_ecu["ECU config<br/>domain<br/>[mod.rs]"]
  node_node_system["System mapping<br/>domain<br/>[mod.rs]"]
end

subgraph group_group_support["Support"]
  node_node_docs["Docs<br/>documentation<br/>[index.md]"]
  node_node_tests["Tests<br/>[test.py]"]
  node_node_ci["CI<br/>workflows<br/>[CI.yml]"]
end

node_node_python_init -->|"imports"| node_node_lib
node_node_python_abstraction -->|"wraps"| node_node_abstraction_root
node_node_python_comm -->|"wraps"| node_node_comm
node_node_python_datatype -->|"wraps"| node_node_datatype
node_node_python_ecu -->|"wraps"| node_node_ecu
node_node_python_swc -->|"wraps"| node_node_swc
node_node_lib -->|"exposes"| node_node_model
node_node_lib -->|"exposes"| node_node_element
node_node_lib -->|"exposes"| node_node_arxmlfile
node_node_lib -->|"exposes"| node_node_spec_version
node_node_model -->|"uses"| node_node_element
node_node_model -->|"uses"| node_node_arxmlfile
node_node_model -->|"checks"| node_node_spec_version
node_node_abstraction_root -->|"contains"| node_node_comm
node_node_abstraction_root -->|"contains"| node_node_datatype
node_node_abstraction_root -->|"contains"| node_node_swc
node_node_abstraction_root -->|"contains"| node_node_ecu
node_node_abstraction_root -->|"contains"| node_node_system
node_node_comm -->|"references"| node_node_datatype
node_node_swc -->|"connects to"| node_node_comm
node_node_swc -->|"typed by"| node_node_datatype
node_node_ecu -->|"maps into"| node_node_system
node_node_docs -->|"documents"| node_node_python_init
node_node_tests -->|"covers"| node_node_python_init
node_node_ci -->|"runs"| node_node_tests
node_node_ci -->|"publishes"| node_node_docs

click node_node_python_init "https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/__init__.py"
click node_node_python_abstraction "https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/__init__.py"
click node_node_python_comm "https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/communication/__init__.py"
click node_node_python_datatype "https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/datatype/__init__.py"
click node_node_python_ecu "https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/ecu_configuration/__init__.py"
click node_node_python_swc "https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/software_component/__init__.py"
click node_node_lib "https://github.com/danielt/autosar-data-py/blob/main/src/lib.rs"
click node_node_model "https://github.com/danielt/autosar-data-py/blob/main/src/model.rs"
click node_node_element "https://github.com/danielt/autosar-data-py/blob/main/src/element.rs"
click node_node_arxmlfile "https://github.com/danielt/autosar-data-py/blob/main/src/arxmlfile.rs"
click node_node_spec_version "https://github.com/danielt/autosar-data-py/blob/main/src/specification.rs"
click node_node_abstraction_root "https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/mod.rs"
click node_node_comm "https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/communication/mod.rs"
click node_node_datatype "https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/datatype/mod.rs"
click node_node_swc "https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/software_component/mod.rs"
click node_node_ecu "https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/ecu_configuration/mod.rs"
click node_node_system "https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/system/mod.rs"
click node_node_docs "https://github.com/danielt/autosar-data-py/blob/main/docs/index.md"
click node_node_tests "https://github.com/danielt/autosar-data-py/blob/main/test/test.py"
click node_node_ci "https://github.com/danielt/autosar-data-py/blob/main/.github/workflows/CI.yml"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_node_python_init,node_node_python_abstraction,node_node_python_comm,node_node_python_datatype,node_node_python_ecu,node_node_python_swc toneBlue
class node_node_lib,node_node_model,node_node_element,node_node_arxmlfile,node_node_spec_version toneAmber
class node_node_abstraction_root,node_node_comm,node_node_datatype,node_node_swc,node_node_ecu,node_node_system toneMint
class node_node_docs,node_node_tests,node_node_ci toneRose
```

## Components

### Python API

Typed Python facade and package entry points

- [autosar_data](https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/__init__.py): package · Public Python entry point for the library · `python/autosar_data/__init__.py`
- [Abstraction API](https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/__init__.py): package · Python facade for AUTOSAR domain modules · `python/autosar_data/abstraction/__init__.py`
- [Comm API](https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/communication/__init__.py): package · Python communication-domain bindings · `python/autosar_data/abstraction/communication/__init__.py`
- [Datatype API](https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/datatype/__init__.py): package · Python datatype-domain bindings · `python/autosar_data/abstraction/datatype/__init__.py`
- [ECU API](https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/ecu_configuration/__init__.py): package · Python ECU configuration bindings · `python/autosar_data/abstraction/ecu_configuration/__init__.py`
- [SWC API](https://github.com/danielt/autosar-data-py/blob/main/python/autosar_data/abstraction/software_component/__init__.py): package · Python software-component bindings · `python/autosar_data/abstraction/software_component/__init__.py`

### Rust Core

PyO3-backed core model and serialization layer

- [PyO3 lib](https://github.com/danielt/autosar-data-py/blob/main/src/lib.rs): rust crate · Rust crate entry point exposed to Python · `src/lib.rs`
- [Model](https://github.com/danielt/autosar-data-py/blob/main/src/model.rs): core model · In-memory AUTOSAR document model and operations · `src/model.rs`
- [Elements](https://github.com/danielt/autosar-data-py/blob/main/src/element.rs): tree core · Generic element tree, attributes, refs, and paths · `src/element.rs`
- [ARXML files](https://github.com/danielt/autosar-data-py/blob/main/src/arxmlfile.rs): file ownership · File membership and write-back boundaries · `src/arxmlfile.rs`
- [Spec & version](https://github.com/danielt/autosar-data-py/blob/main/src/specification.rs): schema/version · Specification rules and AUTOSAR version handling · `src/specification.rs`

### AUTOSAR Abstractions

Domain-specific AUTOSAR modeling layers built on generic elements

- [Abstraction](https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/mod.rs): domain layer · AUTOSAR domain mapping on top of generic elements · `src/abstraction/mod.rs`
- [Communication](https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/communication/mod.rs): domain · Networks, frames, PDUs, transport, and channels · `src/abstraction/communication/mod.rs`
- [Datatypes](https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/datatype/mod.rs): domain · Application and implementation type system · `src/abstraction/datatype/mod.rs`
- [Software components](https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/software_component/mod.rs): domain · Ports, interfaces, behavior, and connectors · `src/abstraction/software_component/mod.rs`
- [ECU config](https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/ecu_configuration/mod.rs): domain · Definition and instantiated ECU configuration values · `src/abstraction/ecu_configuration/mod.rs`
- [System mapping](https://github.com/danielt/autosar-data-py/blob/main/src/abstraction/system/mod.rs): domain · Mapping between systems, components, and communication · `src/abstraction/system/mod.rs`

### Support

Documentation, tests, and CI

- [Docs](https://github.com/danielt/autosar-data-py/blob/main/docs/index.md): documentation · Public API and architecture reference · `docs/index.md`
- [Tests](https://github.com/danielt/autosar-data-py/blob/main/test/test.py): integration tests · Python integration tests covering the major abstractions · `test/test.py`
- [CI](https://github.com/danielt/autosar-data-py/blob/main/.github/workflows/CI.yml): workflows · GitHub Actions workflows for test and pages publishing · `.github/workflows/CI.yml`

## Connections

- autosar_data → PyO3 lib: imports · Python entry point is backed by the Rust extension
- Abstraction API → Abstraction: wraps · Python abstraction API mirrors Rust domain modules
- Comm API → Communication: wraps · Communication bindings expose Rust communication abstractions
- Datatype API → Datatypes: wraps · Datatype bindings expose Rust datatype abstractions
- ECU API → ECU config: wraps · ECU configuration bindings expose Rust ECU abstractions
- SWC API → Software components: wraps · Software component bindings expose Rust SWC abstractions
- PyO3 lib → Model: exposes · Rust crate exports the core model API to Python
- PyO3 lib → Elements: exposes · Rust crate exports generic tree operations
- PyO3 lib → ARXML files: exposes · Rust crate exports ARXML file handling
- PyO3 lib → Spec & version: exposes · Rust crate exports schema and version behavior
- Model → Elements: uses · Model is built on the generic element tree
- Model → ARXML files: uses · Model tracks file membership and serialization boundaries
- Model → Spec & version: checks · Model behavior is constrained by spec and version
- Abstraction → Communication: contains · Domain layer includes communication modeling
- Abstraction → Datatypes: contains · Domain layer includes datatype modeling
- Abstraction → Software components: contains · Domain layer includes software component modeling
- Abstraction → ECU config: contains · Domain layer includes ECU configuration modeling
- Abstraction → System mapping: contains · Domain layer includes system mapping
- Communication → Datatypes: references · Communication artifacts depend on data types and mappings
- Software components → Communication: connects to · Software components interact through communication interfaces and connectors
- Software components → Datatypes: typed by · Ports and interfaces are described using datatype definitions
- ECU config → System mapping: maps into · ECU configuration participates in system mapping
- Docs → autosar_data: documents · Docs describe the public Python-facing API
- Tests → autosar_data: covers · Integration tests exercise the package surface
- CI → Tests: runs · CI executes the test suite
- CI → Docs: publishes · CI includes documentation/site publication
