boostrap framework

evolver/adapter/demo.py

@@ -0,0 +1,8 @@
+from evolver.adapter.interface import Adapter
+
+
+class NoOpAdapter(Adapter):
+    ncalls = 0
+
+    def react(self):
+        self.ncalls += 1

evolver/adapter/interface.py

@@ -0,0 +1,14 @@
+import pydantic
+from abc import ABC, abstractmethod
+
+
+class Adapter(ABC):
+    class Config(pydantic.BaseModel):
+        pass
+
+    def __init__(self, evolver, config: Config = None):
+        self.config = config or self.Config()
+
+    @abstractmethod
+    def react(self):
+        pass

evolver/app/main.py

@@ -1,16 +1,61 @@
+import asyncio
 from fastapi import FastAPI
-from fastapi.responses import RedirectResponse
-
+from evolver.device import Evolver, EvolverConfig
 from .. import __project__, __version__
 
+
 app = FastAPI()
+evolver = Evolver()
 
 
 @app.get("/")
-async def root():
-    return RedirectResponse(url='/docs')
+async def describe_evolver():
+    return {
+        'config': evolver.config,
+        'state': evolver.state,
+        'last_read': evolver.last_read,
+    }
+
+
+@app.get('/state')
+async def get_state():
+    return {
+        'state': evolver.state,
+        'last_read': evolver.last_read,
+    }
+
+
+@app.post("/")
+async def update_evolver(config: EvolverConfig):
+    evolver.update_config(config)
+
+
+@app.get('/schema')
+async def get_schema():
+    return evolver.schema
+
+
+@app.get('/history/{name}')
+async def get_history(name: str):
+    return evolver.history.get(name)
 
 
 @app.get("/healthz")
 async def healthz():
     return {"message": f"Running '{__project__}' ver: '{__version__}'"}
+
+
+async def evolver_async_loop():
+    while True:
+        evolver.loop_once()
+        await asyncio.sleep(evolver.config.interval)
+
+
+@app.on_event('startup')
+async def start_evolver_loop():
+    asyncio.create_task(evolver_async_loop())
+
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=8000, log_level="info")

evolver/app/tests/conftest.py

@@ -1,6 +1,5 @@
 import pytest
 from fastapi.testclient import TestClient
-
 from ..main import app  # Leave as relative for use in template: ssec-jhu/base-template.
 
 

evolver/app/tests/test_app.py

@@ -11,3 +11,22 @@ def test_healthz(self, app_client):
         assert response.status_code == 200
         if __version__:
             assert __version__ in response.json()["message"], response.json()
+
+    def test_evolver_app_default_config_dump_endpoint(self, app_client):
+        response = app_client.get('/')
+        assert response.status_code == 200
+        assert sorted(response.json().keys()) == ['config', 'last_read', 'state']
+
+    def test_evolver_update_config_endpoint(self, app_client):
+        data = {'hardware': {'test': {'driver': 'evolver.hardware.demo.NoOpSensorDriver'}}}
+        response = app_client.post('/', json=data)
+        assert response.status_code == 200
+        newconfig = app_client.get('/').json()['config']
+        assert newconfig['hardware']['test']['driver'] == 'evolver.hardware.demo.NoOpSensorDriver'
+
+    def test_evolver_app_react_loop_setup(self, app_client):
+        # The context manager ensures that startup event loop is called
+        # TODO: check results generated in react (may require hardware at startup, or forced execution of loop)
+        with app_client as client:
+            response = client.get('/')
+            assert response.status_code == 200

evolver/device.py

