Attempt graphql backend

Author: marcelldls

pyproject.toml

@@ -43,6 +43,7 @@ dev = [
     "types-mock",
     "aioca",
     "p4p",
+    "strawberry-graphql[fastapi]",
 ]
 
 [project.scripts]
@@ -61,7 +62,7 @@ version_file = "src/fastcs/_version.py"
 
 [tool.pyright]
 typeCheckingMode = "standard"
-reportMissingImports = false # Ignore missing stubs in imported modules
+reportMissingImports = false  # Ignore missing stubs in imported modules
 
 [tool.pytest.ini_options]
 # Run pytest with all our checkers, and don't spam us with massive tracebacks on error

src/fastcs/backends/graphQL/backend.py

@@ -0,0 +1,14 @@
+from fastcs.backend import Backend
+from fastcs.controller import Controller
+
+from .graphQL import GraphQLServer
+
+
+class GraphQLBackend(Backend):
+    def __init__(self, controller: Controller):
+        super().__init__(controller)
+
+        self._server = GraphQLServer(self._mapping)
+
+    def _run(self):
+        self._server.run()

src/fastcs/backends/graphQL/graphQL.py

@@ -0,0 +1,213 @@
+from collections.abc import Awaitable, Callable, Coroutine
+from dataclasses import dataclass
+from types import MethodType
+from typing import Any
+
+import strawberry
+import uvicorn
+from fastapi import FastAPI
+from strawberry.asgi import GraphQL
+from strawberry.tools import create_type
+from strawberry.types.field import StrawberryField
+
+from fastcs.attributes import AttrR, AttrRW, AttrW, T
+from fastcs.controller import BaseController
+from fastcs.mapping import Mapping
+
+
+@dataclass
+class GraphQLServerOptions:
+    host: str = "localhost"
+    port: int = 8080
+    log_level: str = "info"
+
+
+class GraphQLServer:
+    def __init__(self, mapping: Mapping):
+        self._mapping = mapping
+        self._fields_tree: FieldsTree = FieldsTree("")
+        self._app = self._create_app()
+
+    def _create_app(self) -> FastAPI:
+        _add_dev_attributes(self._fields_tree, self._mapping)
+        _add_dev_commands(self._fields_tree, self._mapping)
+
+        schema_kwargs = {}
+        for key in ["query", "mutation"]:
+            if s_type := self._fields_tree.create_type(key):
+                schema_kwargs[key] = s_type
+        schema = strawberry.Schema(**schema_kwargs)  # type: ignore
+        graphql_app: GraphQL = GraphQL(schema)
+
+        app = FastAPI()
+        app.add_route("/graphql", graphql_app)
+        app.add_websocket_route("/graphql", graphql_app)
+
+        return app
+
+    def run(self, options: GraphQLServerOptions | None = None) -> None:
+        if options is None:
+            options = GraphQLServerOptions()
+
+        uvicorn.run(
+            self._app,
+            host=options.host,
+            port=options.port,
+            log_level=options.log_level,
+        )
+
+
+def _wrap_attr_set(
+    d_attr_name: str,
+    attribute: AttrW[T],
+) -> Callable[[T], Coroutine[Any, Any, None]]:
+    async def _dynamic_f(value):
+        await attribute.process_without_display_update(value)
+        return value
+
+    # Add type annotations for validation, schema, conversions
+    _dynamic_f.__name__ = d_attr_name
+    _dynamic_f.__annotations__["value"] = attribute.datatype.dtype
+    _dynamic_f.__annotations__["return"] = attribute.datatype.dtype
+
+    return _dynamic_f
+
+
+def _wrap_attr_get(
+    d_attr_name: str,
+    attribute: AttrR[T],
+) -> Callable[[], Coroutine[Any, Any, Any]]:
+    async def _dynamic_f() -> Any:
+        return attribute.get()
+
+    _dynamic_f.__name__ = d_attr_name
+    _dynamic_f.__annotations__["return"] = attribute.datatype.dtype
+
+    return _dynamic_f
+
+
+def _wrap_as_field(
+    field_name: str,
+    strawberry_type: type,
+) -> StrawberryField:
+    def _dynamic_field():
+        return strawberry_type()
+
+    _dynamic_field.__name__ = field_name
+    _dynamic_field.__annotations__["return"] = strawberry_type
+
+    return strawberry.field(_dynamic_field)
+
+
+class FieldsTree:
+    def __init__(self, name: str):
+        self.name = name
+        self.children: list[FieldsTree] = []
+        self.fields_dict: dict[str, list[StrawberryField]] = {
+            "query": [],
+            "mutation": [],
+        }
+
+    def insert(self, path: list[str]):
+        # Create child if not exist
+        name = path.pop(0)
+        if not (child := self.get_child(name)):
+            child = FieldsTree(name)
+            self.children.append(child)
+        else:
+            child = self.get_child(name)
+
+        # Recurse if needed
+        if path:
+            return child.insert(path)  # type: ignore
+        else:
+            return child
+
+    def get_child(self, name: str):
+        for child in self.children:
+            if child.name == name:
+                return child
+        return None
+
+    def create_type(self, strawberry_type: str):
+        for child in self.children:
+            child_field = _wrap_as_field(
+                child.name,
+                child.create_type(strawberry_type),
+            )
+            self.fields_dict[strawberry_type].append(child_field)
+
+        return create_type(
+            f"{self.name}{strawberry_type}", self.fields_dict[strawberry_type]
+        )
+
+
+def _add_dev_attributes(
+    fields_tree: FieldsTree,
+    mapping: Mapping,
+) -> None:
+    for single_mapping in mapping.get_controller_mappings():
+        path = single_mapping.controller.path
+        if path:
+            node = fields_tree.insert(path)
+        else:
+            node = fields_tree
+
+        if node is not None:
+            for attr_name, attribute in single_mapping.attributes.items():
+                attr_name = attr_name.title().replace("_", "")
+
+                match attribute:
+                    # mutation for server changes https://graphql.org/learn/queries/
+                    case AttrRW():
+                        node.fields_dict["query"].append(
+                            strawberry.field(_wrap_attr_get(attr_name, attribute))
+                        )
+                        node.fields_dict["mutation"].append(
+                            strawberry.mutation(_wrap_attr_set(attr_name, attribute))
+                        )
+                    case AttrR():
+                        node.fields_dict["query"].append(
+                            strawberry.field(_wrap_attr_get(attr_name, attribute))
+                        )
+                    case AttrW():
+                        node.fields_dict["mutation"].append(
+                            strawberry.mutation(_wrap_attr_set(attr_name, attribute))
+                        )
+
+
+def _wrap_command(
+    method_name: str, method: Callable, controller: BaseController
+) -> Callable[..., Awaitable[bool]]:
+    async def _dynamic_f() -> bool:
+        await MethodType(method, controller)()
+        return True
+
+    _dynamic_f.__name__ = method_name
+
+    return _dynamic_f
+
+
+def _add_dev_commands(
+    fields_tree: FieldsTree,
+    mapping: Mapping,
+) -> None:
+    for single_mapping in mapping.get_controller_mappings():
+        path = single_mapping.controller.path
+        if path:
+            node = fields_tree.insert(path)
+        else:
+            node = fields_tree
+
+        if node is not None:
+            for name, method in single_mapping.command_methods.items():
+                cmd_name = name.title().replace("_", "")
+                node.fields_dict["mutation"].append(
+                    strawberry.mutation(
+                        _wrap_command(
+                            cmd_name,
+                            method.fn,
+                            single_mapping.controller,
+                        )
+                    )
+                )

