dgpost 2.1.2__tar.gz → 2.2.1__tar.gz

{dgpost-2.1.2/src/dgpost.egg-info → dgpost-2.2.1}/PKG-INFO

@@ -1,56 +1,42 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: dgpost
-Version: 2.1.2
+Version: 2.2.1
 Summary: datagram post-processing toolkit
-Home-page: https://github.com/dgbowl/dgpost
-Author: Peter Kraus
-Author-email: peter@tondon.de
-Project-URL: Bug Tracker, https://github.com/dgbowl/dgpost/issues
-Project-URL: Documentation, https://dgbowl.github.io/dgpost/
-Classifier: Programming Language :: Python :: 3.9
+Author: Ueli Sauter
+Author-email: Peter Kraus <peter.kraus@tu-berlin.de>
+Maintainer-email: Peter Kraus <peter.kraus@tu-berlin.de>
+Project-URL: Documentation, https://dgbowl.github.io/dgpost/master
+Project-URL: Issues, https://github.com/dgbowl/dgpost/issues
+Project-URL: Repository, https://github.com/dgbowl/dgpost/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<2.0,>=1.2.0; python_version < "3.10"
-Requires-Dist: numpy>=1.2.0; python_version >= "3.10"
+Requires-Dist: numpy>=1.20
 Requires-Dist: uncertainties<3.2
-Requires-Dist: pandas<2.1; python_version < "3.10"
-Requires-Dist: pandas>=2.1; python_version >= "3.10"
+Requires-Dist: pandas
 Requires-Dist: openpyxl
-Requires-Dist: pint>=0.22
+Requires-Dist: pint>=0.24.1
 Requires-Dist: chemicals>=1.0.0
 Requires-Dist: rdkit>=2022.3
 Requires-Dist: h5netcdf>=1.0
-Requires-Dist: xarray<2024.10.0
-Requires-Dist: xarray-datatree>=0.0.12
-Requires-Dist: dgbowl-schemas>=116
+Requires-Dist: xarray>=2024.10.0
+Requires-Dist: dgbowl-schemas>=122
 Requires-Dist: matplotlib>=3.5.0
-Requires-Dist: requests
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"
-Requires-Dist: Pillow; extra == "testing"
+Requires-Dist: ruff; extra == "testing"
 Provides-Extra: docs
 Requires-Dist: sphinx~=7.2; extra == "docs"
-Requires-Dist: sphinx-rtd-theme; extra == "docs"
-Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
-Requires-Dist: autodoc-pydantic>=2.0.0; extra == "docs"
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: project-url
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
+Requires-Dist: sphinx-rtd-theme~=1.3.0; extra == "docs"
+Requires-Dist: autodoc-pydantic~=2.1.0; extra == "docs"
+Dynamic: license-file
 
 # dgpost: datagram post-processing toolkit
 

dgpost-2.2.1/pyproject.toml

@@ -0,0 +1,69 @@
+[build-system]
+requires = ["setuptools >= 61.0", "setuptools-git-versioning"]
+build-backend = "setuptools.build_meta"
+
+[project]
+dynamic = ["version"]
+name = "dgpost"
+authors = [
+    {name = "Peter Kraus", email = "peter.kraus@tu-berlin.de"},
+    {name = "Ueli Sauter"},
+]
+maintainers = [
+    {name = "Peter Kraus", email = "peter.kraus@tu-berlin.de"},
+]
+description = "datagram post-processing toolkit"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+]
+requires-python = ">= 3.10"
+dependencies = [
+    "numpy >= 1.20",
+    "uncertainties < 3.2",
+    "pandas",
+    "openpyxl",
+    "pint >= 0.24.1",
+    "chemicals >= 1.0.0",
+    "rdkit >= 2022.3",
+    "h5netcdf >= 1.0",
+    "xarray >= 2024.10.0",
+    "dgbowl-schemas >= 122",
+    "matplotlib >= 3.5.0",
+]
+
+[project.optional-dependencies]
+testing = [
+    "pytest",
+    "ruff",
+]
+docs = [
+    "sphinx ~= 7.2",
+    "sphinx-rtd-theme ~= 1.3.0",
+    "autodoc-pydantic ~= 2.1.0",
+]
+
+[project.urls]
+Documentation = "https://dgbowl.github.io/dgpost/master"
+Issues = "https://github.com/dgbowl/dgpost/issues"
+Repository = "https://github.com/dgbowl/dgpost/"
+
+[project.scripts]
+dgpost = "dgpost:run_with_arguments"
+
+[tool.setuptools-git-versioning]
+enabled = true
+dev_template = "{tag}.dev{ccount}"
+dirty_template = "{tag}.dev{ccount}"
+
+[tool.ruff]
+
+[tool.pytest.ini_options]
+log_cli = false
+log_cli_level = "DEBUG"

