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

pychemstation/control/README.md

@@ -0,0 +1,132 @@
+# Examples of usecases
+
+## Initialization
+
+```python
+from pychemstation.control import HPLCController
+
+DEFAULT_METHOD_DIR = "C:\\ChemStation\\1\\Methods\\"
+DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\3\\Data"
+SEQUENCE_DIR = "C:\\USERS\\PUBLIC\\DOCUMENTS\\CHEMSTATION\\3\\Sequence"
+DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\"
+
+hplc_controller = HPLCController(data_dir=DATA_DIR,
+                                 comm_dir=DEFAULT_COMMAND_PATH,
+                                 method_dir=DEFAULT_METHOD_DIR,
+                                 sequence_dir=SEQUENCE_DIR)
+```
+
+## Switching a method
+
+```python
+hplc_controller.switch_method("General-Poroshell")
+```
+
+## Editing a method
+
+```python
+from pychemstation.utils.method_types import *
+
+new_method = MethodDetails(
+    name="My_Method",
+    params=HPLCMethodParams(
+        organic_modifier=7,
+        flow=0.44),
+    timetable=[
+        TimeTableEntry(
+            start_time=0.10,
+            organic_modifer=7,
+            flow=0.34
+        ),
+        TimeTableEntry(
+            start_time=1,
+            organic_modifer=99,
+            flow=0.55
+        )
+    ],
+    stop_time=5,
+    post_time=2
+)
+
+hplc_controller.edit_method(new_method)
+```
+
+## Running a method and get data from last run method
+
+```python
+hplc_controller.run_method(experiment_name="test_experiment")
+chrom = hplc_controller.get_last_run_method_data()
+channel_a_time = chrom.A.x
+```
+
+## Switching a sequence
+
+```python
+hplc_controller.switch_sequence(sequence_name="hplc_testing")
+```
+
+## Editing a Sequence Row
+
+```python
+from pychemstation.utils.sequence_types import *
+from pychemstation.utils.tray_types import *
+
+hplc_controller.edit_sequence_row(SequenceEntry(
+    vial_location=FiftyFourVialPlate(plate=Plate.TWO, letter=Letter.A, num=Num.SEVEN).value(),
+    method="General-Poroshell",
+    num_inj=3,
+    inj_vol=4,
+    sample_name="Blank",
+    sample_type=SampleType.BLANK,
+    inj_source=InjectionSource.HIP_ALS
+), 1)
+```
+
+## Editing entire Sequence Table
+
+```python
+from pychemstation.utils.tray_types import *
+from pychemstation.utils.sequence_types import *
+
+seq_table = SequenceTable(
+    name=DEFAULT_SEQUENCE,
+    rows=[
+        SequenceEntry(
+            vial_location=FiftyFourVialPlate(plate=Plate.TWO, letter=Letter.A, num=Num.SEVEN).value(),
+            method="General-Poroshell",
+            num_inj=3,
+            inj_vol=4,
+            sample_name="Control",
+            sample_type=SampleType.CONTROL,
+            inj_source=InjectionSource.MANUAL
+        ),
+        SequenceEntry(
+            vial_location=TenVialColumn.ONE.value,
+            method="General-Poroshell",
+            num_inj=1,
+            inj_vol=1,
+            sample_name="Sample",
+            sample_type=SampleType.SAMPLE,
+            inj_source=InjectionSource.AS_METHOD
+        ),
+        SequenceEntry(
+            vial_location=10,
+            method="General-Poroshell",
+            num_inj=3,
+            inj_vol=4,
+            sample_name="Blank",
+            sample_type=SampleType.BLANK,
+            inj_source=InjectionSource.HIP_ALS
+        ),
+    ]
+)
+hplc_controller.edit_sequence(seq_table)
+```
+
+## Running a sequence and get data from last run sequence
+
+```python
+hplc_controller.run_sequence(seq_table)
+chroms = hplc_controller.get_last_run_sequence_data()
+channel_A_time = chroms[0].A.x
+```

pychemstation/control/controllers/README.md

@@ -0,0 +1 @@
+# Chemstation Devices and Tables

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

@@ -1,13 +1,17 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.0
+Version: 0.10.1
 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
