robotransform 0.0.3__tar.gz → 0.0.4__tar.gz

{robotransform-0.0.3 → robotransform-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: robotransform
-Version: 0.0.3
+Version: 0.0.4
 Summary: Perform model transformations for the RoboSapiens project.
 Keywords: transformation
 Author: Arkadiusz Michał Ryś

{robotransform-0.0.3 → robotransform-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "robotransform"
-version = "0.0.3"
+version = "0.0.4"
 description="Perform model transformations for the RoboSapiens project."
 authors = [
     {name = "Arkadiusz Michał Ryś", email = "Arkadiusz.Michal.Rys@gmail.com"},

robotransform-0.0.4/src/robotransform/concepts.py

@@ -0,0 +1,598 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Type as ClassType, Any, List, Optional, Union
+
+
+@dataclass
+class ControllerDef:
+    name: str
+    uses: List[QualifiedName]
+    provides: List[QualifiedName]
+    requires: List[QualifiedName]
+    connections: List[Connection]
+    machines: List[Union[StateMachineDef, StateMachineRef]]
+    events: List[Event]
+    operations: List[Operation]
+    variables: List[Variable]
+    parent: Any
+
+
+@dataclass
+class Connection:
+    source: QualifiedName
+    event_source: QualifiedName
+    target: QualifiedName
+    event_target: QualifiedName
+    asynchronous: bool
+    bidirectional: bool
+    parent: Any
+
+
+@dataclass
+class StateMachineRef:
+    name: str
+    ref: QualifiedName
+    parent: Any
+
+
+@dataclass
+class Operation:
+    operation: Union[OperationRef, OperationDef]
+    parent: Any
+
+
+@dataclass
+class OperationRef:
+    name: str
+    ref: QualifiedName
+    parent: Any
+
+
+@dataclass
+class Variable:
+    name: str
+    type: Type
+    parent: Any
+    initial: Optional[Expression] = None
+    modifier: Optional[VariableModifier] = None
+
+
+@dataclass
+class Expression:
+    expression: Union[ForAll, Exists, LambdaExp, Iff]
+    parent: Any
+
+
+@dataclass
+class ForAll:
+    variables: List[Variable]
+    predicate: Expression
+    parent: Any
+    suchthat: Optional[Expression]
+
+
+@dataclass
+class Exists:
+    variables: List[Variable]
+    unique: bool
+    predicate: Expression
+    parent: Any
+    suchthat: Optional[Expression]
+
+
+@dataclass
+class LambdaExp:
+    variables: List[Variable]
+    predicate: Expression
+    parent: Any
+    suchthat: Optional[Expression]
+
+
+@dataclass
+class Iff:
+    left: Implies
+    right: List[Implies]
+    parent: Any
+
+
+@dataclass
+class Implies:
+    left: Or
+    right: List[Or]
+    parent: Any
+
+
+@dataclass
+class Or:
+    left: And
+    right: List[And]
+    parent: Any
+
+
+@dataclass
+class And:
+    left: Not
+    right: List[Not]
+    parent: Any
+
+
+@dataclass
+class Not:
+    exp: Union[Not, Comp]
+    parent: Any
+
+
+@dataclass
+class Comp:
+    left: DefiniteDescription
+
+    parent: Any
+    comp: Optional[Comparison]  # TODO Unify these
+    right: Optional[DefiniteDescription]  # TODO Unify these
+    set: Optional[DefiniteDescription]  # TODO Unify these
+
+
+@dataclass
+class DefiniteDescription:
+    variables: List[Variable]
+    expression: Union[Expression, LetExpression]
+    parent: Any
+    suchthat: Optional[Expression]
+
+
+@dataclass
+class Comparison:
+    operator: str
+    right: DefiniteDescription
+    parent: Any
+
+
+@dataclass
+class LetExpression:
+    declarations: List[Declaration]
+    expression: Union[LetExpression, IfExpression]
+    parent: Any
+
+
+@dataclass
+class Declaration:
+    name: str
+    expression: Expression
+    parent: Any
+
+
+@dataclass
+class IfExpression:
+    condition: Expression
+    ifexp: Expression
+    elseexp: Expression
+    expression: TypedExpression
+    parent: Any
+
+
+@dataclass
+class TypedExpression:
+    expression: PlusMinus
+
+    parent: Any
+    type: Optional[Type]
+
+
+@dataclass
+class PlusMinus:
+    expression: MultDivMod
+    right: List[MultDivMod]
+    parent: Any
+
+
+@dataclass
+class MultDivMod:
+    expression: CatExp
+    right: List[CatExp]
+    parent: Any
+
+
+@dataclass
+class CatExp:
+    expression: Neg
+    right: List[Neg]
+    parent: Any
+
+
+@dataclass
+class Neg:
+    expression: Union[Neg, Selection]
+    parent: Any
+
+
+@dataclass
+class Selection:
+    expression: ArrayExp
+    member: List[QualifiedName]
+    parent: Any
+
+
+@dataclass
+class ArrayExp:
+    expression: CallExp
+    parameters: List[Expression]
+    parent: Any
+
+
+@dataclass
+class CallExp:
+    expression: Atomic
+    args: List[Expression]
+    parent: Any
+
+
+@dataclass
+class Atomic:  # TODO Add subs
+    value: Union[str, int, float, bool]
+    parent: Any
+
+
+@dataclass
+class Node:  # TODO Add subs
+    parent: Any
+
+
+@dataclass
+class Type:
+    source: FunctionType
+    target: Optional[Type] = None
+    parent: Any = None
+
+    def __repr__(self):
+        if self.target:
+            return f"{self.source} <-> {self.target}"
+        return f"{self.source}"
+
+@dataclass
+class Field:
+    name: str
+    type: Type
+    parent: Any
+
+
+@dataclass
+class RecordType:
+    name: str
+    fields: List[Field]
+    parent: Any
+
+@dataclass
+class Parameter:
+    name: str
+    type: Type
+    parent: Any
+
+@dataclass
+class Function:
+    name: str
+    parameters: List[Parameter]
+    type: Type
+    body: Body
+    parent: Any
+
+
+@dataclass
+class Body:
+    elements: List[BodyContent]
+    parent: Any
+
+
+@dataclass
+class BodyContent:
+    parent: Any
+
+
+@dataclass
+class Module:
+    name: str
+    connections: List[Connection]
+    nodes: List[ConnectionNode]
+    parent: Any
+
+
+@dataclass
+class VariableModifier:
+    parent: Any
+
+
+@dataclass
+class Interface:
+    name: str
+    operations: List[OperationSig]
+    events: List[Event]
+    parent: Any
+    clocks: List[Clock]
+    variables: List[Variable]
+
+
+@dataclass
+class Clock:
+    name: str
+
+
+@dataclass
+class OperationSig:
+    name: str
+    parameters: List[Parameter]
+    terminates: bool
+    parent: Any
+
+
+@dataclass
+class RoboticPlatformDef:
+    name: str
+    uses: List[QualifiedName]
+    provides: List[QualifiedName]
+    requires: List[QualifiedName]
+    operations: List[OperationSig]
+    events: List[Event]
+    parent: Any
+    variables: List[Variable]
+
+
+@dataclass
+class OperationDef:
+    name: str
+    parameters: List[Parameter]
+    terminates: str
+    preconditions: List[Expression]
+    postconditions: List[Expression]
+    uses: List[QualifiedName]
+    provides: List[QualifiedName]
+    variables: List[Variable]
+    events: List[Event]
+    nodes: List[Node]
+    transitions: List[Transition]
+    clock: List[Transition]
+    parent: Any
+
+
+@dataclass
+class Package:
+    name: QualifiedName
+    imports: List[Import]
+    controllers: List[ControllerDef]
+    modules: List[Module]
+    functions: List[Function]
+    types: List[RecordType]
+    machines: List[StateMachineDef]
+    interfaces: List[Interface]
+    robots: List[RoboticPlatformDef]
+    operations: List[OperationDef]
+
+
+@dataclass
+class ConnectionNode:  # TODO add subs
+    parent: Any
+
+
+@dataclass
+class QualifiedName:
+    parts: List[str]
+    parent: Any
+
+    def __hash__(self):
+        return hash(str(self.parts))
+
+    def __repr__(self):
+        return "::".join(self.parts)
+
+
+@dataclass
+class StateMachineDef:
+    name: str
+    uses: List[QualifiedName]
+    provides: List[QualifiedName]
+    requires: List[QualifiedName]
+    events: List[Event]
+    nodes: List[Node]
+    transitions: List[Transition]
+    clocks: List[Clock]
+    parent: Any
+    variables: List[Variable]
+
+
+@dataclass
+class Transition:
+    name: str
+    source: QualifiedName
+    target: QualifiedName
+
+    reset: List[ClockReset]
+
+    parent: Any
+    trigger: Optional[Trigger]
+    deadline: Optional[Expression]
+    condition: Optional[ConditionExpr]
+    action: Optional[Statement]
+
+
+@dataclass
+class ConditionExpr:  # TODO
+    parent: Any
+
+
+@dataclass
+class Statement:
+    statements: List[EndStatement]
+    parent: Any
+
+
+@dataclass
+class EndStatement:  # TODO
+    parent: Any
+    deadline: Optional[Expression]
+
+
+@dataclass
+class ClockReset:
+    clock: QualifiedName
+    parent: Any
+
+
+@dataclass
+class Trigger:
+    trigger: Communication
+    probability: Expression
+    parent: Any
+
+
+@dataclass
+class CommunicationStmt:
+    communication: Communication
+    parent: Any
+
+
+@dataclass
+class Communication:
+    event: QualifiedName
+    source: QualifiedName
+    predicate: List[Expression]
+    type: Union[InputType, OutputType, SyncType]
+    parent: Any
+
+
+@dataclass
+class InputType:
+    parameter: QualifiedName
+    parent: Any
+
+
+@dataclass
+class OutputType:
+    value: CallExp
+    parent: Any
+
+
+@dataclass
+class SyncType:
+    value: CallExp
+    parent: Any
+
+
+@dataclass
+class QualifiedNameWithWildcard:
+    name: QualifiedName
+    parent: Any
+
+    def __hash__(self):
+        return hash(str(self.name))
+
+    def __repr__(self):
+        return str(self.name) + "::*"
+
+
+@dataclass
+class Import:
+    name: QualifiedNameWithWildcard
+    parent: Any
+
+    def __repr__(self):
+        return str(self.name)
+
+
+@dataclass
+class FunctionType:
+    source: ProductType
+    parent: Any
+    target: Optional[FunctionType]
+    # added by processor
+    source_chain: list = field(default_factory=list)
+    final_target: Any = None
+
+    def __repr__(self):
+        if self.target:
+            return f"{self.source} -> {self.target}"
+        return f"{self.source}"
+
+
+@dataclass
+class SetType:
+    domain: Type
+    parent: Any
+
+
+@dataclass
+class AnyType:
+    identifier: str
+    parent: Any
+
+
+@dataclass
+class TypeRef:
+    type: Union[SetType, SeqType, AnyType, Type, QualifiedName]
+    parent: Any
+
+    def __repr__(self):
+        return f"{self.type}"
+
+
+@dataclass
+class VectorDef:
+    base: Type
+    size: int # TODO Add processor to set this to into from Atomic
+    parent: Any
+
+
+@dataclass
+class MatrixDef:
+    base: Type
+    rows: Atomic
+    columns: Atomic
+    parent: Any
+
+
+@dataclass
+class VectorType:
+    source: Union[VectorDef, MatrixDef, TypeRef]
+    parent: Any
+
+    def __repr__(self):
+        return f"{self.source}"
+
+
+@dataclass
+class ProductType:
+    types: List[Union[VectorType, TypeRef]]
+    flat_types: List[VectorType] = field(default_factory=list)
+    parent: Any = None
+
+    def __repr__(self):
+        if len(self.types) > 1:
+            joined = "*".join(map(str, self.types))
+            return f"{joined}]"
+        return f"{self.types[0]}"
+
+
+@dataclass
+class SeqType:
+    domain: Type
+    parent: Any
+
+    def __repr__(self):
+        return f"Seq({self.domain})"
+
+
+@dataclass
+class Event:
+    name: str
+    broadcast: bool
+    type: Type
+    parent: Any
+
+    def __repr__(self):
+        return f"Event: {self.name} {self.broadcast, self.type}"
+
+
+def all_concepts() -> List[ClassType]:
+    import inspect
+    return [
+        obj for _, obj in globals().items()
+        if inspect.isclass(obj) and obj.__module__ == __name__
+    ]

robotransform-0.0.4/src/robotransform/filters.py

@@ -0,0 +1,29 @@
+def type_to_port(type) -> str:
+    # TODO this is wrong
+    typename = str(type)
+    data_types = {"int", "integer", "real", "float", "double", "string"}
+    mixed_types = {"event_data", "event data"}
+
+    if typename in data_types:
+        return "data"
+    if typename in mixed_types:
+        return "event data"
+    return "data"
+
+def type_to_aadl_type(type) -> str:
+    typename = str(type)
+    # Boolean,
+    # Character,
+    # Float, Float_32, Float_64,
+    # Integer, Integer_8, Integer_16, Integer_32, Integer_64,
+    # Natural,
+    # String,
+    # Unsigned_8, Unsigned_16, Unsigned_32, Unsigned_64
+    mapping = {
+        "boolean": "Base_Types::Boolean",
+        "nat": "Base_Types::Natural",
+        "real": "Base_Types::Float",
+    }
+    # TODO Seq -> Array[...]
+    # TODO Matrix to Array[Array[...]]
+    return mapping.get(typename, f"messages::{typename}")

{robotransform-0.0.3 → robotransform-0.0.4}/src/robotransform/main.py

@@ -8,8 +8,9 @@ from jinja2 import Environment, FileSystemLoader, Template
 import io
 from typing import Union, Optional, Iterable, Iterator
 
-from robotransform.concepts import all_concepts, RCPackage
-from robotransform.filters import typename_to_port
+from robotransform.concepts import all_concepts, Package
+from robotransform.filters import type_to_port, type_to_aadl_type
+from robotransform.processors import processors
 
 
 @dataclass
@@ -28,7 +29,7 @@ class Store:
                         yield item
                 continue
 
-    def parse_imports(self, package: RCPackage, parent_path: Path, visited):
+    def parse_imports(self, package: Package, parent_path: Path, visited):
         stack = [package]
         while stack:
             package = stack.pop()
@@ -45,7 +46,7 @@ class Store:
                 stack.append(sub_package)
         return visited
 
-    def load(self, imports: bool = True) -> dict[Path, RCPackage]:
+    def load(self, imports: bool = True) -> dict[Path, Package]:
         visited = {}
         for path in self:
             package = parse_robochart(path)
@@ -85,11 +86,12 @@ def get_robochart_metamodel(name: str = "robochart.tx"):
     arklog.debug(f"Loading ({name}) metamodel.")
     metamodel_path = Path(__file__).resolve().parent / name
     metamodel = metamodel_from_str(metamodel_path.read_text(), classes=all_concepts(), memoization=True)
+    metamodel.register_obj_processors(processors)
     return metamodel
 
 
 @lru_cache(maxsize=1)
-def parse_robochart(source: Path | str) -> RCPackage:
+def parse_robochart(source: Path | str) -> Package:
     arklog.debug(f"Parsing ({source}).")
     metamodel = get_robochart_metamodel()
     data = source.read_text() if isinstance(source, Path) else source
@@ -99,8 +101,9 @@ def parse_robochart(source: Path | str) -> RCPackage:
 @lru_cache(maxsize=2)
 def get_template(name: str) -> Template:
     environment = Environment(loader=FileSystemLoader(Path(__file__).resolve().parent / "templates"))
-    environment.filters["typename_to_port"] = typename_to_port # For use with pipes
-    # environment.globals["typename_to_port"] = typename_to_port # For use as a function
+    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
     templates = {
         "messages": "messages.aadl",
         "logical": "logical.aadl",
@@ -108,7 +111,7 @@ def get_template(name: str) -> Template:
     if found := templates.get(name):
         return environment.get_template(found)
     else:
-        raise ValueError(f"No template found for name '{name}'")
+        raise ValueError(f"No template found for name ({name}).")
 
 
 def write_output(data: str, output: Optional[Union[io.TextIOBase, Path, str]] = None) -> str:
@@ -122,7 +125,7 @@ def write_output(data: str, output: Optional[Union[io.TextIOBase, Path, str]] =
         output.write(data)
         output.flush()
     else:
-        raise TypeError(f"Unsupported output type: {type(output)}.")
+        raise TypeError(f"Unsupported output type ({type(output)}).")
     return data
 
 

robotransform-0.0.4/src/robotransform/processors.py

@@ -0,0 +1,59 @@
+from robotransform.concepts import Variable, VectorDef, MatrixDef, TypeRef
+
+
+def flatten_function_type(function_type):
+    current = function_type
+    linear = []
+
+    while current is not None:
+        linear.append(current.source)
+        current = current.target
+
+    function_type.source_chain = linear[:-1]
+    function_type.final_target = linear[-1]
+    return function_type
+
+
+def flatten_product_type(obj):
+    flat = [obj.types[0]] if obj.types else []
+    for t in obj.types[1:]:
+        flat.append(t)
+    obj.flat_types = flat
+    return obj
+
+
+def flatten_variable_list(var_list_obj):
+    flat_vars = []
+    for variable in var_list_obj.variables:
+        variable.modifier = var_list_obj.modifier
+        flat_vars.append(variable)
+    assert (len(flat_vars) == 1)  # TODO Is this always the case?
+    return flat_vars[0]
+
+
+def flatten_vector_type(obj):
+    if isinstance(obj.source, VectorDef):
+        obj.flattened = [obj.source.base]
+    elif isinstance(obj.source, MatrixDef):
+        obj.flattened = [obj.source.base]
+    elif isinstance(obj.source, TypeRef):
+        obj.flattened = [obj.source.type]
+    return obj
+
+
+def convert_variable_no_init(variable_no_init):
+    return Variable(
+        name=variable_no_init.name,
+        type=variable_no_init.type,
+        initial=None,
+        parent=variable_no_init.parent
+    )
+
+
+processors = {
+    "ProductType": flatten_product_type,
+    "FunctionType": flatten_function_type,
+    "VariableList": flatten_variable_list,
+    "VariableNoInit": convert_variable_no_init,
+    "VectorType": flatten_vector_type,
+}

{robotransform-0.0.3 → robotransform-0.0.4}/src/robotransform/robochart.tx

@@ -1,4 +1,4 @@
-RCPackage:
+Package:
   'package' name=QualifiedName? (
     'diagram' ID
     | imports+=Import
@@ -9,7 +9,7 @@ RCPackage:
     | machines+=StateMachineDef
     | operations+=OperationDef
     | functions+=Function
-    | modules+=RCModule
+    | modules+=Module
   )*
 ;
 
@@ -19,12 +19,12 @@ Import: 'import' name=QualifiedNameWithWildcard;
 
 QualifiedNameWithWildcard: name=QualifiedName ('::*')?;
 
-RCModule:
+Module:
   'module' name=ID '{' (connections+=Connection | nodes+=ConnectionNode)* '}'
 ;
 
 Connection:
-  'connection' from=QualifiedName 'on' efrom=QualifiedName 'to' to=QualifiedName 'on' eto=QualifiedName ('(' async?='_async' ')')? ('[' bidirec?='mult' ']')?
+  'connection' source=QualifiedName 'on' event_source=QualifiedName 'to' target=QualifiedName 'on' event_target=QualifiedName ('(' asynchronous?='_async' ')')? ('[' bidirectional?='mult' ']')?
 ;
 
 ConnectionNode: Controller | StateMachine | RoboticPlatform;
@@ -51,7 +51,7 @@ VariableList:
 VariableModifier: 'var' | 'const';
 
 Variable:
-  name=ID ':' kind=Type ('=' initial=Expression)?
+  name=ID ':' type=Type ('=' initial=Expression)?
 ;
 
 Type: source=FunctionType ('<->' target=Type)?;
@@ -70,7 +70,7 @@ VectorDef: 'vector' '(' base=Type ',' size=Atomic ')';
 
 MatrixDef: 'matrix' '(' base=Type ',' rows=Atomic ',' columns=Atomic ')';
 
-TypeRef: kind=SetType | kind=SeqType | kind=AnyType | '(' kind=Type ')' | kind=QualifiedName;
+TypeRef: type=SetType | type=SeqType | type=AnyType | '(' type=Type ')' | type=QualifiedName;
 
 SetType: 'Set(' domain=Type ')';
 
@@ -101,7 +101,7 @@ Atomic:
   | TupleExp
 ;
 
-TypeLit: kind=QualifiedName '::' literal=QualifiedName;
+TypeLit: type=QualifiedName '::' literal=QualifiedName;
 EqualDelim: '<' (values+=PlusMinus[','])? '>';
 
 RefExp:
@@ -117,14 +117,22 @@ FieldDefinition:
 ;
 
 Expression:
+  expression=ForAll
+  | expression=Exists
+  | expression=LambdaExp
+  | expression=Iff
+;
+
+ForAll:
   'forall' variables+=VariableNoInit[','] ('|' suchthat=Expression)? '@' predicate=Expression
-  | ('exists' | unique?='exists1') variables+=VariableNoInit[','] ('|' suchthat=Expression)? '@' predicate=Expression
-  | LambdaExp
-  | Iff
+;
+
+Exists:
+  ('exists' | unique?='exists1') variables+=VariableNoInit[','] ('|' suchthat=Expression)? '@' predicate=Expression
 ;
 
 VariableNoInit:
-  name=ID ':' kind=Type
+  name=ID ':' type=Type
 ;
 
 LambdaExp:
@@ -151,7 +159,7 @@ Not:
   'not' exp=Not | exp=Comp
 ;
 
-Comp: left=DefiniteDescription (Comparison right=DefiniteDescription | 'in' set=DefiniteDescription)*;
+Comp: left=DefiniteDescription (comp=Comparison right=DefiniteDescription | 'in' set=DefiniteDescription)*;
 
 DefiniteDescription:
   'the' variables+=VariableNoInit[','] ('|' suchthat=Expression)? '@' expression=DefiniteDescription
@@ -164,7 +172,7 @@ LetExpression:
 ;
 
 Declaration:
-  name=ID '==' value=Expression
+  name=ID '==' expression=Expression
 ;
 
 IfExpression:
@@ -173,7 +181,7 @@ IfExpression:
 ;
 
 TypedExpression:
-  expression=PlusMinus ('as' kind=Type | 'is' kind=Type)?
+  expression=PlusMinus ('as' type=Type | 'is' type=Type)?
 ;
 
 PlusMinus:
@@ -188,7 +196,7 @@ CatExp:
   expression=Neg ('cat' right=Neg | '^' right=Neg)*
 ;
 
-Neg: '-' exp=Neg | exp=Selection;
+Neg: '-' expression=Neg | expression=Selection;
 
 Selection:
   expression=ArrayExp ('.' member=QualifiedName)*
@@ -227,18 +235,18 @@ TupleExp:
 ;
 
 Comparison:
-  '==' right=DefiniteDescription
-  | '!=' right=DefiniteDescription
-  | '>'  right=DefiniteDescription
-  | '>=' right=DefiniteDescription
-  | '<'  right=DefiniteDescription
-  | '<=' right=DefiniteDescription
-  | 'in' set=DefiniteDescription
+  operator='==' right=DefiniteDescription
+  | operator='!=' right=DefiniteDescription
+  | operator='>'  right=DefiniteDescription
+  | operator='>=' right=DefiniteDescription
+  | operator='<'  right=DefiniteDescription
+  | operator='<=' right=DefiniteDescription
+  | operator='in' set=DefiniteDescription
 ;
 
-Event: broadcast?='_broadcast'? 'event' name=ID (':' kind=Type)?;
+Event: broadcast?='_broadcast'? 'event' name=ID (':' type=Type)?;
 
-Operation: OperationRef | OperationDef;
+Operation: operation=OperationRef | operation=OperationDef;
 
 OperationDef:
   'operation' name=ID '(' (parameters+=Parameter[','])? ')' '{' (
@@ -258,14 +266,14 @@ OperationDef:
 ;
 
 Parameter:
-  name=ID ':' kind=Type
+  name=ID ':' type=Type
 ;
 
 Node: State | Initial | Junction | Final | ProbabilisticJunction;
 
 State:
   'state' name=ID '{'
-    body=StateBody
+    body=Body
     //(
     //  nodes+=Node
     //  | transitions+=Transition
@@ -273,10 +281,6 @@ State:
     //)*
   '}'
 ;
-StateBody: elements*=StateBodyContent;
-StateBodyContent: /[^{}]+/ | NestedStateBlock;
-NestedStateBlock: '{' body=StateBody '}';
-
 
 Initial:
   'initial' name=QualifiedName
@@ -312,23 +316,23 @@ Communication:
   (
     '[|'
     (
-      _from=QualifiedName '=' 'from'
-      ( '|]' | '|' _predicate=Expression '|]' )
-      | _predicate=Expression? '|]'
+      source=QualifiedName '=' 'from'
+      ( '|]' | '|' predicate=Expression '|]' )
+      | predicate=Expression? '|]'
     )
   )?
   (
-    kind=InputType parameter=QualifiedName
-    | kind=OutputType value=CallExp
-    | kind=SyncType value=CallExp
+    type=InputType
+    | type=OutputType
+    | type=SyncType
   )?
 ;
 
-InputType: '?';
+InputType: '?' parameter=QualifiedName;
 
-OutputType: '!';
+OutputType: '!' value=CallExp;
 
-SyncType: '.';
+SyncType: '.' value=CallExp;
 
 ClockReset: '#' clock=QualifiedName;
 
@@ -413,7 +417,7 @@ StateMachine: StateMachineDef | StateMachineRef;
 StateMachineDef:
   'stm' name=ID '{'
     (
-      'uses' interfaces+=QualifiedName[',']
+      'uses' uses+=QualifiedName[',']
       | 'provides' provides+=QualifiedName[',']
       | 'requires' requires+=QualifiedName[',']
       | variables+=VariableList
@@ -474,7 +478,7 @@ RecordType:
 ;
 
 Field:
-  name=ID ':' kind=Type
+  name=ID ':' type=Type
 ;
 
 Enumeration:
@@ -493,14 +497,14 @@ NamedExpression:
 
 // TODO The FunctionBody is there to parse all contents of the function and replaces the pre and post condition parsing to simplify the translation to textx
 Function:
-  'function' name=ID '(' (parameters+=Parameter[','])? ')' ':' kind=Type
-  '{' body=FunctionBody
+  'function' name=ID '(' (parameters+=Parameter[','])? ')' ':' type=Type
+  '{' body=Body
     //( 'precondition' preconditions+=Expression | 'postcondition' postconditions+=Expression)*
   '}'
 ;
-FunctionBody: elements*=FunctionBodyContent;
-FunctionBodyContent: /[^{}]+/ | NestedBlock;
-NestedBlock: '{' body=FunctionBody '}';
+Body: elements*=BodyContent;
+BodyContent: /[^{}]+/ | NestedBlock;
+NestedBlock: '{' body=Body '}';
 
 Comment:
   /\/\/.*$/

{robotransform-0.0.3 → robotransform-0.0.4}/src/robotransform/templates/logical.aadl

@@ -1,5 +1,5 @@
-{%- macro render_port(name, direction, typename) -%}
-  {{ name }}: {{ direction }} {{ typename | typename_to_port }} port messages::{{ typename }};
+{%- macro render_port(name, direction, type) -%}
+  {{ name }}: {{ direction }} {{ type | type_to_port }} port {{ type | type_to_aadl_type}};
 {%- endmacro -%}
 
 {%- macro render_state_threads(machine) -%}
@@ -19,7 +19,7 @@ end {{ state.name }}.impl;
 
 package LogicalArchitecture
 public
-  with messages, Base_Types, MBED;
+  with messages, Base_Types;
 {%- for package in packages %}
   process {{package.name}}
     {%- set interface_vars = package.interfaces | map(attribute="variables") | sum(start=[]) -%}
@@ -28,12 +28,12 @@ public
     features
       {%- for interface in package.interfaces -%}
         {%- for variable in interface.variables %}
-      {{ render_port(variable.name, 'in',  variable.type) }}
+      {{ 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) }}
+      {{ render_port(variable.name, "in",  variable.type) }}
         {%- endfor %}
       {%- endfor -%}
       {%- endif %}

robotransform-0.0.4/src/robotransform/templates/messages.aadl

@@ -0,0 +1,14 @@
+package messages
+public
+  with Base_Types, Data_Model;
+  {%- for package in packages %}
+    {%- for type in package.types %}
+    data {{ type.name }}
+      features
+        {%- for field in type.fields %}
+        {{ field.name }}: provides data access {{ field.type | type_to_aadl_type }};
+        {%- endfor %}
+    end {{type.name}};
+    {%- endfor %}
+  {%- endfor %}
+end messages;

robotransform-0.0.3/src/robotransform/concepts.py

@@ -1,286 +0,0 @@
-from __future__ import annotations
-from typing import Type as ClassType, Any, List, Optional, Union
-
-
-# TODO Flatten this a little bit
-
-class Node:
-    def __init__(self, parent: Optional[Any] = None):
-        self.parent = parent
-
-
-class ControllerDef(Node):
-    def __init__(self, name, uses, provides, requires, connections, machines, events, operations, variables,
-                 parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.uses = uses
-        self.provides = provides
-        self.requires = requires
-        self.connections = connections
-        self.machines = machines
-        self.events = events
-        self.operations = operations
-        self.variables = variables
-
-    def __repr__(self):
-        use_count = len(self.uses)
-        provide_count = len(self.provides)
-        require_count = len(self.requires)
-        connection_count = len(self.connections)
-        machine_count = len(self.machines)
-        event_count = len(self.events)
-        operation_count = len(self.operations)
-        variable_count = len(self.variables)
-        return f"{self.name}: ({use_count} uses), ({provide_count} provides), ({require_count} requires), ({connection_count} connections), ({machine_count} machines, ({event_count} events), ({operation_count} operations), ({variable_count} variables)"
-
-
-class Variable(Node):
-    def __init__(self, name: str, kind, initial, parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.type = kind
-        self.initial = initial
-
-
-class Type(Node):
-    def __init__(self, source: FunctionType, target: Optional[Type], parent: Any):
-        super().__init__(parent)
-        self.source = source
-        self.target = target
-
-    def __repr__(self):
-        if self.target:
-            return f"{self.source} <-> {self.target}"
-        return f"{self.source}"
-
-
-class Field(Node):
-    def __init__(self, name: str, kind: Type, parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.type = kind
-
-    @property
-    def typename(self) -> str:
-        return str(self.type)
-
-    def __repr__(self):
-        return f"{self.name}[{self.type}]"
-
-
-class RecordType(Node):
-    def __init__(self, name: str, fields: List[Field], parent: Any):
-        # Can be datatype or record
-        super().__init__(parent)
-        self.name = name
-        self.fields = fields
-
-    def __repr__(self):
-        return f"{self.name}({self.fields})"
-
-
-class Function(Node):
-    def __init__(self, name: str, parameters, kind, body, parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.parameters = parameters
-        self.kind = kind
-        self.body = body
-
-
-class RCModule(Node):
-    def __init__(self, name: str, connections, nodes, parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.connections = connections
-        self.nodes = nodes
-
-
-class VariableList(Node):
-    def __init__(self, modifier, variables, parent: Any):
-        super().__init__(parent)
-        self.modifier = modifier
-        self.variables = variables
-
-
-class Interface(Node):
-    def __init__(self, name: str, operations, events, variables: List[VariableList], clocks, parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.operations = operations
-        self.events = events
-        self._variables = variables
-        self.clocks = clocks
-
-    @property
-    def variables(self) -> List[Variable]:
-        return [var for v in self._variables for var in v.variables]
-
-
-class RoboticPlatformDef(Node):
-    def __init__(self, name: str, uses, provides, requires, variables, operations, events, parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.uses = uses
-        self.provides = provides
-        self.requires = requires
-        self._variables = variables
-        self.operations = operations
-        self.events = events
-
-    @property
-    def variables(self) -> List[Variable]:
-        return [var for v in self._variables for var in v.variables]
-
-
-class OperationDef(Node):
-    def __init__(self, name: str, parent: Any):
-        super().__init__(parent)
-        self.name = name
-
-
-class RCPackage(Node):
-    def __init__(self, name: QualifiedName, imports: List[Import], controllers: List[ControllerDef],
-                 modules: List[RCModule], functions: List[Function], types: List[RecordType],
-                 machines: List[StateMachineDef], interfaces: List[Interface], robots: List[RoboticPlatformDef],
-                 operations: List[OperationDef]):
-        super().__init__()
-        self.name = name
-        self.imports = imports
-        self.controllers = controllers
-        self.modules = modules
-        self.functions = functions
-        self.types = types
-        self.machines = machines
-        self.interfaces = interfaces
-        self.robots = robots
-        self.operations = operations
-
-    def __repr__(self):
-        return f"{self.name}"
-
-
-class QualifiedName(Node):
-    def __init__(self, parts: List[str], parent: Any):
-        super().__init__(parent)
-        self.parts = parts
-
-    def __repr__(self):
-        return "".join(self.parts)
-
-
-class StateMachineDef(Node):
-    def __init__(self, name, interfaces, provides, requires, variables, events, nodes, transitions, clocks,
-                 parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.interfaces = interfaces
-        self.provides = provides
-        self.requires = requires
-        self._variables = variables
-        self.events = events
-        self.nodes = nodes
-        self.clocks = clocks
-        self.transitions = transitions
-
-    @property
-    def variables(self) -> List[Variable]:
-        return [var for v in self._variables for var in v.variables]
-
-
-class Transition(Node):
-    def __init__(self, name, source, target, trigger, reset, deadline, condition, action, parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.source = source
-        self.target = target
-
-
-class QualifiedNameWithWildcard(Node):
-    def __init__(self, name, parent: Any):
-        super().__init__(parent)
-        self.name = name
-
-    def __repr__(self):
-        return str(self.name) + "::*"
-
-
-class Import(Node):
-    def __init__(self, name, parent: Any):
-        super().__init__(parent)
-        self.name = name
-
-    def __repr__(self):
-        return str(self.name)
-
-
-class FunctionType(Node):
-    def __init__(self, source: ProductType, target: Optional[FunctionType], parent: Any):
-        super().__init__(parent)
-        self.source = source
-        self.target = target
-
-    def __repr__(self):
-        if self.target:
-            return f"{self.source} -> {self.target}"
-        return f"{self.source}"
-
-
-class TypeRef(Node):
-    def __init__(self, kind, parent: Any):
-        super().__init__(parent)
-        self.type = kind
-
-    def __repr__(self):
-        return f"{self.type}"
-
-
-class VectorType(Node):
-    # def __init__(self, source: Union[VectorDef, MatrixDef, TypeRef], parent: Any):
-    def __init__(self, source: Union[TypeRef], parent: Any):
-        super().__init__(parent)
-        self.source = source
-
-    def __repr__(self):
-        return f"{self.source}"
-
-
-class ProductType(Node):
-    def __init__(self, types: List[Union[VectorType, TypeRef]], parent: Any):
-        super().__init__(parent)
-        self.types = types
-
-    def __repr__(self):
-        if len(self.types) > 1:
-            joined = "*".join(map(str, self.types))
-            return f"{joined}]"
-        return f"{self.types[0]}"
-
-
-class SeqType(Node):
-    def __init__(self, domain, parent: Any):
-        super().__init__(parent)
-        self.domain = domain
-
-    def __repr__(self):
-        return f"Seq({self.domain})"
-
-
-class Event(Node):
-    def __init__(self, name: str, broadcast: bool, kind: Type, parent: Any):
-        super().__init__(parent)
-        self.name = name
-        self.broadcast = broadcast
-        self.type = kind
-
-    def __repr__(self):
-        return f"Event: {self.name} {self.broadcast, self.type}"
-
-
-def all_concepts() -> List[ClassType]:
-    import inspect
-    return [
-        obj for _, obj in globals().items()
-        if inspect.isclass(obj) and obj.__module__ == __name__
-    ]

robotransform-0.0.3/src/robotransform/filters.py

@@ -1,12 +0,0 @@
-def typename_to_port(type_name: str) -> str:
-    event_types = {"event"}
-    data_types = {"int", "integer", "real", "float", "double", "string"}
-    mixed_types = {"event_data", "event data"}
-
-    if type_name in event_types:
-        return "event"
-    if type_name in data_types:
-        return "data"
-    if type_name in mixed_types:
-        return "event data"
-    return "data"

robotransform-0.0.3/src/robotransform/templates/messages.aadl

@@ -1,27 +0,0 @@
-package messages
-public
-  with Base_Types, Data_Model;
-  {%- for package in packages %}
-    {%- for type in package.types %}
-    data {{ type.name }}
-      features
-        {%- for field in type.fields %}
-          {%- if field.typename in ['real', 'float', 'double'] %}
-        {{ field.name }}: provides data access Base_Types::Float_64;
-          {%- elif field.typename in ['int', 'integer', 'long'] %}
-        {{ field.name }}: provides data access Base_Types::Integer_64;
-          {%- elif field.typename in ['bool', 'boolean'] %}
-        {{ field.name }}: provides data access Base_Types::Boolean;
-          {%- elif field.typename in ['string', 'text'] %}
-        {{ field.name }}: provides data access Data_Model::String;
-          {%- elif field.typename in ['byte', 'bytes'] %}
-        {{ field.name }}: provides data access Base_Types::Unsigned_8;
-          {%- else %}
-        -- Unknown type '{{ field.typename }}'; adjust mapping
-        {{ field.name }}: provides data access Data_Model::Generic_Type;
-          {%- endif %}
-        {%- endfor %}
-    end {{type.name}};
-    {%- endfor %}
-  {%- endfor %}
-end messages;