pyacquisition 0.1.0__py3-none-any.whl

pyacquisition/__init__.py

@@ -0,0 +1,47 @@
+from .core import Experiment
+from .core.task import Task
+import sys, asyncio
+from dataclasses import dataclass
+
+
+@dataclass
+class MyTask(Task):
+
+    name = "MyTask"
+    description = "My task description"
+    help = "My task help"
+
+    async def run(self, experiment):
+        yield 'STARTING'
+        await asyncio.sleep(1)
+        yield 'STARTING'
+        await asyncio.sleep(1)
+        yield 'STARTING'
+        await asyncio.sleep(1)
+        yield 'STARTING'
+        await asyncio.sleep(1)
+
+
+
+class MyExperiment(Experiment):
+    
+
+    def setup(self) -> None:
+
+
+        self.register_task(MyTask)
+
+
+
+
+def main(*args) -> None:
+    """
+    Main function to run the experiment.
+
+    Args:
+        toml_file (str): Path to the TOML configuration file.
+    """
+    
+    toml_file = " ".join(sys.argv[1:])
+    experiment = MyExperiment.from_config(toml_file=toml_file)
+    experiment.run()

pyacquisition/core/__init__.py

@@ -0,0 +1 @@
+from .experiment import Experiment

pyacquisition/core/adapters/__init__.py

@@ -0,0 +1,15 @@
+from .pyvisa import pyvisa_adapter
+from .mock import mock_adapter 
+
+_adapters = {
+    'pyvisa': pyvisa_adapter,
+    'mock': mock_adapter,
+}
+
+def get_adapter(adapter_name: str):
+    """Get the adapter class by name."""
+
+    if adapter_name in _adapters:
+        return _adapters[adapter_name]()
+    else:
+        raise ValueError(f"Adapter {adapter_name} not found.")

pyacquisition/core/adapters/mock.py

@@ -0,0 +1,120 @@
+def mock_adapter():
+    """
+    Mock adapter function that returns the input data unchanged.
+    
+    Args:
+        data (dict): The input data to be processed.
+    
+    Returns:
+        dict: The unchanged input data.
+    """
+    return MockResourceManager()
+
+
+
+
+class MockResource:
+    def __init__(
+        self, 
+        resource_name,
+        read_termination='', 
+        write_termination='',
+        send_end=True,
+        query_delay=0.0,
+    ):
+        self.resource_name = resource_name
+        self.opened = True
+        self._timeout = 2000  # Default timeout in ms
+        self._read_termination = read_termination
+        self._write_termination = write_termination
+        self._send_end = send_end
+        self._query_delay = query_delay
+
+    @property
+    def timeout(self):
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, value):
+        if value is None or value == float('+inf'):
+            self._timeout = float('+inf')
+        elif value < 1:
+            self._timeout = 0  # Immediate
+        else:
+            self._timeout = value
+
+    @timeout.deleter
+    def timeout(self):
+        self._timeout = float('+inf')
+        
+        
+    @property
+    def read_termination(self):
+        return self._read_termination
+
+
+    @read_termination.setter
+    def read_termination(self, value):
+        self._read_termination = value
+
+
+    @property
+    def write_termination(self):
+        return self._write_termination
+
+
+    @write_termination.setter
+    def write_termination(self, value):
+        self._write_termination = value
+        
+    
+    @property
+    def send_end(self):
+        return self._send_end
+
+
+    @send_end.setter
+    def send_end(self, value):
+        self._send_end = bool(value)
+
+
+    @property
+    def query_delay(self):
+        return self._query_delay
+
+
+    @query_delay.setter
+    def query_delay(self, value):
+        self._query_delay = float(value)
+
+
+    def write(self, command):
+        return f"Mock write to {self.resource_name}: {command}"
+
+
+    def read(self):
+        return f"Mock read from {self.resource_name}"
+
+
+    def close(self):
+        self.opened = False
+        return f"Mock resource {self.resource_name} closed"
+
+
+class MockResourceManager:
+    def __init__(self):
+        self.resources = {}
+
+    def open_resource(self, resource_name):
+        resource = MockResource(resource_name)
+        self.resources[resource_name] = resource
+        return resource
+
+    def list_resources(self):
+        # Return a list of mock resource names
+        return tuple(self.resources.keys())
+
+    def close(self):
+        for resource in self.resources.values():
+            resource.close()
+        self.resources.clear()

pyacquisition/core/adapters/pyvisa.py

@@ -0,0 +1,7 @@
+from pyvisa import ResourceManager
+
+
+def pyvisa_adapter():
+    rm = ResourceManager()
+    print(rm.list_resources())
+    return rm

pyacquisition/core/api_server.py

