pychemstation 0.8.3__py3-none-any.whl → 0.10.0__py3-none-any.whl

pychemstation/utils/spec_utils.py

@@ -0,0 +1,304 @@
+"""
+Module contains various utility function for spectral data processing and
+analysis.
+"""
+
+import numpy as np
+import scipy
+
+from ..utils.num_utils import find_nearest_value_index
+
+
+def create_binary_peak_map(data):
+    """Return binary map of the peaks within data points.
+
+    True values are assigned to potential peak points, False - to baseline.
+
+    Args:
+        data (:obj:np.array): 1D array with data points.
+
+    Returns:
+        :obj:np.array, dtype=bool: Mapping of data points, where True is
+            potential peak region point, False - baseline.
+    """
+    # copying array
+    data_c = np.copy(data)
+
+    # placeholder for the peak mapping
+    peak_map = np.full_like(data_c, False, dtype=bool)
+
+    for _ in range(100500):  # shouldn't take more iterations
+
+        # looking for peaks
+        peaks_found = np.logical_or(
+            data_c > np.mean(data_c) + np.std(data_c) * 3,
+            data_c < np.mean(data_c) - np.std(data_c) * 3,
+        )
+
+        # merging with peak mapping
+        np.logical_or(peak_map, peaks_found, out=peak_map)
+
+        # if no peaks found - break
+        if not peaks_found.any():
+            break
+
+        # setting values to 0 and iterating again
+        data_c[peaks_found] = 0
+
+    return peak_map
+
+
+def combine_map_to_regions(mapping):
+    """Combine True values into their indexes arrays.
+
+    Args:
+        mapping (:obj:np.array): Boolean mapping array to extract the indexes
+            from.
+
+    Returns:
+        :obj:np.array: 2D array with left and right borders of regions, where
+            mapping is True.
+
+    Example:
+        >>> combine_map_to_regions(np.array([True, True, False, True, False]))
+        array([[0, 1],
+                [3, 3]])
+    """
+
+    # No peaks identified, i.e. mapping is all False
+    if not mapping.any():
+        return np.array([], dtype="int64")
+
+    # region borders
+    region_borders = np.diff(mapping)
+
+    # corresponding indexes
+    border_indexes = np.argwhere(region_borders)
+
+    lefts = border_indexes[::2] + 1  # because diff was used to get the index
+
+    # edge case, where first peak doesn't have left border
+    if mapping[border_indexes][0]:
+        # just preppend 0 as first left border
+        # mind the vstack, as np.argwhere produces a vector array
+        lefts = np.vstack((0, lefts))
+
+    rights = border_indexes[1::2]
+
+    # another edge case, where last peak doesn't have a right border
+    if mapping[-1]:  # True if last point identified as potential peak
+        # just append -1 as last peak right border
+        rights = np.vstack((rights, -1))
+
+    # columns as borders, rows as regions, i.e.
+    # :output:[0] -> first peak region
+    return np.hstack((lefts, rights))
+
+
+def filter_regions(x_data, peaks_regions):
+    """Filter peak regions.
+
+    Peak regions are filtered to remove potential false positives (e.g. noise
+        spikes).
+
+    Args:
+        x_data (:obj:np.array): X data points, needed to pick up the data
+            resolution and map the region indexes to the corresponding data
+            points.
+        y_data (:obj:np.array): Y data points, needed to validate if the peaks
+            are actually present in the region and remove invalid regions.
+        peaks_regions (:obj:np.array): 2D Nx2 array with peak regions indexes
+            (rows) as left and right borders (columns).
+
+    Returns:
+        :obj:np.array: 2D Mx2 array with filtered peak regions indexes(rows) as
+            left and right borders (columns).
+    """
+
+    # filter peaks where region is smaller than spectrum resolution
+    # like single spikes, e.g. noise
+    # compute the regions first
+    x_data_regions = np.copy(x_data[peaks_regions])
+
+    # get arguments where absolute difference is greater than data resolution
+    resolution = np.absolute(np.mean(np.diff(x_data)))
+
+    # (N, 1) array!
+    valid_regions_map = np.absolute(np.diff(x_data_regions)) > resolution
+
+    # get their indexes, mind the flattening of all arrays!
+    valid_regions_indexes = np.argwhere(valid_regions_map.flatten()).flatten()
+
+    # filtering!
+    peaks_regions = peaks_regions[valid_regions_indexes]
+
+    return peaks_regions
+
+
+def filter_noisy_regions(y_data, peaks_regions):
+    """Remove noisy regions from given regions array.
+
+    Peak regions are filtered to remove false positive noise regions, e.g.
+        incorrectly assigned due to curvy baseline. Filtering is performed by
+        computing average peak points/data points ratio.
+
+    Args:
+        y_data (:obj:np.array): Y data points, needed to validate if the peaks
+            are actually present in the region and remove invalid regions.
+        peaks_regions (:obj:np.array): 2D Nx2 array with peak regions indexes
+            (rows) as left and right borders (columns).
+
+    Returns:
+        :obj:np.array: 2D Mx2 array with filtered peak regions indexes(rows) as
+            left and right borders (columns).
+    """
+
+    # compute the actual regions data points
+    y_data_regions = []
+    for region in peaks_regions:
+        y_data_regions.append(y_data[region[0]: region[-1]])
+
+    # compute noise data regions, i.e. in between peak regions
+    noise_data_regions = []
+    for row, _ in enumerate(peaks_regions):
+        try:
+            noise_data_regions.append(
+                y_data[peaks_regions[row][1]: peaks_regions[row + 1][0]]
+            )
+        except IndexError:
+            # exception for the last row -> discard
+            pass
+
+    # compute average peaks/data points ratio for noisy regions
+    noise_peaks_ratio = []
+    for region in noise_data_regions:
+        # protection from empty regions
+        if region.size != 0:
+            # minimum height is pretty low to ensure enough noise is picked
+            peaks, _ = scipy.signal.find_peaks(region, height=region.max() * 0.2)
+            noise_peaks_ratio.append(peaks.size / region.size)
+
+    # compute average with weights equal to the region length
+    noise_peaks_ratio = np.average(
+        noise_peaks_ratio, weights=[region.size for region in noise_data_regions]
+    )
+
+    # filtering!
+    valid_regions_indexes = []
+    for row, region in enumerate(y_data_regions):
+        peaks, _ = scipy.signal.find_peaks(region, height=region.max() * 0.2)
+        if peaks.size != 0 and peaks.size / region.size < noise_peaks_ratio:
+            valid_regions_indexes.append(row)
+
+    # protecting from complete cleaning
+    if not valid_regions_indexes:
+        return peaks_regions
+
+    peaks_regions = peaks_regions[np.array(valid_regions_indexes)]
+
+    return peaks_regions
+
+
+def merge_regions(x_data, peaks_regions, d_merge, recursively=True):
+    """Merge peak regions if distance between is less than delta.
+
+    Args:
+        x_data (:obj:np.array): X data points.
+        peaks_regions (:obj:np.array): 2D Nx2 array with peak regions indexes
+            (rows) as left and right borders (columns).
+        d_merge (float): Minimum distance in X data points to merge two or more
+            regions together.
+        recursively (bool, optional): If True - will repeat the procedure until
+            all regions with distance < than d_merge will merge.
+
+    Returns:
+        :obj:np.array: 2D Mx2 array with peak regions indexes (rows) as left and
+            right borders (columns), merged according to predefined minimal
+            distance.
+
+    Example:
+        >>> regions = np.array([
+                [1, 10],
+                [11, 20],
+                [25, 45],
+                [50, 75],
+                [100, 120],
+                [122, 134]
+            ])
+        >>> data = np.ones_like(regions) # ones as example
+        >>> merge_regions(data, regions, 1)
+        array([[  1,  20],
+               [ 25,  45],
+               [ 50,  75],
+               [100, 120],
+               [122, 134]])
+        >>> merge_regions(data, regions, 20, True)
+        array([[  1,  75],
+               [100, 134]])
+    """
+    # the code is pretty ugly but works
+    merged_regions = []
+
+    # converting to list to drop the data of the fly
+    regions = peaks_regions.tolist()
+
+    for i, _ in enumerate(regions):
+        try:
+            # check left border of i regions with right of i+1
+            if abs(x_data[regions[i][-1]] - x_data[regions[i + 1][0]]) <= d_merge:
+                # if lower append merge the regions
+                merged_regions.append([regions[i][0], regions[i + 1][-1]])
+                # drop the merged one
+                regions.pop(i + 1)
+            else:
+                # if nothing to merge, just append the current region
+                merged_regions.append(regions[i])
+        except IndexError:
+            # last row
+            merged_regions.append(regions[i])
+
+    merged_regions = np.array(merged_regions)
+
+    if not recursively:
+        return merged_regions
+
+    # if recursively, check for the difference
+    if (merged_regions == regions).all():
+        # done
+        return merged_regions
+
+    return merge_regions(x_data, merged_regions, d_merge, recursively=True)
+
+
+def expand_regions(x_data, peaks_regions, d_expand):
+    """Expand the peak regions by the desired value.
+
+    Args:
+        x_data (:obj:np.array): X data points.
+        peaks_regions (:obj:np.array): 2D Nx2 array with peak regions indexes
+            (rows) as left and right borders (columns).
+        d_expand (float): Value to expand borders to (in X data scale).
+
+    Returns:
+        :obj:np.array: 2D Nx2 array with expanded peak regions indexes (rows) as
+            left and right borders (columns).
+    """
+
+    data_regions = np.copy(x_data[peaks_regions])
+
+    # determine scale orientation, i.e. decreasing (e.g. ppm on NMR spectrum)
+    # or increasing (e.g. wavelength on UV spectrum)
+    if (data_regions[:, 0] - data_regions[:, 1]).mean() > 0:
+        # ppm-like scale
+        data_regions[:, 0] += d_expand
+        data_regions[:, -1] -= d_expand
+    else:
+        # wavelength-like scale
+        data_regions[:, 0] -= d_expand
+        data_regions[:, -1] += d_expand
+
+    # converting new values to new indexes
+    for index_, value in np.ndenumerate(data_regions):
+        data_regions[index_] = find_nearest_value_index(x_data, value)[1]
+
+    return data_regions.astype(int)

