robotransform 0.0.5__py3-none-any.whl → 0.1.0__py3-none-any.whl

robotransform/__init__.py

@@ -1,7 +1,7 @@
-from robotransform.main import Store, MapleKStore, dump_messages, dump_logical
+from robotransform.main import Store, MapleKStore
+from robotransform.convert import dump_aadl
 __all__ = (
     "Store",
     "MapleKStore",
-    "dump_messages",
-    "dump_logical",
+    "dump_aadl",
 )

robotransform/__main__.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+
+import argparse
+from pathlib import Path
+
+import arklog
+
+from robotransform import Store, dump_aadl
+
+
+def main():
+    parser = argparse.ArgumentParser(description="RoboTransform CLI.")
+    parser.add_argument(
+        "path",
+        type=Path,
+        help="Path to a rct file."
+    )
+    args = parser.parse_args()
+
+    if args.path.exists():
+        arklog.debug(f"Path exists: ({args.path}).")
+        store = Store((args.path,))
+        arklog.info(dump_aadl(store))
+    else:
+        arklog.debug(f"Path does not exist: ({args.path.resolve()}).")
+
+
+if __name__ == "__main__":
+    main()

robotransform/aadl.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Literal
+
+ComponentCategory = Literal[
+    "system", "process", "thread", "data", "processor", "bus", "device",
+    "memory", "virtual_processor", "virtual_bus"
+]
+
+FeatureDirection = Literal["in", "out", "in out"]
+PortCategory = Literal["event", "event_data", "data"]
+
+
+@dataclass
+class Mode:
+    name: str
+    initial: bool = False
+
+    def to_aadl(self, indent: str = "") -> str:
+        initial = "initial " if self.initial else ""
+        lines = [f"{indent}{self.name}: {initial}mode;"]
+        return "\n".join(lines)
+
+
+@dataclass
+class Port:
+    name: str
+    direction: FeatureDirection
+    port_category: PortCategory = "data"
+    data_type: Optional[str] = None
+
+    def to_aadl(self, indent: str = "") -> str:
+        port_type = "data port"
+        if self.port_category == "event":
+            port_type = "event port"
+        elif self.port_category == "event_data":
+            port_type = "event data port"
+        dt = f" {self.data_type}" if self.data_type else ""
+        return f"{indent}{self.name}: {self.direction} {port_type}{dt};"
+
+
+@dataclass
+class Subcomponent:
+    name: str
+    category: ComponentCategory
+    component_type: str
+    component_implementation: Optional[str] = None
+
+    def to_aadl(self, indent: str = "") -> str:
+        impl_part = f".{self.component_implementation}" if self.component_implementation else ""
+        return f"{indent}{self.name}: {self.category} {self.component_type}{impl_part};"
+
+
+@dataclass
+class Connection:
+    name: str
+    source: str
+    destination: str
+    bidirectional: bool = False
+
+    def to_aadl(self, indent: str = "") -> str:
+        arrow = "<->" if self.bidirectional else "->"
+        return f"{indent}{self.name}: {self.source} {arrow} {self.destination};"
+
+
+@dataclass
+class ComponentType:
+    name: str
+    category: ComponentCategory
+    features: Dict[str, Port] = field(default_factory=dict)
+    modes: List[Mode] = field(default_factory=list)
+
+    def to_aadl(self, indent: str = "") -> str:
+        lines = [f"{indent}{self.category} {self.name}"]
+        if self.features:
+            lines.append(f"{indent}  features")
+            for f in self.features.values():
+                lines.append(f.to_aadl(indent + "    "))
+        if self.modes:
+            lines.append(f"{indent}  modes")
+            for m in self.modes:
+                lines.append(m.to_aadl(indent + "    "))
+        lines.append(f"{indent}end {self.name};")
+        return "\n".join(lines)
+
+
+@dataclass
+class BehaviorGuard:
+    expression: str
+
+    def to_aadl(self) -> str:
+        return f"-[{self.expression}]-" if self.expression else ""
+
+
+@dataclass
+class BehaviorTransition:
+    source: str
+    destination: str
+    guard: Optional[BehaviorGuard] = None
+
+    def to_aadl(self) -> str:
+        if self.guard and self.guard.expression:
+            return f"{self.source} -[{self.guard.expression}]-> {self.destination};"
+        return f"{self.source} -> {self.destination};"
+
+
+@dataclass
+class BehaviorSpecification:
+    transitions: List[BehaviorTransition] = field(default_factory=list)
+
+    def add_transition(self, source: str, destination: str, guard_expression: Optional[str] = None) -> None:
+        self.transitions.append(
+            BehaviorTransition(
+                source=source,
+                destination=destination,
+                guard=BehaviorGuard(guard_expression) if guard_expression else None,
+            )
+        )
+
+    def to_aadl(self, indent: str = "") -> str:
+        lines = [f"{indent}annex behaviour_specification {{**", f"{indent}  mode transitions"]
+        for t in self.transitions:
+            lines.append(f"{indent}    {t.to_aadl()}")
+        lines.append(f"{indent}**}};")
+        return "\n".join(lines)
+
+
+@dataclass
+class ComponentImplementation:
+    name: str
+    category: str
+    type_name: str
+    subcomponents: Dict[str, Subcomponent] = field(default_factory=dict)
+    connections: List['Connection'] = field(default_factory=list)
+    modes: List['Mode'] = field(default_factory=list)
+    behavior: Optional['BehaviorSpecification'] = None
+
+    def to_aadl_header(self, indent: str = "") -> str:
+        return f"{indent}{self.category} implementation {self.name} for {self.type_name}"
+
+    def to_aadl(self, indent: str = "") -> str:
+        lines = [self.to_aadl_header(indent)]
+        if self.subcomponents:
+            lines.append(f"{indent}  subcomponents")
+            for s in self.subcomponents.values():
+                lines.append(s.to_aadl(indent + "    "))
+        if self.connections:
+            lines.append(f"{indent}  connections")
+            for c in self.connections:
+                lines.append(c.to_aadl(indent + "    "))
+        if self.modes:
+            lines.append(f"{indent}  modes")
+            for m in self.modes:
+                lines.append(m.to_aadl(indent + "    "))
+        if self.behavior:
+            lines.append(self.behavior.to_aadl(indent + "  "))
+        lines.append(f"{indent}end {self.name};")
+        return "\n".join(lines)
+
+
+@dataclass
+class ThreadImplementation(ComponentImplementation):
+    category: str = field(init=False, default="thread")
+
+@dataclass
+class ProcessImplementation(ComponentImplementation):
+    category: str = field(init=False, default="process")
+
+@dataclass
+class SystemImplementation(ComponentImplementation):
+    category: str = field(init=False, default="system")
+
+
+@dataclass
+class AADLPackage:
+    name: str
+    with_packages: List[str] = field(default_factory=list)
+    public_types: Dict[str, ComponentType] = field(default_factory=dict)
+    public_implementations: Dict[str, ComponentImplementation] = field(default_factory=dict)
+    private_types: Dict[str, ComponentType] = field(default_factory=dict)
+    private_implementations: Dict[str, ComponentImplementation] = field(default_factory=dict)
+
+    def to_aadl(self) -> str:
+        lines = [f"package {self.name}", "public"]
+        if self.with_packages:
+            lines.append(f"  with {', '.join(self.with_packages)};")
+        for t in self.public_types.values():
+            lines.append(t.to_aadl("  "))
+        for i in self.public_implementations.values():
+            lines.append(i.to_aadl("  "))
+        if self.private_types or self.private_implementations:
+            lines.append("private")
+            for t in self.private_types.values():
+                lines.append(t.to_aadl("  "))
+            for i in self.private_implementations.values():
+                lines.append(i.to_aadl("  "))
+        lines.append(f"end {self.name};")
+        return "\n".join(lines)