dgpost-2.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dgpost-2.2.1/src/dgpost/__init__.py

@@ -0,0 +1,8 @@
+import sys
+from importlib.metadata import version
+from .main import run_with_arguments, run
+
+__all__ = ["run_with_arguments", "run"]
+__version__ = version("dgpost")
+
+sys.path += sys.modules["dgpost"].__path__

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/main.py

@@ -5,13 +5,11 @@ dgpost.main
 Module containing the execution functions for dgpost.
 
 """
+
 import argparse
 import logging
 from importlib import metadata
 import copy
-import requests
-import json
-from packaging import version
 
 from dgpost.utils import parse, load, extract, transform, save, plot, pivot
 from dgpost.utils.helpers import combine_tables
@@ -19,29 +17,6 @@ from dgpost.utils.helpers import combine_tables
 logger = logging.getLogger(__name__)
 
 
-def version_check(project="dgpost"):
-    url = f"https://pypi.org/pypi/{project}/json"
-    try:
-        res = requests.get(url, timeout=1)
-    except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
-        logger.debug(f"Version check could not proceed due to Exception={e}.")
-        return
-    jsdata = json.loads(res.text)
-    versions = sorted([version.parse(i) for i in jsdata["releases"].keys()])
-    latest = versions[-1]
-    current = version.parse(metadata.version(project))
-    if latest > current:
-        logger.warning("You are using an out-of-date version of '%s'. ", project)
-        logger.info(
-            "The latest version is '%s', the current version is '%s'.", latest, current
-        )
-        logger.info(
-            "Consider updating using: pip install --upgrade %s==%s", project, latest
-        )
-    else:
-        logger.debug("Your version of '%s' is up-to-date.", project)
-
-
 def run(path: str, patch: str = None) -> tuple[dict, dict]:
     """
     Main API execution function. Loads the `recipe` from the provided ``path``,
@@ -83,8 +58,8 @@ def run(path: str, patch: str = None) -> tuple[dict, dict]:
     tables = {}
 
     logger.info("Processing 'load'.")
-    l = spec.pop("load")
-    for el in l:
+    ldict = spec.pop("load")
+    for el in ldict:
         if patch is None:
             fp = el["path"]
         else:
