pychemstation 0.7.0.dev2__py3-none-any.whl → 0.8.1__py3-none-any.whl

pychemstation/control/table/sequence.py

@@ -1,210 +0,0 @@
-from typing import Any
-
-from copy import deepcopy
-
-import os
-import time
-
-from .table_controller import TableController
-from ...control import CommunicationController
-from ...utils.chromatogram import SEQUENCE_TIME_FORMAT, AgilentHPLCChromatogram
-from ...utils.macro import Command
-from ...utils.sequence_types import SequenceTable, SequenceEntry, SequenceDataFiles, InjectionSource, SampleType
-from ...utils.table_types import TableOperation, RegisterFlag, Table
-from ...utils.tray_types import TenColumn
-
-
-class SequenceController(TableController):
-    """
-    Class containing sequence related logic
-    """
-
-    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table, method_dir: str):
-        self.method_dir = method_dir
-        super().__init__(controller, src, data_dir, table)
-
-    def load(self) -> SequenceTable:
-        rows = self.get_num_rows()
-        self.send(Command.GET_SEQUENCE_CMD)
-        seq_name = self.receive()
-
-        if rows.is_ok() and seq_name.is_ok():
-            return SequenceTable(
-                name=seq_name.ok_value.string_response.partition(".S")[0],
-                rows=[self.get_row(r + 1) for r in range(int(rows.ok_value.num_response))])
-        raise RuntimeError(rows.err_value)
-
-    def get_row(self, row: int) -> SequenceEntry:
-        sample_name = self.get_text(row, RegisterFlag.NAME)
-        vial_location = int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
-        method = self.get_text(row, RegisterFlag.METHOD)
-        num_inj = int(self.get_num(row, RegisterFlag.NUM_INJ))
-        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))
-        return SequenceEntry(sample_name=sample_name,
-                             vial_location=vial_location,
-                             method=None if len(method) == 0 else method,
-                             num_inj=num_inj,
-                             inj_vol=inj_vol,
-                             inj_source=inj_source,
-                             sample_type=sample_type, )
-
-    def switch(self, seq_name: str):
-        """
-        Switch to the specified sequence. The sequence name does not need the '.S' extension.
-
-        :param seq_name: The name of the sequence file
-        """
-        self.send(f'_SeqFile$ = "{seq_name}.S"')
-        self.send(f'_SeqPath$ = "{self.src}"')
-        self.send(Command.SWITCH_SEQUENCE_CMD)
-        time.sleep(2)
-        self.send(Command.GET_SEQUENCE_CMD)
-        time.sleep(2)
-        parsed_response = self.receive().value.string_response
-
-        assert parsed_response == f"{seq_name}.S", "Switching sequence failed."
-
-    def edit(self, sequence_table: SequenceTable):
-        """
-        Updates the currently loaded sequence table with the provided table. This method will delete the existing sequence table and remake it.
-        If you would only like to edit a single row of a sequence table, use `edit_sequence_table_row` instead.
-
-        :param sequence_table:
-        """
-
-        rows = self.get_num_rows()
-        if rows.is_ok():
-            existing_row_num = rows.value.num_response
-            wanted_row_num = len(sequence_table.rows)
-            while existing_row_num != wanted_row_num:
-                if wanted_row_num > existing_row_num:
-                    self.add_row()
-                elif wanted_row_num < existing_row_num:
-                    self.delete_row(int(existing_row_num))
-                self.send(Command.SAVE_SEQUENCE_CMD)
-                existing_row_num = self.get_num_rows().ok_value.num_response
-            self.send(Command.SWITCH_SEQUENCE_CMD)
-
-            for i, row in enumerate(sequence_table.rows):
-                self.edit_row(row=row, row_num=i + 1)
-                self.sleep(1)
-            self.send(Command.SAVE_SEQUENCE_CMD)
-            self.send(Command.SWITCH_SEQUENCE_CMD)
-
-    def edit_row(self, row: SequenceEntry, row_num: int):
-        """
-        Edits a row in the sequence table. If a row does NOT exist, a new one will be created.
-
-        :param row: sequence row entry with updated information
-        :param row_num: the row to edit, based on 1-based indexing
-        """
-        num_rows = self.get_num_rows()
-        if num_rows.is_ok():
-            while num_rows.ok_value.num_response < row_num:
-                self.add_row()
-                self.send(Command.SAVE_SEQUENCE_CMD)
-                num_rows = self.get_num_rows()
-
-        table_register = self.table.register
-        table_name = self.table.name
-
-        if row.vial_location:
-            loc = row.vial_location
-            if isinstance(row.vial_location, InjectionSource):
-                loc = row.vial_location.value
-            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
-                                                                      table_name=table_name,
-                                                                      row=row_num,
-                                                                      col_name=RegisterFlag.VIAL_LOCATION,
-                                                                      val=loc))
-        if row.method:
-            possible_path = os.path.join(self.method_dir, row.method) + ".M\\"
-            method = row.method
-            if os.path.exists(possible_path):
-                method = os.path.join(self.method_dir, row.method)
-            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.METHOD,
-                                                                       val=method))
-
-        if row.num_inj:
-            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
-                                                                      table_name=table_name,
-                                                                      row=row_num,
-                                                                      col_name=RegisterFlag.NUM_INJ,
-                                                                      val=row.num_inj))
-
-        if row.inj_vol:
-            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.INJ_VOL,
-                                                                       val=row.inj_vol))
-
-        if row.inj_source:
-            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.INJ_SOR,
-                                                                       val=row.inj_source.value))
-
-        if row.sample_name:
-            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.NAME,
-                                                                       val=row.sample_name))
-            self.sleepy_send(TableOperation.EDIT_ROW_TEXT.value.format(register=table_register,
-                                                                       table_name=table_name,
-                                                                       row=row_num,
-                                                                       col_name=RegisterFlag.DATA_FILE,
-                                                                       val=row.sample_name))
-        if row.sample_type:
-            self.sleepy_send(TableOperation.EDIT_ROW_VAL.value.format(register=table_register,
-                                                                      table_name=table_name,
-                                                                      row=row_num,
-                                                                      col_name=RegisterFlag.SAMPLE_TYPE,
-                                                                      val=row.sample_type.value))
-
-        self.send(Command.SAVE_SEQUENCE_CMD)
-
-    def run(self):
-        """
-        Starts the currently loaded sequence, storing data
-        under the <data_dir>/<sequence table name> folder.
-        Device must be ready.
-        """
-        timestamp = time.strftime(SEQUENCE_TIME_FORMAT)
-        seq_table = self.load()
-        self.send(Command.RUN_SEQUENCE_CMD.value)
-
-        if self.check_hplc_is_running():
-            folder_name = f"{seq_table.name} {timestamp}"
-            self.data_files.append(SequenceDataFiles(dir=folder_name,
-                                                     sequence_name=seq_table.name))
-
-        run_completed = self.check_hplc_done_running(sequence=seq_table)
-
-        if run_completed.is_ok():
-            self.data_files[-1].dir = run_completed.value
-        else:
-            raise RuntimeError("Run error has occured.")
-
-    def retrieve_recent_data_files(self):
-        sequence_data_files: SequenceDataFiles = self.data_files[-1]
-        return sequence_data_files.dir
-
-    def get_data(self) -> list[dict[str, AgilentHPLCChromatogram]]:
-        parent_dir = self.data_files[-1].dir
-        subdirs = [x[0] for x in os.walk(self.data_dir)]
-        potential_folders = sorted(list(filter(lambda d: parent_dir in d, subdirs)))
-        self.data_files[-1].child_dirs = [f for f in potential_folders if parent_dir in f and ".M" not in f and ".D" in f]
-
-        spectra: list[dict[str, AgilentHPLCChromatogram]] = []
-        for row in self.data_files[-1].child_dirs:
-            self.get_spectrum(row)
-            spectra.append(deepcopy(self.spectra))
-        return spectra