robotransform/convert.py

@@ -0,0 +1,464 @@
+from __future__ import annotations
+
+import io
+import re
+from pathlib import Path
+from typing import Optional, Union
+
+from robotransform.aadl import (
+    AADLPackage,
+    ComponentType,
+    Connection as AADLConnection,
+    Port,
+    Mode,
+    BehaviorSpecification,
+    BehaviorTransition,
+    BehaviorGuard,
+    Subcomponent,
+    ProcessImplementation,
+    ThreadImplementation,
+    SystemImplementation,
+)
+from robotransform.filters import type_to_aadl_type
+from robotransform.main import get_template, write_output
+from robotransform.concepts import Package, StateMachineDef, ControllerDef, RoboticPlatformDef, Variable, Event, Module
+
+_IDENTIFIER_RE = re.compile(r"[^0-9A-Za-z_]")
+
+
+def _aadl_id(value: object) -> str:
+    if value is None:
+        return "unnamed"
+    text = str(value)
+    text = text.replace("::", "_")
+    text = _IDENTIFIER_RE.sub("_", text)
+    if text and text[0].isdigit():
+        text = f"n_{text}"
+    return text or "unnamed"
+
+
+def _local_name(value: object) -> str:
+    if value is None:
+        return "unnamed"
+    if hasattr(value, "parts"):
+        parts = getattr(value, "parts")
+        if parts:
+            return str(parts[-1])
+    text = str(value)
+    return text.split("::")[-1]
+
+
+def _aadl_name(value: object) -> str:
+    return _aadl_id(_local_name(value))
+
+
+def _aadl_qualified_name(value: object) -> str:
+    if hasattr(value, "parts"):
+        parts = getattr(value, "parts")
+        return "::".join(_aadl_id(part) for part in parts)
+    return str(value)
+
+
+def _unique_name(base: str, existing: set[str]) -> str:
+    name = base
+    index = 1
+    while name in existing:
+        name = f"{base}_{index}"
+        index += 1
+    return name
+
+
+def _message_type_name(type_ref: Optional[str]) -> Optional[str]:
+    if not type_ref or "::" not in type_ref:
+        return None
+    package, name = type_ref.split("::", 1)
+    if package != "messages":
+        return None
+    return name
+
+
+def _collect_message_types(packages: list[AADLPackage]) -> set[str]:
+    names: set[str] = set()
+    for pkg in packages:
+        for comp in pkg.public_types.values():
+            for feature in comp.features.values():
+                if isinstance(feature, Port):
+                    msg_name = _message_type_name(feature.data_type)
+                    if msg_name:
+                        names.add(msg_name)
+        for impl in pkg.public_implementations.values():
+            for sub in impl.subcomponents.values():
+                if sub.category != "data":
+                    continue
+                msg_name = _message_type_name(sub.component_type)
+                if msg_name:
+                    names.add(msg_name)
+    return names
+
+
+def _collect_defined_message_types(robo_packages: list[Package]) -> set[str]:
+    names: set[str] = set()
+    for pkg in robo_packages:
+        for record in getattr(pkg, "types", []):
+            names.add(str(getattr(record, "name", "")))
+    return names
+
+
+def _render_messages(robo_packages: list[Package], aadl_packages: list[AADLPackage],
+                     output: Optional[Union[io.TextIOBase, Path, str]]) -> str:
+    used_types = _collect_message_types(aadl_packages)
+    defined_types = _collect_defined_message_types(robo_packages)
+    extra_types = sorted(used_types - defined_types)
+    template = get_template("messages")
+    data = template.render(packages=robo_packages, extra_types=extra_types)
+    return write_output(data, output)
+
+
+def robocart_package_to_aadl_full(rc_pkg: "Package") -> AADLPackage:
+    aadl_pkg = AADLPackage(
+        name=_aadl_name(rc_pkg.name),
+        with_packages=["Base_Types", "messages"],
+    )
+
+    # ---- registries ----
+    def register_type(comp_type: ComponentType) -> ComponentType:
+        return aadl_pkg.public_types.setdefault(comp_type.name, comp_type)
+
+    def register_impl(comp_impl):
+        return aadl_pkg.public_implementations.setdefault(comp_impl.name, comp_impl)
+
+    local_type_names = {str(getattr(t, "name", "")) for t in getattr(rc_pkg, "types", [])}
+
+    # ---- helpers ----
+    def resolve_type(robo_type: object) -> str:
+        typename = str(robo_type)
+        short_name = typename.split("::")[-1]
+        if short_name in local_type_names:
+            return _aadl_id(short_name)
+        return type_to_aadl_type(robo_type)
+
+    def convert_event(ev: "Event") -> Port:
+        data_type = resolve_type(ev.type) if getattr(ev, "type", None) else None
+        port_category = "event_data" if data_type else "event"
+        return Port(
+            name=_aadl_id(ev.name),
+            direction="in out",
+            port_category=port_category,
+            data_type=data_type,
+        )
+
+    def convert_variable(var: "Variable") -> Subcomponent:
+        return Subcomponent(
+            name=_aadl_id(var.name),
+            category="data",
+            component_type=resolve_type(var.type),
+        )
+
+    def transition_guard(transition) -> Optional[str]:
+        trigger = getattr(transition, "trigger", None)
+        if not trigger:
+            return None
+        communication = getattr(trigger, "trigger", None)
+        if communication:
+            return _aadl_name(getattr(communication, "event", ""))
+        return None
+
+    def ensure_process(sm: "StateMachineDef") -> ProcessImplementation:
+        type_name = _aadl_name(sm.name)
+        impl_name = f"{type_name}.impl"
+        if impl_name in aadl_pkg.public_implementations:
+            return aadl_pkg.public_implementations[impl_name]
+
+        proc_type = ComponentType(name=type_name, category="process")
+        for ev in getattr(sm, "events", []):
+            port = convert_event(ev)
+            proc_type.features.setdefault(port.name, port)
+        register_type(proc_type)
+
+        proc_impl = ProcessImplementation(name=impl_name, type_name=type_name)
+
+        nodes = list(getattr(sm, "nodes", []) or [])
+        state_names: list[str] = []
+        initial_names: set[str] = set()
+        for idx, node in enumerate(nodes):
+            node_type = node.__class__.__name__
+            if node_type == "State":
+                raw_name = getattr(node, "name", f"state_{idx}")
+                state_names.append(_aadl_name(raw_name))
+            elif node_type == "Initial":
+                initial_names.add(_aadl_name(getattr(node, "name", "")))
+
+        state_name_set = set(state_names)
+        initial_targets: set[str] = set()
+        transitions: list[BehaviorTransition] = []
+        for t in getattr(sm, "transitions", []):
+            src = _aadl_name(getattr(t, "source", ""))
+            dst = _aadl_name(getattr(t, "target", ""))
+            if src in initial_names and dst in state_name_set:
+                initial_targets.add(dst)
+            if src in state_name_set and dst in state_name_set:
+                guard_expr = transition_guard(t)
+                guard = BehaviorGuard(guard_expr) if guard_expr else None
+                transitions.append(BehaviorTransition(source=src, destination=dst, guard=guard))
+
+        for state_name in state_names:
+            proc_impl.modes.append(Mode(name=state_name, initial=state_name in initial_targets))
+
+        if proc_impl.modes and not any(m.initial for m in proc_impl.modes):
+            proc_impl.modes[0].initial = True
+
+        subcomponent_names = set()
+        for state_name in state_names:
+            thread_type_name = _aadl_id(f"{type_name}_{state_name}_Thread")
+            thread_impl_name = f"{thread_type_name}.impl"
+            register_type(ComponentType(name=thread_type_name, category="thread"))
+            register_impl(ThreadImplementation(name=thread_impl_name, type_name=thread_type_name))
+            sub_name = _unique_name(f"{state_name}_thread", subcomponent_names)
+            subcomponent_names.add(sub_name)
+            proc_impl.subcomponents[sub_name] = Subcomponent(
+                name=sub_name,
+                category="thread",
+                component_type=thread_type_name,
+                component_implementation="impl",
+            )
+
+        for var in getattr(sm, "variables", []):
+            data_sub = convert_variable(var)
+            data_sub.name = _unique_name(data_sub.name, subcomponent_names)
+            subcomponent_names.add(data_sub.name)
+            proc_impl.subcomponents[data_sub.name] = data_sub
+
+        if transitions:
+            behavior = BehaviorSpecification(transitions=transitions)
+            proc_impl.behavior = behavior
+
+        register_impl(proc_impl)
+        return proc_impl
+
+    def connection_endpoint(component, event, subcomponents: set[str]) -> str:
+        component_name = _aadl_name(component)
+        event_name = _aadl_name(event)
+        if component_name in subcomponents:
+            return f"{component_name}.{event_name}"
+        return event_name
+
+    def convert_connection(conn, subcomponents: set[str]) -> AADLConnection:
+        src = _aadl_name(getattr(conn, "source", ""))
+        dst = _aadl_name(getattr(conn, "target", ""))
+        src_evt = _aadl_name(getattr(conn, "event_source", ""))
+        dst_evt = _aadl_name(getattr(conn, "event_target", ""))
+        name = _aadl_id(f"{src}_{src_evt}_to_{dst}_{dst_evt}")
+        return AADLConnection(
+            name=name,
+            source=connection_endpoint(conn.source, conn.event_source, subcomponents),
+            destination=connection_endpoint(conn.target, conn.event_target, subcomponents),
+            bidirectional=getattr(conn, "bidirectional", False),
+        )
+
+    def ensure_controller(controller: "ControllerDef") -> SystemImplementation:
+        type_name = _aadl_name(controller.name)
+        impl_name = f"{type_name}.impl"
+        if impl_name in aadl_pkg.public_implementations:
+            return aadl_pkg.public_implementations[impl_name]
+
+        sys_type = ComponentType(name=type_name, category="system")
+        for ev in getattr(controller, "events", []):
+            port = convert_event(ev)
+            sys_type.features.setdefault(port.name, port)
+        register_type(sys_type)
+
+        sys_impl = SystemImplementation(name=impl_name, type_name=type_name)
+        subcomponent_names = set()
+        port_subcomponents = set()
+
+        for sm in getattr(controller, "machines", []):
+            if isinstance(sm, StateMachineDef) or sm.__class__.__name__ == "StateMachineDef":
+                proc_impl = ensure_process(sm)
+                sub_name = _aadl_name(getattr(sm, "name", "process"))
+                sub_name = _unique_name(sub_name, subcomponent_names)
+                subcomponent_names.add(sub_name)
+                port_subcomponents.add(sub_name)
+                sys_impl.subcomponents[sub_name] = Subcomponent(
+                    name=sub_name,
+                    category="process",
+                    component_type=proc_impl.type_name,
+                    component_implementation="impl",
+                )
+            elif sm.__class__.__name__ == "StateMachineRef":
+                sub_name = _aadl_name(getattr(sm, "name", "process_ref"))
+                sub_name = _unique_name(sub_name, subcomponent_names)
+                subcomponent_names.add(sub_name)
+                port_subcomponents.add(sub_name)
+                sys_impl.subcomponents[sub_name] = Subcomponent(
+                    name=sub_name,
+                    category="process",
+                    component_type=_aadl_qualified_name(getattr(sm, "ref", "")),
+                )
+
+        for var in getattr(controller, "variables", []):
+            data_sub = convert_variable(var)
+            data_sub.name = _unique_name(data_sub.name, subcomponent_names)
+            subcomponent_names.add(data_sub.name)
+            sys_impl.subcomponents[data_sub.name] = data_sub
+
+        for conn in getattr(controller, "connections", []):
+            sys_impl.connections.append(convert_connection(conn, port_subcomponents))
+
+        register_impl(sys_impl)
+        return sys_impl
+
+    def ensure_robotic_platform(platform: "RoboticPlatformDef") -> SystemImplementation:
+        type_name = _aadl_name(platform.name)
+        impl_name = f"{type_name}.impl"
+        if impl_name in aadl_pkg.public_implementations:
+            return aadl_pkg.public_implementations[impl_name]
+
+        sys_type = ComponentType(name=type_name, category="system")
+        for ev in getattr(platform, "events", []):
+            port = convert_event(ev)
+            sys_type.features.setdefault(port.name, port)
+        register_type(sys_type)
+
+        sys_impl = SystemImplementation(name=impl_name, type_name=type_name)
+        subcomponent_names = set()
+
+        for var in getattr(platform, "variables", []):
+            data_sub = convert_variable(var)
+            data_sub.name = _unique_name(data_sub.name, subcomponent_names)
+            subcomponent_names.add(data_sub.name)
+            sys_impl.subcomponents[data_sub.name] = data_sub
+
+        register_impl(sys_impl)
+        return sys_impl
+
+    def ensure_module(module: "Module") -> SystemImplementation:
+        type_name = _aadl_name(module.name)
+        impl_name = f"{type_name}.impl"
+        if impl_name in aadl_pkg.public_implementations:
+            return aadl_pkg.public_implementations[impl_name]
+
+        module_type = ComponentType(name=type_name, category="system")
+        register_type(module_type)
+
+        module_impl = SystemImplementation(name=impl_name, type_name=type_name)
+        subcomponent_names = set()
+        port_subcomponents = set()
+
+        for node in getattr(module, "nodes", []):
+            node_type = node.__class__.__name__
+            if node_type == "ControllerDef":
+                controller_impl = ensure_controller(node)
+                sub_name = _aadl_name(getattr(node, "name", "controller"))
+                sub_name = _unique_name(sub_name, subcomponent_names)
+                subcomponent_names.add(sub_name)
+                port_subcomponents.add(sub_name)
+                module_impl.subcomponents[sub_name] = Subcomponent(
+                    name=sub_name,
+                    category="system",
+                    component_type=controller_impl.type_name,
+                    component_implementation="impl",
+                )
+            elif node_type == "ControllerRef":
+                sub_name = _aadl_name(getattr(node, "name", "controller_ref"))
+                sub_name = _unique_name(sub_name, subcomponent_names)
+                subcomponent_names.add(sub_name)
+                port_subcomponents.add(sub_name)
+                module_impl.subcomponents[sub_name] = Subcomponent(
+                    name=sub_name,
+                    category="system",
+                    component_type=_aadl_qualified_name(getattr(node, "ref", "")),
+                )
+            elif node_type == "StateMachineDef":
+                proc_impl = ensure_process(node)
+                sub_name = _aadl_name(getattr(node, "name", "process"))
+                sub_name = _unique_name(sub_name, subcomponent_names)
+                subcomponent_names.add(sub_name)
+                port_subcomponents.add(sub_name)
+                module_impl.subcomponents[sub_name] = Subcomponent(
+                    name=sub_name,
+                    category="process",
+                    component_type=proc_impl.type_name,
+                    component_implementation="impl",
+                )
+            elif node_type == "StateMachineRef":
+                sub_name = _aadl_name(getattr(node, "name", "process_ref"))
+                sub_name = _unique_name(sub_name, subcomponent_names)
+                subcomponent_names.add(sub_name)
+                port_subcomponents.add(sub_name)
+                module_impl.subcomponents[sub_name] = Subcomponent(
+                    name=sub_name,
+                    category="process",
+                    component_type=_aadl_qualified_name(getattr(node, "ref", "")),
+                )
+            elif node_type == "RoboticPlatformDef":
+                platform_impl = ensure_robotic_platform(node)
+                sub_name = _aadl_name(getattr(node, "name", "platform"))
+                sub_name = _unique_name(sub_name, subcomponent_names)
+                subcomponent_names.add(sub_name)
+                port_subcomponents.add(sub_name)
+                module_impl.subcomponents[sub_name] = Subcomponent(
+                    name=sub_name,
+                    category="system",
+                    component_type=platform_impl.type_name,
+                    component_implementation="impl",
+                )
+            elif node_type == "RoboticPlatformRef":
+                sub_name = _aadl_name(getattr(node, "name", "platform_ref"))
+                sub_name = _unique_name(sub_name, subcomponent_names)
+                subcomponent_names.add(sub_name)
+                port_subcomponents.add(sub_name)
+                module_impl.subcomponents[sub_name] = Subcomponent(
+                    name=sub_name,
+                    category="system",
+                    component_type=_aadl_qualified_name(getattr(node, "ref", "")),
+                )
+
+        for conn in getattr(module, "connections", []):
+            module_impl.connections.append(convert_connection(conn, port_subcomponents))
+
+        register_impl(module_impl)
+        return module_impl
+
+    # ---- top-level package conversion ----
+    for record in getattr(rc_pkg, "types", []):
+        data_name = _aadl_name(getattr(record, "name", "data"))
+        register_type(ComponentType(name=data_name, category="data"))
+
+    for ctl in getattr(rc_pkg, "controllers", []):
+        ensure_controller(ctl)
+
+    for sm in getattr(rc_pkg, "machines", []):
+        if isinstance(sm, StateMachineDef) or sm.__class__.__name__ == "StateMachineDef":
+            ensure_process(sm)
+
+    for robot in getattr(rc_pkg, "robots", []):
+        ensure_robotic_platform(robot)
+
+    for mod in getattr(rc_pkg, "modules", []):
+        ensure_module(mod)
+
+    return aadl_pkg
+
+
+def dump_aadl(rc_input: Union["Package", "Store"], output: Optional[Union[io.TextIOBase, Path, str]] = None,
+              template_name: str = "aadl",
+              messages_output: Optional[Union[io.TextIOBase, Path, str]] = None) -> str:
+    # If a Store, render all packages inside it
+    if hasattr(rc_input, "__iter__") and not isinstance(rc_input, Package):
+        robo_packages = list(rc_input.load().values())
+        packages = [robocart_package_to_aadl_full(pkg) for pkg in robo_packages]
+    else:
+        robo_packages = [rc_input]
+        packages = [robocart_package_to_aadl_full(rc_input)]
+
+    template = get_template(template_name)
+    data = template.render(packages=packages)
+    write_output(data, output)
+
+    if messages_output is None and isinstance(output, (str, Path)):
+        messages_output = Path(output).parent / "messages.aadl"
+
+    if messages_output is not None:
+        _render_messages(robo_packages, packages, messages_output)
+
+    return data

