ivoryOS 0.1.0__tar.gz

ivoryOS-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2024 Ivory Zhang | Hein Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

ivoryOS-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+graft sdl_webui/static
+graft sdl_webui/templates
+global-exclude *.pyc

ivoryOS-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.1
+Name: ivoryOS
+Version: 0.1.0
+Summary: an open-source Python package enabling Self-Driving Labs (SDLs) interoperability
+Home-page: https://gitlab.com/heingroup/ivoryos
+Author: Ivory Zhang
+Author-email: ivoryzhang@chem.ubc.ca
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ax-platform
+Requires-Dist: bcrypt
+Requires-Dist: Flask-Login
+Requires-Dist: Flask-Session
+Requires-Dist: Flask-SocketIO
+Requires-Dist: Flask-SQLAlchemy
+Requires-Dist: Flask-WTF
+Requires-Dist: mysqlclient==2.1.1
+Requires-Dist: SQLAlchemy-Utils
+Requires-Dist: openai
+Requires-Dist: python-dotenv
+
+![ivoryos.png](ivoryos.png)
+# ivoryOS: interoperable Web UI for SDLs
+ivoryOS is an open-source Python package enabling SDL interoperability. Add a web UI to SDLs anytime.
+## Description
+Granting SDLs flexibility and modularity makes it almost impossible to design a UI, yet it's a necessity for allowing more people to interact with it (democratisation). 
+This web UI aims to ease up the control of any Python-based SDLs by displaying functions and parameters for initialized modules dynamically. 
+The modules can be hardware API, high-level functions, or experiment workflow.
+With the least modification of the current workflow, user can design, save and run their experiment and monitor the process. 
+## Design AI-assistant
+To streamline the experimental design on SDLs, we also integrate Large Language Models (LLMs) to interpret the inspected functions and generate code according to task descriptions.
+
+## Installation
+```
+pip install ivoryos
+```
+
+## Usage
+In your SDL script, use `ivoryos(__name__)`. Example in [sample_code.py](example/dummy_ur/dummy_deck.py)
+
+```python
+from ivoryos.app import ivoryos
+ivoryos(__name__)
+```
+
+
+## Enable LLMs with [OpenAI API](https://github.com/openai/openai-python)
+1. Create a `.env` file in project repo for `OPENAI_API_KEY`
+```
+OPENAI_API_KEY="Your API Key"
+```
+2. In your SDL script, define model, you can use any GPT models.
+```python
+from ivoryos.app import ivoryos
+ivoryos(__name__, model="gpt-3.5-turbo")
+```
+
+## Enable local LLMs with [Ollama](https://ollama.com/)
+1. Download Ollama.
+2. pull models from Ollama
+3. In your SDL script, define LLM server and model, you can use any models available on Ollama.
+```python
+from ivoryos.app import ivoryos
+ivoryos(__name__, llm_server="localhost", model="llama3.1")
+```
+
+## Developing
+coming soon
+
+## Authors and Acknowledgement
+Ivory Zhang, Lucy Hao
+
+Authors acknowledge all former and current Hein Lab members for their valuable suggestions. 
+
+## License
+[LICENSE](LICENSE)

ivoryOS-0.1.0/README.md

