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

CHAP/reader.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python
-"""
+'''
 File       : reader.py
 Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>
 Description: generic Reader module
-"""
+'''
 
 # system modules
 import argparse
@@ -16,14 +16,14 @@ from time import time
 # from pipeline import PipelineObject
 
 class Reader():
-    """
+    '''
     Reader represent generic file writer
-    """
+    '''
 
     def __init__(self):
-        """
+        '''
         Constructor of Reader class
-        """
+        '''
         self.__name__ = self.__class__.__name__
         self.logger = logging.getLogger(self.__name__)
         self.logger.propagate = False
@@ -75,119 +75,24 @@ class Reader():
             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 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)
-
-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 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 OptionParser():
     '''User based option parser'''
     def __init__(self):
         self.parser = argparse.ArgumentParser(prog='PROG')
-        self.parser.add_argument("--filename", action="store",
-            dest="filename", default="", help="Input file")
-        self.parser.add_argument("--reader", action="store",
-            dest="reader", default="Reader", help="Reader class name")
-        self.parser.add_argument('--log-level', choices=logging._nameToLevel.keys(),
+        self.parser.add_argument(
+            '--filename', action='store',
+            dest='filename', default='', help='Input file')
+        self.parser.add_argument(
+            '--reader', action='store',
+            dest='reader', default='Reader', help='Reader class name')
+        self.parser.add_argument(
+            '--log-level', choices=logging._nameToLevel.keys(),
             dest='log_level', default='INFO', help='logging level')
 
-def main():
+def main(opt_parser=OptionParser):
     '''Main function'''
-    optmgr  = OptionParser()
+
+    optmgr  = opt_parser()
     opts = optmgr.parser.parse_args()
     clsName = opts.reader
     try:
@@ -203,7 +108,7 @@ def main():
     reader.logger.addHandler(log_handler)
     data = reader.read(filename=opts.filename)
 
-    print(f"Reader {reader} reads from {opts.filename}, data {data}")
+    print(f'Reader {reader} reads from {opts.filename}, data {data}')
 
 if __name__ == '__main__':
     main()

CHAP/saxswaxs/__init__.py

@@ -0,0 +1,6 @@
+# from CHAP.saxswaxs.reader import
+# from CHAP.saxswaxs.processor import
+# from CHAP.saxswaxs.writer import
+
+from CHAP.common import (IntegrateMapProcessor,
+                         MapProcessor)

CHAP/saxswaxs/processor.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python  
+
+if __name__ == '__main__':
+    from CHAP.processor import main
+    main()

CHAP/saxswaxs/reader.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python  
+
+if __name__ == '__main__':
+    from CHAP.reader import main
+    main()

CHAP/saxswaxs/writer.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python  
+
+if __name__ == '__main__':
+    from CHAP.writer import main
+    main()

CHAP/sin2psi/__init__.py

@@ -0,0 +1,7 @@
+# from CHAP.sin2psi.reader import
+# from CHAP.sin2psi.processor import
+# from CHAP.sin2psi.writer import
+
+from CHAP.common import (IntegrateMapProcessor,
+                         MapProcessor,
+                         StrainAnalysisProcessor)

CHAP/sin2psi/processor.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python  
+
+if __name__ == '__main__':
+    from CHAP.processor import main
+    main()

CHAP/sin2psi/reader.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python  
+
+if __name__ == '__main__':
+    from CHAP.reader import main
+    main()

CHAP/sin2psi/writer.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python  
+
+if __name__ == '__main__':
+    from CHAP.writer import main
+    main()

CHAP/tomo/__init__.py

@@ -0,0 +1,5 @@
+# from CHAP.tomo.reader import
+from CHAP.tomo.processor import TomoDataProcessor
+# from CHAP.tomo.writer import
+
+from CHAP.common import MapProcessor

CHAP/tomo/models.py

@@ -0,0 +1,125 @@
+# system modules
+
+# third party imports
+from pydantic import (
+        BaseModel,
+        StrictBool,
+        conint,
+        conlist,
+        confloat,
+        constr,
+)
+from typing import Literal, Optional
+
+
+class Detector(BaseModel):
+    """
+    Detector class to represent the detector used in the experiment.
+    
+    :ivar prefix: Prefix of the detector in the SPEC file.
+    :type prefix: str
+    :ivar rows: Number of pixel rows on the detector
+    :type rows: int
+    :ivar columns: Number of pixel columns on the detector
+    :type columns: int
+    :ivar pixel_size: Pixel size of the detector in mm
+    :type pixel_size: int or list[int]
+    :ivar lens_magnification: Lens magnification for the detector
+    :type lens_magnification: float, optional
+    """
+    prefix: constr(strip_whitespace=True, min_length=1)
+    rows: conint(gt=0)
+    columns: conint(gt=0)
+    pixel_size: conlist(item_type=confloat(gt=0, allow_inf_nan=False), min_items=1, max_items=2)
+    lens_magnification: confloat(gt=0, allow_inf_nan=False) = 1.0
+
+
+class TomoSetupConfig(BaseModel):
+    """
+    Class representing the configuration for the tomography reconstruction setup.
+
+    :ivar detectors: Detector used in the tomography experiment
+    :type detectors: Detector
+    """
+    detector: Detector.construct()
+    include_raw_data: Optional[StrictBool] = False
+
+
+class TomoReduceConfig(BaseModel):
+    """
+    Class representing the configuration for tomography image reductions.
+
+    :ivar tool_type: Type of tomography reconstruction tool; always set to "reduce_data"
+    :type tool_type: str, optional
+    :ivar detectors: Detector used in the tomography experiment
+    :type detectors: Detector
+    :ivar img_x_bounds: Detector image bounds in the x-direction
+    :type img_x_bounds: list[int], optional
+    """
+    tool_type: Literal['reduce_data'] = 'reduce_data'
+    detector: Detector = Detector.construct()
+    img_x_bounds: Optional[conlist(item_type=conint(ge=0), min_items=2, max_items=2)]
+
+
+class TomoFindCenterConfig(BaseModel):
+    """
+    Class representing the configuration for tomography find center axis.
+
+    :ivar tool_type: Type of tomography reconstruction tool; always set to "find_center"
+    :type tool_type: str, optional
+    :ivar center_stack_index: Stack index of tomography set to find center axis (offset 1)
+    :type center_stack_index: int, optional
+    :ivar lower_row: Lower row index for center finding
+    :type lower_row: int, optional
+    :ivar lower_center_offset: Center at lower row index
+    :type lower_center_offset: float, optional
+    :ivar upper_row: Upper row index for center finding
+    :type upper_row: int, optional
+    :ivar upper_center_offset: Center at upper row index
+    :type upper_center_offset: float, optional
+    """
+    tool_type: Literal['find_center'] = 'find_center'
+    center_stack_index: Optional[conint(ge=1)]
+    lower_row: Optional[conint(ge=-1)]
+    lower_center_offset: Optional[confloat(allow_inf_nan=False)]
+    upper_row: Optional[conint(ge=-1)]
+    upper_center_offset: Optional[confloat(allow_inf_nan=False)]
+
+
+class TomoReconstructConfig(BaseModel):
+    """
+    Class representing the configuration for tomography image reconstruction.
+
+    :ivar tool_type: Type of tomography reconstruction tool; always set to "reconstruct_data"
+    :type tool_type: str, optional
+    :ivar x_bounds: Reconstructed image bounds in the x-direction
+    :type x_bounds: list[int], optional
+    :ivar y_bounds: Reconstructed image bounds in the y-direction
+    :type y_bounds: list[int], optional
+    :ivar z_bounds: Reconstructed image bounds in the z-direction
+    :type z_bounds: list[int], optional
+    """
+    tool_type: Literal['reconstruct_data'] = 'reconstruct_data'
+    x_bounds: Optional[conlist(item_type=conint(ge=-1), min_items=2, max_items=2)]
+    y_bounds: Optional[conlist(item_type=conint(ge=-1), min_items=2, max_items=2)]
+    z_bounds: Optional[conlist(item_type=conint(ge=-1), min_items=2, max_items=2)]
+
+
+class TomoCombineConfig(BaseModel):
+    """
+    Class representing the configuration for combined tomography stacks.
+
+    :ivar tool_type: Type of tomography reconstruction tool; always set to "combine_data"
+    :type tool_type: str, optional
+    :ivar x_bounds: Reconstructed image bounds in the x-direction
+    :type x_bounds: list[int], optional
+    :ivar y_bounds: Reconstructed image bounds in the y-direction
+    :type y_bounds: list[int], optional
+    :ivar z_bounds: Reconstructed image bounds in the z-direction
+    :type z_bounds: list[int], optional
+    """
+    tool_type: Literal['combine_data'] = 'combine_data'
+    x_bounds: Optional[conlist(item_type=conint(ge=-1), min_items=2, max_items=2)]
+    y_bounds: Optional[conlist(item_type=conint(ge=-1), min_items=2, max_items=2)]
+    z_bounds: Optional[conlist(item_type=conint(ge=-1), min_items=2, max_items=2)]
+