tests/backends/graphQL/test_graphQL.py

@@ -0,0 +1,74 @@
+import json
+
+import pytest
+
+from fastcs.attributes import AttrR
+from fastcs.datatypes import Bool, Float, Int
+
+
+class TestGraphQLServer:
+    @pytest.fixture(autouse=True)
+    def _server_client(self, graphQL_client):
+        self._client = graphQL_client
+
+    def client_read(self, field: str, value):
+        query = f"query {{{field}}}"
+        response = self._client.post("/graphql", json={"query": query})
+        assert response.status_code == 200
+        assert response.json()["data"] == {field: value}
+
+    def client_write(self, field: str, value):
+        mutation = f"mutation {{{field}(value: {json.dumps(value)})}}"
+        response = self._client.post("/graphql", json={"query": mutation})
+        assert response.status_code == 200
+        assert response.json()["data"] == {field: value}
+
+    def client_exec(self, field: str):
+        mutation = f"mutation {{{field}}}"
+        response = self._client.post("/graphql", json={"query": mutation})
+        assert response.status_code == 200
+        assert response.json()["data"] == {field: True}
+
+    def test_read_int(self):
+        self.client_read("ReadInt", AttrR(Int())._value)
+
+    def test_read_write_int(self):
+        self.client_read("ReadWriteInt", AttrR(Int())._value)
+        self.client_write("ReadWriteInt", AttrR(Int())._value)
+
+    def test_read_write_float(self):
+        self.client_read("ReadWriteFloat", AttrR(Float())._value)
+        self.client_write("ReadWriteFloat", AttrR(Float())._value)
+
+    def test_read_bool(self):
+        self.client_read("ReadBool", AttrR(Bool())._value)
+
+    def test_write_bool(self):
+        self.client_write("WriteBool", AttrR(Bool())._value)
+
+    # # We need to discuss enums
+    # def test_string_enum(self):
+
+    def test_big_enum(self):
+        self.client_read(
+            "BigEnum", AttrR(Int(), allowed_values=list(range(1, 18)))._value
+        )
+
+    def test_go(self):
+        self.client_exec("Go")
+
+    def test_read_child1(self):
+        query = "query { SubController01 { ReadWriteInt }}"
+        response = self._client.post("/graphql", json={"query": query})
+        assert response.status_code == 200
+        assert response.json()["data"] == {
+            "SubController01": {"ReadWriteInt": AttrR(Int())._value}
+        }
+
+    def test_read_child2(self):
+        query = "query { SubController02 { ReadWriteInt }}"
+        response = self._client.post("/graphql", json={"query": query})
+        assert response.status_code == 200
+        assert response.json()["data"] == {
+            "SubController02": {"ReadWriteInt": AttrR(Int())._value}
+        }

