robotransform 0.0.2__py3-none-any.whl

robotransform/concepts.py

@@ -0,0 +1,286 @@
+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/filters.py

@@ -0,0 +1,12 @@
+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/main.py

@@ -0,0 +1,146 @@
+from dataclasses import dataclass, fields
+from functools import lru_cache
+from pathlib import Path
+
+import arklog
+from textx import metamodel_from_str
+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
+
+
+@dataclass
+class Store:
+    packages: Iterable[Path]
+
+    def __iter__(self) -> Iterator[Path]:
+        for f in fields(self):
+            value = getattr(self, f.name)
+            if isinstance(value, Path):
+                yield value
+                continue
+            if isinstance(value, Iterable):
+                for item in value:
+                    if isinstance(item, Path):
+                        yield item
+                continue
+
+    def parse_imports(self, package: RCPackage, parent_path: Path, visited):
+        stack = [package]
+        while stack:
+            package = stack.pop()
+            for imp in package.imports:
+                name = imp.name.name.parts[-1]
+                if name in visited:
+                    continue
+                path = parent_path / f"{name}.rct"
+                if not path.exists():
+                    arklog.debug(f"Can't import {path}.")
+                    continue
+                subpkg = parse_robochart(path)
+                visited[path] = subpkg
+                stack.append(subpkg)
+        return visited
+
+    def load(self, imports: bool = True) -> dict[Path, RCPackage]:
+        visited = {}
+        for path in self:
+            package = parse_robochart(path)
+            visited[path] = package
+            if imports:
+                visited |= self.parse_imports(package, path.parent, visited)
+        return visited
+
+
+@dataclass
+class MapleKStore(Store):
+    monitor: Path
+    analysis: Path
+    plan: Path
+    legitimate: Path
+    execute: Path
+    knowledge: Path
+
+    def __init__(self, monitor: Path, analysis: Path, plan: Path, legitimate: Path, execute: Path, knowledge: Path,
+                 additional: Optional[Iterable[Path]] = None):
+        self.monitor = monitor
+        self.analysis = analysis
+        self.plan = plan
+        self.legitimate = legitimate
+        self.execute = execute
+        self.knowledge = knowledge
+        self.packages = [monitor, analysis, plan, legitimate, execute, knowledge]
+        if additional is not None:
+            self.packages += additional
+
+    def verify(self):
+        pass
+
+
+@lru_cache(maxsize=1)
+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)
+    return metamodel
+
+
+@lru_cache(maxsize=1)
+def parse_robochart(source: Path | str) -> RCPackage:
+    arklog.debug(f"Parsing ({source}).")
+    metamodel = get_robochart_metamodel()
+    data = source.read_text() if isinstance(source, Path) else source
+    return metamodel.model_from_str(data)
+
+
+@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
+    templates = {
+        "messages": "messages.aadl",
+        "logical": "logical.aadl",
+    }
+    if found := templates.get(name):
+        return environment.get_template(found)
+    else:
+        raise ValueError(f"No template found for name '{name}'")
+
+
+def write_output(data: str, output: Optional[Union[io.TextIOBase, Path, str]] = None) -> str:
+    if output is None:
+        return data
+    if isinstance(output, (str, Path)):
+        output = Path(output)
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(data)
+    elif isinstance(output, io.TextIOBase):
+        output.write(data)
+        output.flush()
+    else:
+        raise TypeError(f"Unsupported output type: {type(output)}.")
+    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
+
+
+if __name__ == "__main__":
+    main()