@@ -187,7 +162,7 @@ def run_with_arguments():
     parser.add_argument(
         "--version",
         action="version",
-        version=f'%(prog)s version {metadata.version("dgpost")}',
+        version=f"%(prog)s version {metadata.version('dgpost')}",
     )
 
     parser.add_argument(
@@ -225,5 +200,4 @@ def run_with_arguments():
     logging.basicConfig(level=loglevel)
     logging.debug(f"loglevel set to '{logging._levelToName[loglevel]}'")
 
-    version_check()
     run(args.infile, patch=args.patch)

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/transform/catalysis.py

@@ -36,9 +36,6 @@ import pint
 import logging
 import numpy as np
 from typing import Iterable
-
-logger = logging.getLogger(__name__)
-
 from dgpost.utils.helpers import (
     name_to_chem,
     columns_to_smiles,
@@ -48,6 +45,8 @@ from dgpost.utils.helpers import (
     separate_data,
 )
 
+logger = logging.getLogger(__name__)
+
 
 @load_data(
     ("xin", None, dict),
@@ -182,7 +181,7 @@ def conversion(
     if product is not None:
         logger.warning(
             "Specifying reactant- and product-based conversion using "
-            f"'product' is deprecated and will stop working in dgpost-2.0. "
+            "'product' is deprecated and will stop working in dgpost-2.0. "
             "Use 'type={product,reactant,mixed}' instead."
         )
         type = "product" if product else "reactant"

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/transform/chromatography.py

@@ -61,7 +61,7 @@ def integrate_trace(
          and interpolating between the ends of all matched peaks. If consecutive
          peaks are found, the interpolation spans the whole domain.
       #) The baseline is subtracted from the signal and the peak areas are
-         integrated using the :func:`numpy.trapz` function.
+         integrated using the :func:`numpy.trapezoid` function.
       #) The peak height is taken from the original ``signal`` data.
 
     The format of the ``species`` specification, used for peak matching, is as follows:
@@ -227,7 +227,7 @@ def integrate_trace(
         e = v["rlim"] + 1
         py = signal[s:e] - baseline[s:e]
         px = time[s:e]
-        A = np.trapz(py, px)
+        A = np.trapezoid(py, px)
         retval[f"{output}->area->{k}"] = A
         retval[f"{output}->height->{k}"] = py[v["max"] - s]
 

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/transform/circuit_utils/circuit_components.py

@@ -2,6 +2,7 @@
 dgpost.transform.circuit_utils.circuit_components
 =================================================
 """
+
 from typing import Type
 
 import numpy as np

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/transform/circuit_utils/circuit_parser.py

@@ -2,6 +2,7 @@
 dgpost.transform.circuit_utils.circuit_parser
 =============================================
 """
+
 import re
 import warnings
 import logging
@@ -156,7 +157,7 @@ def fit_routine(
     with warnings.catch_warnings():
         warnings.filterwarnings("ignore", message="overflow encountered in tanh")
 
-        logger.debug(f"Started fitting routine")
+        logger.debug("Started fitting routine")
         for i in range(repeat):
             logger.debug(f"Fitting routine pass {i}")
             opt_result = least_squares(
@@ -168,7 +169,7 @@ def fit_routine(
                 ftol=1e-9,
             )
             initial_value = opt_result.x
-            logger.debug(f"Finished least squares")
+            logger.debug("Finished least squares")
             opt_result = minimize(
                 opt_func,
                 initial_value,
@@ -178,6 +179,6 @@ def fit_routine(
                 method="Nelder-Mead",
             )
             initial_value = opt_result.x
-            logger.debug(f"Finished Nelder-Mead")
-    logger.debug(f"Finished fitting routine")
+            logger.debug("Finished Nelder-Mead")
+    logger.debug("Finished fitting routine")
     return opt_result

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/transform/electrochemistry.py

@@ -19,6 +19,7 @@ charge and timestamps.
     nernst
 
 """
+
 import pint
 import numpy as np
 import pandas as pd
@@ -48,7 +49,7 @@ ureg = pint.get_application_registry()
 def nernst(
     Ewe: pint.Quantity,
     R: pint.Quantity = pint.Quantity(0.0, "Ω"),
-    I: pint.Quantity = pint.Quantity(0.0, "A"),
+    I: pint.Quantity = pint.Quantity(0.0, "A"),  # noqa: E741
     Eref: pint.Quantity = pint.Quantity(0.0, "V"),
     T: pint.Quantity = pint.Quantity(298.15, "K"),
     n: int = None,
@@ -148,7 +149,7 @@ def nernst(
 )
 def fe(
     rate: dict[str, pint.Quantity],
-    I: pint.Quantity,
+    I: pint.Quantity,  # noqa: E741
     charges: dict[str, int],
     output: str = None,
 ) -> dict[str, pint.Quantity]:
@@ -214,7 +215,7 @@ def fe(
 )
 def charge(
     time: pint.Quantity,
-    I: pint.Quantity,
+    I: pint.Quantity,  # noqa: E741
     t0: pint.Quantity = None,
     output: str = "Q",
 ) -> dict[str, pint.Quantity]:
@@ -327,10 +328,10 @@ def average_current(
         dt = np.diff(time)
         dQ = np.diff(Q)
 
-    I = dQ / dt
+    current = dQ / dt
 
-    if len(I) != nts:
-        I = np.insert(I, 0, ureg.Quantity(0, "A"))
+    if len(current) != nts:
+        current = np.insert(current, 0, ureg.Quantity(0, "A"))
 
-    ret = {output: I}
+    ret = {output: current}
     return ret

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/transform/impedance.py

@@ -26,6 +26,7 @@ to find the :func:`~dgpost.transform.impedance.lowest_real_impedance` in the dat
     in this module have to be called on each timestep individually.
 
 """
+
 import logging
 from typing import Union
 import numpy as np

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/transform/rates.py

@@ -17,6 +17,7 @@ rates from the concentration profile of a batch mixture.
     flow_to_molar
 
 """
+
 import pint
 import pandas as pd
 import numpy as np

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/transform/reflection.py

@@ -27,25 +27,28 @@ factors to the reflection trace data. The use of the peak-height based pruning v
 
 
 """
+
 import pint
 import numpy as np
 import uncertainties as uc
 from scipy.optimize import curve_fit
+from scipy.signal import find_peaks
 
 from dgpost.utils.helpers import separate_data, load_data
 
 
-def _find_peak(near, absgamma, freq) -> int:
+def _find_peak(near, absgamma, freq, height=0.2) -> int:
     if near is None:
-        logmag = -10 * np.log10(absgamma)
-        return np.argmax(logmag)
+        return np.argmax((1 - absgamma))
     else:
-        dp = len(freq) // 10
-        idx = np.argmax(freq > near)
-        s = max(0, idx - dp)
-        e = min(len(freq), idx + dp)
-        logmag = -10 * np.log10(absgamma[s:e])
-        return s + np.argmax(logmag)
+        peaks, _ = find_peaks((1 - absgamma), height=height)
+        nearest = None
+        for pi in peaks:
+            if nearest is None:
+                nearest = pi
+            elif abs(freq[pi] - near) < abs(freq[nearest] - near):
+                nearest = pi
+        return nearest
 
 
 @load_data(
@@ -60,6 +63,7 @@ def prune_cutoff(
     freq: pint.Quantity,
     near: pint.Quantity = None,
     cutoff: float = 0.4,
+    height: float = 0.2,
     output: str = "pruned",
 ) -> dict[str, pint.Quantity]:
     """
@@ -87,17 +91,18 @@ def prune_cutoff(
 
     near
         A frequency used to select the point around which to prune. By default, pruning
-        is performed around the highest peak in :math:`\\text{log}|\\Gamma|`. When set,
-        pruning will be perfomed around any maximum in :math:`\\text{log}|\\Gamma|` that
-        exists within 10% of the trace size on either side of the selected point. This
-        means that for a trace size of 20001 points, 2000 points below and 2000 points
-        above the point corresponding to the selected frequency will be used to find a
-        local maximum.
+        is performed around the highest peak in :math:`(1 - \\Gamma)`. When ``near`` is
+        set, the peak nearest in frequency as identified using :func:`~scipy.signal.find_peaks`
+        will be used for pruning.
 
     cutoff
         Relative peak height below which the reflection trace should be pruned.
         Uses a fraction of normalised :math:`|\\Gamma|`. Defaults to ``0.4``.
 
+    height
+        Peak height in :math:`(1 - \\Gamma)` passed to :func:`~scipy.signal.find_peaks`,
+        defaults to ``0.2``.
+
     output
         Name for the output namespace. Defaults to ``"pruned"``.
 
@@ -111,18 +116,20 @@ def prune_cutoff(
     re, _, _ = separate_data(real)
     im, _, _ = separate_data(imag)
     absgamma = np.abs(re + 1j * im)
-    pi = _find_peak(near, absgamma, freq)
+
+    pi = _find_peak(near, absgamma, freq, height=height)
+
     max_v = absgamma.max()
     min_v = absgamma[pi]
     norm = (absgamma - min_v) / (max_v - min_v)
-    for l in range(pi - 1):
-        li = pi - l
+    for left in range(pi - 1):
+        li = pi - left
         if norm[li] <= cutoff:
             pass
         else:
             break
-    for r in range(len(absgamma) - pi):
-        ri = pi + r
+    for rght in range(len(absgamma) - pi):
+        ri = pi + rght
         if norm[ri] <= cutoff:
             pass
         else:
@@ -169,13 +176,10 @@ def prune_gradient(
         corresponding to the reflection coefficient data. Defaults to ``Hz``.
 
     near
-        A frequency used to select around which peak to prune. By default, pruning
-        is performed around the highest peak in :math:`\\text{log}|\\Gamma|`. When set,
-        pruning will be perfomed around any maximum in :math:`\\text{log}|\\Gamma|` that
-        exists within 10% of the trace size on either side of the selected point. This
-        means that for a trace size of 20001 points, 2000 points below and 2000 points
-        above the point corresponding to the selected frequency will be used to find a
-        local maximum.
+        A frequency used to select the point around which to prune. By default, pruning
+        is performed around the highest peak in :math:`(1 - \\Gamma)`. When ``near`` is
+        set, the peak nearest in frequency as identified using :func:`~scipy.signal.find_peaks`
+        will be used for pruning.
 
     threshold
         Threshold for the gradient in the :math:`\\text{abs}(\\Gamma)` below which the
@@ -199,15 +203,15 @@ def prune_gradient(
 
     pi = _find_peak(near, absgamma, freq)
 
-    for l in range(pi - 1):
-        li = pi - l
-        if abs(grad[li]) > threshold or l < 100:
+    for left in range(pi - 1):
+        li = pi - left
+        if abs(grad[li]) > threshold or left < 100:
             pass
         else:
             break
-    for r in range(absgamma.size - pi):
-        ri = pi + r
-        if abs(grad[ri]) > threshold or r < 100:
+    for rght in range(absgamma.size - pi):
+        ri = pi + rght
+        if abs(grad[ri]) > threshold or rght < 100:
             pass
         else:
             break

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/transform/table.py

@@ -19,6 +19,7 @@ stripping or replacing uncertainties from data.
 
 
 """
+
 import pint
 import pandas as pd
 import numpy as np

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/utils/__init__.py

@@ -5,3 +5,5 @@ from .parse import parse
 from .save import save
 from .plot import plot
 from .pivot import pivot
+
+__all__ = ["extract", "transform", "load", "parse", "save", "plot", "pivot"]

{dgpost-2.1.2 → dgpost-2.2.1}/src/dgpost/utils/extract.py

@@ -61,10 +61,10 @@ The data pulled out of the datagram in the second step using the prescription in
 are interpolated onto the index of the existing :class:`pd.DataFrame`.
 
 """
+
 import numpy as np
 import pandas as pd
-import datatree
-import xarray as xr
+from xarray import DataTree
 import uncertainties as uc
 import uncertainties.unumpy as unp
 from typing import Union, Any, Optional
@@ -83,14 +83,14 @@ logger = logging.getLogger(__name__)
 
 
 def get_step(
-    obj: Union[pd.DataFrame, datatree.DataTree, dict, None],
+    obj: Union[pd.DataFrame, DataTree, dict, None],
     at: Optional[dict] = None,
-) -> Union[pd.DataFrame, datatree.DataTree, list[dict], None]:
+) -> Union[pd.DataFrame, DataTree, list[dict], None]:
     if obj is None:
         return None
     elif isinstance(obj, pd.DataFrame):
         return obj
-    elif isinstance(obj, datatree.DataTree):
+    elif isinstance(obj, DataTree):
         if at is not None and "step" in at:
             return obj[at["step"]]
         elif at is not None and "steps" in at:
@@ -115,7 +115,7 @@ def get_step(
             if isinstance(step, int):
                 assert step < len(obj["steps"]), (
                     f"extract: specified step index {step} is out of bounds "
-                    f"of the supplied datagtam with {len(obj['steps'])} steps."
+                    f"of the supplied datagram with {len(obj['steps'])} steps."
                 )
                 ret += obj["steps"][step]["data"]
             elif isinstance(step, str):
@@ -148,7 +148,7 @@ def get_constant(spec: dict, ts: pd.Index):
 
 
 def extract(
-    obj: Union[dict, pd.DataFrame, datatree.DataTree, None],
+    obj: Union[dict, pd.DataFrame, DataTree, None],
     spec: dict,
     index: pd.Index = None,
 ) -> pd.DataFrame:
@@ -229,8 +229,8 @@ def _(obj: pd.DataFrame, columns: list[dict]) -> list[pd.Series]:
     return series
 
 
-@extract_obj.register(datatree.DataTree)
-def _(obj: datatree.DataTree, columns: list[dict]) -> list[pd.Series]:
+@extract_obj.register(DataTree)
+def _(obj: DataTree, columns: list[dict]) -> list[pd.Series]:
     def get_key_recurse(dt, keys):
         key = keys.pop(0)
         if len(keys) == 0:
@@ -259,6 +259,8 @@ def _(obj: datatree.DataTree, columns: list[dict]) -> list[pd.Series]:
                 if vals.coords.dtypes[coord].kind in {"O", "U"}:
                     splits = vals[coord].values
                     break
+            else:
+                splits = [None]
         else:
             coord = None
             splits = [None]
@@ -276,6 +278,8 @@ def _(obj: datatree.DataTree, columns: list[dict]) -> list[pd.Series]:
             if sigs is None:
                 if coord is None:
                     data = vals
+                elif split is None:
+                    data = vals.values
                 else:
                     data = vals.loc[{coord: split}]
                     name.append(split)