robotransform/filters.py

@@ -1,9 +1,4 @@
-def type_to_port(_type) -> str:
-    # TODO this is wrong
-    if str(_type) in {"event", }:
-        return "event"
-    return "data"
-
+from __future__ import annotations
 def type_to_aadl_type(_type) -> str:
     typename = str(_type)
     # Boolean,

robotransform/main.py

@@ -1,3 +1,4 @@
+import logging
 from dataclasses import dataclass, fields
 from functools import lru_cache
 from pathlib import Path
@@ -6,10 +7,10 @@ import arklog
 from textx import metamodel_from_str
 from jinja2 import Environment, FileSystemLoader, Template
 import io
-from typing import Union, Optional, Iterable, Iterator
+from typing import Union, Optional, Iterable, Iterator, Callable
 
 from robotransform.concepts import all_concepts, Package
-from robotransform.filters import type_to_port, type_to_aadl_type
+from robotransform.filters import type_to_aadl_type
 from robotransform.processors import processors
 
 
@@ -29,30 +30,39 @@ class Store:
                         yield item
                 continue
 
-    def parse_imports(self, package: Package, parent_path: Path, visited):
+    def parse_imports(self, package: Package, parent_path: Path, visited: dict[Path, Package]):
         stack = [package]
+        unresolved = []
         while stack:
