ECGProcess 1.1.0__py3-none-any.whl

ecgprocess/utils/reader_tools.py

@@ -0,0 +1,508 @@
+"""
+Tools to help read and process ECG files.
+
+Functions and classes are predominantly aimed to map ECG files to native
+python objects such as dictionary and systematically process these. Functions
+specifically focussed on ECG signals, such as calculating the limb leads,
+are collected in `ecgprocess.utils.ecg_tools`.
+"""
+
+import re
+import pydicom
+import warnings
+import xmltodict
+import numpy as np
+from lxml import etree
+from pathlib import Path
+from typing import (
+    Optional, Any,
+)
+from ecgprocess.utils.general import(
+    parse_number,
+)
+from ecgprocess.constants import (
+    CoreData as Core,
+    UtilsReaderNames as RNames,
+)
+from ecgprocess.errors import (
+    is_type,
+    MissingTagError,
+)
+from ecgprocess.constants import UtilsGeneralNames as UGNames
+from ecgprocess.errors import XMLValidationError
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# constants
+WARN1 = "XML file is valid (ignoring XML elements not in the supplied XSD)."
+CTypes = Core.DataTypes
+CProc = Core.ProcessingData
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Base class with slots
+class BaseReader:
+    '''
+    An ECGDICOMReader base class implementing the more efficient __slots__ for
+    the waveform arrays, while still retaining __dict__ dynamic attribute
+    creation.
+    '''
+    __slots__ = (CTypes.WaveForms, CTypes.MedianBeats,
+                 CTypes.MetaData, CTypes.OtherData, CProc.RAW)
+    # /////////////////////////////////////////////////////////////////////////
+    def __init__(self, waveforms=None, medianbeats=None, metadata=None,
+                 otherdata=None, raw=None):
+        '''
+        Initialises slots entries to `None`.
+        '''
+        setattr(self, CTypes.WaveForms, waveforms)
+        setattr(self, CTypes.MedianBeats,medianbeats)
+        setattr(self, CTypes.MetaData,metadata)
+        setattr(self, CTypes.OtherData, otherdata)
+        setattr(self, CProc.RAW,raw)
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+def validate_xml(xml_path:str|Path, xsd_path:str|Path, strict:bool=True,
+                 verbose:bool=True,
+                 ) -> etree._ElementTree:
+    """
+    Validates an XML file against an XSD schema.
+    
+    Parameters
+    ----------
+    xml_path : `str` or `Path`
+        Path to the XML file.
+    xsd_path : `str` or `Path`
+        Path to the XSD file.
+    strict : `bool`, default `True`
+        If False, ignores elements in the XML that are not in the XSD.
+        
+    Returns
+    -------
+    etree._ElementTree
+        The parsed XML document.
+    
+    Raises
+    ------
+    XMLValidationError
+        Raised if the XSD and XML are incompatible.
+    """
+    # #### Check input
+    is_type(strict, bool)
+    is_type(verbose, bool)
+    is_type(xml_path, (str, Path))
+    is_type(xsd_path, (str, Path))
+    # #### Load the XSD schema
+    with open(xsd_path, 'rb') as xsd:
+        schema_root = etree.XML(xsd.read())
+    schema = etree.XMLSchema(schema_root)
+    # #### Parse the XML file
+    try:
+        with open(xml_path, 'rb') as xml:
+            xml_doc = etree.parse(xml)
+    except etree.XMLSyntaxError:
+        parser = etree.XMLParser(resolve_entities=False, huge_tree=True)
+        with open(xml_path, 'rb') as xml:
+            xml_doc = etree.parse(xml, parser=parser,)
+    # #### Compare XML against XSD
+    is_valid = schema.validate(xml_doc)
+    # #### Do we want to raise errors when XML elements are absent in the XSD
+    if not is_valid and not strict:
+        # if strict is False remove error relating to missing XSD elements
+        errors = [err.message for err in schema.error_log]
+        filtered_errs = [err for err in schema.error_log if\
+                           not UGNames.LXML_ERROR in err.message]
+        # check if there are any other type of errors
+        is_valid = len(filtered_errs) == 0
+        if is_valid:
+            # Where there any errors to begin with
+            if verbose == True and len(schema.error_log) > 0:
+                warnings.warn(WARN1)
+        else:
+            errors = [err.message for err in filtered_errs]
+            raise XMLValidationError(errors)
+    elif is_valid == False:
+        errors = [err.message for err in schema.error_log]
+        raise XMLValidationError(errors)
+    # return xml_doc
+    return xml_doc
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+def xml_to_dict(xml_doc:etree._ElementTree, encoding:str='utf-8',
+                ) -> dict[str, Any]:
+    """
+    Converts an lxml ElementTree document to a dictionary.
+    
+    Parameters
+    ----------
+    xml_doc : `etree._ElementTree`
+        A validated XML document.
+    encoding : `str`, default `utf-8`
+        
+    Returns
+    -------
+    dict [`str`, `any`]
+        A dictionary representation of the XML data.
+    """
+    is_type(encoding,str)
+    is_type(xml_doc, etree._ElementTree)
+    # convert to string
+    xml_str = etree.tostring(xml_doc, encoding=encoding)
+    # parste to dict
+    xml_dict = xmltodict.parse(xml_str)
+    # returning stuf.
+    return xml_dict
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+def dicom_to_dict(ds: pydicom.dataset.Dataset) -> dict[str, Any]:
+    """
+    Turn a pydicom Dataset into a dict with keys derived from the Element names.
+    
+    Parameters
+    ----------
+    ds : `pydicom.dataset.Dataset`
+        The DICOM dataset to convert.
+    
+    Returns
+    -------
+    dict [`str`, `any`]
+        A dictionary representation of the dataset.
+    """
+    output = {}
+    for elem in ds:
+        # SQ: sequences should be dealt with through recursion
+        # Each sequence element contains a list of sub-elements
+        # (nested datasets), which may themselves have multiple elements.
+        if elem.VR != "SQ":
+            output[elem.name] = elem.value
+        else:
+            output[elem.name] = [dicom_to_dict(item) for item in elem]
+    # Extract waveform data if available
+    if hasattr(ds, RNames.DICOM_WAVE_ARRAY):
+        # Attempt to extract waveform data if the method exists
+        waveform_data = {}
+        # Extract the waveform data
+        try:
+            waveform_data["ECG_Leads"] = ds.waveform_array(0).T.tolist()
+        except (IndexError, AttributeError):
+            pass
+        # Extract median beats
+        try:
+            waveform_data["Median_Beats"] = ds.waveform_array(1).T.tolist()
+        except (IndexError, AttributeError):
+            pass
+        if waveform_data:
+            output["WaveformData"] = waveform_data
+    # return
+    return output
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+def flatten_dict(d:dict[str, Any], parent_prefix:str='', sep:str='.',
+                 skip_root:bool=True,
+                 ) -> dict[str, Any]:
+    """
+    Recursively flatten a nested dictionary, optionally skipping the root
+    element.
+    
+    Parameters
+    ----------
+    d : dict
+        The dictionary to flatten.
+    parent_prefix : str, default ''
+        The base string added as a prefix to all keys during recursion.
+        Useful for maintaining context or indicating a higher-level structure.
+    sep : str, default '.'
+        The key separator
+    skip_root : bool, default True
+        If True, skips the first level (root) key.
+    
+    Returns
+    -------
+    dict
+        A flattened dictionary where nested keys are concatenated into a single
+        key.
+    
+    Examples
+    --------
+    >>> nested_dict = {
+    ...     'a': {
+    ...         'b': 1,
+    ...         'c': {
+    ...             'd': 2
+    ...         }
+    ...     }
+    ... }
+    >>> flatten_dict(nested_dict)
+    {'b': 1, 'c.d': 2}
+    
+    >>> flatten_dict(nested_dict, skip_root=False)
+    {'a.b': 1, 'a.c.d': 2}
+    
+    >>> flatten_dict(nested_dict, sep='_', skip_root=False)
+    {'a_b': 1, 'a_c_d': 2}
+    """
+    # check input
+    is_type(d, dict)
+    is_type(parent_prefix, str)
+    is_type(sep, str)
+    is_type(skip_root, bool)
+    # initiate empty results
+    res = []
+    # If skipping the root, adjust d to be the first nested dictionary level
+    if skip_root and isinstance(d, dict) and len(d) == 1:
+        _, d = next(iter(d.items()))
+    # loop over the remaining keys and values
+    for k, v in d.items():
+        new_key = f"{parent_prefix}{sep}{k}" if parent_prefix else k
+        # if v is dict, unpack
+        if isinstance(v, dict):
+            res.extend(flatten_dict(v, new_key, sep=sep, skip_root=False).items())
+        # if v is list, unpack
+        elif isinstance(v, list):
+            for i, item in enumerate(v):
+                # flatten lists
+                if item is not None and isinstance(item, dict):
+                    res.extend(flatten_dict(item, f"{new_key}_{i}",
+                                            sep=sep, skip_root=False).\
+                                 items())
+                # otherwise add non-dict and None types
+                else:
+                    res.append((f"{new_key}_{i}", item))
+        # otherwise simply assign
+        else:
+            res.append((new_key, v))
+    return dict(res)
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+def get_ecg_data(data_dict:dict[str, Any],
+                 config:dict[str, str],
+                 parse_numeric:bool=True,
+                 as_array:bool=False,
+                 bits:np.dtype | None =None,
+                 skip_empty:bool=True,
+                 **kwargs:Optional[Any],
+                 ) -> tuple[dict[str, Any], list[str]]:
+    '''
+    Extracts metadata or signal data from a `data_dict` based on a supplied
+    `config` dictionary.
+    
+    Parameters
+    ----------
+    data_dict : `dict` [`str`, `any`]
+        A dictionary with keys and values matching the config object
+    config : `dict` [`str`, `str`]
+        a dictionary where the values match some keys in `data_dict` and the
+        keys represent the names these will be stored to.
+    parse_numeric : `bool`, default `True`
+        Will check if a numbers are accidentally presented as strings and parse
+        these to numbers.
+    as_array : `bool`, default `False`
+        Whether data should be mapped to `np.array` using a direct map:
+        `np.array(., dtype=bits)`.
+    bits : `np.dtype`, default `None`
+        np.array bits passed to numpy.array dtype.
+    skip_empty : `bool`, default `True`
+        Whether to skip config values not matching data_dict keys.
+    **kwargs
+        keyword arguments to `parse_number`.
+    
+    Returns
+    -------
+    dict
+        A dictionary with the extracted signal data or metadata.
+    list
+        A list with `config` values which did not match `data_dict` keys.
+    
+    Notes
+    -----
+    Whenever a config value starts with "[STARTSWITH]", the algorithm gathers
+    all relevant values in data_dict that share the specific prefix remaining
+    after stripping the quoted text. These values are concatenated into a
+    single string, where the original breaks between the values is indicated
+    by `[DELIM]`.
+    '''
+    # #### check input
+    is_type(data_dict, dict)
+    is_type(config, dict)
+    is_type(skip_empty, bool)
+    is_type(as_array, bool)
+    is_type(parse_numeric, bool)
+    STARTS = '[STARTSWITH]'
+    DELIM = '[DELIM]'
+    # #### initialise object
+    results_dict = {}
+    results_missing = []
+    # #### extract signal data
+    for t, s in config.items():
+        # cutting this in half using HIT
+        HIT = False
+        if not s is None:
+            if s.startswith(STARTS):
+                HIT = True
+                # Strip the [STARTSWITH] part
+                prefix = s[len(STARTS):]
+                # extracting entries which start with STARTS
+                combi = DELIM.join(str(v) for k, v in data_dict.items()\
+                                   if k.startswith(prefix)) or None
+                if combi is None:
+                    results_missing.append(s)
+                    # setting these to none to ensure key consistency
+                    results_dict[t] = None
+                    if skip_empty == False:
+                        # Should an Error be returned
+                        raise MissingTagError(s)
+                else:
+                    results_dict[t] = combi
+        if HIT == False:
+            if s in data_dict:
+            # if s in data_dict:
+                # Check if numerics are accidentally strings.
+                if parse_numeric:
+                    parsed_string = parse_number(data_dict[s], **kwargs)
+                    results_dict[t] = parsed_string
+                    if isinstance(parsed_string, list):
+                        if len(parsed_string) == 1:
+                            results_dict[t] = parsed_string[0]
+                else:
+                    results_dict[t] = data_dict[s]
+                # Do we want to extract signals and store these in a numpy array..
+                if as_array == True:
+                    try:
+                        results_dict[t] = np.array(results_dict[t], dtype=bits)
+                    except ValueError:
+                        pass
+            elif skip_empty == False and not s is None:
+                # Should an Error be returned
+                raise MissingTagError(s)
+            else:
+                # assign None and append missing metadata
+                results_dict[t] = None
+                results_missing.append(s)
+    # return
+    return results_dict, results_missing
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+def subset_dict(data:dict[str, Any], pattern:dict[str, str],
+                substitute:tuple[str,str]|None=(r'_[0-9]{1,2}\.*', ' '),
+                character_trim:int=0,
+                verbose:bool=True, skip_empty:bool=True,
+                ) -> dict[str, Any]:
+    """
+    This will identify a subset of `data` items based on a `startswith` call
+    using the `pattern` key, and based on the patternl values this function
+    will identify the single entry in the subset whose values contains a
+    unique name which will be added as a prefix to the subset keys.
+    
+    Parameters
+    ---------
+    data : `dict` [`str`, `any`]
+        The dictionary to be subsetted and transformed.
+    pattern : `dict` [`str`, `str`]
+        A dictionary where each key is a prefix to match against the keys of
+        `data`, and each value defines the suffix to search within the matching
+        keys in `data`. The value found in `data` corresponding to this suffix
+        is used as the prefix for the resulting dictionary keys. The pattern
+        keys will be matched to the data keys based on a `startswith`, while
+        the pattern values will be matched to the data keys using:
+        `value in key`.
+    substitute : `tuple` [`str`,`str`] or `None`, default `(r"_[0-9]{1,2}\\.*", " ")`
+        A tuple containing a regular expression pattern and replacement string.
+        This substitution is applied to the remaining portion of the `data` key
+        after removing the matching prefix.
+    character_trim : int, default `0`
+        The number of characters which should be removed from the right-hand
+        side of the `data` key which did not match the `pattern` key.
+    verbose : `bool`, default `True`
+        Whether warnings should be issued.
+    
+    Returns
+    -------
+    dict [`str`, `any`]
+        A dictionary with keys grouped and transformed based on the `pattern`
+        and `substitute`. The keys are prefixed with values derived from `data`.
+    
+    Examples
+    --------
+    >>> data = {
+    ...     "Sequence_0.Referenced Waveform Channels_0": "Channel 1",
+    ...     "Sequence_0.Referenced Waveform Channels_1": "Channel 2",
+    ...     "Sequence_0.Annotation Group Number": 1,
+    ...     "Sequence_0.Unformatted Text Value": "Event A",
+    ...     "Sequence_8.Measurement Units Code Sequence_0.Code Value": "bpm",
+    ...     "Sequence_8.Measurement Units Code Sequence_0.Code Meaning": "Heart Rate",
+    ...     "Sequence_15.Measurement Units Code Sequence_0.Code Meaning": "Temperature",
+    ...     "Sequence_15.Referenced Waveform Channels_1": "Channel 10",
+    ...     "Sequence_15.Numeric Value": 36.7,
+    ...     "Other Annotation Sequence_1.Some Value": "Other Data",
+    ...     "Other Annotation Sequence_1.Code Meaning": "Other Code Meaning",
+    ... }
+    >>> pattern = {
+    ...     "Sequence_15": "Code Meaning",
+    ...     "Sequence_8": "Code Meaning",
+    ...     "Sequence_16": "Code Meaning",
+    ...     "Sequence_11": "Code Meaning",
+    ...     "Other Annotation Sequence_1": "Code Meaning",
+    ... }
+    >>> subset_dict(data, pattern)
+    {'Temperature (Referenced Waveform Channels)': 'Channel 10',
+     'Temperature (Numeric Value)': 36.7,
+     'Heart Rate (Measurement Units Code SequenceCode Value)': 'bpm',
+     'Other Code Meaning (Some Value)': 'Other Data'}
+    """
+    # #### confirm input
+    is_type(data, dict)
+    is_type(pattern, dict)
+    is_type(substitute, (type(None), tuple))
+    if not substitute is None:
+        if len(substitute) != 2:
+            raise ValueError("`substitute` should be a `Nonetype` or a tuple "
+                             "with exactly two entries.")
+    # #### empty default
+    # regex=True
+    grouped = {}
+    unmatched_keys = set(pattern.keys())
+    # #### loop
+    for d_name, g_name in pattern.items():
+        # fist get all data entries where the key starts with `d_name`
+        prefix = None
+        sub_dict = {}
+        for k, v in data.items():
+            mtch = k.startswith(d_name)
+            if mtch:
+                # remove from unmatched
+                unmatched_keys.discard(d_name)
+                # Subset the non-matching string
+                d_name_len = len(d_name)
+                str_remainder = k[d_name_len + character_trim:]
+                # Do we want a cleaner string
+                str_remainder_clean = str_remainder
+                if not substitute is None:
+                    m, r = substitute
+                    str_remainder_clean = re.sub(m, r, str_remainder).strip()
+                # Check g_name is in str_remainder
+                if g_name in str_remainder:
+                    if prefix is not None:
+                        raise ValueError(
+                            f"For pattern {d_name}, `prefix`: {prefix} is "
+                            f"already set, cannot assign new value: {v} "
+                            f"please ensure `{g_name}` is unique.")
+                    prefix = v
+                else:
+                    sub_dict[str_remainder_clean] = v
+        # next confirm prefix is not None, and add the prefix
+        if len(sub_dict) > 0:
+            if prefix is None:
+                if skip_empty:
+                    continue
+                else:
+                    raise ValueError(f"`{g_name}` was not found in data.")
+            grouped.update(
+                {f"{prefix} ({key})": val for key, val in sub_dict.items()}
+            )
+            del sub_dict
+    # do we want to return un-matching keys
+    if verbose and unmatched_keys:
+            warnings.warn("The following keys did not match any pattern: "
+                          f"{', '.join(unmatched_keys)}")
+    # return
+    return grouped
+
+

