ChessAnalysisPipeline 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

CHAP/common/reader.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+'''
+File       : reader.py
+Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>
+Description: Module for Writers used in multiple experiment-specific workflows.
+'''
+
+# system modules
+import argparse
+import json
+import logging
+import sys
+from time import time
+
+# local modules
+from CHAP import Reader
+
+class BinaryFileReader(Reader):
+    def _read(self, filename):
+        '''Return a content of a given file name
+
+        :param filename: name of the binart file to read from
+        :return: the content of `filename`
+        :rtype: binary
+        '''
+        with open(filename, 'rb') as file:
+            data = file.read()
+        return(data)
+
+class MultipleReader(Reader):
+    def read(self, readers):
+        '''Return resuts from multiple `Reader`s.
+
+        :param readers: a dictionary where the keys are specific names that are
+            used by the next item in the `Pipeline`, and the values are `Reader`
+            configurations.
+        :type readers: list[dict]
+        :return: The results of calling `Reader.read(**kwargs)` for each item
+            configured in `readers`.
+        :rtype: list[dict[str,object]]
+        '''
+
+        t0 = time()
+        self.logger.info(f'Executing "read" with {len(readers)} Readers')
+
+        data = []
+        for reader_config in readers:
+            reader_name = list(reader_config.keys())[0]
+            reader_class = getattr(sys.modules[__name__], reader_name)
+            reader = reader_class()
+            reader_kwargs = reader_config[reader_name]
+
+            data.extend(reader.read(**reader_kwargs))
+
+        self.logger.info(f'Finished "read" in {time()-t0:.3f} seconds\n')
+
+        return(data)
+
+class NexusReader(Reader):
+    def _read(self, filename, nxpath='/'):
+        '''Return the NeXus object stored at `nxpath` in the nexus file
+        `filename`.
+
+        :param filename: name of the NeXus file to read from
+        :type filename: str
+        :param nxpath: path to a specific loaction in the NeXus file to read
+            from, defaults to `'/'`
+        :type nxpath: str, optional
+        :raises nexusformat.nexus.NeXusError: if `filename` is not a NeXus
+            file or `nxpath` is not in `filename`.
+        :return: the NeXus structure indicated by `filename` and `nxpath`.
+        :rtype: nexusformat.nexus.NXobject
+        '''
+
+        from nexusformat.nexus import nxload
+
+        nxobject = nxload(filename)[nxpath]
+        return(nxobject)
+
+class URLReader(Reader):
+    def _read(self, url, headers={}):
+        '''Make an HTTPS request to the provided URL and return the results.
+        Headers for the request are optional.
+
+        :param url: the URL to read
+        :type url: str
+        :param headers: headers to attach to the request, defaults to `{}`
+        :type headers: dict, optional
+        :return: the content of the response
+        :rtype: object
+        '''
+
+        import requests
+
+        resp = requests.get(url, headers=headers)
+        data = resp.content
+
+        self.logger.debug(f'Response content: {data}')
+
+        return(data)
+
+class YAMLReader(Reader):
+    def _read(self, filename):
+        '''Return a dictionary from the contents of a yaml file.
+
+        :param filename: name of the YAML file to read from
+        :return: the contents of `filename`
+        :rtype: dict
+        '''
+
+        import yaml
+
+        with open(filename) as file:
+            data = yaml.safe_load(file)
+        return(data)
+
+if __name__ == '__main__':
+    from CHAP.reader import main
+    main()

CHAP/common/utils/__init__.py

@@ -0,0 +1,37 @@
+from CHAP.common.utils.fit import (Fit,
+                                   FitMap,
+                                   FitMultipeak)
+from CHAP.common.utils.material import Material
+
+# def create_mask(data, bounds, exclude_bounds=True, current_mask=None):
+#     '''Return a boolean array that masks out the values in `bounds` when applied
+#     to `data`.
+
+#     :param data: the array for which a mask will be constructed
+#     :type data: Union[list, numpy.ndarray]
+#     :param bounds: a range of values in `data` (min, max) that the mask will
+#         exclude (or include if `exclude_bounds=False`).
+#     :type bounds: tuple
+#     :param exclude_bounds: should applying the mask to `data`  exclude (`True`)
+#         or include (`False`) the value ranges in `bounds`, defaults to `True`
+#     :type exclude_bounds: True, optional
+#     :param current_mask: an existing mask array for `data` that will be "or"-ed
+#         with the mask constructed from `bounds` before returning, defaults to
+#         None
+#     :type current_mask: numpy.ndarray(dtype=numpy.bool_), optional
+#     :return: a boolean mask array for `data`.
+#     :rtype: numpy.ndarray(dtype=numpy.bool_)
+#     '''
+
+#     import numpy as np
+
+#     min_, max_ = bounds
+#     if exclude_bounds:
+#         mask = np.logical_or(data < min_, data > max_)
+#     else:
+#         mask = np.logical_and(data > min_, data < max_)
+
+#     if current_mask is not None:
+#         mask = np.logical_or(mask, current_mask)
+
+#     return(mask)