@@ -0,0 +1,133 @@
+import time
+import pydantic
+from evolver.util import load_class_fqcn
+from evolver.hardware.interface import SensorDriver, EffectorDriver
+from evolver.serial import EvolverSerialUART
+from evolver.history import HistoryServer
+
+
+DEFAULT_SERIAL = EvolverSerialUART
+DEFAULT_HISTORY = HistoryServer
+
+
+class AdapterDescriptor(pydantic.BaseModel):
+    driver: str
+    config: dict = {}
+
+    def driver_from_descriptor(self, evolver):
+        cls = load_class_fqcn(self.driver)
+        conf = cls.Config.model_validate(self.config)
+        return cls(evolver, conf)
+
+
+class HardwareDriverDescriptor(AdapterDescriptor):
+    calibrator: AdapterDescriptor = None
+
+
+class EvolverConfig(pydantic.BaseModel):
+    vials: list = list(range(16))
+    hardware: dict[str, HardwareDriverDescriptor] = {}
+    adapters: list[AdapterDescriptor] = []
+    serial: AdapterDescriptor = None
+    history: AdapterDescriptor = None
+    enable_react: bool = True
+    enable_commit: bool = True
+    interval: int = 20
+
+
+class Evolver:
+    hardware = {}
+    adapters = []
+    last_read = {}
+
+    def __init__(self, config: EvolverConfig = EvolverConfig()):
+        self.update_config(config)
+
+    def update_config(self, config: EvolverConfig):
+        self.config = config
+        for name, driver in config.hardware.items():
+            self.setup_driver(name, driver)
+        for name in list(self.hardware.keys()):
+            if name not in config.hardware.keys():
+                del(self.hardware[name])
+                del(self.last_read[name])
+        self.adapters = []
+        for adapter in config.adapters:
+            self.setup_adapter(adapter)
+        if config.serial is not None:
+            self.serial = config.serial.driver_from_descriptor(self)
+        else:
+            self.serial = DEFAULT_SERIAL()
+        if config.history is not None:
+            self.history = config.history.driver_from_descriptor(self)
+        else:
+            self.history = DEFAULT_HISTORY()
+
+    def setup_driver(self, name, driver_config: HardwareDriverDescriptor):
+        driver_class = load_class_fqcn(driver_config.driver)
+        config = driver_class.Config.model_validate(driver_config.config)
+        calibrator = None
+        if driver_config.calibrator is not None:
+            calibrator = driver_config.calibrator.driver_from_descriptor(self)
+        self.hardware[name] = driver_class(self, config, calibrator)
+        self.last_read[name] = -1
+
+    def setup_adapter(self, adapter):
+        self.adapters.append(adapter.driver_from_descriptor(self))
+
+    def get_hardware(self, name):
+        return self.hardware[name]
+
+    @property
+    def sensors(self):
+        return {k: v for k,v in self.hardware.items() if isinstance(v, SensorDriver)}
+
+    @property
+    def effectors(self):
+        return {k: v for k,v in self.hardware.items() if isinstance(v, EffectorDriver)}
+
+    @property
+    def calibration_status(self):
+        return {name: device.calibrator.status for name,device in self.hardware.items()}
+
+    @property
+    def state(self):
+        return {name: device.get() for name,device in self.sensors.items()}
+
+    @property
+    def schema(self):
+        hardware_schemas = []
+        for n, hw in self.hardware.items():
+            s = {'name': n, 'kind': str(type(hw)),'config': hw.Config.model_json_schema()}
+            if isinstance(hw, SensorDriver):
+                s['output'] = hw.Output.model_json_schema()
+            if isinstance(hw, EffectorDriver):
+                s['input'] = hw.Input.model_json_schema()
+            hardware_schemas.append(s)
+        return {
+            'hardware': hardware_schemas,
+            'adapters': [{'kind': str(type(a)), 'config': a.Config.model_json_schema()} for a in self.adapters],
+        }
+
+    def read_state(self):
+        for name, device in self.sensors.items():
+            device.read()
+            self.last_read[name] = time.time()
+            self.history.put(name, device.get())
+
+
+    def evaluate_adapters(self):
+        for adapter in self.adapters:
+            adapter.react()
+
+    def commit_proposals(self):
+        for device in self.effectors.values():
+            device.commit()
+
+    def loop_once(self):
+        self.read_state()
+        # for any hardware awaiting calibration, call calibration update method here
+        if self.config.enable_react:
+            self.evaluate_adapters()
+        if self.config.enable_commit:
+            self.commit_proposals()