tests/conftest.py

@@ -8,9 +8,11 @@
 
 import pytest
 from aioca import purge_channel_caches
+from fastapi.testclient import TestClient
 
 from fastcs.attributes import AttrR, AttrRW, AttrW, Handler, Sender, Updater
-from fastcs.controller import Controller
+from fastcs.backends.graphQL.backend import GraphQLBackend
+from fastcs.controller import Controller, SubController
 from fastcs.datatypes import Bool, Float, Int, String
 from fastcs.mapping import Mapping
 from fastcs.wrappers import command, scan
@@ -49,7 +51,27 @@ class TestHandler(Handler, TestUpdater, TestSender):
     pass
 
 
+class TestSubController(SubController):
+    read_write_int: AttrRW = AttrRW(Int(), handler=TestHandler())
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @command()
+    async def go(self):
+        pass
+
+
 class TestController(Controller):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._sub_controllers: list[TestSubController] = []
+        for index in range(1, 3):
+            controller = TestSubController()
+            self._sub_controllers.append(controller)
+            self.register_sub_controller(f"SubController{index:02d}", controller)
+
     read_int: AttrR = AttrR(Int(), handler=TestUpdater())
     read_write_int: AttrRW = AttrRW(Int(), handler=TestHandler())
     read_write_float: AttrRW = AttrRW(Float())
@@ -120,3 +142,10 @@ def ioc():
     except ValueError:
         # Someone else already called communicate
         pass
+
+
+@pytest.fixture(scope="class")
+def graphQL_client():
+    app = GraphQLBackend(TestController())._server._app
+    client = TestClient(app)
+    return client