@@ -0,0 +1,55 @@
+![ivoryos.png](ivoryos.png)
+# ivoryOS: interoperable Web UI for SDLs
+ivoryOS is an open-source Python package enabling SDL interoperability. Add a web UI to SDLs anytime.
+## Description
+Granting SDLs flexibility and modularity makes it almost impossible to design a UI, yet it's a necessity for allowing more people to interact with it (democratisation). 
+This web UI aims to ease up the control of any Python-based SDLs by displaying functions and parameters for initialized modules dynamically. 
+The modules can be hardware API, high-level functions, or experiment workflow.
+With the least modification of the current workflow, user can design, save and run their experiment and monitor the process. 
+## Design AI-assistant
+To streamline the experimental design on SDLs, we also integrate Large Language Models (LLMs) to interpret the inspected functions and generate code according to task descriptions.
+
+## Installation
+```
+pip install ivoryos
+```
+
+## Usage
+In your SDL script, use `ivoryos(__name__)`. Example in [sample_code.py](example/dummy_ur/dummy_deck.py)
+
+```python
+from ivoryos.app import ivoryos
+ivoryos(__name__)
+```
+
+
+## Enable LLMs with [OpenAI API](https://github.com/openai/openai-python)
+1. Create a `.env` file in project repo for `OPENAI_API_KEY`
+```
+OPENAI_API_KEY="Your API Key"
+```
+2. In your SDL script, define model, you can use any GPT models.
+```python
+from ivoryos.app import ivoryos
+ivoryos(__name__, model="gpt-3.5-turbo")
+```
+
+## Enable local LLMs with [Ollama](https://ollama.com/)
+1. Download Ollama.
+2. pull models from Ollama
+3. In your SDL script, define LLM server and model, you can use any models available on Ollama.
+```python
+from ivoryos.app import ivoryos
+ivoryos(__name__, llm_server="localhost", model="llama3.1")
+```
+
+## Developing
+coming soon
+
+## Authors and Acknowledgement
+Ivory Zhang, Lucy Hao
+
+Authors acknowledge all former and current Hein Lab members for their valuable suggestions. 
+
+## License
+[LICENSE](LICENSE)

ivoryOS-0.1.0/example/abstract_robot_classes/abclocation.py

@@ -0,0 +1,6 @@
+from abc import ABC
+
+
+class ABCLocation(ABC):
+    def __init__(self, robot_movement_information):
+        self.robot_movement_information = robot_movement_information

ivoryOS-0.1.0/example/abstract_robot_classes/arm.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from example.abstract_robot_classes.abclocation import ABCLocation
+from example.abstract_robot_classes.moveable import Moveable
+
+
+class Arm(ABC):
+    def __init__(self, name: str):
+        self.name = name
+
+    @abstractmethod
+    def move(self, from_loc: ABCLocation, to_loc: ABCLocation, moveable: Optional[Moveable] = None):
+        pass
+
+    @abstractmethod
+    def pick_up(self, moveable: Moveable, location: ABCLocation):
+        pass
+
+    @abstractmethod
+    def put_down(self, moveable: Moveable, location: ABCLocation):
+        pass

ivoryOS-0.1.0/example/abstract_robot_classes/chemical.py

@@ -0,0 +1,5 @@
+from abc import ABC
+
+
+class Chemical(ABC):
+    pass

ivoryOS-0.1.0/example/abstract_robot_classes/container.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from example.abstract_robot_classes.chemical import Chemical
+from example.abstract_robot_classes.moveable import Moveable
+from example.kinova_deck.moving.kinova_movable_config import KinovaMoveableConfig
+
+
+class Container(Moveable, ABC):
+    def __init__(self, name: str, config: Optional[KinovaMoveableConfig] = None):
+        super().__init__(name, config)
+
+    @abstractmethod
+    def update_contents(self, chemical: Chemical, amount_ul: int):
+        pass

ivoryOS-0.1.0/example/abstract_robot_classes/handler.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+from .arm import Arm
+from .chemical import Chemical
+from .container import Container
+from .abclocation import ABCLocation
+from .moveable import Moveable
+
+
+class Handler(Moveable, ABC):
+    @abstractmethod
+    def dispense(self, chemical: Chemical, container: Container, location: ABCLocation, arm: Arm):
+        pass

ivoryOS-0.1.0/example/abstract_robot_classes/moveable.py

@@ -0,0 +1,18 @@
+from abc import ABC
+from typing import Optional
+
+from example.abstract_robot_classes.moveableconfig import MoveableConfig
+
+
+class Moveable(ABC):
+    def __init__(self, name: str,
+                 config: Optional[MoveableConfig] = None,
+                 offset_x: float = 0,
+                 offset_y: float = 0,
+                 offset_z: float = 0):
+        self.name = name
+        self.gripped = False
+        self.config: Optional[MoveableConfig] = config
+        self.offset_x = offset_x
+        self.offset_y = offset_y
+        self.offset_z = offset_z

ivoryOS-0.1.0/example/abstract_robot_classes/moveableconfig.py