-            package = stack.pop()
-            for imp in package.imports:
+            current_package = stack.pop()
+            for imp in current_package.imports:
                 name = imp.name.name.parts[-1]
-                if name in visited:
-                    continue
                 path = parent_path / f"{name}.rct"
+
+                if path in visited or path in unresolved:  # check path, not name
+                    continue
                 if not path.exists():
-                    arklog.debug(f"Can't import {path}.")
+                    arklog.debug(f"Can't import ({path}).")
+                    unresolved.append(path)
                     continue
+
                 sub_package = parse_robochart(path)
-                visited[path] = sub_package
+                visited[path] = sub_package  # mark visited immediately
                 stack.append(sub_package)
+
         return visited
 
     def load(self, imports: bool = True) -> dict[Path, Package]:
-        visited = {}
+        visited: dict[Path, Package] = {}
+
         for path in self:
-            package = parse_robochart(path)
-            visited[path] = package
-            if imports:
-                visited |= self.parse_imports(package, path.parent, visited)
+            if path not in visited:
+                package = parse_robochart(path)
+                visited[path] = package  # mark visited immediately
+                if imports:
+                    # parse imports recursively
+                    visited |= self.parse_imports(package, path.parent, visited)
+
         return visited
 
 
@@ -98,15 +108,13 @@ def parse_robochart(source: Path | str) -> Package:
     return metamodel.model_from_str(data)
 
 
