pychemstation 0.7.0.dev1__py3-none-any.whl → 0.8.0__py3-none-any.whl

pychemstation/utils/tray_types.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import math
 from dataclasses import dataclass
 from enum import Enum
 from typing import Union
@@ -18,28 +17,23 @@ class Num(Enum):
     NINE = 9
 
     @classmethod
-    def from_num(cls, num: int) -> Num:
-        match num:
-            case 1:
-                return Num.ONE
-            case 2:
-                return Num.TWO
-            case 3:
-                return Num.THREE
-            case 4:
-                return Num.FOUR
-            case 5:
-                return Num.FIVE
-            case 6:
-                return Num.SIX
-            case 7:
-                return Num.SEVEN
-            case 8:
-                return Num.EIGHT
-            case 9:
-                return Num.NINE
-            case _:
-                raise ValueError("Num is one of 1 to 9")
+    def from_num(cls, num: int):
+        num_mapping = {
+        1: Num.ONE,
+        2: Num.TWO,
+        3: Num.THREE,
+        4: Num.FOUR,
+        5: Num.FIVE,
+        6: Num.SIX,
+        7: Num.SEVEN,
+        8: Num.EIGHT,
+        9: Num.NINE
+    }
+
+        if num in num_mapping:
+            return num_mapping[num]
+        else:
+            raise ValueError("Num must be between 1 and 9")
 
 
 class Plate(Enum):
@@ -63,25 +57,32 @@ class Letter(Enum):
 
     @classmethod
     def from_str(cls, let: str) -> Letter:
-        match let:
-            case "A":
-                return Letter.A
-            case "B":
-                return Letter.B
-            case "C":
-                return Letter.C
-            case "D":
-                return Letter.D
-            case "E":
-                return Letter.E
-            case "F":
-                return Letter.F
-            case _:
-                raise ValueError("Letter is one of A to F")
+        letter_mapping = {
+        "A": Letter.A,
+        "B": Letter.B,
+        "C": Letter.C,
+        "D": Letter.D,
+        "E": Letter.E,
+        "F": Letter.F
+    }
+
+        if let in letter_mapping:
+            return letter_mapping[let]
+        else:
+            raise ValueError("Letter must be one of A to F")
 
 
 @dataclass
 class FiftyFourVialPlate:
+    """
+    Class to represent the 54 vial tray. Assumes you have:
+    2 plates (P1 or P2)
+    6 rows (A B C D E F)
+    9 columns (1 2 3 4 5 6 7 8 9)
+
+    valid vial locations: P1-A2, P2-F9
+    invalid vial locations: P3-A1, P1-Z3, P2-B10
+    """
     plate: Plate
     letter: Letter
     num: Num
@@ -91,6 +92,12 @@ class FiftyFourVialPlate:
 
     @classmethod
     def from_str(cls, loc: str):
+        """
+        Converts a string representing the vial location into numerical representation for Chemstation.
+        :param loc: vial location
+        :returns: `FiftyFourVialPlate` object representing the vial location
+        :raises: ValueError if string is invalid tray location
+        """
         if len(loc) != 5:
             raise ValueError("Plate locations must be PX-LY, where X is either 1 or 2 and Y is 1 to 9")
         try:
@@ -104,7 +111,17 @@ class FiftyFourVialPlate:
             raise ValueError("Plate locations must be PX-LY, where X is either 1 or 2 and Y is 1 to 9")
 
     @classmethod