@@ -0,0 +1,13 @@
+from abc import ABC
+from dataclasses import dataclass
+
+# TODO: replace any
+@dataclass
+class MoveableSequence(ABC):
+    location_A: any
+    location_B: any
+
+
+@dataclass
+class MoveableConfig(ABC):
+    safe_moves: list[MoveableSequence]

ivoryOS-0.1.0/example/dummy_ur/dummy_balance.py

@@ -0,0 +1,10 @@
+class DummyBalance:
+
+    def __init__(self, com_port: str):
+        self.com_port = com_port
+
+    def weigh_sample(self):
+        print(f"Weighing sample using {self.com_port}")
+
+    def dose_solid(self, amount_in_mg: float):
+        print(f"Dosing {amount_in_mg} mg using {self.com_port}")

ivoryOS-0.1.0/example/dummy_ur/dummy_deck.py

@@ -0,0 +1,113 @@
+import time
+
+from example.dummy_ur.dummy_balance import DummyBalance
+from example.dummy_ur.dummy_pump import DummyPump
+
+# some constant values
+a = {"a": 1, "b": 3}
+
+
+class DummySDLDeck:
+    def __init__(self, pump: DummyPump, balance: DummyBalance):
+        self.pump = pump
+        self.balance = balance
+
+    def dose_solvent(self, name: str, amount_in_ml: float = 5, rate_ml_per_minute: float = 1):
+        self.pump.dose_liquid(amount_in_ml=amount_in_ml, rate_ml_per_minute=rate_ml_per_minute)
+        self.balance.weigh_sample()
+        print("dosing solvent")
+
+    def dose_solid(self, amount_in_mg: float = 5, bring_in: bool = False):
+        """dose current chemical"""
+        self.balance.dose_solid(amount_in_mg=amount_in_mg)
+        self.balance.weigh_sample()
+        print("dosing solid")
+
+    def equilibrate(self, temp: float, duration: float):
+        print("equilibrate")
+
+    def sample(self, sample_volume: float = 10):
+        print("sample")
+
+    def dilute(self, solvent: str, factor: float):
+        print("dilute")
+
+    def analyze(self):
+        print("analyze")
+
+    def filtration(self):
+        print("filtration")
+
+
+balance = DummyBalance("Fake com port 1")
+pump = DummyPump("Fake com port 2")
+deck = DummySDLDeck(pump, balance)
+
+
+class DummyExperiment:
+    def __init__(self, deck):
+        self.deck = deck
+
+    def cooling_crystal(self,
+                        low_temp: float,
+                        temp_diff: float,
+                        cooling_rate: float,
+                        mass_mg: float,
+                        solvent_A: str,
+                        solvent_B: str,
+                        solvent_ratio: float
+                        ):
+        print(type(mass_mg))
+
+    def reslurry(self):
+        pass
+
+    def solubility(self,
+                   temp: float,
+                   temp_time_min: float,
+                   duplicates:int,
+                   ):
+        pass
+
+    def calibration_curve(self,
+                          mass_in_mg: float,
+                          temp: float,
+                          temp_time_min: float,
+                          initial_volume_ml: float,
+                          sample_volume_ml: float,
+                          dilution_factor: int,
+                          number_of_dilutions: int,
+                          ):
+        pass
+
+
+cryst_co = DummyExperiment(deck)
+
+
+class ShakerDemo:
+    def __init__(self, deck):
+        self.deck = deck
+
+    def move_sample_to_shaker(self, location:str="A1"):
+        pass
+
+    def shake_for_duration(self, duration: float):
+        time.sleep(duration)
+
+    def move_vial_to_tray(self,  location:str="A1"):
+        pass
+
+vial_shaker = ShakerDemo(deck)
+
+if __name__ == "__main__":
+    from ivoryos.app import ivoryos
+    ivoryos(__name__, model="llama3.1", llm_server='localhost',)
+
+
+    # ivoryos(__name__, model="gpt-3.5-turbo")
+
+"""add 10 mg of acetaminophen, dose 1 ml of methanol, equilibrate for 10 minute at 50 degrees, filter the sample and analyze with HPLC"""
+"""i want to run a cooling crystal experiment, with low temperature being 20, and high temperature being 40, cooling rate being 0.1, I want to dose 11 mg of my sample, and use 
+water as solvent a and isopropanol for solvent b, the solvent ratio being 0.1"""
+
+

