puda-drivers 0.0.18__tar.gz → 0.0.20__tar.gz

{puda_drivers-0.0.18 → puda_drivers-0.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: puda-drivers
-Version: 0.0.18
+Version: 0.0.20
 Summary: Hardware drivers for the PUDA platform.
 Project-URL: Homepage, https://github.com/PUDAP/puda
 Project-URL: Issues, https://github.com/PUDAP/puda/issues
@@ -16,6 +16,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Hardware
 Requires-Python: >=3.10
 Requires-Dist: nats-py>=2.12.0
+Requires-Dist: numpy==2.4.2
 Requires-Dist: opencv-python>=4.12.0.88
 Requires-Dist: pyserial~=3.5
 Description-Content-Type: text/markdown

{puda_drivers-0.0.18 → puda_drivers-0.0.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "puda-drivers"
-version = "0.0.18"
+version = "0.0.20"
 description = "Hardware drivers for the PUDA platform."
 readme = "README.md"
 authors = [
@@ -21,6 +21,7 @@ license-files = ["LICEN[CS]E*"]
 
 dependencies = [
     "nats-py>=2.12.0",
+    "numpy==2.4.2",  # Explicit numpy to ensure proper Windows wheels (avoids MINGW-W64 builds)
     "opencv-python>=4.12.0.88",
     "pyserial~=3.5",
 ]

puda_drivers-0.0.20/src/puda_drivers/labware/MEA_cell_MTP.json

@@ -0,0 +1,56 @@
+{
+    
+    "ordering": [
+        [
+            "A1"
+        ]
+
+    ],
+    "brand": {
+        "brand": "Custom",
+        "brandId": []
+    },
+    "metadata": {
+        "displayName": "MEA cell MTP",
+        "displayCategory": "functionalLabware",
+        "tags": []
+    },
+    "dimensions": {
+        "xDimension": 127,
+        "yDimension": 85,
+        "zDimension": 28
+    },
+    "wells": {
+        "A1": {
+            "shape": "square",
+            "x": 63.5,
+            "y": 42.5,
+            "z": 25
+        }
+    },
+    "groups": [
+        {
+            "metadata": {
+                "wellBottomShape": "flat"
+            },
+            "wells": [
+                "A1"
+            ]
+        }
+    ],
+    "parameters": {
+        "format": "irregular",
+        "quirks": [],
+        "isTiprack": false,
+        "isMagneticModuleCompatible": false,
+        "loadName": "MEA_cell_MTP"
+    },
+    "namespace": "custom_beta",
+    "version": 1,
+    "schemaVersion": 2,
+    "cornerOffsetFromSlot": {
+        "x": 0,
+        "y": 0,
+        "z": 0
+    }
+}

{puda_drivers-0.0.18 → puda_drivers-0.0.20}/src/puda_drivers/labware/labware.py

@@ -3,14 +3,14 @@
 import json
 import inspect
 from pathlib import Path
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional
 from abc import ABC
 from puda_drivers.core import Position
 
 
 class StandardLabware(ABC):
     """
-    Generic Parent Class for all Labware on a microplate 
+    Generic Parent Class for all Labware on a microplate
     """
     def __init__(self, labware_name: str):
         """
@@ -63,7 +63,7 @@ class StandardLabware(ABC):
         
         with open(definition_path, "r", encoding="utf-8") as f:
             return json.load(f)
-        
+
     def __str__(self):
         """
         Return a string representation of the labware.
@@ -92,7 +92,7 @@ class StandardLabware(ABC):
             List of well identifiers (e.g., ["A1", "A2", "B1", ...])
         """
         return list(self._wells.keys())
-    
+
     def get_well_position(self, well_id: str) -> Position:
         """
         Get the position of a well from definition.json.
@@ -110,39 +110,65 @@ class StandardLabware(ABC):
         well_id_upper = well_id.upper()
         if well_id_upper not in self._wells:
             raise KeyError(f"Well '{well_id}' not found in tip rack definition")
-        
+
         # Get the well data from the definition
         well_data = self._wells.get(well_id_upper, {})
-        
+
         # Return position of the well (x, y are already center coordinates)
         return Position(
             x=well_data.get("x", 0.0),
             y=well_data.get("y", 0.0),
-            z=well_data.get("z", 0.0), 
+            z=well_data.get("z", 0.0),
         )
-        
-    def get_height(self) -> float:
+
+    def get_height(self, well_name: Optional[str] = None) -> float:
         """
         Get the height of the labware.
-        
+
+        Args:
+            well_name: Optional well name within the labware (e.g., "A1" for a well in a tiprack)
+                If not provided, the height of the labware is returned (zDimension).
         Returns:
-            Height of the labware (zDimension)
+            Height of the labware (zDimension) or the height of the well (z)
             
         Raises:
-            KeyError: If dimensions or zDimension is not found in the definition
+            KeyError: If dimensions or zDimension is not found in the definition, or if well_name is not found in the labware
         """
         dimensions = self._definition.get("dimensions")
         if dimensions is None:
             raise KeyError("'dimensions' not found in labware definition")
         
-        if "zDimension" not in dimensions:
-            raise KeyError("'zDimension' not found in labware dimensions")
-        
-        return dimensions["zDimension"]
-        
+        if well_name:
+            well_data = self._wells.get(well_name.upper(), {})
+            if well_data is None:
+                raise KeyError(f"Well '{well_name}' not found in labware definition")
+            return well_data.get("z")
+        else:
+            if "zDimension" not in dimensions:
+                raise KeyError("'zDimension' not found in labware dimensions")
+            return dimensions["zDimension"]
+
     def get_insert_depth(self) -> float:
         """
-        Get the insert depth of the labware.
+        Get the insert depth of the labware. This should be added to all labware definitions.
+        
+        insert_depth represents the maximum internal Z-axis clearance of the
+        labware. It is calculated as the absolute difference between the Top
+        Plane (the highest point of the well opening) and the Internal Floor
+        (the physical bottom of the well).
+        
+        Top of Labware (Z = 0 reference)
+              │      │
+        ┌─────┴──────┴─────┐  <─── Opening
+        │                  │
+        │      SPACE       │  }
+        │    AVAILABLE     │  }
+        │       FOR        │  }  insert_depth
+        │    INSERTION     │  }  (e.g., 40mm)
+        │                  │  }
+        └──────┬───────────┘
+               │
+        Bottom of Well (Limit)
         
         Returns:
             Insert depth of the labware

{puda_drivers-0.0.18 → puda_drivers-0.0.20}/src/puda_drivers/labware/polyelectric_8_wellplate_30000ul.json

@@ -1,4 +1,5 @@
 {
+    "insert_depth": 70,
     "ordering": [
         [
             "A1",
@@ -30,7 +31,7 @@
     "dimensions": {
         "xDimension": 128,
         "yDimension": 85.5,
-        "zDimension": 54
+        "zDimension": 74
     },
     "wells": {
         "A1": {

{puda_drivers-0.0.18 → puda_drivers-0.0.20}/src/puda_drivers/labware/trash_bin.json

@@ -1,4 +1,5 @@
 {
+  "insert_depth": 0,
   "ordering": [
     ["A1"]
   ],
@@ -11,7 +12,7 @@
   "dimensions": {
     "xDimension": 127.76,
     "yDimension": 85.48,
-    "zDimension": 0
+    "zDimension": 10
   },
   "wells": {
     "A1": {

puda_drivers-0.0.20/src/puda_drivers/machines/__init__.py

@@ -0,0 +1,4 @@
+from .first import First
+from .biologic import Biologic
+
+__all__ = ["First", "Biologic"]

puda_drivers-0.0.20/src/puda_drivers/machines/biologic.py

@@ -0,0 +1,357 @@
+"""
+BiologicMachine class for handling Biologic device commands.
+
+This module provides a wrapper around easy_biologic that enables dynamic command
+handling via getattr, allowing command-based execution patterns for Biologic
+electrochemical testing devices.
+"""
+import logging
+import sys
+from typing import Dict, Any, Type
+
+logger = logging.getLogger(__name__)
+
+# Only import easy_biologic on Windows (allows class inspection on Linux)
+if sys.platform == "win32":
+    import easy_biologic as ebl
+    import easy_biologic.base_programs as blp
+else:
+    ebl = None
+    blp = None
+
+
+class Biologic:
+    """
+    Wrapper around easy_biologic that provides command handlers for Biologic devices.
+    
+    This class wraps easy_biologic.base_programs to allow for dynamic method lookup
+    via getattr, enabling command-based execution patterns. Each method (OCV, CA, PEIS, etc.)
+    wraps the corresponding base program class and provides a consistent interface.
+    
+    Example:
+        machine = Biologic("192.168.1.2")
+        handler = getattr(machine, "OCV", None)  # Get handler dynamically
+        result = handler(params={"time": 60}, channels=[1, 2])
+    """
+    
+    def __init__(self, device_ip: str):
+        """
+        Initialize the Biologic machine.
+        
+        Args:
+            device_ip: IP address of the Biologic device
+        """
+        self.device_ip = device_ip
+        self.device = None
+        logger.info("BiologicMachine initialized with IP: %s (not connected yet)", device_ip)
+    
+    def startup(self):
+        """
+        Connect to the Biologic device.
+        
+        This method should be called before executing any commands to establish
+        the connection to the device.
+        
+        Raises:
+            OSError: If easy_biologic cannot be used (e.g., on non-Windows systems)
+        """
+        if ebl is None:
+            raise OSError("easy_biologic can only be used on Windows.")
+        if self.device is None:
+            self.device = ebl.BiologicDevice(self.device_ip)
+            logger.info("BiologicDevice connected with IP: %s", self.device_ip)
+        else:
+            logger.warning("BiologicDevice already connected")
+    
+    def _run_base_program(
+        self,
+        program_class: Type[blp.BiologicProgram],
+        params: dict[str, Any],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Generic helper method to run any base program.
+        
+        This method handles the common pattern:
+        1. Create the program instance with params and kwargs
+        2. Run the program (with appropriate signature)
+        3. Return the data
+        
+        Args:
+            program_class: The base program class to instantiate (e.g., blp.OCV, blp.CA)
+            params: Dictionary of parameters for the program
+            **kwargs: Additional keyword arguments:
+                - For standard programs: retrieve_data [Default: True]
+                - For MPP/MPP_Cycles: data, by_channel, cv
+                - channels: Optional list of channel numbers (for constructor)
+            
+        Returns:
+            Dictionary containing the program data
+        
+        Raises:
+            RuntimeError: If startup() has not been called yet
+        """
+        if self.device is None:
+            raise RuntimeError("Device not connected. Call startup() before executing commands.")
+        
+        # Check program class type to determine run signature
+        # MPP and MPP_Cycles use: data, by_channel, cv
+        # MPP_Tracking uses: folder, by_channel
+        # Standard programs use: retrieve_data
+        if issubclass(program_class, blp.MPP):
+            # MPP/MPP_Cycles style: extract run parameters
+            data = kwargs.pop('data', 'data')
+            by_channel = kwargs.pop('by_channel', False)
+            cv_params = kwargs.pop('cv', {})
+            run_kwargs = {'data': data, 'by_channel': by_channel, 'cv': cv_params}
+        elif program_class == blp.MPP_Tracking:
+            # MPP_Tracking style: extract run parameters
+            folder = kwargs.pop('folder', None)
+            by_channel = kwargs.pop('by_channel', False)
+            run_kwargs = {'folder': folder, 'by_channel': by_channel}
+        else:
+            # Standard program style: extract retrieve_data
+            retrieve_data = kwargs.pop('retrieve_data', True)
+            run_kwargs = {'retrieve_data': retrieve_data}
+        
+        # Create program instance - pass all remaining kwargs directly to constructor
+        program = program_class(
+            device=self.device,
+            params=params,
+            **kwargs
+        )
+        
+        # Run the program with appropriate signature
+        program.run(**run_kwargs)
+        
+        return program.data
+    
+    def OCV(
+        self,
+        params: dict[str, Any],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Run OCV (Open Circuit Voltage) test.
+        
+        Args:
+            params: Dictionary containing:
+                - time: Test duration in seconds
+                - time_interval: Maximum time between readings. [Default: 1]
+                - voltage_interval: Maximum interval between voltage readings. [Default: 0.01]
+            **kwargs: Additional keyword arguments passed to program constructor:
+                - channels: Optional list of channel numbers
+                - retrieve_data: Whether to automatically retrieve data after running [Default: True]
+            
+        Returns:
+            Dictionary containing the OCV data (keyed by channel)
+        """
+        logger.info("Running OCV test: params=%s", params)
+        return self._run_base_program(blp.OCV, params, **kwargs)
+        
+    def CA(
+        self,
+        params: dict[str, Any],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Run CA (Chronoamperometry) test.
+        
+        Args:
+            params: Dictionary containing:
+                - voltages: List of voltages.
+                - durations: List of times in seconds.
+                - vs_initial: If step is vs. initial or previous. [Default: False]
+                - time_interval: Maximum time interval between points. [Default: 1]
+                - current_interval: Maximum current change between points. [Default: 0.001]
+                - current_range: Current range. Use ec_lib.IRange. [Default: IRange.m10]
+            **kwargs: Additional keyword arguments passed to program constructor:
+                - channels: Optional list of channel numbers
+                - retrieve_data: Whether to automatically retrieve data after running [Default: True]
+            
+        Returns:
+            Dictionary containing the CA data (keyed by channel)
+        """
+        logger.info("Running CA test: params=%s", params)
+        return self._run_base_program(blp.CA, params, **kwargs)
+
+  
+    def PEIS(
+        self,
+        params: dict[str, Any],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Run PEIS (Potentiostatic Electrochemical Impedance Spectroscopy) test.
+        
+        Args:
+            params: Dictionary containing:
+                - voltage: Initial potential in Volts.
+                - amplitude_voltage: Sinus amplitude in Volts.
+                - initial_frequency: Initial frequency in Hertz.
+                - final_frequency: Final frequency in Hertz.
+                - frequency_number: Number of frequencies.
+                - duration: Overall duration in seconds.
+                - vs_initial: If step is vs. initial or previous. [Default: False]
+                - time_interval: Maximum time interval between points in seconds. [Default: 1]
+                - current_interval: Maximum time interval between points in Amps. [Default: 0.001]
+                - sweep: Defines whether the spacing between frequencies is logarithmic ('log') or linear ('lin'). [Default: 'log']
+                - repeat: Number of times to repeat the measurement and average the values for each frequency. [Default: 1]
+                - correction: Drift correction. [Default: False]
+                - wait: Adds a delay before the measurement at each frequency. The delay is expressed as a fraction of the period. [Default: 0]
+            **kwargs: Additional keyword arguments passed to program constructor:
+                - channels: Optional list of channel numbers
+                - retrieve_data: Whether to automatically retrieve data after running [Default: True]
+
+        Returns:
+            Dictionary containing the PEIS data (keyed by channel)
+        """
+        logger.info("Running PEIS test: params=%s", params)
+        return self._run_base_program(blp.PEIS, params, **kwargs)
+
+
+    def GEIS(
+        self,
+        params: dict[str, Any],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Run GEIS (Galvanostatic Electrochemical Impedance Spectroscopy) test.
+        
+        Args:
+            params: Dictionary containing:
+                - current: Initial current in Ampere.
+                - amplitude_current: Sinus amplitude in Ampere.
+                - initial_frequency: Initial frequency in Hertz.
+                - final_frequency: Final frequency in Hertz.
+                - frequency_number: Number of frequencies.
+                - duration: Overall duration in seconds.
+                - vs_initial: If step is vs. initial or previous. [Default: False]
+                - time_interval: Maximum time interval between points in seconds. [Default: 1]
+                - potential_interval: Maximum interval between points in Volts. [Default: 0.001]
+                - sweep: Defines whether the spacing between frequencies is logarithmic ('log') or linear ('lin'). [Default: 'log']
+                - repeat: Number of times to repeat the measurement and average the values for each frequency. [Default: 1]
+                - correction: Drift correction. [Default: False]
+                - wait: Adds a delay before the measurement at each frequency. The delay is expressed as a fraction of the period. [Default: 0]
+            **kwargs: Additional keyword arguments passed to program constructor:
+                - channels: Optional list of channel numbers
+                - retrieve_data: Whether to automatically retrieve data after running [Default: True]
+            
+        Returns:
+            Dictionary containing the GEIS data (keyed by channel)
+        """
+        logger.info("Running GEIS test: params=%s", params)
+        return self._run_base_program(blp.GEIS, params, **kwargs)
+      
+    def CV(
+        self,
+        params: dict[str, Any],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Run CV (Cyclic Voltammetry) test.
+        
+        Args:
+            params: Dictionary containing:
+                - start: Start voltage. [Default: 0]
+                - end: End voltage. Boundary voltage in forward scan. [Default: 0.5]
+                - E2: Boundary voltage in backward scan. [Default: 0]
+                - Ef: End voltage in the final cycle scan [Default: 0]
+                - step: Voltage step. dEN/1000 [Default: 0.01]
+                - rate: Scan rate in V/s. [Default: 0.01]
+                - average: Average over points. [Default: False]
+                - N_Cycles: Number of cycles. [Default: 0]
+            **kwargs: Additional keyword arguments passed to program constructor:
+                - channels: Optional list of channel numbers
+                - retrieve_data: Whether to automatically retrieve data after running [Default: True]
+            
+        Returns:
+            Dictionary containing the CV data (keyed by channel)
+        """
+        logger.info("Running CV test: params=%s", params)
+        return self._run_base_program(blp.CV, params, **kwargs)
+      
+    def MPP_Tracking(
+        self,
+        params: dict[str, Any],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Run MPP_Tracking (Maximum Power Point Tracking) test.
+        
+        Args:
+            params: Dictionary containing:
+                - run_time: Run time in seconds.
+                - init_vmpp: Initial v_mpp.
+                - probe_step: Voltage step for probe. [Default: 0.005 V]
+                - probe_points: Number of data points to collect for probe. [Default: 5]
+                - probe_interval: How often to probe in seconds. [Default: 2]
+                - record_interval: How often to record a data point in seconds. [Default: 1]
+            **kwargs: Additional keyword arguments:
+                - channels: Optional list of channel numbers
+                - folder: Folder or file for saving data [Default: None]
+                - by_channel: Save data by channel [Default: False]
+            
+        Returns:
+            Dictionary containing the MPP_Tracking data (keyed by channel)
+        """
+        logger.info("Running MPP_Tracking test: params=%s", params)
+        return self._run_base_program(blp.MPP_Tracking, params, **kwargs)
+    
+    def MPP(
+        self,
+        params: dict[str, Any],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Run MPP (Maximum Power Point) test.
+        
+        Makes a CV scan and Voc scan and runs MPP tracking.
+        
+        Args:
+            params: Dictionary containing:
+                - run_time: Run time in seconds.
+                - probe_step: Voltage step for probe. [Default: 0.005 V]
+                - probe_points: Number of data points to collect for probe. [Default: 5]
+                - probe_interval: How often to probe in seconds. [Default: 2]
+                - record_interval: How often to record a data point in seconds. [Default: 1]
+            **kwargs: Additional keyword arguments:
+                - channels: Optional list of channel numbers
+                - data: Data folder path. [Default: 'data']
+                - by_channel: Save data by channel. [Default: False]
+                - cv: Parameters passed to CV to find initial MPP, or {} for default. [Default: {}]
+            
+        Returns:
+            Dictionary containing the MPP data (keyed by channel)
+        """
+        logger.info("Running MPP test: params=%s", params)
+        return self._run_base_program(blp.MPP, params, **kwargs)
+    
+    def MPP_Cycles(
+        self,
+        params: dict[str, Any],
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Run MPP_Cycles (MPP tracking with periodic CV scans) test.
+        
+        Args:
+            params: Dictionary containing:
+                - run_time: Cycle run time in seconds.
+                - cycles: Number of cycles to perform.
+                - probe_step: Voltage step for probe. [Default: 0.01 V]
+                - probe_points: Number of data points to collect for probe. [Default: 5]
+                - probe_interval: How often to probe in seconds. [Default: 2]
+                - record_interval: How often to record a data point in seconds. [Default: 1]
+            **kwargs: Additional keyword arguments:
+                - channels: Optional list of channel numbers
+                - data: Data folder path. [Default: 'data']
+                - by_channel: Save data by channel. [Default: False]
+                - cv: Parameters for the CV. [Default: {}]
+            
+        Returns:
+            Dictionary containing the MPP_Cycles data (keyed by channel)
+        """
+        logger.info("Running MPP_Cycles test: params=%s", params)
+        return self._run_base_program(blp.MPP_Cycles, params, **kwargs)
+