pychemstation 0.10.0__tar.gz → 0.10.2__tar.gz

pychemstation-0.10.2/.gitignore

@@ -0,0 +1,7 @@
+.idea/*
+.pytest_cache/*
+.env
+.venv
+**/__pycache__/
+target
+.DS_Store

pychemstation-0.10.2/.gitlab-ci.yml

@@ -0,0 +1,16 @@
+stages:
+  - deploy
+
+pages:
+  stage: deploy
+  image: python:3.12-slim
+  before_script:
+    - apt-get update && apt-get install make --no-install-recommends -y
+    - python -m pip install -e .
+  script:
+    - pdoc -o doc pychemstation
+  after_script:
+    - mv doc/ ./public/
+  artifacts:
+    paths:
+    - public

pychemstation-0.10.2/CHANGELOG.md

@@ -0,0 +1,5 @@
+## 0.4.3 (2024-12-29)
+
+### changed (1 change)
+
+- [Add new  version to pypi](https://gitlab.com/heingroup/hein-analytical-control/-/commit/727d09d38ed43d56e4791983c4d740b73237b557)

pychemstation-0.10.2/CONTRIBUTING.md

@@ -0,0 +1,98 @@
+# Contributing Guide
+
+Modified from [here](https://github.com/cncf/project-template/blob/main/CONTRIBUTING.md#contributing-guide).
+
+* [Ways to Contribute](#ways-to-contribute)
+* [Find an Issue](#find-an-issue)
+* [Ask for Help](#ask-for-help)
+* [Pull Request Lifecycle](#pull-request-lifecycle)
+* [Development Environment Setup](#development-environment-setup)
+* [Sign Your Commits](#sign-your-commits)
+* [Pull Request Checklist](#pull-request-checklist)
+
+Welcome! We are glad that you want to contribute to Hein Analytical Control! 💖
+
+As you get started, you are in the best position to give us feedback on areas of
+our project that we need help with including:
+
+* Problems found during setting up a new developer environment
+* Gaps in our Quickstart Guide or documentation
+* Bugs in our Python scripts
+
+If anything doesn't make sense, or doesn't work when you run it, please open a
+bug report and let us know!
+
+## Ways to Contribute
+
+We welcome many different types of contributions including:
+
+* New features
+* Bug fixes
+* Documentation
+
+## Find an Issue
+
+If there are currently issues present, please feel free to take one! 
+Comment with something like "I would like to take this issue", 
+and our team will communicate further with you in that issue.
+
+## Ask for Help
+
+The best way to reach us with a question when contributing is to ask on:
+
+* The original GitLab issue
+* Via email at: hao.lucyy@gmail.com (only inquiries sent to this email regarding this library will be answered)
+
+## Pull Request Lifecycle
+
+⚠️ **Explain your pull request process**
+
+## Development Environment Setup
+
+First, clone this repo. All required packages are specified in `pyproject.toml`. 
+We use [poetry](https://python-poetry.org/), but you can adjust the `pyproject.toml` to 
+work with your Python package manager. Activate your environment via your package manager's instructions
+and this should be all you need to start development.
+
+To update documentation, we use [Sphinx](https://www.sphinx-doc.org/en/master/). Install via instructions on
+Sphinx's website. If you want a local version of the documentation website, then `cd docs`, `make clean`, `make html`.
+Then within `docs/build`, open `index.html` in your browser.
+
+## Sign Your Commits
+
+### DCO
+Licensing is important to open source projects. It provides some assurances that
+the software will continue to be available based under the terms that the
+author(s) desired. We require that contributors sign off on commits submitted to
+our project's repositories. The [Developer Certificate of Origin
+(DCO)](https://probot.github.io/apps/dco/) is a way to certify that you wrote and
+have the right to contribute the code you are submitting to the project.
+
+You sign-off by adding the following to your commit messages. Your sign-off must
+match the git user and email associated with the commit.
+
+    This is my commit message
+
+    Signed-off-by: Your Name <your.name@example.com>
+
+Git has a `-s` command line option to do this automatically:
+
+    git commit -s -m 'This is my commit message'
+
+If you forgot to do this and have not yet pushed your changes to the remote
+repository, you can amend your commit with the sign-off by running 
+
+    git commit --amend -s 
+
+## Pull Request Checklist
+
+When you submit your pull request, or you push new commits to it, our automated
+systems will run some checks on your new code. We require that your pull request
+passes these checks, but we also have more criteria than just that before we can
+accept and merge it. We recommend that you check the following things locally
+before you submit your code:
+
+- have you provided a doc string for new functionality OR if you have extended an existing function,
+ensure the doc string is still valid 
+- are you using type annotations? 
+- are your commit messages following the mentioned conventions?

{pychemstation-0.10.0/pychemstation.egg-info → pychemstation-0.10.2}/PKG-INFO

@@ -1,13 +1,17 @@
 Metadata-Version: 2.4
 Name: pychemstation
-Version: 0.10.0
+Version: 0.10.2
 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.2/build/lib/pychemstation/analysis/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 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.10.2/build/lib/pychemstation/analysis/utils.py

@@ -0,0 +1,63 @@
+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