ivoryOS-0.1.0/example/dummy_ur/dummy_pump.py

@@ -0,0 +1,8 @@
+class DummyPump:
+
+    def __init__(self, com_port: str):
+        self.com_port = com_port
+
+    def dose_liquid(self, amount_in_ml: float, rate_ml_per_minute:float):
+        print(f"pretending dosing {amount_in_ml} at {rate_ml_per_minute} ml/min")
+

ivoryOS-0.1.0/example/kinova_deck/chemicals.py

@@ -0,0 +1,15 @@
+from example.abstract_robot_classes.chemical import Chemical
+
+
+class Liquid(Chemical):
+    def __init__(self, name: str, formula: str, density: float = -1):
+        self.name = name
+        self.formula = formula
+        self.density: float = density
+
+
+class Solid(Chemical):
+    def __init__(self, name: str, formula: str, density: float = -1):
+        self.name = name
+        self.formula = formula
+        self.density: float = density

ivoryOS-0.1.0/example/kinova_deck/components/balance.py

@@ -0,0 +1,49 @@
+from serial import Serial
+
+
+class Balance:
+    def __init__(self, port: str):
+        self.port = port
+        self.ser = Serial(port)
+
+    def stable_weight(self):
+        response = self.send_command("S")
+        return self.get_reading(response)
+
+    def weight_immediately(self):
+        response = self.send_command("SI")
+        return self.get_reading(response)
+
+    def tare(self):
+        response = self.send_command("T")
+        return self.get_reading(response)
+
+    def zero(self):
+        self.send_command("Z")
+        return
+
+    def tare_immediately(self):
+        response = self.ser.write("TI")
+        return self.get_reading(response)
+
+    def zero_immediately(self):
+        self.send_command("ZI")
+
+    def send_command(self, command):
+        if not command.endswith("\n\r"):
+            command += "\n\r"
+        self.ser.write(command.encode())
+        response = self.ser.readline()
+        return response.decode().strip()
+
+    @staticmethod
+    def get_reading(response):
+        _, _, number, unit = response.split()
+        return (float(number))
+
+
+if __name__ == "__main__":
+    b = Balance("COM7")
+    w = b.stable_weight()
+    print(w)
+    print()

ivoryOS-0.1.0/example/kinova_deck/components/capper.py

@@ -0,0 +1,68 @@
+from ftdi_serial import Serial
+
+"""
+decapper
+"""
+
+class Capper:
+    def __init__(self, port, baud=115200, bytesize=8, timeout=20):
+        # self.somatic = serial_.Serial(port=port, baudrate=baud, bytesize=bytesize,
+        #                             timeout=timeout, stopbits=serial_.STOPBITS_ONE)
+        self.capper = Serial(device_port=port, baudrate=baud, data_bits=bytesize, read_timeout=timeout)
+
+        print(f"Established connection with {self.capper} at {port}")
+
+    def connect(self):
+        self.capper.__init__()
+
+    def disconnect(self):
+        # put capper in its default state of "closed" before closing connection
+        # self.home()
+        self.capper.close()
+        print("Disconnected capper")
+
+    def open(self):
+        cmd = f"open"
+        self._execute(cmd)
+
+    def close(self):
+        cmd = "close"
+        self._execute(cmd)
+
+    def tighten(self):
+        cmd = "tighten"
+        self._execute(cmd)
+
+    def loosen(self):
+        cmd = "loosen"
+        self._execute(cmd)
+
+    def home(self):
+        cmd = "home"
+        self._execute(cmd)
+
+
+    def _execute(self, cmd, wait=True):
+        ans = None
+        self.capper.write(cmd.encode())
+
+        # Serial device returns "-4" when action complete
+        while True:
+            # ans = self.somatic.readline().decode("ascii").strip()
+            ans = self.capper.read_line().decode("ascii").strip()
+            if ans == "1":
+                break
+        return ans
+
+
+if __name__ == "__main__":
+    capper = Capper("COM9")
+    capper.home()
+    capper.open()
+    capper.close()
+    # x.loosen()
+    # x.tighten()
+    # time.sleep(3)
+    # x.home()
+
+