-@lru_cache(maxsize=2)
+@lru_cache(maxsize=3)
 def get_template(name: str) -> Template:
     environment = Environment(loader=FileSystemLoader(Path(__file__).resolve().parent / "templates"))
-    environment.filters["type_to_port"] = type_to_port # For use with pipes
-    environment.filters["type_to_aadl_type"] = type_to_aadl_type # For use with pipes
-    # environment.globals["type_to_port"] = type_to_port # For use as a function
+    environment.filters["type_to_aadl_type"] = type_to_aadl_type  # For use with pipes
     templates = {
-        "messages": "messages.aadl",
-        "logical": "logical.aadl",
+        "messages": "messages.aadl.jinja",
+        "aadl": "aadl.jinja",
     }
     if found := templates.get(name):
         return environment.get_template(found)
@@ -129,18 +137,6 @@ def write_output(data: str, output: Optional[Union[io.TextIOBase, Path, str]] =
     return data
 
 
-def dump_messages(store: Store, output: Optional[Union[io.TextIOBase, Path, str]] = None) -> None:
-    template = get_template("messages")
-    output = output if output else Path("output/generated/messages/messages.aadl")
-    write_output(template.render(packages=store.load().values()), output)
-
-
-def dump_logical(store: Store, output: Optional[Union[io.TextIOBase, Path, str]] = None) -> None:
-    template = get_template("logical")
-    output = output if output else Path("output/generated/LogicalArchitecture.aadl")
-    write_output(template.render(packages=store.load().values()), output)
-
-
 def main():
     pass
 

robotransform/robochart.tx

@@ -302,7 +302,7 @@ Transition:
   'transition' name=ID '{'
     'from' source=QualifiedName
     'to' target=QualifiedName
-    trigger?=Trigger
+    (trigger=Trigger)?
     (reset*=ClockReset '<{' deadline=Expression '}')?
     ('condition' condition=ConditionExpr)?
     ('action' action=Statement)?

robotransform/templates/aadl.jinja

@@ -0,0 +1,18 @@
+{#- Render all AADL packages -#}
+{% for pkg in packages -%}
+package {{ pkg.name }}
+public
+{% if pkg.with_packages -%}
+  with {{ pkg.with_packages | join(', ') }};
+{% endif -%}
+{% for comp in pkg.public_types.values() -%}
+{{ comp.to_aadl("  ") }}
+{% endfor -%}
+{% for impl in pkg.public_implementations.values() -%}
+{{ impl.to_aadl("  ") }}
+{% endfor -%}
+end {{ pkg.name }};
+{% if not loop.last %}
+
+{% endif -%}
+{% endfor %}

robotransform/templates/{messages.aadl → messages.aadl.jinja}

@@ -11,4 +11,10 @@ public
     end {{type.name}};
     {%- endfor %}
   {%- endfor %}
+  {%- if extra_types %}
+    {%- for type_name in extra_types %}
+    data {{ type_name }}
+    end {{ type_name }};
+    {%- endfor %}
+  {%- endif %}
 end messages;

{robotransform-0.0.5.dist-info → robotransform-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotransform
-Version: 0.0.5
+Version: 0.1.0
 Summary: Perform model transformations for the RoboSapiens project.
 Keywords: transformation
 Author: Arkadiusz Michał Ryś
@@ -688,23 +688,14 @@ Requires-Dist: arkfast>=0.1.0,<1
 Requires-Dist: textx>=4.2.3,<5
 Requires-Dist: jinja2>=3.1.6,<4
 Requires-Dist: pyecore>=0.15.2,<1
-Requires-Dist: sphinx ; extra == 'doc'
-Requires-Dist: sphinx-rtd-theme ; extra == 'doc'
-Requires-Dist: sphinx-tabs ; extra == 'doc'
-Requires-Dist: sphinx-toolbox ; extra == 'doc'
-Requires-Dist: sphinxext-opengraph ; extra == 'doc'
-Requires-Dist: sphinx-notfound-page ; extra == 'doc'
-Requires-Dist: sphinxcontrib-drawio ; extra == 'doc'
-Requires-Dist: readthedocs-sphinx-search ; extra == 'doc'
-Requires-Dist: myst-parser ; extra == 'doc'
-Requires-Dist: pytest ; extra == 'test'
-Requires-Python: >=3.12
+Requires-Python: >=3.14
 Project-URL: source, https://git.rys.one/phd/robosapiens/robotransform
-Provides-Extra: doc
-Provides-Extra: test
+Provides-Extra: gui
 Description-Content-Type: text/markdown
 
 # RoboTransform
 
-Library to perform model to model transformations in the context of RoboSapiens.
+Library to perform model-to-model transformations in the context of RoboSAPIENS.
 
+For installation steps follow [the documentation](https://robotransform-0f96de.pages.rys.one/).
+We also provide [the reasoning behind certain decisions](-/jobs/artifacts/main/download?job=typst).

robotransform-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+robotransform/__init__.py,sha256=xvdDZSVP3mLi7gN7a2Qdtyvh-ZQ1YwXlIaGFvcb1Ulg,157
+robotransform/__main__.py,sha256=PcaDvzku32_BZ3c9ODZMUJKveARGID3FGOq0XA60c7o,617
+robotransform/aadl.py,sha256=tPlmiSltLSbC8kqU-FlxyDPdcdTjUT4rKHwEweFgBow,6664
+robotransform/concepts.py,sha256=MXPff6XwQyabWJcSC5armw3eI4xGDmnd6yZpmHdO6m8,9933
+robotransform/convert.py,sha256=KStKLUDAXD15j4-jzqIG-rga8c5WGB3J4URjAGuJvt0,18819
+robotransform/filters.py,sha256=uEG2xs-gvtxpmyItbXtjLeOXgCJlACbPgAL1Hi2n5iE,838
+robotransform/main.py,sha256=xrbu1Dal027VPAYSzRjHFqh7OuFHQZ_tkL_xz7lYFro,4620
+robotransform/processors.py,sha256=8NaNFTAm3iaNAzbp5D8-Uv_qIWyxVklIbmGtXi5--nM,1578
+robotransform/robochart.tx,sha256=lM4ooS8jvb949q20X4t6jZzh1M3VCtlxUORlWS3GA4w,10229
+robotransform/templates/aadl.jinja,sha256=7BHQvBPsJby5XSmiqEXd8mrQwEdSG3WPtwzcDu8WSlY,424
+robotransform/templates/messages.aadl.jinja,sha256=1EOMiBE-Lh5FWnfjSsVoICDU_-ZcgFEY1sMasXP5k00,530
+robotransform-0.1.0.dist-info/WHEEL,sha256=XV0cjMrO7zXhVAIyyc8aFf1VjZ33Fen4IiJk5zFlC3g,80
+robotransform-0.1.0.dist-info/entry_points.txt,sha256=NvmK-01oEE7ji06NbIxr7pZGUEJwbwMLjjfHssOVmB0,52
+robotransform-0.1.0.dist-info/METADATA,sha256=MwlUaGCSB2st_rvml5t5CzYM2oSmJ8U8LMNDYoYZ-h0,42259
+robotransform-0.1.0.dist-info/RECORD,,

{robotransform-0.0.5.dist-info → robotransform-0.1.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.15
+Generator: uv 0.9.26
 Root-Is-Purelib: true
-Tag: py3-none-any
+Tag: py3-none-any

robotransform/templates/logical.aadl

@@ -1,72 +0,0 @@
-{%- macro render_port(name, direction, type) -%}
-  {{ name }}: {{ direction }} {{ type | type_to_port }} port {{ type | type_to_aadl_type}};
-{%- endmacro -%}
-
-{%- macro render_node_threads(machine) -%}
-  {%- for node in machine.nodes %}
-  thread {{ node.name }}
-    features {# TODO: Replace these with real resolved fields #}
-      input:  in  data port Base_Types::Float;
-      output: out data port Base_Types::Float;
-  end {{ node.name }};
-  thread implementation {{ node.name }}.impl
-  end {{ node.name }}.impl;
-  {%- endfor %}
-{%- endmacro -%}
-
-package LogicalArchitecture
-public
-  with messages, Base_Types;
-{%- for package in packages %}
-  process {{package.name}}
-    {%- set interface_vars = package.interfaces | map(attribute="variables") | sum(start=[]) -%}
-    {%- set machine_vars = package.machines | map(attribute="variables") | sum(start=[]) -%}
-    {%- if interface_vars or machine_vars %}
-    features
-      {%- for interface in package.interfaces -%}
-        {%- for variable in interface.variables %}
-      {{ render_port(variable.name, "in",  variable.type) }}
-        {%- endfor %}
-      {%- endfor %}
-      {%- for machine in package.machines -%}
-        {%- for variable in machine.variables %}
-      {{ render_port(variable.name, "in",  variable.type) }}
-        {%- endfor %}
-      {%- endfor -%}
-      {%- endif %}
-  end {{package.name}};
-  process implementation {{package.name}}.impl
-  {%- set machines_with_nodes = package.machines | selectattr('nodes') | selectattr('nodes', '!=', []) | list %}
-    {%- if machines_with_nodes %}
-    modes
-      {%- for machine in machines_with_nodes -%}
-        {% for node in machine.nodes %}
-      {{node.name}}: mode;
-        {%- endfor %}
-      {%- endfor %}
-  {%- endif %}
-  {%- if machines_with_nodes %}
-    subcomponents
-      {%- for machine in machines_with_nodes -%}
-        {% for node in machine.nodes %}
-      {{node.name}}: thread {{node.name}}; {# TODO: Filter so not all nodes are transformed into threads #}
-        {%- endfor %}
-      {%- endfor %}
-  {%- endif %}
-  {%- set machines_with_transitions = package.machines | selectattr("transitions") | selectattr('transitions', '!=', []) | list %}
-  {%- if machines_with_transitions %}
-    connections
-      {%- for machine in machines_with_transitions -%}
-        {% for transition in machine.transitions %}
-      {{ transition.name }}: port {{ transition.source }} -> {{ transition.target }}; {# TODO: Check if these are correct #}
-        {%- endfor %}
-      {%- endfor %}
-  {%- endif %}
-  end {{package.name}}.impl;
-  {%- if machines_with_nodes %}
-    {%- for machine in machines_with_nodes -%}
-      {{ render_node_threads(machine) }}
-    {%- endfor %}
-  {%- endif %}
-{%- endfor %}
-end LogicalArchitecture;

robotransform-0.0.5.dist-info/RECORD

@@ -1,12 +0,0 @@
-robotransform/__init__.py,sha256=8IkQ3Astb5vWt6yKgB0e3FqniYWPy9wufasZR9OwXmI,166
-robotransform/concepts.py,sha256=MXPff6XwQyabWJcSC5armw3eI4xGDmnd6yZpmHdO6m8,9933
-robotransform/filters.py,sha256=E9yM36Rktb28v32F9SQg0lB9xYPB1YcR5A4o45e7PRY,936
-robotransform/main.py,sha256=afE30HpVo5weXeBO60LOpkCDS4cZ0EKo-nuD0xUG5cI,5025
-robotransform/processors.py,sha256=8NaNFTAm3iaNAzbp5D8-Uv_qIWyxVklIbmGtXi5--nM,1578
-robotransform/robochart.tx,sha256=dz_4hr-reu9ubuXdZR4WNKkp-gs_txgzyRvR-p7nphA,10227
-robotransform/templates/logical.aadl,sha256=_kvpAij37DjL4aHrizBrwG5RCO7LJXD0tkl__vCdAZU,2743
-robotransform/templates/messages.aadl,sha256=gSEULreDkIM-ukODyD1WnaV1qFTw_j5EAM2Z9u-Xkmo,383
-robotransform-0.0.5.dist-info/WHEEL,sha256=z-mOpxbJHqy3cq6SvUThBZdaLGFZzdZPtgWLcP2NKjQ,79
-robotransform-0.0.5.dist-info/entry_points.txt,sha256=NvmK-01oEE7ji06NbIxr7pZGUEJwbwMLjjfHssOVmB0,52
-robotransform-0.0.5.dist-info/METADATA,sha256=y3dPRoUqXaWAnWip65BJtH82q2LV5E4_y9uJnV_6br0,42563
-robotransform-0.0.5.dist-info/RECORD,,