reciprocalspaceship 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

reciprocalspaceship/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.2

reciprocalspaceship/__init__.py

@@ -37,6 +37,7 @@ from reciprocalspaceship.dtypes import StructureFactorAmplitudeDtype  # F
 from reciprocalspaceship.dtypes import WeightDtype  # W
 from reciprocalspaceship.dtypes import summarize_mtz_dtypes
 from reciprocalspaceship.io import (
+    read_cif,
     read_crystfel,
     read_csv,
     read_mtz,

reciprocalspaceship/algorithms/scale_merged_intensities.py

@@ -185,6 +185,7 @@ def scale_merged_intensities(
     mean_intensity_method="isotropic",
     bins=100,
     bw=2.0,
+    minimum_sigma=-np.inf,
 ):
     """
     Scales merged intensities using Bayesian statistics in order to
@@ -240,6 +241,9 @@ def scale_merged_intensities(
         parameter controls the distance that each reflection impacts in
         reciprocal space. Only affects output if mean_intensity_method is
         \"anisotropic\".
+    minimum_sigma : float
+        Minimum value imposed on Sigma (default: -np.inf, that is: no minimum).
+
 
     Returns
     -------
@@ -281,14 +285,11 @@ def scale_merged_intensities(
     I, Sig = ds[intensity_key].to_numpy(), ds[sigma_key].to_numpy()
     if mean_intensity_method == "isotropic":
         dHKL = ds["dHKL"].to_numpy(dtype=np.float64)
-        Sigma = (
-            mean_intensity_by_resolution(I / multiplicity, dHKL, bins) * multiplicity
-        )
+        Sigma = mean_intensity_by_resolution(I / multiplicity, dHKL, bins)
     elif mean_intensity_method == "anisotropic":
-        Sigma = (
-            mean_intensity_by_miller_index(I / multiplicity, ds.get_hkls(), bw)
-            * multiplicity
-        )
+        Sigma = mean_intensity_by_miller_index(I / multiplicity, ds.get_hkls(), bw)
+    Sigma = np.clip(Sigma, a_min=minimum_sigma, a_max=np.inf)
+    Sigma = Sigma * multiplicity
 
     # Initialize outputs
     ds[outputI] = 0.0

reciprocalspaceship/commandline/mtzdump.py

@@ -81,7 +81,6 @@ def summarize(mtz, precision):
 
 
 def main():
-
     # Parse commandline arguments
     parser = parse_arguments()
     args = parser.parse_args()

reciprocalspaceship/dataset.py

@@ -12,7 +12,8 @@ from reciprocalspaceship.decorators import (
     range_indexed,
     spacegroupify,
 )
-from reciprocalspaceship.dtypes.base import MTZDtype, MTZInt32Dtype
+from reciprocalspaceship.dtypes.base import MTZDtype
+from reciprocalspaceship.dtypes.integer import MTZInt32Dtype
 from reciprocalspaceship.utils import (
     apply_to_hkl,
     assign_with_binedges,
@@ -1233,6 +1234,11 @@ class DataSet(pd.DataFrame):
         # Compute new HKLs and phase shifts
         hkls = dataset.get_hkls()
         compressed_hkls, inverse = np.unique(hkls, axis=0, return_inverse=True)
+
+        # The behavior of np.unique changed with v2.0. This block maintains v1 compatibility
+        if inverse.shape[-1] == 1:
+            inverse = inverse.squeeze(-1)
+
         asu_hkls, isym, phi_coeff, phi_shift = hkl_to_asu(
             compressed_hkls, dataset.spacegroup, return_phase_shifts=True
         )

reciprocalspaceship/decorators.py

@@ -100,7 +100,7 @@ def spacegroupify(func=None, *sg_args):
             for arg in sg_args:
                 if arg in bargs.arguments:
                     bargs.arguments[arg] = _convert_spacegroup(bargs.arguments[arg])
-            return f(**bargs.arguments)
+            return f(*bargs.args, **bargs.kwargs)
 
         return wrapped
 
@@ -155,7 +155,7 @@ def cellify(func=None, *cell_args):
             for arg in cell_args:
                 if arg in bargs.arguments:
                     bargs.arguments[arg] = _convert_unitcell(bargs.arguments[arg])
-            return f(**bargs.arguments)
+            return f(*bargs.args, **bargs.kwargs)
 
         return wrapped
 

reciprocalspaceship/dtypes/__init__.py

@@ -1,22 +1,24 @@
-from reciprocalspaceship.dtypes.anomalousdifference import AnomalousDifferenceDtype
-from reciprocalspaceship.dtypes.batch import BatchDtype
-from reciprocalspaceship.dtypes.hklindex import HKLIndexDtype
-from reciprocalspaceship.dtypes.intensity import FriedelIntensityDtype, IntensityDtype
-from reciprocalspaceship.dtypes.m_isym import M_IsymDtype
-from reciprocalspaceship.dtypes.mtzint import MTZIntDtype
-from reciprocalspaceship.dtypes.mtzreal import MTZRealDtype
-from reciprocalspaceship.dtypes.phase import HendricksonLattmanDtype, PhaseDtype
-from reciprocalspaceship.dtypes.stddev import (
+from reciprocalspaceship.dtypes.floating import (
+    AnomalousDifferenceDtype,
+    FriedelIntensityDtype,
+    FriedelStructureFactorAmplitudeDtype,
+    HendricksonLattmanDtype,
+    IntensityDtype,
+    MTZRealDtype,
+    NormalizedStructureFactorAmplitudeDtype,
+    PhaseDtype,
     StandardDeviationDtype,
     StandardDeviationFriedelIDtype,
     StandardDeviationFriedelSFDtype,
-)
-from reciprocalspaceship.dtypes.structurefactor import (
-    FriedelStructureFactorAmplitudeDtype,
-    NormalizedStructureFactorAmplitudeDtype,
     StructureFactorAmplitudeDtype,
+    WeightDtype,
+)
+from reciprocalspaceship.dtypes.integer import (
+    BatchDtype,
+    HKLIndexDtype,
+    M_IsymDtype,
+    MTZIntDtype,
 )
-from reciprocalspaceship.dtypes.weight import WeightDtype
 
 # ExtensionDtypes are appended to the end of the Dtype registry.
 # Since we want to overwrite a few of the one-letter strings, we need

reciprocalspaceship/dtypes/base.py

@@ -1,282 +1,37 @@
-import numpy as np
-import pandas as pd
-from pandas.api.extensions import ExtensionDtype
-from pandas.core.arrays.floating import FloatingArray
-from pandas.core.arrays.floating import coerce_to_array as coerce_to_float_array
-from pandas.core.arrays.integer import IntegerArray
-from pandas.core.arrays.integer import coerce_to_array as coerce_to_int_array
-from pandas.core.dtypes.common import (
-    is_float,
-    is_float_dtype,
-    is_integer_dtype,
-    is_numeric_dtype,
-)
-from pandas.util._decorators import cache_readonly
+from reciprocalspaceship.dtypes.internals import NumericArray, NumericDtype
 
 
-class MTZDtype(ExtensionDtype):
+class MTZDtype(NumericDtype):
     """Base ExtensionDtype for implementing persistent MTZ data types"""
 
-    def is_friedel_dtype(self):
-        """Returns whether MTZ dtype represents a Friedel dtype"""
-        raise NotImplementedError
-
-    @classmethod
-    def construct_from_string(cls, string):
-        if not isinstance(string, str):
-            raise TypeError(
-                f"'construct_from_string' expects a string, got {type(string)}"
-            )
-        elif string != cls.name and string != cls.mtztype:
-            raise TypeError(f"Cannot construct a '{cls.__name__}' from '{string}'")
-        return cls()
-
-
-class MTZInt32Dtype(MTZDtype, pd.Int32Dtype):
-    """Base ExtensionDtype class for MTZDtype backed by pd.Int32Dtype"""
-
-    def _get_common_dtype(self, dtypes):
-        if len(set(dtypes)) == 1:
-            # only itself
-            return self
-        else:
-            return super(pd.Int32Dtype, self)._get_common_dtype(dtypes)
-
-    def __repr__(self):
-        return self.name
-
-
-class MTZIntegerArray(IntegerArray):
-    """Base ExtensionArray class for integer arrays backed by pd.IntegerArray"""
-
-    def _maybe_mask_result(self, result, mask, other, op_name: str):
-        """
-        Parameters
-        ----------
-        result : array-like
-        mask : array-like bool
-        other : scalar or array-like
-        op_name : str
-        """
-        if is_integer_dtype(result):
-            return type(self)(result, mask, copy=False)
-        return super()._maybe_mask_result(
-            result=result, mask=mask, other=other, op_name=op_name
-        )
+    def __repr__(self) -> str:
+        return f"{self.name}"
 
-    @cache_readonly
-    def dtype(self):
-        return self._dtype
+    @property
+    def _is_numeric(self) -> bool:
+        return True
 
     @classmethod
-    def _from_sequence(cls, scalars, dtype=None, copy=False):
-        values, mask = coerce_to_int_array(scalars, dtype=dtype, copy=copy)
-        return cls(values, mask)
-
-    @classmethod
-    def _from_factorized(cls, values, original):
-        values, mask = coerce_to_int_array(values, dtype=original.dtype)
-        return cls(values, mask)
-
-    def reshape(self, *args, **kwargs):
-        return self._data.reshape(*args, **kwargs)
-
-    def to_numpy(self, dtype=None, copy=False, **kwargs):
+    def construct_array_type(cls):
         """
-        Convert to a NumPy Array.
-
-        If `dtype` is None and array does not contain any NaNs, this method
-        will return a np.int32 array.  Otherwise it will return a ndarray of
-        object dtype.
-
-        Parameters
-        ----------
-        dtype : dtype, default np.int32 or np.float32
-            The numpy dtype to return
-        copy : bool, default False
-            Whether to ensure that the returned value is a not a view on
-            the array. Note that ``copy=False`` does not *ensure* that
-            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
-            a copy is made, even if not strictly necessary. This is typically
-            only possible when no missing values are present and `dtype`
-            is the equivalent numpy dtype.
+        Return the array type associated with this dtype.
 
         Returns
         -------
-        numpy.ndarray
+        type
         """
-        if dtype is None and not self._hasna:
-            dtype = np.int32
-
-        # na_value is hard-coded to np.nan -- this prevents other functions
-        # from resetting it.
-        return super().to_numpy(dtype=dtype, copy=copy, na_value=np.nan)
-
-    def value_counts(self, dropna=True):
-        """
-        Returns a DataSeries containing counts of each category.
-        Every category will have an entry, even those with a count of 0.
-
-        Parameters
-        ----------
-        dropna : bool, default True
-            Don't include counts of NaN.
-
-        Returns
-        -------
-        counts : DataSeries
-        """
-        from pandas import Index
-
-        import reciprocalspaceship as rs
-
-        # compute counts on the data with no nans
-        data = self._data[~self._mask]
-        value_counts = Index(data).value_counts()
-        array = value_counts.values
-
-        # TODO(extension)
-        # if we have allow Index to hold an ExtensionArray
-        # this is easier
-        index = value_counts.index.astype(object)
-
-        # if we want nans, count the mask
-        if not dropna:
-
-            # TODO(extension)
-            # appending to an Index *always* infers
-            # w/o passing the dtype
-            array = np.append(array, [self._mask.sum()])
-            index = Index(
-                np.concatenate(
-                    [index.values, np.array([self.dtype.na_value], dtype=object)]
-                ),
-                dtype=object,
-            )
-
-        return rs.DataSeries(array, index=index)
-
-
-class MTZFloat32Dtype(MTZDtype, pd.Float32Dtype):
-    """Base ExtensionDtype class for MTZDtype backed by pd.Float32Dtype"""
-
-    def _get_common_dtype(self, dtypes):
-        if len(set(dtypes)) == 1:
-            # only itself
-            return self
-        else:
-            return super(pd.Float32Dtype, self)._get_common_dtype(dtypes)
-
-    def __repr__(self):
-        return self.name
-
-
-class MTZFloatArray(FloatingArray):
-    """Base ExtensionArray class for floating point arrays backed by pd.FloatingArray"""
-
-    def _maybe_mask_result(self, result, mask, other, op_name: str):
-        """
-        Parameters
-        ----------
-        result : array-like
-        mask : array-like bool
-        other : scalar or array-like
-        op_name : str
-        """
-        # if we have a float operand we are by-definition
-        # a float result
-        # or our op is a divide
-        if (
-            (is_float_dtype(other) or is_float(other))
-            or (op_name in ["rtruediv", "truediv"])
-            or (is_float_dtype(self.dtype) and is_numeric_dtype(result.dtype))
-        ):
-            return type(self)(result, mask, copy=False)
-        return super()._maybe_mask_result(
-            result=result, mask=mask, other=other, op_name=op_name
-        )
-
-    @cache_readonly
-    def dtype(self):
-        return self._dtype
+        return NotImplementedError
 
     @classmethod
-    def _from_sequence(cls, scalars, dtype=None, copy=False):
-        values, mask = coerce_to_float_array(scalars, dtype=dtype, copy=copy)
-        return cls(values, mask)
-
-    def _coerce_to_array(self, value):
-        return coerce_to_float_array(value, dtype=self.dtype)
-
-    def to_numpy(self, dtype=None, copy=False, **kwargs):
-        """
-        Convert to a NumPy Array.
-
-        If `dtype` is None it will default to a float32 ndarray.
-
-        Parameters
-        ----------
-        dtype : dtype, default np.float32
-            The numpy dtype to return
-        copy : bool, default False
-            Whether to ensure that the returned value is a not a view on
-            the array. Note that ``copy=False`` does not *ensure* that
-            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
-            a copy is made, even if not strictly necessary. This is typically
-            only possible when no missing values are present and `dtype`
-            is the equivalent numpy dtype.
-
-        Returns
-        -------
-        numpy.ndarray
-        """
-        if dtype is None:
-            dtype = np.float32
-
-        # na_value is hard-coded to np.nan -- this prevents other functions
-        # from resetting it.
-        return super().to_numpy(dtype=dtype, copy=copy, na_value=np.nan)
-
-    def value_counts(self, dropna=True):
-        """
-        Returns a DataSeries containing counts of each category.
-        Every category will have an entry, even those with a count of 0.
-
-        Parameters
-        ----------
-        dropna : bool, default True
-            Don't include counts of NaN.
-
-        Returns
-        -------
-        counts : DataSeries
-        """
-        from pandas import Index
-
-        import reciprocalspaceship as rs
-
-        # compute counts on the data with no nans
-        data = self._data[~self._mask]
-        value_counts = Index(data).value_counts()
-        array = value_counts.values
-
-        # TODO(extension)
-        # if we have allow Index to hold an ExtensionArray
-        # this is easier
-        index = value_counts.index.astype(object)
-
-        # if we want nans, count the mask
-        if not dropna:
-
-            # TODO(extension)
-            # appending to an Index *always* infers
-            # w/o passing the dtype
-            array = np.append(array, [self._mask.sum()])
-            index = Index(
-                np.concatenate(
-                    [index.values, np.array([self.dtype.na_value], dtype=object)]
-                ),
-                dtype=object,
+    def construct_from_string(cls, string):
+        if not isinstance(string, str):
+            raise TypeError(
+                f"'construct_from_string' expects a string, got {type(string)}"
             )
+        elif string != cls.name and string != cls.mtztype:
+            raise TypeError(f"Cannot construct a '{cls.__name__}' from '{string}'")
+        return cls()
 
-        return rs.DataSeries(array, index=index)
+    def is_friedel_dtype(self):
+        """Returns whether MTZ dtype represents a Friedel dtype"""
+        raise NotImplementedError