-    def from_int(cls, num: int) -> FiftyFourVialPlate:
+    def from_int(cls, num: int) -> Tray:
+        """
+        Converts an integer representation of a vial location to a `FiftyFourVialPlate` or `TenVialColumn` object
+
+        :param num: numerical representation of a vial location
+        :returns: the proper vial location object
+        :raises: ValueError no matching can be made
+        """
+        if num in range(1, 11):
+            return TenVialColumn(num)
+
         row_starts = [
             # plate 1
             FiftyFourVialPlate.from_str('P1-F1'),
@@ -148,6 +165,9 @@ class FiftyFourVialPlate:
 
 
 class TenVialColumn(Enum):
+    """
+    Class to represent the 10 vial locations.
+    """
     ONE = 1
     TWO = 2
     THREE = 3

{pychemstation-0.7.0.dev1.dist-info → pychemstation-0.8.0.dist-info}/METADATA

@@ -1,21 +1,24 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.7.0.dev1
-Summary: Library to interact with Chemstation software, primarily used in Hein lab
-Home-page: https://gitlab.com/heingroup/device-api/pychemstation
-Author: Lucy Hao
-Author-email: lhao03@student.ubc.ca
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Description-Content-Type: text/markdown
+Version: 0.8.0
+Author-email: lucyhao <hao.lucyy@gmail.com>
 License-File: LICENSE
-Requires-Dist: polling
-Requires-Dist: seabreeze
-Requires-Dist: xsdata
-Requires-Dist: result
-Requires-Dist: rainbow-api
-Requires-Dist: aghplctools==4.8.6
+Requires-Python: >=3.8
+Requires-Dist: aghplctools>=4.8.8
+Requires-Dist: coverage>=7.6.1
+Requires-Dist: matplotlib>=3.7.5
+Requires-Dist: pandas>=2.0.3
+Requires-Dist: pdoc>=14.7.0
+Requires-Dist: polling>=0.3.2
+Requires-Dist: pytest>=7.3.5
+Requires-Dist: rainbow-api>=1.0.10
+Requires-Dist: result>=0.17.0
+Requires-Dist: scipy>=1.10.1
+Requires-Dist: seabreeze>=2.9.2
+Requires-Dist: setuptools>=75.3.2
+Requires-Dist: twine>=6.1.0
+Requires-Dist: xsdata>=24.9
+Description-Content-Type: text/markdown
 
 # Agilent HPLC Macro Control
 
@@ -67,13 +70,14 @@ from pychemstation.control import HPLCController
 import pandas as pd
 
 # these paths will be unique to your Chemstation setup
-DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"
 DEFAULT_METHOD = "GENERAL-POROSHELL"
+DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"
 DEFAULT_METHOD_DIR = "C:\\ChemStation\\1\\Methods\\"
-DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
-SEQUENCE_DIR = "C:\\USERS\\PUBLIC\\DOCUMENTS\\CHEMSTATION\\2\\Sequence"
+DATA_DIR_2 = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data\\"
+DATA_DIR_3 = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data\\"
+SEQUENCE_DIR = "C:\\USERS\\PUBLIC\\DOCUMENTS\\CHEMSTATION\\2\\Sequence\\"
 
-hplc_controller = HPLCController(data_dir=DATA_DIR,
+hplc_controller = HPLCController(data_dirs=[DATA_DIR_2, DATA_DIR_3],
                                  comm_dir=DEFAULT_COMMAND_PATH,
                                  sequence_dir=SEQUENCE_DIR,
                                  method_dir=DEFAULT_METHOD_DIR)
@@ -107,4 +111,4 @@ Lucy Hao, Maria Politi
   Group. Copyright © Cronin Group, used under the [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/) license.
 - Adapted from the [MACROS](https://github.com/Bourne-Group/HPLCMethodOptimisationGUI)
   used in [**Operator-free HPLC automated method development guided by Bayesian optimization**](https://pubs.rsc.org/en/content/articlelanding/2024/dd/d4dd00062e),
-  created by members in the Bourne Group.  Copyright © Bourne Group, used under the [MIT](https://opensource.org/license/mit) license.
+  created by members in the Bourne Group.  Copyright © Bourne Group, used under the [MIT](https://opensource.org/license/mit) license.

pychemstation-0.8.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+pychemstation/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
+pychemstation/out.txt,sha256=PLwo0w7AOhwQUSmvf3jupRuBH9eEtPmVhLrVaFoDqJo,5990
+pychemstation/tests.ipynb,sha256=rDrl2AyP47sWO5ZmPxUrMzExS8ex1k1NIe9UbMwkKio,41136
+pychemstation/analysis/__init__.py,sha256=EWoU47iyn9xGS-b44zK9eq50bSjOV4AC5dvt420YMI4,44
+pychemstation/analysis/base_spectrum.py,sha256=dPULGlr-sMHNMDIdyzlvX8taw_nkBliKTb00lNI8cwk,16517
+pychemstation/analysis/process_report.py,sha256=wysKaA06UeK_9ba2SZc9maP4P-HQfZDMD9NNt21kWcY,11850
+pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-GKjiDi8,10201
+pychemstation/analysis/utils.py,sha256=rgpTJTrpsiBANbtsfys9xj0sqlTe__3J0OSeoygaQTM,2081
+pychemstation/control/README.md,sha256=7Q0rY014y7Qq8wfL7GSQG0l2P1PXfmgB0qZ2YkkE7n0,3350
+pychemstation/control/__init__.py,sha256=4xTy8X-mkn_PPZKr7w9rnj1wZhtmTesbQptPhpYmKXs,64
+pychemstation/control/hplc.py,sha256=E_QFMOqUabiqCO6Pu4lZYTsiWhdQULw4AqyKPwiQx90,12628
+pychemstation/control/controllers/README.md,sha256=S5cd4NJmPjs6TUH98BtPJJhiS1Lu-mxLCNS786ogOrQ,32
+pychemstation/control/controllers/__init__.py,sha256=LuFEsVGN5sXuHW_DG61DWBDJ_fU4dMls4bQJ5XNRaok,166
+pychemstation/control/controllers/comm.py,sha256=fRCFh3Ye-HnoGaur69NRdkLHNtdlMoJjIOTqeJe1tAk,7720
+pychemstation/control/controllers/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/control/controllers/devices/device.py,sha256=d9SwasjXTXplkRK5eH3asrNPo3BBZmAz6CKBYAuKSIc,1249
+pychemstation/control/controllers/devices/injector.py,sha256=ynPQtvMFt1iK0LQBf4ZEYdxJCyavmashXwyCQbmRjuw,5542
+pychemstation/control/controllers/tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/control/controllers/tables/method.py,sha256=UMLwzsMYsZx53PMgmKIe6LcK4JjAUpuK41x9VMJObNw,17709
+pychemstation/control/controllers/tables/ms.py,sha256=JFD-tOhu8uRyKdl-E3-neRssii8MNqVRIlsrnFhNY_M,682
+pychemstation/control/controllers/tables/sequence.py,sha256=UT0KUDnn8A-19V24ZgW3KduSulvtbdvsJF9NJBUrz9M,13109
+pychemstation/control/controllers/tables/table.py,sha256=L7OECX502lk2o88hu5Sdb3O4cJxsNGic2193oSz7urI,12298
+pychemstation/generated/__init__.py,sha256=GAoZFAYbPVEJDkcOw3e1rgOqd7TCW0HyKNPM8OMehMg,1005
+pychemstation/generated/dad_method.py,sha256=zfS9op450CRSGPKkUr9qUyPBbND06b9N8SUU9j4cosM,8408
+pychemstation/generated/pump_method.py,sha256=c_FB14rgODZyH5eDb3kxZAI77xRj1HMpQkE2R6MypNA,12180
+pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/utils/chromatogram.py,sha256=s6mqru88E9YQGLbdr2Thm2plf8urCFoHHkMqW6_1Rz4,3338
+pychemstation/utils/injector_types.py,sha256=hTgC-4xnO-EXOLOsCZ0L6TX4KUsB14Q-5jU4_hCzmfM,822
+pychemstation/utils/macro.py,sha256=WgXGR8fgyR_QhRML9NUD3oZZBT4LLSI9uwuragHEe2k,2904
+pychemstation/utils/method_types.py,sha256=5FK7RThLhaQcLrzRi_qLnlPqZuGPtwwipP6eMoq0kpE,1638
+pychemstation/utils/parsing.py,sha256=bnFIsZZwFy9NKzVUf517yN-ogzQbm0hp_aho3KUD6Is,9317
+pychemstation/utils/pump_types.py,sha256=HWQHxscGn19NTrfYBwQRCO2VcYfwyko7YfBO5uDhEm4,93
+pychemstation/utils/sequence_types.py,sha256=x2EClcq6ROdzeLZg63XcXXTknwl2aZ48Vuyru0xZjgA,1086
+pychemstation/utils/table_types.py,sha256=7txqW_oNpkh4venSkGEtreVe6UV9dzNB1DTrIeTkQHA,3217
+pychemstation/utils/tray_types.py,sha256=eOO-muUjadyvCM8JnYAZVyxJeyYBlENP1zXiFskAFbs,5049
+pychemstation-0.8.0.dist-info/METADATA,sha256=7cSMnoyDeOne85r2n7Bh3IsBeC5xWGVhuu4I0hNTeCo,4491
+pychemstation-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pychemstation-0.8.0.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.8.0.dist-info/RECORD,,

{pychemstation-0.7.0.dev1.dist-info → pychemstation-0.8.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

pychemstation/control/comm.py

@@ -1,206 +0,0 @@
-"""
-Module to provide API for the communication with Agilent HPLC systems.
-
-HPLCController sends commands to Chemstation software via a command file.
-Answers are received via reply file. On the Chemstation side, a custom
-Macro monitors the command file, executes commands and writes to the reply file.
-Each command is given a number (cmd_no) to keep track of which commands have
-been processed.
-
-Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
-"""
-
-import os
-import time
-
-from result import Result, Ok, Err
-from ..utils.macro import *
-from ..utils.method_types import *
-
-
-class CommunicationController:
-    """
-    Class that communicates with Agilent using Macros
-    """
-
-    # maximum command number
-    MAX_CMD_NO = 255
-
-    def __init__(
-            self,
-            comm_dir: str,
-            cmd_file: str = "cmd",
-            reply_file: str = "reply",
-    ):
-        """
-        :param comm_dir:
-        :param cmd_file: Name of command file
-        :param reply_file: Name of reply file
-        """
-        if os.path.isdir(comm_dir):
-            self.cmd_file = os.path.join(comm_dir, cmd_file)
-            self.reply_file = os.path.join(comm_dir, reply_file)
-            self.cmd_no = 0
-        else:
-            raise FileNotFoundError(f"comm_dir: {comm_dir} not found.")
-        self._most_recent_hplc_status = None
-
-        # Create files for Chemstation to communicate with Python
-        open(self.cmd_file, "a").close()
-        open(self.reply_file, "a").close()
-
-        self.reset_cmd_counter()
-
-    def get_num_val(self, cmd: str) -> Union[int, float, Err]:
-        self.send(Command.GET_NUM_VAL_CMD.value.format(cmd=cmd))
-        res = self.receive()
-        if res.is_ok():
-            return res.ok_value.num_response
-        else:
-            raise RuntimeError("Failed to get number.")
-
-    def get_text_val(self, cmd: str) -> str:
-        self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
-        res = self.receive()
-        if res.is_ok():
-            return res.ok_value.string_response
-        else:
-            raise RuntimeError("Failed to get string")
-
-    def get_status(self) -> Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]:
-        """Get device status(es).
-
-        :return: list of ChemStation's current status
-        """
-        self.send(Command.GET_STATUS_CMD)
-        time.sleep(1)
-
-        try:
-            parsed_response = self.receive().value.string_response
-            self._most_recent_hplc_status = str_to_status(parsed_response)
-            return self._most_recent_hplc_status
-        except IOError:
-            return HPLCErrorStatus.NORESPONSE
-        except IndexError:
-            return HPLCErrorStatus.MALFORMED
-
-    def set_status(self):
-        """Updates current status of HPLC machine"""
-        self._most_recent_hplc_status = self.get_status()
-
-    def check_if_running(self) -> bool:
-        """Checks if HPLC machine is in an available state, meaning a state that data is not being written.
-
-        :return: whether the HPLC machine is in a safe state to retrieve data back."""
-        self.set_status()
-        hplc_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        time.sleep(30)
-        self.set_status()
-        hplc_actually_avail = isinstance(self._most_recent_hplc_status, HPLCAvailStatus)
-        return hplc_avail and hplc_actually_avail
-
-    def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
-        """Low-level execution primitive. Sends a command string to HPLC.
-
-        :param cmd: string to be sent to HPLC
-        :param cmd_no: Command number
-        :param num_attempts: Number of attempts to send the command before raising exception.
-        :raises IOError: Could not write to command file.
-        """
-        err = None
-        for _ in range(num_attempts):
-            time.sleep(1)
-            try:
-                with open(self.cmd_file, "w", encoding="utf8") as cmd_file:
-                    cmd_file.write(f"{cmd_no} {cmd}")
-            except IOError as e:
-                err = e
-                continue
-            else:
-                return
-        else:
-            raise IOError(f"Failed to send command #{cmd_no}: {cmd}.") from err
-
-    def _receive(self, cmd_no: int, num_attempts=100) -> Result[str, str]:
-        """Low-level execution primitive. Recives a response from HPLC.
-
-        :param cmd_no: Command number
-        :param num_attempts: Number of retries to open reply file
-        :raises IOError: Could not read reply file.
-        :return: Potential ChemStation response
-        """
-        err = None
-        for _ in range(num_attempts):
-            time.sleep(1)
-
-            try:
-                with open(self.reply_file, "r", encoding="utf_16") as reply_file:
-                    response = reply_file.read()
-            except OSError as e:
-                err = e
-                continue
-
-            try:
-                first_line = response.splitlines()[0]
-                response_no = int(first_line.split()[0])
-            except IndexError as e:
-                err = e
-                continue
-
-            # check that response corresponds to sent command
-            if response_no == cmd_no:
-                return Ok(response)
-            else:
-                continue
-        else:
-            return Err(f"Failed to receive reply to command #{cmd_no} due to {err}.")
-
-    def sleepy_send(self, cmd: Union[Command, str]):
-        self.send("Sleep 0.1")
-        self.send(cmd)
-        self.send("Sleep 0.1")
-
-    def send(self, cmd: Union[Command, str]):
-        """Sends a command to Chemstation.
-
-        :param cmd: Command to be sent to HPLC
-        """
-        if self.cmd_no == self.MAX_CMD_NO:
-            self.reset_cmd_counter()
-
-        cmd_to_send: str = cmd.value if isinstance(cmd, Command) else cmd
-        self.cmd_no += 1
-        self._send(cmd_to_send, self.cmd_no)
-        f = open("out.txt", "a")
-        f.write(cmd_to_send + "\n")
-        f.close()
-
-    def receive(self) -> Result[Response, str]:
-        """Returns messages received in reply file.
-
-        :return: ChemStation response 
-        """
-        num_response_prefix = "Numerical Responses:"
-        str_response_prefix = "String Responses:"
-        possible_response = self._receive(self.cmd_no)
-        if Ok(possible_response):
-            lines = possible_response.value.splitlines()
-            for line in lines:
-                if str_response_prefix in line and num_response_prefix in line:
-                    string_responses_dirty, _, numerical_responses = line.partition(num_response_prefix)
-                    _, _, string_responses = string_responses_dirty.partition(str_response_prefix)
-                    return Ok(Response(string_response=string_responses.strip(),
-                                       num_response=float(numerical_responses.strip())))
-            return Err(f"Could not retrieve HPLC response")
-        else:
-            return Err(f"Could not establish response to HPLC: {possible_response}")
-
-    def reset_cmd_counter(self):
-        """Resets the command counter."""
-        self._send(Command.RESET_COUNTER_CMD.value, cmd_no=self.MAX_CMD_NO + 1)
-        self._receive(cmd_no=self.MAX_CMD_NO + 1)
-        self.cmd_no = 0
-
-    def stop_macro(self):
-        """Stops Macro execution. Connection will be lost."""
-        self.send(Command.STOP_MACRO_CMD)

pychemstation/control/controllers/devices/column.py

@@ -1,12 +0,0 @@
-from ....control.controllers import CommunicationController
-from .device import DeviceController
-from ....utils.table_types import Table
-
-
-class ColumnController(DeviceController):
-
-    def __init__(self, controller: CommunicationController, table: Table):
-        super().__init__(controller, table)
-
-    def get_row(self, row: int):
-        pass

pychemstation/control/controllers/devices/pump.py

@@ -1,43 +0,0 @@
-from ....control.controllers import CommunicationController
-from .device import DeviceController
-from ....utils.pump_types import Pump
-from ....utils.table_types import Table
-
-
-class PumpController(DeviceController):
-
-    def __init__(self, controller: CommunicationController, table: Table):
-        super().__init__(controller, table)
-        self.A1 = Pump(in_use=True, solvent="A1")
-        self.B1 = Pump(in_use=True, solvent="B1")
-        self.A2 = Pump(in_use=False, solvent="A2")
-        self.B2 = Pump(in_use=False, solvent="B2")
-
-    def validate_pumps(self):
-        invalid_A_pump_usage = self.A1.in_use and self.A2.in_use
-        invalid_B_pump_usage = self.B1.in_use and self.B2.in_use
-        if invalid_A_pump_usage or invalid_B_pump_usage:
-            raise AttributeError
-
-    def switch_pump(self, num: int, pump: str):
-        if pump == "A":
-            if num == 1:
-                self.A1.in_use = True
-                self.A2.in_use = False
-            elif num == 2:
-                self.A1.in_use = False
-                self.A2.in_use = True
-        elif pump == "B":
-            if num == 1:
-                self.B1.in_use = True
-                self.B2.in_use = False
-            elif num == 2:
-                self.B1.in_use = False
-                self.B2.in_use = True
-        self.purge()
-
-    def purge(self):
-        pass
-
-    def get_row(self, row: int):
-        pass