pychemstation 0.6.3__tar.gz → 0.6.6__tar.gz

{pychemstation-0.6.3 → pychemstation-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.6.3
+Version: 0.6.6
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao

{pychemstation-0.6.3 → pychemstation-0.6.6}/pychemstation/analysis/process_report.py

@@ -8,7 +8,7 @@ from aghplctools.ingestion.text import _no_peaks_re, _area_report_re, _header_bl
     _signal_table_re, chunk_string
 from result import Result, Err, Ok
 
-from pychemstation.utils.tray_types import FiftyFourVialPlate, int_to_ffvp, Tray
+from pychemstation.utils.tray_types import Tray, FiftyFourVialPlate
 
 
 @dataclass
@@ -239,7 +239,7 @@ def process_csv_report(folder_path: str) -> Result[AgilentReport, AnyStr]:
 
         return Ok(AgilentReport(
             signals=signals,
-            vial_location=int_to_ffvp(vial_location),
+            vial_location=FiftyFourVialPlate.from_int(vial_location),
             solvents=solvents
         ))
 

{pychemstation-0.6.3 → pychemstation-0.6.6}/pychemstation/control/controllers/tables/sequence.py

@@ -41,8 +41,9 @@ class SequenceController(TableController):
         inj_vol = int(self.get_text(row, RegisterFlag.INJ_VOL))
         inj_source = InjectionSource(self.get_text(row, RegisterFlag.INJ_SOR))
         sample_type = SampleType(self.get_num(row, RegisterFlag.SAMPLE_TYPE))
+        vial_enum = TenVialColumn(vial_location) if vial_location <= 10 else FiftyFourVialPlate.from_int(num=vial_location)
         return SequenceEntry(sample_name=sample_name,
-                             vial_location=vial_location,
+                             vial_location=vial_enum,
                              method=None if len(method) == 0 else method,
                              num_inj=num_inj,
                              inj_vol=inj_vol,

{pychemstation-0.6.3 → pychemstation-0.6.6}/pychemstation/control/controllers/tables/table.py

@@ -8,7 +8,7 @@ import abc
 import os
 import warnings
 from dataclasses import dataclass
-from typing import Union, Optional
+from typing import Union, Optional, AnyStr
 
 import numpy as np
 import polling
@@ -48,13 +48,13 @@ class TableController(abc.ABC):
 
             if src and os.path.isdir(src):
                 self.src: str = src
-            else:
-                warnings.warn(f"dir: {src} not found.")
+            elif isinstance(src, str):
+                raise FileNotFoundError(f"dir: {src} not found.")
 
             if data_dir and os.path.isdir(data_dir):
                 self.data_dir: str = data_dir
-            else:
-                warnings.warn(f"dir: {data_dir} not found.")
+            elif isinstance(data_dir, str):
+                raise FileNotFoundError(f"dir: {data_dir} not found.")
 
             if hasattr(self, "data_dir"):
                 self.spectra: dict[str, Optional[AgilentHPLCChromatogram]] = {

{pychemstation-0.6.3 → pychemstation-0.6.6}/pychemstation/control/hplc.py

@@ -43,12 +43,17 @@ class HPLCController:
                  data_dir: str,
                  method_dir: str,
                  sequence_dir: str,
+                 sequence_data_dir: Optional[str] = None,
                  offline: bool = False):
         """Initialize HPLC controller. The `hplc_talk.mac` macro file must be loaded in the Chemstation software.
         `comm_dir` must match the file path in the macro file.
 
         :param comm_dir: Name of directory for communication, where ChemStation will read and write from. Can be any existing directory.
-        :raises FileNotFoundError: If either `data_dir`, `method_dir`, `sequence_dir`, or `comm_dir` is not a valid directory.
+        :param data_dir: Name of directory for storing data after method or sequence runs.
+        :param method_dir: Name of directory where method files are stored.
+        :param sequence_dir: Name of directory where sequence files are stored.
+        :param sequence_data_dir: Name of directory for storing sequence data, if different from method
+        :raises FileNotFoundError: If either `data_dir`, `method_dir`, `sequence_dir`, `sequence_data_dir`or `comm_dir` is not a valid directory.
         """
         self.comm = CommunicationController(comm_dir=comm_dir) if not offline else None
         self.method_controller = MethodController(controller=self.comm,
@@ -61,7 +66,7 @@ class HPLCController:
                                                                                          offline=offline))
         self.sequence_controller = SequenceController(controller=self.comm,
                                                       src=sequence_dir,
-                                                      data_dir=data_dir,
+                                                      data_dir=data_dir if not sequence_data_dir else sequence_data_dir,
                                                       table=self.SEQUENCE_TABLE,
                                                       method_dir=method_dir,
                                                       offline=offline)

{pychemstation-0.6.3 → pychemstation-0.6.6}/pychemstation/utils/method_types.py

@@ -23,7 +23,7 @@ class Param:
 
 @dataclass
 class HPLCMethodParams:
-    organic_modifier: int
+    organic_modifier: float
     flow: float
     pressure: Optional[float] = None  # TODO: find this
 
@@ -51,6 +51,6 @@ class MethodDetails:
     params: HPLCMethodParams
     timetable: list[TimeTableEntry]
     injector_program: Optional[InjectorTable] = None
-    stop_time: Optional[int] = None
-    post_time: Optional[int] = None
+    stop_time: Optional[float] = None
+    post_time: Optional[float] = None
     dad_wavelengthes: Optional[list[Signal]] = None

{pychemstation-0.6.3 → pychemstation-0.6.6}/pychemstation/utils/sequence_types.py

@@ -43,7 +43,7 @@ class SequenceEntry:
     data_file: Optional[str] = None
     method: Optional[str] = None
     num_inj: Optional[int] = 1
-    inj_vol: Optional[int] = 2
+    inj_vol: Optional[float] = 2
     inj_source: Optional[InjectionSource] = InjectionSource.HIP_ALS
     sample_type: Optional[SampleType] = SampleType.SAMPLE
 

pychemstation-0.6.6/pychemstation/utils/tray_types.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from enum import Enum
+from typing import Union
+
+
+class Num(Enum):
+    ONE = 1
+    TWO = 2
+    THREE = 3
+    FOUR = 4
+    FIVE = 5
+    SIX = 6
+    SEVEN = 7
+    EIGHT = 8
+    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")
+
+
+class Plate(Enum):
+    ONE = -96
+    TWO = 4000
+
+    @classmethod
+    def from_num(cls, plate: int) -> Plate:
+        if 1 <= plate <= 2:
+            return Plate.ONE if plate == 1 else Plate.TWO
+        raise ValueError("Plate is one or 1 or 2")
+
+
+class Letter(Enum):
+    A = 4191
+    B = 4255
+    C = 4319
+    D = 4383
+    E = 4447
+    F = 4511
+
+    @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")
+
+
+@dataclass
+class FiftyFourVialPlate:
+    plate: Plate
+    letter: Letter
+    num: Num
+
+    def value(self) -> int:
+        return self.plate.value + self.letter.value + self.num.value
+
+    @classmethod
+    def from_str(cls, loc: str):
+        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:
+            plate = int(loc[1])
+            letter = loc[3]
+            num = int(loc[4])
+            return FiftyFourVialPlate(plate=Plate.from_num(plate),
+                                      letter=Letter.from_str(letter),
+                                      num=Num.from_num(num))
+        except Exception as e:
+            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:
+        row_starts = [
+            # plate 1
+            FiftyFourVialPlate.from_str('P1-F1'),
+            FiftyFourVialPlate.from_str('P1-E1'),
+            FiftyFourVialPlate.from_str('P1-D1'),
+            FiftyFourVialPlate.from_str('P1-C1'),
+            FiftyFourVialPlate.from_str('P1-B1'),
+            FiftyFourVialPlate.from_str('P1-A1'),
+            # plate 2
+            FiftyFourVialPlate.from_str('P2-F1'),
+            FiftyFourVialPlate.from_str('P2-E1'),
+            FiftyFourVialPlate.from_str('P2-D1'),
+            FiftyFourVialPlate.from_str('P2-C1'),
+            FiftyFourVialPlate.from_str('P2-B1'),
+            FiftyFourVialPlate.from_str('P2-A1'),
+        ]
+
+        # find which row
+        possible_row = None
+        for i in range(0, 6):
+            p1_val = row_starts[i].value()
+            p2_val = row_starts[6 + i].value()
+            if num >= p2_val:
+                possible_row = row_starts[6 + i]
+            elif p1_val <= num < row_starts[-1].value():
+                possible_row = row_starts[i]
+            if possible_row:
+                break
+
+        # determine which num
+        if possible_row:
+            starting_loc = possible_row
+            base_val = starting_loc.plate.value + starting_loc.letter.value
+            for i in range(1, 10):
+                if num - i == base_val:
+                    return FiftyFourVialPlate(
+                        plate=starting_loc.plate,
+                        letter=starting_loc.letter,
+                        num=Num.from_num(i))
+        raise ValueError("Number didn't match any location. " + str(num))
+
+
+class TenVialColumn(Enum):
+    ONE = 1
+    TWO = 2
+    THREE = 3
+    FOUR = 4
+    FIVE = 5
+    SIX = 6
+    SEVEN = 7
+    EIGHT = 8
+    NINE = 9
+    TEN = 10
+
+
+Tray = Union[FiftyFourVialPlate, TenVialColumn]

{pychemstation-0.6.3 → pychemstation-0.6.6}/pychemstation.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.6.3
+Version: 0.6.6
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/device-api/pychemstation
 Author: Lucy Hao

{pychemstation-0.6.3 → pychemstation-0.6.6}/pychemstation.egg-info/SOURCES.txt

@@ -43,9 +43,6 @@ pychemstation/utils/table_types.py
 pychemstation/utils/tray_types.py
 tests/__init__.py
 tests/constants.py
-tests/test_comb.py
-tests/test_comm.py
-tests/test_inj.py
-tests/test_method.py
-tests/test_proc_rep.py
-tests/test_sequence.py
+tests/test_nightly.py
+tests/test_runs_stable.py
+tests/test_stable.py

{pychemstation-0.6.3 → pychemstation-0.6.6}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setuptools.setup(
     name="pychemstation",
-    version="0.6.3",
+    version="0.6.6",
     author="Lucy Hao",
     author_email="lhao03@student.ubc.ca",
     description="Library to interact with Chemstation software, primarily used in Hein lab",

{pychemstation-0.6.3 → pychemstation-0.6.6}/tests/constants.py

@@ -1,5 +1,8 @@
+import os
 import random
 
+from pychemstation.control import HPLCController
+from pychemstation.utils.macro import Command
 from pychemstation.utils.method_types import *
 from pychemstation.utils.sequence_types import *
 
@@ -63,3 +66,19 @@ seq_entry = SequenceEntry(
     sample_name="Test",
     sample_type=SampleType(int(random.random() * 3)),
 )
+
+
+def set_up_utils(num: int) -> HPLCController:
+    path_constants = room(num)
+    for path in path_constants:
+        if not os.path.exists(path):
+            raise FileNotFoundError(
+                f"{path} does not exist on your system. If you would like to run tests, please change this path.")
+
+    controller = HPLCController(comm_dir=path_constants[0],
+                                method_dir=path_constants[1],
+                                data_dir=path_constants[2],
+                                sequence_dir=path_constants[3])
+    controller.send(Command.SAVE_METHOD_CMD.value.format(commit_msg="method saved by pychemstation"))
+    controller.send(Command.SAVE_SEQUENCE_CMD)
+    return controller

pychemstation-0.6.3/tests/test_inj.py → pychemstation-0.6.6/tests/test_nightly.py

@@ -1,14 +1,15 @@
-import os
 import unittest
 
-from pychemstation.control import HPLCController
+from pluggy import Result
+
+from pychemstation.analysis.process_report import process_csv_report
 from pychemstation.utils.tray_types import FiftyFourVialPlate, Letter, Plate, Num
 from tests.constants import *
 
 offline = True
 
 
-class TestInj(unittest.TestCase):
+class TestNightly(unittest.TestCase):
     def setUp(self):
         path_constants = room(254)
         for path in path_constants:
@@ -34,6 +35,46 @@ class TestInj(unittest.TestCase):
     def test_plate_number(self):
         self.assertEqual(4096, FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.A, num=Num.FOUR).value())
 
+    def test_build_peak_regex(self):
+        try:
+            # TODO
+            print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_parse_area_report(self):
+        try:
+            # TODO
+            print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_process_export_report(self):
+        try:
+            import pandas as pd
+
+            file_path = "/Users/lucyhao/Codes/pychemstation/tests/0_2025-03-15 19-14-35.D/Report00.CSV"
+            df = pd.read_csv(file_path, encoding="utf-16")
+
+            # Print the first column
+            print(df)
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_process_folder(self):
+        try:
+            # TODO
+            print('yes')
+        except Exception as e:
+            self.fail(f"Should have not failed, {e}")
+
+    def test_report_csv(self):
+        try:
+            report: Result = process_csv_report(folder_path="0_2025-03-15 19-14-35.D")
+            print(report)
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
 
 if __name__ == '__main__':
     unittest.main()

pychemstation-0.6.6/tests/test_runs_stable.py

@@ -0,0 +1,88 @@
+
+import unittest
+
+from pychemstation.utils.tray_types import FiftyFourVialPlate, Plate, Letter, Num
+from tests.constants import *
+
+run_too = True
+
+
+class TestRunsStable(unittest.TestCase):
+    def setUp(self):
+        self.hplc_controller = set_up_utils(254)
+
+    def test_run_method(self):
+        try:
+            self.hplc_controller.run_method(experiment_name="test_experiment")
+            chrom = self.hplc_controller.get_last_run_method_data()
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+    def test_run_10_times(self):
+        self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+        rand_method = MethodDetails(
+            name=DEFAULT_METHOD,
+            params=HPLCMethodParams(
+                organic_modifier=5,
+                flow=0.65),
+            timetable=[TimeTableEntry(
+                start_time=0.50,
+                organic_modifer=99,
+                flow=0.65)],
+            stop_time=1,
+            post_time=0)
+        self.hplc_controller.edit_method(rand_method, save=True)
+        try:
+            for _ in range(10):
+                self.hplc_controller.run_method(experiment_name="limiting_testing")
+        except Exception as e:
+            self.fail(f"Should have not failed: {e}")
+
+    def test_update_method_update_seq_table_run(self):
+        try:
+            loc = FiftyFourVialPlate(plate=Plate.ONE, letter=Letter.F, num=Num.TWO)
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            seq_table = SequenceTable(
+                name=DEFAULT_SEQUENCE,
+                rows=[SequenceEntry(
+                    vial_location=loc,
+                    sample_name="run seq with new method",
+                    method=DEFAULT_METHOD,
+                    inj_source=InjectionSource.HIP_ALS,
+                    inj_vol=0.5,
+                    num_inj=1,
+                    sample_type=SampleType.SAMPLE
+                )])
+            self.hplc_controller.edit_sequence(seq_table) # bug didnt delete all the rows, left an extra
+
+            self.hplc_controller.method_controller.switch(DEFAULT_METHOD)
+            rand_method = MethodDetails(
+                name=DEFAULT_METHOD,
+                params=HPLCMethodParams(
+                    organic_modifier=5,
+                    flow=0.65),
+                timetable=[TimeTableEntry(
+                    start_time=random.randint(1, 3) + 0.50,
+                    organic_modifer=100,
+                    flow=0.65)],
+                stop_time=random.randint(4, 6),
+                post_time=1)
+            self.hplc_controller.edit_method(rand_method, save=True)
+            if run_too:
+                self.hplc_controller.preprun()
+                self.hplc_controller.run_sequence()
+                chrom = self.hplc_controller.get_last_run_sequence_data()
+                # report = process_csv_report(self.hplc_controller.sequence_controller.data_files[-1].child_dirs[-1])
+                # self.assertEqual(loc, report.ok_value.vial_location)
+        except Exception:
+            self.fail("Failed")
+
+    def test_run_sequence(self):
+        try:
+            self.hplc_controller.switch_sequence(sequence_name=DEFAULT_SEQUENCE)
+            self.hplc_controller.preprun()
+            self.hplc_controller.run_sequence()
+            chrom = self.hplc_controller.get_last_run_sequence_data()
+            self.assertTrue(len(chrom) == 1)
+        except Exception:
+            self.fail("Failed")