pychemstation/control/table/table_controller.py

@@ -1,201 +0,0 @@
-"""
-Abstract module containing shared logic for Method and Sequence tables.
-
-Authors: Lucy Hao
-"""
-
-import abc
-import os
-import time
-from typing import Union, Optional
-
-import polling
-from result import Result, Ok, Err
-
-from ...control.controllers.comm import CommunicationController
-from ...utils.chromatogram import AgilentHPLCChromatogram, AgilentChannelChromatogramData
-from ...utils.macro import Command, HPLCRunningStatus, Response
-from ...utils.method_types import MethodTimetable
-from ...utils.sequence_types import SequenceDataFiles, SequenceTable
-from ...utils.table_types import Table, TableOperation, RegisterFlag
-
-
-class TableController(abc.ABC):
-
-    def __init__(self, controller: CommunicationController, src: str, data_dir: str, table: Table):
-        self.controller = controller
-        self.table = table
-
-        if os.path.isdir(src):
-            self.src: str = src
-        else:
-            raise FileNotFoundError(f"dir: {src} not found.")
-
-        if os.path.isdir(data_dir):
-            self.data_dir: str = data_dir
-        else:
-            raise FileNotFoundError(f"dir: {data_dir} not found.")
-
-        self.spectra: dict[str, AgilentHPLCChromatogram] = {
-            "A": AgilentHPLCChromatogram(self.data_dir),
-            "B": AgilentHPLCChromatogram(self.data_dir),
-            "C": AgilentHPLCChromatogram(self.data_dir),
-            "D": AgilentHPLCChromatogram(self.data_dir),
-        }
-
-        self.data_files: Union[list[SequenceDataFiles], list[str]] = []
-
-    def receive(self) -> Result[Response, str]:
-        for _ in range(10):
-            try:
-                return self.controller.receive()
-            except IndexError:
-                continue
-        return Err("Could not parse response")
-
-    def send(self, cmd: Union[Command, str]):
-        self.controller.send(cmd)
-
-    def sleepy_send(self, cmd: Union[Command, str]):
-        self.controller.sleepy_send(cmd)
-
-    def sleep(self, seconds: int):
-        """
-        Tells the HPLC to wait for a specified number of seconds.
-
-        :param seconds: number of seconds to wait
-        """
-        self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
-
-    def get_num(self, row: int, col_name: RegisterFlag) -> float:
-        return self.controller.get_num_val(TableOperation.GET_ROW_VAL.value.format(register=self.table.register,
-                                                                                   table_name=self.table.name,
-                                                                                   row=row,
-                                                                                   col_name=col_name.value))
-
-    def get_text(self, row: int, col_name: RegisterFlag) -> str:
-        return self.controller.get_text_val(TableOperation.GET_ROW_TEXT.value.format(register=self.table.register,
-                                                                                     table_name=self.table.name,
-                                                                                     row=row,
-                                                                                     col_name=col_name.value))
-
-    @abc.abstractmethod
-    def get_row(self, row: int):
-        pass
-
-    def delete_row(self, row: int):
-        self.sleepy_send(TableOperation.DELETE_ROW.value.format(register=self.table.register,
-                                                                table_name=self.table.name,
-                                                                row=row))
-
-    def add_row(self):
-        """
-        Adds a row to the provided table for currently loaded method or sequence.
-        Import either the SEQUENCE_TABLE or METHOD_TIMETABLE from hein_analytical_control.constants.
-        You can also provide your own table.
-
-        :param table: the table to add a new row to
-        """
-        self.sleepy_send(TableOperation.NEW_ROW.value.format(register=self.table.register,
-                                                             table_name=self.table.name))
-
-    def delete_table(self):
-        """
-        Deletes the table for the current loaded method or sequence.
-        Import either the SEQUENCE_TABLE or METHOD_TIMETABLE from hein_analytical_control.constants.
-        You can also provide your own table.
-
-        :param table: the table to delete
-        """
-        self.sleepy_send(TableOperation.DELETE_TABLE.value.format(register=self.table.register,
-                                                                  table_name=self.table.name))
-
-    def new_table(self):
-        """
-        Creates the table for the currently loaded method or sequence. Import either the SEQUENCE_TABLE or
-        METHOD_TIMETABLE from hein_analytical_control.constants. You can also provide your own table.
-
-        :param table: the table to create
-        """
-        self.send(TableOperation.CREATE_TABLE.value.format(register=self.table.register,
-                                                           table_name=self.table.name))
-
-    def get_num_rows(self) -> Result[int, str]:
-        self.send(TableOperation.GET_NUM_ROWS.value.format(register=self.table.register,
-                                                           table_name=self.table.name,
-                                                           col_name=RegisterFlag.NUM_ROWS))
-        self.send(Command.GET_ROWS_CMD.value.format(register=self.table.register,
-                                                    table_name=self.table.name,
-                                                    col_name=RegisterFlag.NUM_ROWS))
-        res = self.controller.receive()
-
-        if res.is_ok():
-            self.send("Sleep 0.1")
-            self.send('Print Rows')
-            return res
-        else:
-            return Err("No rows could be read.")
-
-    def check_hplc_is_running(self) -> bool:
-        started_running = polling.poll(
-            lambda: isinstance(self.controller.get_status(), HPLCRunningStatus),
-            step=5,
-            max_tries=100)
-        return started_running
-
-    def check_hplc_done_running(self,
-                                method: Optional[MethodTimetable] = None,
-                                sequence: Optional[SequenceTable] = None) -> Result[str, str]:
-        """
-        Checks if ChemStation has finished running and can read data back
-
-        :param method: if you are running a method and want to read back data, the timeout period will be adjusted to be longer than the method's runtime
-        :return: Return True if data can be read back, else False.
-        """
-        timeout = 10 * 60
-        if method:
-            timeout = ((method.first_row.maximum_run_time + 2) * 60)
-        if sequence:
-            timeout *= len(sequence.rows)
-
-        most_recent_folder = self.retrieve_recent_data_files()
-        finished_run = polling.poll(
-            lambda: self.controller.check_if_running(),
-            timeout=timeout,
-            step=12
-        )
-
-        if finished_run:
-            if os.path.exists(most_recent_folder):
-                return Ok(most_recent_folder)
-            else:
-                return self.fuzzy_match_most_recent_folder(most_recent_folder)
-        else:
-            return Err("Run did not complete as expected")
-
-    def fuzzy_match_most_recent_folder(self, most_recent_folder) -> Result[str, str]:
-        subdirs = [x[0] for x in os.walk(self.data_dir)]
-        potential_folders = sorted(list(filter(lambda d: most_recent_folder in d, subdirs)))
-        parent_dirs = []
-        for folder in potential_folders:
-            path = os.path.normpath(folder)
-            split_folder = path.split(os.sep)
-            if most_recent_folder in split_folder[-1]:
-                parent_dirs.append(folder)
-        parent_dir = sorted(parent_dirs, reverse=True)[0]
-        return Ok(parent_dir)
-
-    @abc.abstractmethod
-    def retrieve_recent_data_files(self):
-        pass
-
-    @abc.abstractmethod
-    def get_data(self) -> Union[list[AgilentChannelChromatogramData], AgilentChannelChromatogramData]:
-        pass
-
-    def get_spectrum(self, data_file: str):
-        """
-        Load chromatogram for any channel in spectra dictionary.
-        """
-        for channel, spec in self.spectra.items():
-            spec.load_spectrum(data_path=data_file, channel=channel)

