ivoryOS 0.1.0__py3-none-any.whl

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

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

example/abstract_robot_classes/chemical.py

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

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

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

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

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]

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}")

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"""
+
+

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")
+

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

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()

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()
+
+