evolver/hardware/demo.py

@@ -0,0 +1,28 @@
+from copy import copy
+from evolver.hardware.interface import SensorDriver, EffectorDriver, VialConfigBaseModel, BaseCalibrator
+
+
+class NoOpSensorDriver(SensorDriver):
+    class Config(VialConfigBaseModel):
+        echo_raw: int = 1
+        echo_val: int = 2
+
+    def read(self):
+        self.outputs = {
+            i: self.Output(vial=i, raw=self.config.echo_raw, value=self.config.echo_val)
+            for i in self.config.vials
+        }
+
+    def get(self):
+        return self.outputs
+
+
+class NoOpEffectorDriver(EffectorDriver):
+    def commit(self):
+        self.comitted = copy(self.proposal)
+
+
+class NoOpCalibrator(BaseCalibrator):
+    @property
+    def status(self):
+        return True

evolver/hardware/interface.py

@@ -0,0 +1,80 @@
+import pydantic
+from abc import ABC, abstractmethod
+
+
+class VialConfigBaseModel(pydantic.BaseModel):
+    vials: list[int] | None = None
+
+
+class VialBaseModel(pydantic.BaseModel):
+    vial: int
+
+
+class BaseCalibrator(ABC):
+    class Config(pydantic.BaseModel):
+        calibfile: str = None
+
+    def __init__(self, evovler = None, config: Config = Config()):
+        self.config = config
+
+    @property
+    @abstractmethod
+    def status(self):
+        pass
+
+
+class HardwareDriver(ABC):
+    class Config(pydantic.BaseModel):
+        pass
+    calibrator = None
+
+    def __init__(self, evolver, config = None, calibrator = None):
+        self.evolver = evolver
+        self.reconfigure(config or self.Config())
+        if calibrator:
+            self.calibrator = calibrator
+
+    def reconfigure(self, config):
+        self.config = config
+
+
+class VialHardwareDriver(HardwareDriver):
+    def reconfigure(self, config):
+        super().reconfigure(config)
+        if config.vials is None:
+            config.vials = self.evolver.config.vials
+        else:
+            if not set(config.vials).issubset(self.evolver.all_vials):
+                raise ValueError('invalid vials found in config')
+
+
+class SensorDriver(VialHardwareDriver):
+    class Config(VialConfigBaseModel):
+        pass
+    class Output(VialBaseModel):
+        raw: int
+        value: float
+    outputs: dict[int, Output] = {}
+
+    def get(self) -> list[Output]:
+        return self.outputs
+
+    @abstractmethod
+    def read(self):
+        pass
+
+
+class EffectorDriver(VialHardwareDriver):
+    class Config(VialConfigBaseModel):
+        pass
+    class Input(VialBaseModel):
+        value: float
+    proposal: dict[int, Input] = {}
+    committed: dict[int, Input] = {}
+
+    def set(self, input: Input):
+        self.proposal[input.vial] = input
+
+    @abstractmethod
+    def commit(self):
+        pass

evolver/history.py

@@ -0,0 +1,28 @@
+import time
+import pydantic
+from abc import ABC, abstractmethod
+from collections import defaultdict
+
+
+class History(ABC):
+    class Config(pydantic.BaseModel):
+        pass
+
+    @abstractmethod
+    def put(self, name, data):
+        pass
+
+    @abstractmethod
+    def get(self, query):
+        pass
+
+
+class HistoryServer(History):
+    def __init__(self, config = None):
+        self.history = defaultdict(list)
+
+    def put(self, name, data):
+        self.history[name].append((time.time(), data))
+
+    def get(self, name):
+        return self.history[name]