+Project-URL: Documentation, https://pychemstation-e5a086.gitlab.io/pychemstation.html
+Project-URL: Repository, https://gitlab.com/heingroup/device-api/pychemstation
 Author-email: lucyhao <hao.lucyy@gmail.com>
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
 License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
 Requires-Dist: aghplctools>=4.8.8
 Requires-Dist: coverage>=7.6.1
 Requires-Dist: matplotlib>=3.7.5
@@ -22,9 +26,7 @@ Requires-Dist: seabreeze>=2.9.2
 Requires-Dist: setuptools>=75.3.2
 Requires-Dist: twine>=6.1.0
 Requires-Dist: xsdata>=24.9
-Dynamic: author
-Dynamic: home-page
-Dynamic: license-file
+Description-Content-Type: text/markdown
 
 # Agilent HPLC Macro Control
 
@@ -123,4 +125,4 @@ Lucy Hao, Maria Politi
   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.
+  the [MIT](https://opensource.org/license/mit) license.

{pychemstation-0.10.0.dist-info → pychemstation-0.10.1.dist-info}/RECORD

@@ -2,31 +2,20 @@ 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/README.md,sha256=y73F-qh4g3k9Z9vBeQATqqhbwMfKB5MvGqJi5GgSUJQ,3357
 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/README.md,sha256=S5cd4NJmPjs6TUH98BtPJJhiS1Lu-mxLCNS786ogOrQ,32
 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
@@ -42,21 +31,7 @@ pychemstation/utils/sequence_types.py,sha256=WyJWL18Q86TgoUpYH2_CevoTZuhcui0EnyH
 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.10.1.dist-info/METADATA,sha256=gWFw70cbvfeIPV1T3IJDLDktm4FjjXn1JvPfTDQZoDw,5274
+pychemstation-0.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pychemstation-0.10.1.dist-info/licenses/LICENSE,sha256=9bdF75gIf1MecZ7oymqWgJREVz7McXPG-mjqrTmzzD8,18658
+pychemstation-0.10.1.dist-info/RECORD,,

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

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

pychemstation/analysis/spec_utils.py

@@ -1,304 +0,0 @@
-"""
-Module contains various utility function for spectral data processing and
-analysis.
-"""
-
-import numpy as np
-import scipy
-
-from .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/analysis/utils.py

@@ -1,63 +0,0 @@
-import numpy as np
-
-
-def find_nearest_value_index(array, value) -> tuple[float, int]:
-    """Returns closest value and its index in a given array.
-
-    :param array: An array to search in.
-    :type array: np.array(float)
-    :param value: Target value.
-    :type value: float
-
-    :returns: Nearest value in array and its index.
-    """
-
-    index_ = np.argmin(np.abs(array - value))
-    return array[index_], index_
-
-
-def interpolate_to_index(array, ids, precision: int = 100) -> np.array:
-    """Find value in between arrays elements.
-
-    Constructs linspace of size "precision" between index+1 and index to
-    find approximate value for array[index], where index is float number.
-    Used for 2D data, where default scipy analysis occurs along one axis only,
-    e.g. signal.peak_width.
-
-    Rough equivalent of array[index], where index is float number.
-
-    :param array: Target array.
-    :type array: np.array(float)
-    :param ids: An array with "intermediate" indexes to interpolate to.
-    :type ids: np.array[float]
-    :param precision: Desired presion.
-
-    :returns: New array with interpolated values according to provided indexes "ids".
-
-    Example:
-        >>> interpolate_to_index(np.array([1.5]), np.array([1,2,3], 100))
-            array([2.50505051])
-    """
-
-    # breaking ids into fractional and integral parts
-    prec, ids = np.modf(ids)
-
-    # rounding and switching type to int
-    prec = np.around(prec * precision).astype("int32")
-    ids = ids.astype("int32")
-
-    # linear interpolation for each data point
-    # as (n x m) matrix where n is precision and m is number of indexes
-    space = np.linspace(array[ids], array[ids + 1], precision)
-
-    # due to rounding error the index may become 100 in (100, ) array
-    # as a consequence raising IndexError when such array is indexed
-    # therefore index 100 will become the last (-1)
-    prec[prec == 100] = -1
-
-    # precise slicing
-    true_values = np.array(
-        [space[:, index[0]][value] for index, value in np.ndenumerate(prec)]
-    )
-
-    return true_values