@@ -0,0 +1,186 @@
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from websockets.exceptions import ConnectionClosedOK
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
+import asyncio
+from .logging import logger
+from .consumer import Consumer
+from .response import StringResponse, DictResponse
+from enum import Enum
+
+
+class WebsocketEndpoint(Consumer):
+    """
+    A class that handles WebSocket connections and data streaming.
+    """
+
+        
+    @staticmethod
+    def _enum_to_selected_dict(enum_instance):
+        """
+        Converts an enum instance to a dictionary with enum names as keys and their values as values.
+        """
+        return {
+            item.name: {
+                "value": item.value,
+                "selected": item == enum_instance,
+            } for item in enum_instance.__class__
+        }
+    
+        
+    async def run(self, websocket: WebSocket):
+        """
+        Start the WebSocket server and listen for incoming connections.
+        """
+        
+        await websocket.accept()
+        logger.debug("[FastApi] Client connected")
+        try:
+            while True:
+                data = await self.consume()
+                for key, value in data.items():
+                    if isinstance(value, Enum):
+                        data[key] = APIServer._enum_to_selected_dict(value)
+                await websocket.send_json(data)
+        except WebSocketDisconnect:
+            logger.debug("[FastApi] Client disconnected")
+        except ConnectionClosedOK:
+            logger.debug("[FastApi] Connection closed normally")
+        except Exception as e:
+            logger.error(f"[FastApi] An error occurred: {e}")
+            await websocket.close()
+
+
+
+class APIServer:
+    
+    
+    def __init__(
+        self,
+        host: str = "localhost",
+        port: int = 8000,
+        #allowed_cors_origins: list = ["http://localhost:3000"],
+    ):
+        
+        self.host = host
+        self.port = port
+        
+        self.app = FastAPI(
+            title="PyAcquisition API",
+            description="API for PyAcquisition",
+        )
+
+        self.websocket_endpoints = {}
+        
+        # self.app.add_middleware(
+        #     CORSMiddleware,
+        #     allow_origins=allowed_cors_origins,
+        #     allow_credentials=True,
+        #     allow_methods=["*"],
+        #     allow_headers=["*"],
+        # )
+        
+        logger.debug("[FastApi] APIServer initialized")
+        
+
+    
+    
+    @staticmethod
+    def _enum_to_selected_dict(enum_instance):
+        """
+        Converts an enum instance to a dictionary with enum names as keys and their values as values.
+        """
+        return {
+            item.name: {
+                "value": item.value,
+                "selected": item == enum_instance,
+            } for item in enum_instance.__class__
+        }
+    
+    
+    def add_websocket_endpoint(self, url: str):
+        """
+        Adds a WebSocket endpoint to the FastAPI app.
+
+        Args:
+            url (str): The URL path for the WebSocket endpoint.
+        """
+
+        self.websocket_endpoints[url] = WebsocketEndpoint()
+        
+        @self.app.websocket(url)
+        async def websocket_endpoint(websocket: WebSocket):
+            """
+			WebSocket endpoint that polls the provided async function and sends data to connected clients.
+
+			Args:
+				websocket (WebSocket): WebSocket connection object.
+			"""
+            await self.websocket_endpoints[url].run(websocket)
+            
+        logger.debug(f"[FastApi] WebSocket endpoint added at '{url}'")
+            
+    
+    def setup(self):
+        """
+        Sets up the API server. This method is called before running the server.
+        """
+        logger.debug(f"[FastApi] Server setup started at {self.host}:{self.port}")
+        logger.debug("[FastApi] Server setup completed")
+        
+        
+    def run(self):
+        """
+        A coroutine that runs the FastAPI server.
+        """
+        try:
+            config = uvicorn.Config(
+                self.app,
+                host=self.host,
+                port=self.port,
+                log_level="warning",
+            )
+            server = uvicorn.Server(config)
+            return server.serve()
+        except Exception as e:
+            # Log the exception or handle it as needed
+            logger.error(f"[FastApi] An error occurred while running the server: {e}")
+            return None
+        
+        
+    def teardown(self):
+        """
+        Cleans up the API server. This method is called after the server has stopped.
+        """
+        logger.debug("[FastApi] Server teardown started")
+        logger.debug("[FastApi] Server teardown completed")
+        
+        
+    def register_endpoints(self, api_server):
+        """
+        Registers endpoints to the FastAPI app.
+        """
+        
+        
+        @api_server.app.get("/ping")
+        async def ping() -> DictResponse:
+            """
+            Endpoint to check if the API server is running.
+            """
+            return DictResponse(
+                status=200,
+                data={"message": "Pong!"},
+            )
+            
+            
+        @api_server.app.get("/list_websockets")
+        async def list_websockets() -> DictResponse:
+            """
+            Endpoint to list all available WebSocket endpoints.
+            """
+            return DictResponse(
+                status=200,
+                data={"websockets": list(api_server.websocket_endpoints.keys())},
+            )
+        
+    

pyacquisition/core/broadcaster.py