ecgprocess-1.1.0.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: ECGProcess
+Version: 1.1.0
+Summary: A python module to process and standardise ECG data
+Author-email: "A. Floriaan Schmidt" <floriaanschmidt@gmail.com>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://gitlab.com/SchmidtAF/ECGProcess
+Project-URL: Documentation, https://SchmidtAF.gitlab.io/ECGProcess/
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: <3.14,>=3.11
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: lxml>=5
+Requires-Dist: xmltodict>=0.14
+Requires-Dist: pandas>=2.1.1
+Requires-Dist: numpy>=1.26
+Requires-Dist: scipy>=1.7
+Requires-Dist: tensorflow>=2.16
+Requires-Dist: pydicom>=2
+Requires-Dist: matplotlib>=3.9
+Provides-Extra: dev
+Requires-Dist: pytest>=6; extra == "dev"
+Requires-Dist: pytest-mock>=3.0; extra == "dev"
+Requires-Dist: pytest-dependency>=0.5; extra == "dev"
+Requires-Dist: codespell; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: bump2version>=1; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: sphinx-rtd-theme; extra == "dev"
+Requires-Dist: sphinx-bootstrap-theme; extra == "dev"
+Requires-Dist: furo; extra == "dev"
+Requires-Dist: myst-parser; extra == "dev"
+Requires-Dist: nbsphinx; extra == "dev"
+Requires-Dist: nbsphinx-link; extra == "dev"
+Requires-Dist: sphinx-argparse; extra == "dev"
+Requires-Dist: numpydoc; extra == "dev"
+Requires-Dist: docutils<0.21; extra == "dev"
+Requires-Dist: notebook; extra == "dev"
+Requires-Dist: jupyter; extra == "dev"
+Dynamic: license-file
+
+![Schematic](https://ecgprocess-schmidtaf-f9abe0f74d20c469a1e6cca62c7f636ef6bf6b9ffe.gitlab.io/_static/ECGProcessSchematic.png)
+
+# An ECG processing module
+__version__: `1.1.0`
+
+
+This repository host a mixture of function dealing with processing 
+electrocardiogram (ECG) data, and preparing these data for analysis.
+The processing functions are intended for user defined parametrisation 
+(using user supplied configuration files `cnf`) about the data which 
+should be extracted, covering signal data such as waveforms or
+median beats, as well as metadata relevant for downstream QC or as
+tabular information. 
+
+The module implements a basic application programming interface, mapping
+ECG data from distinct file types (e.g. XML or DICOM) to class attributes
+providing a fixed interface for downstream analysis and interrogation. 
+
+The documentation for ECGProcess can be found [here](https://SchmidtAF.gitlab.io/ECGProcess/). 
+
+
+## Installation 
+At present, the repository is undergoing development and no packages exist yet 
+on PyPy or in Conda.
+Therefore it is recommended that it is installed in either of the two ways
+listed below.
+First, clone this repository and then `cd` to the root of the repository.
+
+```sh
+git clone git@gitlab.com:SchmidtAF/ECGProcess.git
+cd ECGProcess
+```
+
+### Installation using conda dependencies
+A conda environment is provided in a `yaml` file in the directory 
+`./resources/conda/envs/`.
+A new conda environment called `ecgprocess` can be built using the command:
+
+```sh
+# From the root of the repository
+conda env create --file ./resources/conda/envs/conda_create.yaml
+```
+
+To add to an existing environment use:
+
+```sh
+# From the root of the repository
+conda env update --file ./resources/conda/envs/conda_update.yaml
+```
+
+Next the package can be installed: 
+
+```sh
+python -m pip install .
+```
+
+Or for an editable (developer) install run the command below from the root of 
+the repository.
+The difference with this is that you can just to a `git pull` to 
+update repository, or switch branches without re-installing:
+
+```sh
+python -m pip install -e .
+
+```
+### Installation not using any conda dependencies
+If you are not using conda in any way then install the dependencies via `pip` 
+and install repository as an editable install also via pip:
+
+Install dependencies:
+
+```sh
+python -m pip install --upgrade -r requirements.txt
+```
+
+Then to install repository you can either do:
+
+```sh
+python -m pip install .
+```
+
+Or for an editable (developer) install run the command below from the root of
+the repository.
+The difference with this is that you can just to a `git pull` to update
+repository, or switch branches without re-installing:
+
+```sh
+python -m pip install -e .
+```
+
+## Next steps...
+After installation you might wish to try the `pytest` to confirm 
+everything is in working order. 
+
+```sh
+# From the root of the repository
+pytest tests
+```
+
+## Usage
+
+Please have a look at the examples in 
+[resources](https://gitlab.com/SchmidtAF/ECGProcess/-/tree/master/resources/examples)
+for some possible recipes. 
+

ecgprocess-1.1.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+ecgprocess/__init__.py,sha256=ZygAIkX6Nbjag1czWdQa-yP-GM1mBE_9ss21Xh__JFc,34
+ecgprocess/_version.py,sha256=b6-WiVk0Li5MaV2rBnHYl104TsouINojSWKqHDas0js,22
+ecgprocess/constants.py,sha256=otryxvYntmB6c_xH_eMMpVXNe0F-7OKqvbh1zTaYA40,5933
+ecgprocess/errors.py,sha256=BDZPl_4cLgGV3AAiiphS3xnx9f57VBcvr0hmRLz_Ks4,12025
+ecgprocess/plot_ecgs.py,sha256=ia6ypRperf5GBNYvizyw_Xv5H8AQQU6oR8hAjb_U4xg,38832
+ecgprocess/process_dicom.py,sha256=tm8IMU0D-3xKNE2MfUB7BtbmSdhlwk_WgiX45HZx_PI,9667
+ecgprocess/process_xml.py,sha256=ep9l69q5WYf3PKUMhguGSLtQsqyX1dbPxw1R5jt7rp0,12750
+ecgprocess/tabular.py,sha256=Yk3UbqV2nEugNT54HNVL2o6_bXEOOfL3nwjW_OW0N4I,63742
+ecgprocess/example_data/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+ecgprocess/example_data/examples.py,sha256=nbdHfEWyruNwYo0vtoKTwfLldGOwx6fFgXPK8t6kXw4,17864
+ecgprocess/example_data/example_datasets/.example-XML1.xml.un~,sha256=8VbZNIN8SRTsrhE-hC_OKtScnKcd2oT2XlR7GMNiOjs,2872
+ecgprocess/example_data/example_datasets/.example-XML1.xsd.un~,sha256=jSMJf_mChOZ-LP6Rk9ikjQmpkQ0e3-AC49ykZ1QHbKU,377534
+ecgprocess/example_data/example_datasets/.example-XML1_a.xsd.un~,sha256=raUIHMAEEB9vtz40UdXQntp-uj4ZW35reqzUw338ceY,22780
+ecgprocess/example_data/example_datasets/.example-XML1_d.xsd.un~,sha256=1zEIOMdzGlbu5OlOiyxzWwncGsP1QtDyQk6PWRFKu2Q,238478
+ecgprocess/example_data/example_datasets/.example-XML1_wrong.xsd.un~,sha256=e_Vkp2EQ-xDHtPU8qP4p6nuCCnlmWAcWhWVZh_RjliU,2558
+ecgprocess/example_data/example_datasets/example-DICOM1.dcm,sha256=dBkuaxVeZU21tpJ9ELwKg60MqT65v4rPcBBj7JHD0oM,142376
+ecgprocess/example_data/example_datasets/example-DICOM2.dcm,sha256=Tg75DfNb8ZyPITWEU0paJqaz30a4QSL0IX1NSxnhu0Q,143650
+ecgprocess/example_data/example_datasets/example-XML1.xml,sha256=sAuj7rTz9rWXcBN5Z0o3uD7UNRSn9aJ1vYsAS1NaycI,517675
+ecgprocess/example_data/example_datasets/example-XML1.xsd,sha256=auIlBkM2Ps8NRLRQE0ZEBqXiSHezZZO3DfFqrbdw5U8,30011
+ecgprocess/example_data/example_datasets/example-XML1_error.xsd,sha256=CCOYDskNP_2xxcgLIu4vyt_rKpE6oVRdi7kvDxfVXks,30178
+ecgprocess/example_data/example_datasets/example-XML1_wrong.xsd,sha256=CCOYDskNP_2xxcgLIu4vyt_rKpE6oVRdi7kvDxfVXks,30178
+ecgprocess/example_data/example_datasets/string_data.txt,sha256=Ss_TTlNXIF_-oI6RNCx9Xc2YXv_6OZhmY1f6iq4GK_E,18
+ecgprocess/utils/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+ecgprocess/utils/config_tools.py,sha256=KznuK0vENK5eyXz2a2WYWlGVzyZH_alTApIG0nsjUEE,23155
+ecgprocess/utils/ecg_tools.py,sha256=chCZ9mP8yEAprRqGFw88R9h1fDteIRXAPecogsWMQYE,11027
+ecgprocess/utils/engineering_tools.py,sha256=lUuj5qajRVOFm1QWQ78iI6B_6I-HcsBKx1P0bF3aVV8,14802
+ecgprocess/utils/general.py,sha256=v3UA70Og_YAw50PePPQ0Vi5grjumabqxINnyqE-bnCU,13057
+ecgprocess/utils/reader_tools.py,sha256=Uwd6QT_crn446B45P43ZOZOi2FdyVQHvoWO2o9FJWlY,19283
+ecgprocess-1.1.0.dist-info/licenses/LICENCE.txt,sha256=IGTG-FiCwz8h8OpA1dOMUEGxlg0US7wOW3ZDmQI-ouo,778
+ecgprocess-1.1.0.dist-info/METADATA,sha256=a9t-XhFP3VZO8Ddu8XQaHfOMzVzCGFZAiTjGuuh85d0,4928
+ecgprocess-1.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ecgprocess-1.1.0.dist-info/top_level.txt,sha256=i1wlvtScBPYBll7dyIgwR3qyrg9_u7m-uQ2_z0L6snw,11
+ecgprocess-1.1.0.dist-info/RECORD,,