pychemstation-0.7.0.dev2.dist-info/RECORD

@@ -1,58 +0,0 @@
-pychemstation/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
-pychemstation/analysis/__init__.py,sha256=EWoU47iyn9xGS-b44zK9eq50bSjOV4AC5dvt420YMI4,44
-pychemstation/analysis/base_spectrum.py,sha256=XPf9eJ72uz0CnxCY5uFOyu1MbVX-OTTXeN1tLzIMok4,16536
-pychemstation/analysis/process_report.py,sha256=3NWBK1g9fwjmdHoIlMxlXBlbyU5oXyK-_roEE7ZcPXM,10412
-pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-GKjiDi8,10201
-pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
-pychemstation/control/__init__.py,sha256=4xTy8X-mkn_PPZKr7w9rnj1wZhtmTesbQptPhpYmKXs,64
-pychemstation/control/comm.py,sha256=u44g1hTluQ0yUG93Un-QAshScoDpgYRrZfFTgweP5tY,7386
-pychemstation/control/hplc.py,sha256=XhZgJEU-dHHYu2GUFGlxystlLpZ6rxRzpmBVhJ3hixc,10256
-pychemstation/control/controllers/__init__.py,sha256=EM6LBNSTJqYVatmnvPq0P-S3q0POA88c-y64zL79I_I,252
-pychemstation/control/controllers/comm.py,sha256=IU4I_Q42VNCNUlVi93MxCmw2EBY9hiBDkU9FxubKg3c,7441
-pychemstation/control/controllers/method.py,sha256=XUclB7lQ_SIkquR58MBmmi9drHIPEq9AR8VprTLenvI,15503
-pychemstation/control/controllers/sequence.py,sha256=kYNxxck2I-q9mZDEZwG8bJ_99FfLmunS13EAHOS65wU,8288
-pychemstation/control/controllers/table_controller.py,sha256=70ovnIjLKkJborS1ztk445Mv42TtUM9jUniaQmZuyWQ,11031
-pychemstation/control/controllers/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/control/controllers/devices/column.py,sha256=SCpCnVFZFUM9LM51MbWkVcBRayN3WFxy7lz9gs2PYeY,348
-pychemstation/control/controllers/devices/dad.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/control/controllers/devices/device.py,sha256=QUFpUwmGxMzmG1CiRhNauV5cVZEJyRXyQDNQuW8Qfxk,762
-pychemstation/control/controllers/devices/injector.py,sha256=ynPQtvMFt1iK0LQBf4ZEYdxJCyavmashXwyCQbmRjuw,5542
-pychemstation/control/controllers/devices/pump.py,sha256=DJQh4lNXEraeC1CWrsKmsITOjuYlRI3tih_XRB3F1hg,1404
-pychemstation/control/controllers/tables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/control/controllers/tables/method.py,sha256=CVyln3TI-lWuaYiSINDJWGdvXSVa7o-yVEyy4TNNhG8,16492
-pychemstation/control/controllers/tables/ms.py,sha256=JFD-tOhu8uRyKdl-E3-neRssii8MNqVRIlsrnFhNY_M,682
-pychemstation/control/controllers/tables/sequence.py,sha256=svDHwIWsElXveJ-I4odtf_hP5MLmv_7TKJrCdoki4Yk,9236
-pychemstation/control/controllers/tables/table.py,sha256=tVcvb2119t2NOGxOJvSqy432yR1rAvfj-Vr1CTnG1DY,12205
-pychemstation/control/table/__init__.py,sha256=RgMN4uIWHdNUHpGRBWdzmzAbk7XEKl6Y-qtqWCxzSZU,124
-pychemstation/control/table/method.py,sha256=THVoGomSXff_CTU3eAYme0BYwkPzab5UgZKsiZ29QSk,12196
-pychemstation/control/table/sequence.py,sha256=Eri52AnbE3BGthfrRSvYKYciquUzvHKo0lYUTySYYE8,10542
-pychemstation/control/table/table_controller.py,sha256=HVNYUXqtyFTAvb67fa3RO5RHgmBTFMsYRHKpiXdYcfs,8313
-pychemstation/generated/__init__.py,sha256=GAoZFAYbPVEJDkcOw3e1rgOqd7TCW0HyKNPM8OMehMg,1005
-pychemstation/generated/dad_method.py,sha256=0W8Z5WDtF5jpIcudMqb7XrkTnR2EGg_QOCsHRFQ0rmM,8402
-pychemstation/generated/pump_method.py,sha256=sUhE2Oo00nzVcoONtq3EMWsN4wLSryXbG8f3EeViWKg,12174
-pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pychemstation/utils/chromatogram.py,sha256=-q3_hL9GTyi4C95os7IwAiOrkTM4EXIiigm-nW9pFmM,3221
-pychemstation/utils/injector_types.py,sha256=SD452SwEHNx4Xs2p-mhg6X0pd99XewQ1Zbu-r9kPOJs,817
-pychemstation/utils/macro.py,sha256=PZ916baFfqCkPaSqpdjm2N5mhfg4V4H8KQl7N5l3rUw,2916
-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=0kg7gZXFk7O5l0K1BEBaF4OFFdja3-hFUG9UbN5PBcs,3173
-pychemstation/utils/tray_types.py,sha256=3W0IE20SEqnRRa6pZ4Jv94Cn4-3-LGoP-hxUz5LCztc,4403
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/constants.py,sha256=3E0GUPV-ozPVZ6Qrfq3aTDqCgVWt1fUk8_u4cfyuUvg,3560
-tests/test_comb.py,sha256=TS-CbtiPbntL4u6E1gSZ6xquNp6cQxIFdJqUr2ak7PA,5515
-tests/test_comm.py,sha256=iwl-Ey-xoytXmlNrjG84pDm82Ry_QUX6wY4gmVh4NDc,2516
-tests/test_inj.py,sha256=UakPA1Sd1GAbFvFepEredWcWPoW7PMLKotfqVZ1i4hE,1434
-tests/test_method.py,sha256=KB7yAtVb4gZftnYzh-VfPb9LGVZOHUIW6OljEYRtbhA,4570
-tests/test_nightly.py,sha256=WpLZfs-n9oPrwz-64gWJB5oxJGYz_ab4sLZ4E-xFBpY,2654
-tests/test_proc_rep.py,sha256=sxRiTBybVm6lyAqmgrri-T2EfZgs27oSgbYXSsN9CwU,1380
-tests/test_runs_stable.py,sha256=sT9gNt7Rscz73BybpRGYj8RSGPBR58wrzvIAFFK-_pM,5530
-tests/test_sequence.py,sha256=vs5-dqkItRds_tPM2-N6MNJ37FB0nLRFaDzBV8d42i8,4880
-tests/test_stable.py,sha256=UFb9rUBnOk7JabcweNIYZLWpBHWGbqKAtsTNfxDhEFg,12208
-pychemstation-0.7.0.dev2.dist-info/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
-pychemstation-0.7.0.dev2.dist-info/METADATA,sha256=A6ZUpxSn1kImFamlVNU1jnXB_oDHrqeSIj9gy6rRu3I,4409
-pychemstation-0.7.0.dev2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pychemstation-0.7.0.dev2.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
-pychemstation-0.7.0.dev2.dist-info/RECORD,,