@@ -0,0 +1,54 @@
+import asyncio
+
+class Broadcaster:
+    """
+    A class responsible for broadcasting messages to subscribed consumers.
+    """
+
+    def __init__(self):
+        """
+        Initialize the Broadcaster.
+        """
+        self._subscribers = []
+
+
+    def subscribe(self, consumer):
+        """
+        Subscribe a consumer to this broadcaster.
+
+        Args:
+            consumer (Consumer): The consumer to subscribe.
+        """
+        self._subscribers.append(consumer)
+        
+        
+    def unsubscribe(self, consumer):
+        """
+        Unsubscribe a consumer from this broadcaster.
+
+        Args:
+            consumer (Consumer): The consumer to unsubscribe.
+        """
+        self._subscribers.remove(consumer)
+        
+
+    async def broadcast(self, message):
+        """
+        Broadcast a message to all subscribed consumers.
+
+        Args:
+            message (Any): The message to broadcast.
+        """
+        for subscriber in self._subscribers:
+            await subscriber.queue.put(message)
+            
+            
+    def broadcast_sync(self, message):
+        """
+        Broadcast a message to all subscribed consumers synchronously.
+
+        Args:
+            message (Any): The message to broadcast.
+        """
+        for subscriber in self._subscribers:
+            subscriber.queue.put_nowait(message)

pyacquisition/core/consumer.py

@@ -0,0 +1,141 @@
+import asyncio
+from .logging import logger
+
+
+class Consumer:
+    """
+    A consumer class that can subscribe and unsubscribe to a Broadcaster.
+    """
+
+    def __init__(self, callbacks=[], async_callbacks=[]):
+        """
+        Initialize the Consumer.
+        """
+        self.queue = asyncio.Queue()
+        self._callbacks = callbacks
+        self._async_callbacks = async_callbacks
+        
+        
+    def _execute_callbacks(self, message):
+        """
+        Execute all registered callbacks with the given message.
+
+        Args:
+            message (Any): The message to pass to the callbacks.
+        """
+        for callback in self._callbacks:
+            callback(message)
+            
+            
+    async def _execute_async_callbacks(self, message):
+        """
+        Execute all registered async callbacks with the given message.
+
+        Args:
+            message (Any): The message to pass to the async callbacks.
+        """
+        for async_callback in self._async_callbacks:
+            await async_callback(message)
+            
+            
+    def add_callback(self, callback):
+        """
+        Add a callback to be executed when a message is consumed.
+
+        Args:
+            callback (callable): The callback function to add.
+        """
+        self._callbacks.append(callback)
+        
+        
+    def remove_callback(self, callback):
+        """
+        Remove a callback from the list of callbacks.
+
+        Args:
+            callback (callable): The callback function to remove.
+        """
+        if callback in self._callbacks:
+            self._callbacks.remove(callback)
+        
+        
+    def add_async_callback(self, async_callback):
+        """
+        Add an async callback to be executed when a message is consumed.
+
+        Args:
+            async_callback (callable): The async callback function to add.
+        """
+        self._async_callbacks.append(async_callback)
+        
+        
+    def remove_async_callback(self, async_callback):
+        """
+        Remove an async callback from the list of async callbacks.
+
+        Args:
+            async_callback (callable): The async callback function to remove.
+        """
+        if async_callback in self._async_callbacks:
+            self._async_callbacks.remove(async_callback)
+        
+
+    def subscribe_to(self, broadcaster):
+        """
+        Subscribe to a Broadcaster.
+
+        Args:
+            broadcaster (Broadcaster): The broadcaster to subscribe to.
+        """
+        broadcaster.subscribe(self)
+
+        
+    def unsubscribe(self, broadcaster):
+        """
+        Unsubscribe from a Broadcaster.
+
+        Args:
+            broadcaster (Broadcaster): The broadcaster to unsubscribe from.
+        """
+        broadcaster.unsubscribe(self)   
+
+
+    async def consume(self, timeout=None):
+        """
+        Consume a single message from the queue with a timeout.
+
+        Args:
+            timeout (float or None): The maximum time (in seconds) to wait for a message. Defaults to None (no timeout).
+
+        Returns:
+            Any: The message from the queue, or None if the timeout is reached.
+        """
+        try:
+            message = await asyncio.wait_for(self.queue.get(), timeout=timeout)
+            self._execute_callbacks(message)
+            await self._execute_async_callbacks(message)
+            return message
+        except asyncio.TimeoutError:
+            return None
+        except Exception as e:
+            logger.error(f"Error consuming message: {e}")
+            return None
+        
+        
+    async def consume_all(self, timeout=None):
+        """
+        Consume all messages from the queue with a timeout.
+
+        Args:
+            timeout (float or None): The maximum time (in seconds) to wait for messages. Defaults to None (no timeout).
+
+        Returns:
+            list: A list of messages from the queue.
+        """
+        messages = []
+        while True:
+            message = await self.consume(timeout=timeout)
+            if message is None:
+                break
+            messages.append(message)
+        return messages