ChessAnalysisPipeline 0.0.17.dev6__tar.gz → 0.0.17.dev8__tar.gz

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/CHAP/__init__.py

@@ -23,5 +23,4 @@ from CHAP.reader import Reader
 from CHAP.processor import Processor
 from CHAP.writer import Writer
 
-version = 'v0.0.17.dev6'
-#version = 'v0.0.17'
+version = 'v0.0.17.dev8'

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/CHAP/common/utils.py

@@ -14,7 +14,7 @@ import subprocess
 import json
 
 # Third party modules
-import pkg_resources
+from importlib.metadata import distributions
 
 def osinfo():
     """Helper function to provide osinfo."""
@@ -58,8 +58,9 @@ def environments():
     # Check for Virtualenv (excluding Conda)
     elif hasattr(sys, 'real_prefix') or os.getenv('VIRTUAL_ENV'):
         venv_name = os.path.basename(os.getenv('VIRTUAL_ENV', 'unknown-venv'))
-        packages = [{'name': pkg.key, 'version': pkg.version}
-                    for pkg in pkg_resources.working_set]
+        packages = [{'name': pkg.metadata['Name'],
+                     'version': pkg.version}
+                    for pkg in distributions()]
         environments_.append({
             'name': venv_name,
             'version': sys.version.split()[0],
@@ -71,8 +72,9 @@ def environments():
 
     # System Python (not inside Conda or Virtualenv)
     else:
-        packages = [{'name': pkg.key, 'version': pkg.version}
-                    for pkg in pkg_resources.working_set]
+        packages = [{'name': pkg.metadata['Name'],
+                     'version': pkg.version}
+                    for pkg in distributions()]
         environments_.append({
             'name': 'system-python',
             'version': sys.version.split()[0],

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/CHAP/edd/models.py

@@ -718,7 +718,8 @@ class MCAEnergyCalibrationConfig(MCACalibrationConfig):
         """
         if self.peak_energies is None:
             raise ValueError('peak_energies is required')
-        if not 0 <= self.max_peak_index < len(self.peak_energies):
+        if (self.max_peak_index is not None
+                and not 0 <= self.max_peak_index < len(self.peak_energies)):
             raise ValueError('max_peak_index out of bounds')
         return self
 

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/CHAP/edd/select_material_params_gui.py

@@ -145,7 +145,8 @@ class MaterialParamSelector:
 #                pos=['4a', '8c'])
 #                #pos=[(0,0,0), (1/4, 1/4, 1/4), (3/4, 3/4, 3/4)])
             self.material_name, sgnum=self.sgnum,
-            lattice_parameters_angstroms=self.lattice_parameters)
+            # lattice_parameters_angstroms = lattice_parameters FIX?
+            lattice_parameters_angstroms = self.lattice_parameters
             material.material_name = name
             material.sgnum = _material.sgnum
             material.lattice_parameters = [

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/CHAP/foxden/models.py

@@ -20,25 +20,23 @@ from CHAP import CHAPBaseModel
 class FoxdenRequestConfig(CHAPBaseModel):
     """FOXDEN HTTP request base configuration class.
 
-    :param url: URL of service.
-    :type url: str
     :param did: FOXDEN dataset identifier (did).
     :type did: string, optional
-    :param query: FOXDEN query.
-    :type query: string, optional
-    :param method: HTTP request method (not case sensitive),
-        defaults to `'POST'`.
-    :type method: Literal['DELETE', 'GET', 'POST', 'PUT'], optional
-#    :param scope: FOXDEN scope (not case sensitive).
-#    :type scope: Literal['read', 'write'], optional
-#    :param idx: Ask Valentin, currently it's ignored
-#    :type idx: int, optional
     :param limit: Maximum number of returned records,
         defaults to `10`.
     :type limit: int, optional
+    :param query: FOXDEN query.
+    :type query: string, optional
     :param verbose: Verbose output flag, defaults to `False`.
     :type verbose: bool, optional
     """
+#    :param method: HTTP request method (not case sensitive),
+#        defaults to `'POST'`.
+#    :type method: Literal['DELETE', 'GET', 'POST', 'PUT'], optional
+#    :param scope: FOXDEN scope (not case sensitive).
+#    :type scope: Literal['read', 'write'], optional
+#    :param idx: Ask Valentin, currently it's ignored
+#    :type idx: int, optional
     # Mimics golib.services.data.ServiceQuery
     did: Optional[constr(
         strict=True, strip_whitespace=True, to_lower=True)] = None

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/CHAP/giwaxs/processor.py

@@ -254,76 +254,83 @@ class GiwaxsConversionProcessor(Processor):
         data_curved, q_par, q_perp, q_par_rect, q_perp_rect,
         return_maps=False, normalize=True):
         """
-        data_rect = curved_to_rect(...):
-            distributes counts from a curvilinear grid (data_curved),
-            e.g. x-ray data collected in angular space, into a
-            rectilinear grid (reciprocal space). 
+        ::
+
+            data_rect = curved_to_rect(...):
+                distributes counts from a curvilinear grid
+                (data_curved), e.g. x-ray data collected in angular
+                space, into a rectilinear grid (reciprocal space). 
         
-        data_rect, norm, xmap, ymap, xwid, ywid =
-                curved_to_rect(..., return_maps=True):
-            distributes counts from a curvilinear grid (data_curved),
-            e.g. x-ray data collected in angular space, into a
-            rectilinear grid (reciprocal space). 
+            data_rect, norm, xmap, ymap, xwid, ywid =
+                    curved_to_rect(..., return_maps=True):
+                distributes counts from a curvilinear grid
+                (data_curved), e.g. x-ray data collected in angular
+                space, into a rectilinear grid (reciprocal space). 
  
-        q_par, q_perp, and data_curved are M x N following the normal
-            convention where the the first & second index corrspond to
-            the vertical (y) and horizontal (x) locations of the
-            scattering pattern.
-        q_par, q_perp represent the q coordinates of the center of
-            pixels whose intensities are stored in data_curved.
-            Reiterating the convention above, q_par and q_perp vary
-            primarilly along the 2nd and 1st index, respectively.
-        q_par_rect and q_perp_rect are evenly-spaced, monotonically
-            increasing, arrays determining the new grid.
+            q_par, q_perp, and data_curved are M x N following the
+                normal convention where the the first & second index
+                corrspond to the vertical (y) and horizontal (x)
+                locations of the scattering pattern.
+            q_par, q_perp represent the q coordinates of the center of
+                pixels whose intensities are stored in data_curved.
+                Reiterating the convention above, q_par and q_perp vary
+                primarilly along the 2nd and 1st index, respectively.
+            q_par_rect and q_perp_rect are evenly-spaced, monotonically
+                increasing, arrays determining the new grid.
            
-        data_rect : the new matrix with intensity from data_curved
-                    disctributed into a regular grid defined by
-                    q_par_rect, q_perp_rect.
-        norm : a matrix with the same shape of data_rect representing
-               the area of the pixel in the original angular units. 
-               It should be used to normalize the resulting array as
-               norm_z = data_rect / norm.
-
-        Algorithm:
-           Step 1 : Compute xmap, ymap, which containt the values of
-                    q_par and q_perp, but represented in pixel units of
-                    the target coordinates q_par_rect, q_perp_rect.
-                    In other words, xmap(i,j) = 3.4 means that
-                    q_par(i,j) lands 2/5 of the q_distance between
-                    q_par_rect(3) and q_par_rect(4). Intensity in
-                    qpar(i,j) should thus be distributed in a 2:3 ratio
-                    among neighboring mini-columns of pixels 3 and 4.
-           Step 2 : Use the procedure described by Barna et al
-                    (RSI v.70, p. 2927, 1999) to distribute intensity
-                    from each source pixel i,j into each of 9
-                    destination pixels around the xmap(i,j) and
-                    ymap(i,j). Keep track of how many source "pixels"
-                    are placed into each bin in the variable, "norm".
-                    Note also that if xmap(i,j)-floor(xmap(i,j)) > 0.5,
-                    the "center" pixel of the 9 destination pixels is
-                    floor(xmap+0.5).
-           (Outside this function): The normalized intensity in each
-               new pixel can be obtained asI = data_rect./norm, but
-               with the caveat that zero values of "norm" should be
-               changed to ones first, norm(data_rect == 0) = 1.0.
-
-        Example Usage: 
-            1. Compute the values of q_par and q_perp for each pixel in
-               the image z (according to scattering geometry).
-            2. Set or determing a good target grid, e.g.:        
-               min_qpar, max_qpar = q_par.mix(), q_par.max()
-               min_qperp, max_qperp = q_perp.mix(), q_perp.max()
-               q_par_rect, q_par_step = np.linspace(min_qpar ,
-                   max_qpar, image_dim[1], retstep=True)
-               q_perp_rect, q_perp_step = np.linspace(min_qperp,
-                   max_qperp, image_dim[0], retstep=True)
-           3. data_rect = curved_to_rect(data_curved, q_par, q_perp,
-                  q_par_rect, q_perp_rect)
-           4. plt.imshow(data_rect, extent = [
-                  q_par_rect[0], q_par_rect[-1],
-                  q_perp_rect[-1], q_perp_rect[0]])
-              xlabel(r'q$_\parallel$'' [\u212b$^{-1}$]')
-              ylabel(r'q$_\perp$'' [\u212b$^{-1}$]')
+            data_rect : the new matrix with intensity from data_curved
+                        disctributed into a regular grid defined by
+                        q_par_rect, q_perp_rect.
+            norm : a matrix with the same shape of data_rect
+                   representing the area of the pixel in the original
+                   angular units. It should be used to normalize the
+                   resulting array as norm_z = data_rect / norm.
+
+            Algorithm:
+               Step 1 : Compute xmap, ymap, which containt the values
+                        of q_par and q_perp, but represented in pixel
+                        units of the target coordinates q_par_rect,
+                        q_perp_rect.
+                        In other words, xmap(i,j) = 3.4 means that
+                        q_par(i,j) lands 2/5 of the q_distance between
+                        q_par_rect(3) and q_par_rect(4). Intensity in
+                        qpar(i,j) should thus be distributed in a 2:3
+                        ratio among neighboring mini-columns of pixels
+                        3 and 4.
+               Step 2 : Use the procedure described by Barna et al
+                        (RSI v.70, p. 2927, 1999) to distribute
+                        intensity from each source pixel i,j into each
+                        of 9 destination pixels around the xmap(i,j)
+                        and ymap(i,j). Keep track of how many source
+                        "pixels" are placed into each bin in the
+                        variable, "norm". Note also that if
+                        xmap(i,j)-floor(xmap(i,j)) > 0.5,
+                        the "center" pixel of the 9 destination pixels
+                        is floor(xmap+0.5).
+               (Outside this function): The normalized intensity in
+                   each new pixel can be obtained as
+                   I = data_rect./norm, but with the caveat that zero
+                   values of "norm" should be changed to ones first,
+                   norm(data_rect == 0) = 1.0.
+
+            Example Usage: 
+                1. Compute the values of q_par and q_perp for each
+                   pixel in the image z (according to scattering
+                   geometry).
+                2. Set or determing a good target grid, e.g.:        
+                   min_qpar, max_qpar = q_par.mix(), q_par.max()
+                   min_qperp, max_qperp = q_perp.mix(), q_perp.max()
+                   q_par_rect, q_par_step = np.linspace(min_qpar ,
+                       max_qpar, image_dim[1], retstep=True)
+                   q_perp_rect, q_perp_step = np.linspace(min_qperp,
+                       max_qperp, image_dim[0], retstep=True)
+               3. data_rect = curved_to_rect(data_curved, q_par,
+                      q_perp, q_par_rect, q_perp_rect)
+               4. plt.imshow(data_rect, extent = [
+                      q_par_rect[0], q_par_rect[-1],
+                      q_perp_rect[-1], q_perp_rect[0]])
+                  xlabel(r'q$_\parallel$'' [\u212b$^{-1}$]')
+                  ylabel(r'q$_\perp$'' [\u212b$^{-1}$]')
         """
         out_width, out_height = q_par_rect.size, q_perp_rect.size
 

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/CHAP/server.py

@@ -5,48 +5,53 @@ File       : server.py
 Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>
 Description: Python server with thread pool and CHAP pipeline
 
-### Client side:
+===========
+Client side
+===========
 cat /tmp/chap.json
 {"pipeline": [{"common.PrintProcessor": {}}], "input": 1}
 
-### curl call to the server with our CHAP pipeline
+==========================================
+Curl call to the server with CHAP pipeline
+==========================================
 curl -X POST -H "Content-type: application/json" -d@/tmp/chap.json http://localhost:5000/pipeline
 {"pipeline": [{"common.PrintProcessor":{}}], "status":"ok"}
 
-### Server side:
+===========
+Server side
+===========
 flask --app server run
- * Serving Flask app 'server'
- * Debug mode: off
+
+* Serving Flask app 'server'
+* Debug mode: off
+
 WARNING: This is a development server. Do not use it in a production
 deployment. Use a production WSGI server instead.
- * Running on http://127.0.0.1:5000
+
+* Running on http://127.0.0.1:5000
+
 Press CTRL+C to quit
-...
-
-CHAP.server         : Call pipeline args=()
-    kwds={'pipeline': [{'common.PrintProcessor': {}}]}
-CHAP.server         : pipeline [{'common.PrintProcessor': {}}]
-CHAP.server         : Loaded
-    <CHAP.common.processor.PrintProcessor object at 0x10e0f1ed0>
-CHAP.server         : Loaded
-    <CHAP.pipeline.Pipeline object at 0x10e0f1f10> with 1 items
-
-CHAP.server         : Calling "execute" on <CHAP.pipeline.Pipeline
-    object at 0x10e0f1f10>
-Pipeline            : Executing "execute"
-
-Pipeline            : Calling "process" on
-    <CHAP.common.processor.PrintProcessor object at 0x10e0f1ed0>
-PrintProcessor      : Executing "process" with
-    type(data)=<class 'NoneType'>
-PrintProcessor data :
-None
-PrintProcessor      : Finished "process" in 0.000 seconds
-
-Pipeline            : Executed "execute" in 0.000 seconds
-127.0.0.1 - - [07/Apr/2023 09:11:22] "POST /pipeline HTTP/1.1" 200 -
-"""
 
+CHAP output::
+
+    CHAP.server         : Call pipeline args=()
+        kwds={'pipeline': [{'common.PrintProcessor': {}}]}
+    CHAP.server         : pipeline [{'common.PrintProcessor': {}}]
+    CHAP.server         : Loaded
+        <CHAP.common.processor.PrintProcessor object at 0x10e0f1ed0>
+    CHAP.server         : Loaded
+        <CHAP.pipeline.Pipeline object at 0x10e0f1f10> with 1 items
+    CHAP.server         : Calling "execute" on <CHAP.pipeline.Pipeline
+        object at 0x10e0f1f10>
+    Pipeline            : Executing "execute"
+    Pipeline            : Calling "process" on
+        <CHAP.common.processor.PrintProcessor object at 0x10e0f1ed0>
+    PrintProcessor      : Executing "process" with
+        type(data)=<class 'NoneType'>
+    PrintProcessor data : None
+    PrintProcessor      : Finished "process" in 0.000 seconds
+    Pipeline            : Executed "execute" in 0.000 seconds
+"""
 # System modules
 import time
 from queue import Queue

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/CHAP/tomo/models.py

@@ -6,6 +6,7 @@ from typing import (
     Optional,
 )
 from pydantic import (
+    ConfigDict,
     conint,
     conlist,
     confloat,
@@ -40,7 +41,7 @@ class Detector(CHAPBaseModel):
     pixel_size: conlist(
         item_type=confloat(gt=0, allow_inf_nan=False),
         min_length=1, max_length=2)
-    lens_magnification: confloat(gt=0, allow_inf_nan=False) = 1.0
+    lens_magnification: Optional[confloat(gt=0, allow_inf_nan=False)] = 1.0
 
 
 class TomoReduceConfig(CHAPBaseModel):
@@ -208,3 +209,5 @@ class TomoSimConfig(CHAPBaseModel):
     beam_intensity: Optional[confloat(gt=0, allow_inf_nan=False)] = 1.e9
     background_intensity: Optional[confloat(gt=0, allow_inf_nan=False)] = 20
     slit_size: Optional[confloat(gt=0, allow_inf_nan=False)] = 1.0
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/CHAP/utils/models.py

@@ -91,19 +91,53 @@ def lorentzian(x, amplitude=1.0, center=0.0, sigma=1.0):
 def rectangle(
         x, amplitude=1.0, center1=0.0, sigma1=1.0, center2=1.0,
         sigma2=1.0, form='linear'):
-    """Return a rectangle function.
-
-    Starts at 0.0, rises to `amplitude` (at `center1` with width
-    `sigma1`), then drops to 0.0 (at `center2` with width `sigma2`)
-    with `form`:
-    - `'linear'` (default) = ramp_up + ramp_down
-    - `'atan'`, `'arctan`' = amplitude*(atan(arg1) + atan(arg2))/pi
-    - `'erf'`              = amplitude*(erf(arg1) + erf(arg2))/2.
-    - `'logisitic'`        = amplitude*[1 - 1/(1 + exp(arg1)) -
-                             1/(1+exp(arg2))]
-
-    where ``arg1 = (x - center1)/sigma1`` and
-    ``arg2 = -(x - center2)/sigma2``.
+    r"""
+    Return a rectangle function.
+
+    Starts at 0.0, rises to ``amplitude`` (at ``center1`` with width
+    ``sigma1``), then drops to 0.0 (at ``center2`` with width
+    ``sigma2``)
+
+    :param x: Input values where the function is evaluated.
+    :type x: float or numpy.ndarray
+    :param amplitude: Maximum height of the rectangle, defaults to 1.0.
+    :type amplitude: float, optional
+    :param center1: Location of the rising edge, defaults to 0.0.
+    :type center1: float, optional
+    :param sigma1: Width or smoothness of the rising edge,
+        defaults to 1.0.
+    :type sigma1: float, optional
+    :param center2: Location of the falling edge, defaults to 1.0.
+    :type center2: float, optional
+    :param sigma2: Width or smoothness of the falling edge,
+        defaults to 1.0.
+    :type sigma2: float, optional
+    :param form: Shape type of the transition edges:
+
+        - ``'linear'``: Simple ramp-up and ramp-down.
+        - ``'atan'`` or ``'arctan'``: Inverse tangent transitions.
+        - ``'erf'``: Error function (Gaussian-like) transitions.
+        - ``'logistic'``: Sigmoidal (logistic function) transitions.
+    :type form: str, optional
+
+    :returns: The evaluated rectangle function values.
+    :rtype: float or numpy.ndarray
+
+    .. note::
+        The output is calculated based on the selected ``form``:
+
+        - **atan**: $\frac{A}{\pi} [ \arctan(arg_1) + \arctan(arg_2) ]$
+        - **erf**:
+          $\frac{1}{2} A [ \text{erf}(arg_1) + \text{erf}(arg_2) ]$
+        - **logistic**:
+          $A [ \frac{1}{1 + \exp(-arg_1)} +
+          \frac{1}{1 + \exp(-arg_2)} - 1 ]$
+
+        The function is constructed using normalized arguments for the
+        rising and falling edges:
+        $arg_1 = \frac{x - center_1}{\sigma_1}$
+        and
+        $arg_2 = \frac{center_2 - x}{\sigma_2}$
     """
     arg1 = (x - center1)/max(tiny, sigma1)
     arg2 = (center2 - x)/max(tiny, sigma2)

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/ChessAnalysisPipeline.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ChessAnalysisPipeline
-Version: 0.0.17.dev6
+Version: 0.0.17.dev8
 Summary: CHESS analysis pipeline framework
 Home-page: https://github.com/CHESSComputing/ChessAnalysisPipeline
 Author: Keara Soloway, Rolf Verberg, Valentin Kuznetsov
@@ -11,9 +11,9 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy==1.26.4
-Requires-Dist: pydantic==2.7.3
-Requires-Dist: pyyaml==6.0.3
+Requires-Dist: numpy
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
 
 [![DOI](https://zenodo.org/badge/600053436.svg)](https://zenodo.org/badge/latestdoi/600053436)
 ![pylint](https://github.com/CHESSComputing/ChessAnalysisPipeline/actions/workflows/pylint-check.yml/badge.svg)

chessanalysispipeline-0.0.17.dev8/ChessAnalysisPipeline.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+pydantic
+pyyaml

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ChessAnalysisPipeline
-Version: 0.0.17.dev6
+Version: 0.0.17.dev8
 Summary: CHESS analysis pipeline framework
 Home-page: https://github.com/CHESSComputing/ChessAnalysisPipeline
 Author: Keara Soloway, Rolf Verberg, Valentin Kuznetsov
@@ -11,9 +11,9 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy==1.26.4
-Requires-Dist: pydantic==2.7.3
-Requires-Dist: pyyaml==6.0.3
+Requires-Dist: numpy
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
 
 [![DOI](https://zenodo.org/badge/600053436.svg)](https://zenodo.org/badge/latestdoi/600053436)
 ![pylint](https://github.com/CHESSComputing/ChessAnalysisPipeline/actions/workflows/pylint-check.yml/badge.svg)

{chessanalysispipeline-0.0.17.dev6 → chessanalysispipeline-0.0.17.dev8}/setup.py

@@ -12,8 +12,7 @@ import os
 import setuptools
 
 # [set version]
-version = 'v0.0.17.dev6'
-#version = 'v0.0.17'
+version = 'v0.0.17.dev8'
 # [version set]
 
 def datafiles(idir, pattern=None):
@@ -86,8 +85,8 @@ setuptools.setup(
     ],
     python_requires='>=3.10',
     install_requires=[
-        'numpy==1.26.4',
-        'pydantic==2.7.3',
-        'pyyaml==6.0.3',
+        'numpy',
+        'pydantic',
+        'pyyaml',
     ],
 )

chessanalysispipeline-0.0.17.dev6/ChessAnalysisPipeline.egg-info/requires.txt

@@ -1,3 +0,0 @@
-numpy==1.26.4
-pydantic==2.7.3
-pyyaml==6.0.3