pychemstation-0.7.0.dev2.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-pychemstation
-tests

tests/constants.py

@@ -1,88 +0,0 @@
-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 *
-
-DEFAULT_METHOD = "GENERAL-POROSHELL-OPT"
-DEFAULT_SEQUENCE = "hplc_testing"
-
-# CONSTANTS: paths only work in Hein group HPLC machine in room 242
-DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\hplc-method-optimization\\tests\\"
-DEFAULT_METHOD_DIR = "C:\\ChemStation\\1\\Methods\\"
-DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data\\LC-BO\\"
-SEQUENCE_DIR = "C:\\USERS\\PUBLIC\\DOCUMENTS\\CHEMSTATION\\3\\Sequence"
-SEQUENCE_DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data\\"
-
-HEIN_LAB_CONSTANTS = [DEFAULT_COMMAND_PATH,
-                      DEFAULT_METHOD_DIR,
-                      DATA_DIR,
-                      SEQUENCE_DIR,
-                      SEQUENCE_DATA_DIR]
-
-# these CONSTANTS work in rm 254
-DEFAULT_COMMAND_PATH_254 = "D:\\\git_repositories\\\hplc_comm\\"
-DEFAULT_METHOD_DIR_254 = "D:\\Chemstation\\1\\Methods\\"
-DATA_DIR_254 = "D:\\Chemstation\\1\\Data\\LC BO\\"
-SEQUENCE_DIR_254 = "C:\\1\\Sequence\\"
-SEQUENCE_DATA_DIR_254 = "D:\\Chemstation\\1\\Data\\"
-
-HEIN_LAB_CONSTANTS_254 = [DEFAULT_COMMAND_PATH_254,
-                          DEFAULT_METHOD_DIR_254,
-                          DATA_DIR_254,
-                          SEQUENCE_DIR_254,
-                          SEQUENCE_DATA_DIR_254]
-
-
-def room(num: int):
-    if num == 242:
-        return HEIN_LAB_CONSTANTS
-    elif num == 254:
-        return HEIN_LAB_CONSTANTS_254
-
-
-def gen_rand_method():
-    org_modifier = int(random.random() * 10)
-    max_run_time = int(random.random() * 10)
-    post_run_time = int(random.random() * 10)
-    flow = float(random.random() * 10) / 10
-    flow_1 = float(random.random() * 10) / 10
-    flow_2 = float(random.random() * 10) / 10
-    return MethodDetails(name=DEFAULT_METHOD,
-                         timetable=[TimeTableEntry(start_time=0.10,
-                                                   organic_modifer=org_modifier,
-                                                   flow=flow_1),
-                                    TimeTableEntry(start_time=1,
-                                                   organic_modifer=100 - int(random.random() * 10),
-                                                   flow=flow_2)],
-                         stop_time=max_run_time,
-                         post_time=post_run_time,
-                         params=HPLCMethodParams(organic_modifier=org_modifier, flow=flow))
-
-
-seq_entry = SequenceEntry(
-    vial_location=TenVialColumn.ONE,
-    method=DEFAULT_METHOD,
-    num_inj=int(random.random() * 10),
-    inj_vol=int(random.random() * 10),
-    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_dirs=[path_constants[2], path_constants[4]],
-                                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