{pychemstation-0.8.3.dist-info → pychemstation-0.10.0.dist-info}/METADATA

@@ -1,10 +1,13 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.8.3
-Summary: Library to interact with Chemstation software, primarily used in Hein lab.
+Version: 0.10.0
+Summary: Library to interact with Chemstation software, primarily used in Hein lagit branch -mb
+Home-page: https://gitlab.com/heingroup/device-api/pychemstation
+Author: Lucy Hao
 Author-email: lucyhao <hao.lucyy@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Python: >=3.8
 Requires-Dist: aghplctools>=4.8.8
 Requires-Dist: coverage>=7.6.1
 Requires-Dist: matplotlib>=3.7.5
@@ -19,7 +22,9 @@ 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
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
 
 # Agilent HPLC Macro Control
 
@@ -27,8 +32,12 @@ Description-Content-Type: text/markdown
 
 [![PyPI Latest Release](https://img.shields.io/pypi/v/pychemstation.svg)](https://pypi.org/project/pychemstation/)
 
+> **_NOTE:_** If you are running Python **3.8**, use versions 0.**8**.x. If you are running Python **>=3.10**, use
+> version 0.**10**.x. You are welcome to use newer pychemstation versions with older Python versions, but functionality
+> is not guaranteed!
+
 Unofficial Python package to control Agilent Chemstation; we are not affiliated with Agilent.
-Check out the [docs](https://hein-analytical-control-5e6e85.gitlab.io/) for usage instructions. This project is under
+Check out the [docs](https://pychemstation-e5a086.gitlab.io/pychemstation.html) for usage instructions. This project is under
 active development, and breaking changes may occur at any moment.
 
 ## Getting started
@@ -110,6 +119,8 @@ Lucy Hao, Maria Politi
 
 - Adapted from [**AnalyticalLabware**](https://github.com/croningp/analyticallabware), created by members in the Cronin
   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.
+- 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.

pychemstation-0.10.0.dist-info/RECORD

@@ -0,0 +1,62 @@
+pychemstation/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
+pychemstation/analysis/__init__.py,sha256=Vi31PZ7fgIvyuIhkgCNvEYeV_jtUCa8FCrAGbpks7zc,83
+pychemstation/analysis/base_spectrum.py,sha256=9WkOLk2qTAYTF1ALNUenVPoosOtBiLRvy2ni8zlGU5w,16540
+pychemstation/analysis/process_report.py,sha256=ZOgcRUMGXdGMrMFcdzsSwdOk6OBp-PpcA83vSvnmVSg,11871
+pychemstation/analysis/spec_utils.py,sha256=UOo9hJR3evJfmaohEEsyb7aq6X996ofuUfu-GKjiDi8,10201
+pychemstation/analysis/utils.py,sha256=ISupAOb_yqA4_DZRK9v18UL-XjUQccAicIJKb1VMnGg,2055
+pychemstation/control/__init__.py,sha256=Js79QczKZxDNZrzG1-4yl_whCoP2aw-yDAQJungiiic,100
+pychemstation/control/comm.py,sha256=u44g1hTluQ0yUG93Un-QAshScoDpgYRrZfFTgweP5tY,7386
+pychemstation/control/hplc.py,sha256=f7NHcCWtc_ApasjU5VMQtEvWQxoIboi_-RU9dkjORrs,13215
+pychemstation/control/controllers/__init__.py,sha256=r7UU0u5zuJHO_KTqt-4Gy65BMlyXtxrdskiOhtO9Yw4,260
+pychemstation/control/controllers/comm.py,sha256=AN3A3ThvIsOKWY7Kmb_tnE5pRUqI7O2ID8M54z_w-uE,7831
+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=JNBKVRka1I3LA1lElIeUO0j93BTK5IJufTPNq95OhNE,1473
+pychemstation/control/controllers/devices/injector.py,sha256=s40jFd0B_wJn4ID6SgAk_F8WhnGbbflpiti4uwIhaSs,1950
+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=LHoNRSTsSrrktghqNnU5KTRXDczcuGgqdqKEs_3sUXI,18609
+pychemstation/control/controllers/tables/ms.py,sha256=JFD-tOhu8uRyKdl-E3-neRssii8MNqVRIlsrnFhNY_M,682
+pychemstation/control/controllers/tables/sequence.py,sha256=DwX0wi5GhHmk8wnl89X2MKvqTSojLycV4IEvNjdVdWg,13400
+pychemstation/control/controllers/tables/table.py,sha256=zMzsQgkLxM3LVe9w-OM8WjLZxTo9zrmBTNH182gAyh8,12750
+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=xTUiSCvkXcxBUhjVm1YZKu-tHs16k23pF-0xYrQSwWA,8408
+pychemstation/generated/pump_method.py,sha256=797RsSDI2-QPf_BX8isZQx0O3aRx84EGIXJXhXw3IS0,12180
+pychemstation/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychemstation/utils/chromatogram.py,sha256=2Los_ix_wAi4yxG_9neGRnNYPre9_uC1mrne3Ygit5c,3242
+pychemstation/utils/injector_types.py,sha256=PXwJK1uXs8hlQ6dWIEbAGfk2BpQJQmN3SlUbL4ntZz0,822
+pychemstation/utils/macro.py,sha256=Lh8aGcwo9sC2Sfc19Wgms5d3VgBLV3VXdvspqNHYE18,2931
+pychemstation/utils/method_types.py,sha256=ZOFMJ7wpqWBRJNIvOux-7Ou4nJVSuyWRHrd37wMnPa0,1638
+pychemstation/utils/num_utils.py,sha256=rgpTJTrpsiBANbtsfys9xj0sqlTe__3J0OSeoygaQTM,2081
+pychemstation/utils/parsing.py,sha256=iFdnie-v0u5JI4cctJye_yhWQxHgy72_PWZ7w57Ltvg,9318
+pychemstation/utils/pump_types.py,sha256=HWQHxscGn19NTrfYBwQRCO2VcYfwyko7YfBO5uDhEm4,93
+pychemstation/utils/sequence_types.py,sha256=WyJWL18Q86TgoUpYH2_CevoTZuhcui0EnyHYdrp3Nmo,1070
+pychemstation/utils/spec_utils.py,sha256=MQZPDwCYZRfkEhNJQUt74huPexXBlJ3W4o7_230JWcE,10210
+pychemstation/utils/table_types.py,sha256=7txqW_oNpkh4venSkGEtreVe6UV9dzNB1DTrIeTkQHA,3217
+pychemstation/utils/tray_types.py,sha256=eOO-muUjadyvCM8JnYAZVyxJeyYBlENP1zXiFskAFbs,5049
+pychemstation-0.10.0.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/constants.py,sha256=4XZkV9pw3PLYy6R-18Pbf5ry2iNmAM-jqXA2MuKKkh4,5422
+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_offline_stable.py,sha256=nUyX-LGiQYMjJ1fvjByFBAUS6eMqaqlq6ufoHb8Ai0E,2911
+tests/test_online_stable.py,sha256=f--r8QqGJtx3kDQi1j0pM5v1IOT4SC7B636otZRYfhE,11325
+tests/test_proc_rep.py,sha256=sxRiTBybVm6lyAqmgrri-T2EfZgs27oSgbYXSsN9CwU,1380
+tests/test_runs_stable.py,sha256=hmsI0ZjJRsjSdiRPqXPqEoIxS2sqZIyybNpQpacRs9Q,10235
+tests/test_sequence.py,sha256=vs5-dqkItRds_tPM2-N6MNJ37FB0nLRFaDzBV8d42i8,4880
+tests/test_stable.py,sha256=UFb9rUBnOk7JabcweNIYZLWpBHWGbqKAtsTNfxDhEFg,12208
+pychemstation-0.10.0.dist-info/METADATA,sha256=8jxjr4cJvOZcxFtKJKwkrriG_prk1tmal1_xPD8ruVM,4998
+pychemstation-0.10.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pychemstation-0.10.0.dist-info/top_level.txt,sha256=zXfKu_4nYWwPHo3OsuhshMNC3SPkcoTGCyODjURaghY,20
+pychemstation-0.10.0.dist-info/RECORD,,

{pychemstation-0.8.3.dist-info → pychemstation-0.10.0.dist-info}/WHEEL

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

pychemstation-0.10.0.dist-info/top_level.txt

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

tests/constants.py

@@ -0,0 +1,134 @@
+import os
+import random
+import shutil
+
+from pychemstation.control import HPLCController
+from pychemstation.utils.macro import Command
+from pychemstation.utils.method_types import (
+    HPLCMethodParams,
+    MethodDetails,
+    TimeTableEntry,
+)
+from pychemstation.utils.sequence_types import SampleType, SequenceEntry
+from pychemstation.utils.tray_types import FiftyFourVialPlate, TenVialColumn
+
+VIAL_PLATES = [
+    FiftyFourVialPlate.from_str('P1-A7'),
+    FiftyFourVialPlate.from_str('P1-B4'),
+    FiftyFourVialPlate.from_str('P1-C2'),
+    FiftyFourVialPlate.from_str('P1-D8'),
+    FiftyFourVialPlate.from_str('P1-E3'),
+    FiftyFourVialPlate.from_str('P1-F5'),
+    # plate 2
+    FiftyFourVialPlate.from_str('P2-A7'),
+    FiftyFourVialPlate.from_str('P2-B2'),
+    FiftyFourVialPlate.from_str('P2-C1'),
+    FiftyFourVialPlate.from_str('P2-D8'),
+    FiftyFourVialPlate.from_str('P2-E3'),
+    FiftyFourVialPlate.from_str('P2-F6'),
+]
+
+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_2 = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
+SEQUENCE_DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data\\"
+
+HEIN_LAB_CONSTANTS_242 = [DEFAULT_COMMAND_PATH,
+                          DEFAULT_METHOD_DIR,
+                          DATA_DIR,
+                          SEQUENCE_DIR,
+                          SEQUENCE_DATA_DIR_2,
+                          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_242
+    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, offline: bool = False, runs: bool = False) -> HPLCController:
+    path_constants = room(num)
+    if not offline:
+        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(offline=offline,
+                                comm_dir=path_constants[0],
+                                method_dir=path_constants[1],
+                                data_dirs=[path_constants[2], path_constants[4], path_constants[5]],
+                                sequence_dir=path_constants[3],
+                                debug=True)
+    if not offline:
+        controller.send(Command.SAVE_METHOD_CMD.value.format(commit_msg="method saved by pychemstation"))
+        controller.send(Command.SAVE_SEQUENCE_CMD)
+    if runs:
+        controller.instrument_on()
+        controller.preprun()
+    return controller
+
+
+
+def clean_up(hplc_controller: HPLCController):
+    if hasattr(hplc_controller.method_controller, "data_dirs") and hasattr(hplc_controller.sequence_controller, "data_dirs"):
+        files = hplc_controller.method_controller.data_files + [d.dir for d in hplc_controller.sequence_controller.data_files]
+        data_dirs = hplc_controller.method_controller.data_dirs
+        for folder in files:
+            if os.path.isdir(folder):
+                shutil.rmtree(folder)
+            else:
+                for data_dir in data_dirs:
+                    possible_path = os.path.join(data_dir, folder)
+                    if os.path.isdir(possible_path):
+                        shutil.rmtree(possible_path)