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

reciprocalspaceship/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.4

reciprocalspaceship/__init__.py

@@ -1,8 +1,15 @@
 # Version number for reciprocalspaceship
 def getVersionNumber():
-    import pkg_resources
+    version = None
+    try:
+        from setuptools.version import metadata
+
+        version = metadata.version("reciprocalspaceship")
+    except ImportError:
+        from setuptools.version import pkg_resources
+
+        version = pkg_resources.require("reciprocalspaceship")[0].version
 
-    version = pkg_resources.require("reciprocalspaceship")[0].version
     return version
 
 

reciprocalspaceship/commandline/cifdump.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python
+"""
+Summarize the contents of a CIF file.
+
+Examples
+--------
+In order to summarize contents of file.cif::
+
+    > rs.cifdump file.cif
+
+If you would like to interactively inspect file.cif in an IPython
+shell, use the "--embed" argument::
+
+    > rs.cifdump file.cif --embed
+
+If multiple CIF files are listed, they will be summarized sequentially,
+and can be accessed in an IPython shell as a dictionary called `cifs`::
+
+    > rs.cifdump file1.cif file2.cif file3.cif --embed
+
+Usage Details
+-------------
+"""
+import argparse
+
+import pandas as pd
+
+import reciprocalspaceship as rs
+
+# If matplotlib is available, use pylab to setup IPython environment
+try:
+    from pylab import *
+except:
+    pass
+
+
+def parse_arguments():
+    """Parse commandline arguments"""
+
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawTextHelpFormatter, description=__doc__
+    )
+
+    # Required arguments
+    parser.add_argument("cif", nargs="+", help="CIF file(s) to summarize")
+
+    # Optional arguments
+    parser.add_argument(
+        "--embed",
+        action="store_true",
+        help=(
+            "CIF file(s) will be summarized, and an IPython " "shell will be started"
+        ),
+    )
+    parser.add_argument(
+        "-p",
+        "--precision",
+        type=int,
+        default=3,
+        help="Number of significant digits to output for floats",
+    )
+
+    return parser
+
+
+def summarize(cif, precision):
+    """Summarize contents of CIF file"""
+    with pd.option_context("display.precision", precision):
+        print(f"Spacegroup: {cif.spacegroup.short_name()}")
+        print(f"Extended Hermann-Mauguin name: {cif.spacegroup.xhm()}")
+        print(
+            (
+                f"Unit cell dimensions: {cif.cell.a:.3f} {cif.cell.b:.3f} {cif.cell.c:.3f} "
+                f"{cif.cell.alpha:.3f} {cif.cell.beta:.3f} {cif.cell.gamma:.3f}"
+            )
+        )
+        print(f"\ncif.head():\n\n{cif.head()}")
+        print(f"\ncif.describe():\n\n{cif.describe()}")
+        print(f"\ncif.dtypes:\n\n{cif.dtypes}")
+    return
+
+
+def main():
+    # Parse commandline arguments
+    parser = parse_arguments()
+    args = parser.parse_args()
+
+    if len(args.cif) == 1:
+        cif = rs.read_cif(args.cif[0])
+        summarize(cif, args.precision)
+    else:
+        cifs = dict(zip(args.cif, map(rs.read_cif, args.cif)))
+        for key, value in cifs.items():
+            print(f"CIF file: {key}\n")
+            summarize(value, args.precision)
+            print(f"{'-'*50}")
+
+    # Begin IPython shell
+    if args.embed:
+        from IPython import embed
+
+        bold = "\033[1m"
+        end = "\033[0m"
+        if "cifs" in locals():
+            header = f"rs.DataSets stored in {bold}cifs{end} dictionary"
+        else:
+            header = f"rs.DataSet stored as {bold}cif{end}"
+        print()
+        embed(colors="neutral", header=header)
+
+    return
+
+
+if __name__ == "__main__":
+    parser = main()

reciprocalspaceship/commandline/mtzdump.py

@@ -74,9 +74,13 @@ def summarize(mtz, precision):
                 f"{mtz.cell.alpha:.3f} {mtz.cell.beta:.3f} {mtz.cell.gamma:.3f}"
             )
         )
-        print(f"\nmtz.head():\n\n{mtz.head()}")
-        print(f"\nmtz.describe():\n\n{mtz.describe()}")
-        print(f"\nmtz.dtypes:\n\n{mtz.dtypes}")
+        if mtz.cell is not None:
+            dHKL = mtz.compute_dHKL().dHKL
+            print(f"Resolution range:  {dHKL.max():.3f} - {dHKL.min():.3f} Å")
+        with pd.option_context("display.max_rows", None):
+            print(f"\nmtz.head():\n\n{mtz.head()}")
+            print(f"\nmtz.describe().T:\n\n{mtz.describe().T}")
+            print(f"\nmtz.dtypes:\n\n{mtz.dtypes}")
     return
 
 

reciprocalspaceship/dataset.py

@@ -43,6 +43,23 @@ class DataSet(pd.DataFrame):
     and attributes, please see the `Pandas.DataFrame documentation`_.
 
     .. _Pandas.DataFrame documentation: https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html
+
+    Attributes
+    ----------
+    acentrics : rs.DataSet
+        Access only the acentric reflections in this dataset
+    cell : gemmi.UnitCell
+        The unit cell
+    centrics : rs.DataSet
+        Access only the centric reflections in this dataset
+    hkls : ndarray, shape=(n_reflections, 3)
+        Miller indices in DataSet.
+    merged : bool
+        Whether this is a merged dataset or unmerged
+    spacegroup : gemmi.SpaceGroup
+        The space group
+    reindexing_ops : list
+        Possible reindexing ops consistent with the cell and spacegroup
     """
 
     _metadata = ["_spacegroup", "_cell", "_index_dtypes", "_merged"]
@@ -131,6 +148,38 @@ class DataSet(pd.DataFrame):
     def merged(self, val):
         self._merged = val
 
+    @property
+    @range_indexed
+    def hkls(self):
+        """Miller indices"""
+        hkl = self[["H", "K", "L"]].to_numpy(dtype=np.int32)
+        return hkl
+
+    def get_hkls(self):
+        """Get the Miller indices of the dataset."""
+        return self.hkls
+
+    @hkls.setter
+    @range_indexed
+    def hkls(self, hkls):
+        if isinstance(hkls, DataSet):
+            """Convert to numpy if hkls is a dataset"""
+            hkls = hkls.hkls
+        if isinstance(hkls, np.ndarray):
+            h, k, l = hkls[..., 0], hkls[..., 1], hkls[..., 2]
+        else:
+            """Try coercing to numpy"""
+            try:
+                hkls = np.array(hkls)
+                h, k, l = hkls[..., 0], hkls[..., 1], hkls[..., 2]
+            except:
+                raise ValueError(
+                    "Unable to convert hkls to a suitable type. Please ensure hkls is a numpy array or rs.DataSet"
+                )
+        self["H"] = DataSeries(h, index=self.index, dtype="H")
+        self["K"] = DataSeries(k, index=self.index, dtype="H")
+        self["L"] = DataSeries(l, index=self.index, dtype="H")
+
     @property
     def centrics(self):
         """Access centric reflections in DataSet"""
@@ -258,7 +307,14 @@ class DataSet(pd.DataFrame):
         )
 
     def reset_index(
-        self, level=None, drop=False, inplace=False, col_level=0, col_fill=""
+        self,
+        level=None,
+        drop=False,
+        inplace=False,
+        col_level=0,
+        col_fill="",
+        allow_duplicates=lib.no_default,
+        names=None,
     ):
         """
         Reset the index or a specific level of a MultiIndex.
@@ -281,6 +337,12 @@ class DataSet(pd.DataFrame):
         col_fill : object
             If the columns have multiple levels, determines how the other
             levels are named. If None then the index name is repeated.
+        allow_duplicates : bool
+            Allow duplicate column labels to be created.
+        names : int, str, tuple, list
+            Using the given string, rename the DataSet column which contains the
+            index data. If the DataSet has a MultiIndex, this has to be a list or
+            tuple with length equal to the number of levels.
 
         Returns
         -------
@@ -317,6 +379,8 @@ class DataSet(pd.DataFrame):
                 inplace=inplace,
                 col_level=col_level,
                 col_fill=col_fill,
+                allow_duplicates=allow_duplicates,
+                names=names,
             )
             _handle_cached_dtypes(self, columns, drop)
             return
@@ -327,6 +391,8 @@ class DataSet(pd.DataFrame):
                 inplace=inplace,
                 col_level=col_level,
                 col_fill=col_fill,
+                allow_duplicates=allow_duplicates,
+                names=names,
             )
             dataset._index_dtypes = dataset._index_dtypes.copy()
             dataset = _handle_cached_dtypes(dataset, columns, drop)
@@ -406,6 +472,7 @@ class DataSet(pd.DataFrame):
         """
         return cls(gemmiMtz)
 
+    @range_indexed
     def to_gemmi(
         self,
         skip_problem_mtztypes=False,
@@ -575,6 +642,7 @@ class DataSet(pd.DataFrame):
         result = super().join(*args, **kwargs)
         return result.__finalize__(self)
 
+    @range_indexed
     def write_mtz(
         self,
         mtzfile,
@@ -1158,7 +1226,7 @@ class DataSet(pd.DataFrame):
 
         return result
 
-    def is_isomorphous(self, other, cell_threshold=0.05):
+    def is_isomorphous(self, other, cell_threshold=0.5):
         """
         Determine whether DataSet is isomorphous to another DataSet. This
         method confirms isomorphism by ensuring the spacegroups are equivalent,
@@ -1195,7 +1263,8 @@ class DataSet(pd.DataFrame):
         for param in params:
             param1 = self.cell.__getattribute__(param)
             param2 = other.cell.__getattribute__(param)
-            if (np.abs((param1 - param2)) / 100.0) > cell_threshold:
+            diff = 200.0 * np.abs(param1 - param2) / (param1 + param2)
+            if diff > cell_threshold:
                 return False
 
         return True
@@ -1565,24 +1634,6 @@ class DataSet(pd.DataFrame):
         warnings.simplefilter("always")
         warnings.warn(message, DeprecationWarning)
 
-        if dmin is not None:
-            ds = self.loc[self.compute_dHKL().dHKL >= dmin, [key]]
-        else:
-            ds = self.loc[:, [key]]
-
-        if gridsize is None:
-            gridsize = self.get_reciprocal_grid_size(dmin=dmin, sample_rate=sample_rate)
-
-        # Set up P1 unit cell
-        p1 = ds.expand_to_p1()
-        p1 = p1.expand_anomalous()
-
-        # Get data and indices
-        data = p1[key].to_numpy()
-        H = p1.get_hkls()
-
-        # Populate grid
-        grid = np.zeros(gridsize, dtype=data.dtype)
-        grid[H[:, 0], H[:, 1], H[:, 2]] = data
-
-        return grid
+        return self.to_reciprocal_grid(
+            key, sample_rate=sample_rate, dmin=dmin, grid_size=gridsize
+        )

reciprocalspaceship/decorators.py

@@ -4,6 +4,8 @@ from inspect import signature
 import gemmi
 import numpy as np
 
+import reciprocalspaceship as rs
+
 
 def inplace(f):
     """
@@ -46,9 +48,11 @@ def range_indexed(f):
         names = ds.index.names
         ds = ds._index_from_names([None], inplace=True)
         result = f(ds, *args, **kwargs)
-        result = result._index_from_names(names, inplace=True)
         ds = ds._index_from_names(names, inplace=True)
-        return result.__finalize__(ds)
+        if isinstance(result, rs.DataSet):
+            result = result._index_from_names(names, inplace=True)
+            result = result.__finalize__(ds)
+        return result
 
     return wrapped
 

reciprocalspaceship/dtypes/internals.py

@@ -1359,7 +1359,7 @@ class NumericArray(BaseMaskedArray):
 
 @wraps(libmissing.is_numeric_na)
 def is_numeric_na(values):
-    allowed_dtypes = ("float32", "int32")
+    allowed_dtypes = ("float64", "float32", "int32")
     if isinstance(values, np.ndarray) and values.dtype in allowed_dtypes:
         return np.isnan(values)
     return libmissing.is_numeric_na(values)

reciprocalspaceship/io/__init__.py

@@ -1,6 +1,7 @@
 from reciprocalspaceship.io.ccp4map import write_ccp4_map
 from reciprocalspaceship.io.crystfel import read_crystfel
 from reciprocalspaceship.io.csv import read_csv
+from reciprocalspaceship.io.dials import print_refl_info, read_dials_stills
 from reciprocalspaceship.io.mtz import (
     from_gemmi,
     read_cif,

reciprocalspaceship/io/common.py

@@ -0,0 +1,48 @@
+import logging
+import warnings
+from contextlib import contextmanager
+from importlib.util import find_spec
+
+
+def set_ray_loglevel(level):
+    logger = logging.getLogger("ray")
+    logger.setLevel(level)
+    for handler in logger.handlers:
+        handler.setLevel(level)
+
+
+def check_for_ray():
+    has_ray = True
+    if find_spec("ray") is None:
+        has_ray = False
+
+        message = (
+            "ray (https://www.ray.io/) is not available..." "Falling back to serial."
+        )
+        warnings.warn(message, ImportWarning)
+    return has_ray
+
+
+def check_for_mpi():
+    try:
+        from mpi4py import MPI
+
+        return True
+    except Exception as err:
+        message = (
+            f"Failed `from mpi4py import MPI` with {err}. Falling back to serial mode."
+        )
+        warnings.warn(message, ImportWarning)
+        return False
+
+
+@contextmanager
+def ray_context(log_level="DEBUG", **ray_kwargs):
+    import ray
+
+    set_ray_loglevel(log_level)
+    ray.init(**ray_kwargs)
+    try:
+        yield ray
+    finally:
+        ray.shutdown()

reciprocalspaceship/io/crystfel.py

@@ -1,13 +1,12 @@
 import mmap
 import re
-from contextlib import contextmanager
-from importlib.util import find_spec
 from typing import Union
 
 import gemmi
 import numpy as np
 
 from reciprocalspaceship import DataSet, concat
+from reciprocalspaceship.io.common import check_for_ray, ray_context
 from reciprocalspaceship.utils import angle_between, eV2Angstroms
 
 # See Rupp Table 5-2
@@ -60,17 +59,6 @@ _block_markers = {
 }
 
 
-@contextmanager
-def ray_context(**ray_kwargs):
-    import ray
-
-    ray.init(**ray_kwargs)
-    try:
-        yield ray
-    finally:
-        ray.shutdown()
-
-
 class StreamLoader(object):
     """
     An object that loads stream files into rs.DataSet objects in parallel.
@@ -304,15 +292,7 @@ class StreamLoader(object):
 
         # Check whether ray is available
         if use_ray:
-            if find_spec("ray") is None:
-                use_ray = False
-                import warnings
-
-                message = (
-                    "ray (https://www.ray.io/) is not available..."
-                    "Falling back to serial stream file parser."
-                )
-                warnings.warn(message, ImportWarning)
+            use_ray = check_for_ray()
 
         with open(self.filename, "r") as f:
             memfile = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
@@ -507,10 +487,9 @@ def read_crystfel(
         The type of byte-encoding (optional, 'utf-8').
     columns : list (optional)
         Optionally specify the columns of the output by a list of strings.
-        The default list is:
-            [ "H", "K", "L", "I", "SigI", "BATCH", "s1x", "s1y", "s1z", "ewald_offset",
-            "angular_ewald_offset", "XDET", "YDET" ]
-        See `rs.io.crystfel.StreamLoader().available_column_names` for a list of available column names.
+        The default list is: [ "H", "K", "L", "I", "SigI", "BATCH", "s1x", "s1y", "s1z", "ewald_offset", "angular_ewald_offset", "XDET", "YDET" ]
+        See `rs.io.crystfel.StreamLoader().available_column_names` for a list of available
+        column names and *Notes* for a description of the returned columns
     parallel : bool (optional)
         Read the stream file in parallel using [ray.io](https://docs.ray.io) if it is available.
     num_cpus : int (optional)
@@ -524,6 +503,18 @@ def read_crystfel(
     Returns
     --------
     rs.DataSet
+
+    Notes
+    -----
+    The following columns are included in the returned DataSet object:
+
+        - H, K, L: Miller indices of each reflection
+        - I, SigI: Intensity and associated uncertainty
+        - BATCH: Image number
+        - s1x, s1y, s1z: scattered beam wavevector which points from the sample to the bragg peak
+        - ewald_offset: the distance in cartesian space (1/angstroms) between the observed reflection and the ewald sphere
+        - angular_ewald_offset: the distance in polar coordinates (degrees) between the observed reflection and the ewald sphere
+        - XDET, YDET: Internal detector panel coordinates
     """
     if not streamfile.endswith(".stream"):
         raise ValueError("Stream file should end with .stream")

reciprocalspaceship/io/dials.py

@@ -0,0 +1,330 @@
+import logging
+import sys
+
+import msgpack
+import numpy as np
+import pandas
+
+LOGGER = logging.getLogger("rs.io.dials")
+if not LOGGER.handlers:
+    LOGGER.setLevel(logging.DEBUG)
+    console = logging.StreamHandler(stream=sys.stdout)
+    console.setLevel(logging.DEBUG)
+    LOGGER.addHandler(console)
+
+import reciprocalspaceship as rs
+from reciprocalspaceship.decorators import cellify, spacegroupify
+from reciprocalspaceship.io.common import check_for_ray, set_ray_loglevel
+
+MSGPACK_DTYPES = {
+    "double": np.float64,
+    "float": np.float32,
+    "int": np.int32,
+    "cctbx::miller::index<>": np.int32,
+    "vec3<double>": np.float64,
+    "std::size_t": np.intp,
+}
+
+DEFAULT_COLS = [
+    "miller_index",
+    "intensity.sum.value",
+    "intensity.sum.variance",
+    "xyzcal.px",
+    "s1",
+    "delpsical.rad",
+    "id",
+]
+
+
+def _set_logger(verbose):
+    level = logging.CRITICAL
+    if verbose:
+        level = logging.DEBUG
+
+    for log_name in ("rs.io.dials", "ray"):
+        logger = logging.getLogger(log_name)
+        logger.setLevel(level)
+        for handler in logger.handlers:
+            handler.setLevel(level)
+
+
+def get_msgpack_data(data, name):
+    """
+
+    Parameters
+    ----------
+    data: msgpack data dict
+    name: msgpack data key
+
+    Returns
+    -------
+    numpy array of values
+    """
+    dtype, (num, buff) = data[name]
+    if dtype in MSGPACK_DTYPES:
+        dtype = MSGPACK_DTYPES[dtype]
+    else:
+        dtype = None  # should we warn here ?
+    vals = np.frombuffer(buff, dtype).reshape((num, -1))
+    data_dict = {}
+    for i, col_data in enumerate(vals.T):
+        data_dict[f"{name}.{i}"] = col_data
+
+    # remove the .0 suffix if data is a scalar type
+    if len(data_dict) == 1:
+        data_dict[name] = data_dict.pop(f"{name}.0")
+
+    return data_dict
+
+
+def _concat(refl_data):
+    """combine output of _get_refl_data"""
+    LOGGER.debug("Combining and formatting tables!")
+    if isinstance(refl_data, rs.DataSet):
+        ds = refl_data
+    else:
+        refl_data = [ds for ds in refl_data if ds is not None]
+        ds = rs.concat(refl_data, check_isomorphous=False)
+    expt_ids = set(ds.BATCH)
+    LOGGER.debug(f"Found {len(ds)} refls from {len(expt_ids)} expts.")
+    LOGGER.debug("Mapping batch column.")
+    expt_id_map = {name: i for i, name in enumerate(expt_ids)}
+    ds.BATCH = [expt_id_map[eid] for eid in ds.BATCH]
+    rename_map = {"miller_index.0": "H", "miller_index.1": "K", "miller_index.2": "L"}
+    ds.rename(columns=rename_map, inplace=True)
+    LOGGER.debug("Finished combining tables!")
+    return ds
+
+
+def _get_refl_data(fname, unitcell, spacegroup, extra_cols=None):
+    """
+
+    Parameters
+    ----------
+    fname: integrated refl file
+    unitcell: gemmi.UnitCell instance
+    spacegroup: gemmi.SpaceGroup instance
+    extra_cols: list of additional columns to read
+
+    Returns
+    -------
+    RS dataset (pandas Dataframe)
+
+    """
+    LOGGER.debug(f"Loading {fname}")
+    pack = _get_refl_pack(fname)
+    refl_data = pack["data"]
+    expt_id_map = pack["identifiers"]
+
+    if "miller_index" not in refl_data:
+        raise IOError("refl table must have a miller_index column")
+
+    ds_data = {}
+    col_names = DEFAULT_COLS if extra_cols is None else DEFAULT_COLS + extra_cols
+    for col_name in col_names:
+        if col_name in refl_data:
+            col_data = get_msgpack_data(refl_data, col_name)
+            LOGGER.debug(f"... Read in data for {col_name}")
+            ds_data = {**col_data, **ds_data}
+
+    if "id" in ds_data:
+        ds_data["BATCH"] = np.array([expt_id_map[li] for li in ds_data.pop("id")])
+    ds = rs.DataSet(
+        ds_data,
+        cell=unitcell,
+        spacegroup=spacegroup,
+    )
+    ds["PARTIAL"] = True
+    return ds
+
+
+def _read_dials_stills_serial(fnames, unitcell, spacegroup, extra_cols=None, **kwargs):
+    """run read_dials_stills without trying to import ray"""
+    result = [
+        _get_refl_data(fname, unitcell, spacegroup, extra_cols) for fname in fnames
+    ]
+    return result
+
+
+def _read_dials_stills_ray(fnames, unitcell, spacegroup, numjobs=10, extra_cols=None):
+    """
+
+    Parameters
+    ----------
+    fnames: integration files
+    unitcell: gemmi.UnitCell instance
+    spacegroup: gemmi.SpaceGroup instance
+    numjobs: number of jobs
+    extra_cols: list of additional columns to read from refl tables
+
+    Returns
+    -------
+    RS dataset (pandas Dataframe)
+    """
+    from reciprocalspaceship.io.common import ray_context
+
+    with ray_context(
+        log_level=LOGGER.level,
+        num_cpus=numjobs,
+        log_to_driver=LOGGER.level == logging.DEBUG,
+    ) as ray:
+        # get the refl data
+        get_refl_data = ray.remote(_get_refl_data)
+        refl_data = ray.get(
+            [
+                get_refl_data.remote(fname, unitcell, spacegroup, extra_cols)
+                for fname in fnames
+            ]
+        )
+    return refl_data
+
+
+def dials_to_mtz_dtypes(ds, inplace=True):
+    """
+    Coerce the dtypes in ds into ones that can be written to an mtz file.
+    This will downcast doubles to single precision. If "variance" columns
+    are present, they will be converted to "sigma" and assigned
+    StandardDeviationDtype.
+
+    Parameters
+    ----------
+    ds : rs.DataSet
+    inplace : bool (optional)
+        Convert ds dtypes in place without makeing a copy. Defaults to True.
+
+    Returns
+    -------
+    ds : rs.DataSet
+    """
+    rename_map = {}
+    for name in ds:
+        if "variance" in name:
+            new_name = name.replace("variance", "sigma")
+            rename_map[name] = new_name
+            ds[name] = np.sqrt(ds[name]).astype("Q")
+            LOGGER.debug(
+                f"Converted column {name} to MTZ-Type Q, took sqrt of the values, and renamed to {new_name}."
+            )
+    ds.rename(columns=rename_map, inplace=True)
+    ds.infer_mtz_dtypes(inplace=True)
+    return ds
+
+
+@cellify
+@spacegroupify
+def read_dials_stills(
+    fnames,
+    unitcell=None,
+    spacegroup=None,
+    numjobs=10,
+    parallel_backend=None,
+    extra_cols=None,
+    verbose=False,
+    comm=None,
+    mtz_dtypes=False,
+):
+    """
+    Read reflections from still images processed by DIALS from fnames and return
+    them as a DataSet. By default, this function will not convert the data from
+    dials into an MTZ compatible format.
+
+    Parameters
+    ----------
+    fnames : list or tuple or string
+        A list or tuple of filenames (strings) or a single filename.
+    unitcell : gemmi.UnitCell or similar (optional)
+        The unit cell assigned to the returned dataset.
+    spacegroup : gemmi.SpaceGroup or similar (optional)
+        The spacegroup assigned to the returned dataset.
+    numjobs : int
+        If backend==ray, specify the number of jobs (ignored if backend==mpi).
+    parallel_backend : string (optional)
+        "ray", "mpi", or None for serial.
+    extra_cols : list (optional)
+        Optional list of additional column names to extract from the refltables. By default, this method will search for
+        miller_index, id, s1, xyzcal.px, intensity.sum.value, intensity.sum.variance, delpsical.rad
+    verbose : bool
+        Whether to print logging info to stdout
+    comm : mpi4py.MPI.Comm
+        Optionally override the communicator used by backend='mpi'
+    mtz_dtypes : bool (optional)
+        Optionally convert columns to mtz compatible dtypes. Note this will downcast double precision (64-bit)
+        floats to single precision (32-bit).
+
+    Returns
+    -------
+    ds : rs.DataSet
+        The dataset containing reflection info aggregated from fnames. This method will not convert any of the
+        columns to native rs MTZ dtypes. DIALS data are natively double precision (64-bit). Converting to MTZ
+        will downcast them to 32-bit. Use ds.infer_mtz_dtypes() to convert to native rs dtypes if required.
+    """
+    _set_logger(verbose)
+    if isinstance(fnames, str):
+        fnames = [fnames]
+
+    if parallel_backend not in ["ray", "mpi", None]:
+        raise NotImplementedError("parallel_backend should be ray, mpi, or none")
+
+    kwargs = {
+        "fnames": fnames,
+        "unitcell": unitcell,
+        "spacegroup": spacegroup,
+        "extra_cols": extra_cols,
+    }
+    reader = _read_dials_stills_serial
+    if parallel_backend == "ray":
+        kwargs["numjobs"] = numjobs
+        from reciprocalspaceship.io.common import check_for_ray
+
+        if check_for_ray():
+            reader = _read_dials_stills_ray
+    elif parallel_backend == "mpi":
+        from reciprocalspaceship.io.common import check_for_mpi
+
+        if check_for_mpi():
+            from reciprocalspaceship.io.dials_mpi import read_dials_stills_mpi as reader
+
+            kwargs["comm"] = comm
+    result = reader(**kwargs)
+    if result is not None:
+        result = _concat(result)
+    if mtz_dtypes:
+        dials_to_mtz_dtypes(result, inplace=True)
+    return result
+
+
+def _get_refl_pack(filename):
+    pack = msgpack.load(open(filename, "rb"), strict_map_key=False)
+    try:
+        assert len(pack) == 3
+        _, _, pack = pack
+    except (TypeError, AssertionError):
+        raise IOError("File does not appear to be dials::af::reflection_table")
+    return pack
+
+
+def print_refl_info(reflfile):
+    """print contents of `fname`, a reflection table file saved with DIALS"""
+    pack = _get_refl_pack(reflfile)
+    if "identifiers" in pack:
+        idents = pack["identifiers"]
+        print(f"\nFound {len(idents)} experiment identifiers in {reflfile}:")
+        for i, ident in idents.items():
+            print(f"\t{i}: {ident}")
+    if "data" in pack:
+        data = pack["data"]
+        columns = []
+        col_space = 0
+        for name in data:
+            dtype, (_, buff) = data[name]
+            columns.append((name, dtype))
+            col_space = max(len(dtype), len(name), col_space)
+        names, dtypes = zip(*columns)
+        df = pandas.DataFrame({"names": names, "dtypes": dtypes})
+        print(
+            "\nReflection contents:\n"
+            + df.to_string(index=False, col_space=col_space + 5, justify="center")
+        )
+
+    if "nrows" in pack:
+        print(f"\nNumber of reflections: {pack['nrows']} \n")

reciprocalspaceship/io/dials_mpi.py

@@ -0,0 +1,44 @@
+from itertools import chain
+
+from reciprocalspaceship.decorators import cellify, spacegroupify
+from reciprocalspaceship.io import dials
+
+
+def mpi_starmap(comm, func, iterable):
+    results = []
+    for i, item in enumerate(iterable):
+        if i % comm.size == comm.rank:
+            results.append(func(*item))
+    results = comm.gather(results)
+    if comm.rank == 0:
+        return chain.from_iterable(results)
+    return None
+
+
+@cellify
+@spacegroupify
+def read_dials_stills_mpi(fnames, unitcell, spacegroup, extra_cols=None, comm=None):
+    """
+
+    Parameters
+    ----------
+    fnames: integrated reflection tables
+    unitcell: unit cell tuple (6 params Ang,Ang,Ang,deg,deg,deg)
+    spacegroup: space group name e.g. P4
+    extra_cols: list of additional column names to read from the refl table
+    comm: Optionally override the MPI communicator. The default is MPI.COMM_WORLD
+
+    Returns
+    -------
+    RS dataset (pandas Dataframe) if MPI rank==0 else None
+    """
+    if comm is None:
+        from mpi4py import MPI
+
+        comm = MPI.COMM_WORLD
+    ds = mpi_starmap(
+        comm,
+        dials._get_refl_data,
+        ((f, unitcell, spacegroup, extra_cols) for f in fnames),
+    )
+    return ds

reciprocalspaceship/io/mtz.py

@@ -133,16 +133,15 @@ def to_gemmi(
     mtz.datasets[0].dataset_name = dataset_name
 
     # Construct data for Mtz object
-    temp = dataset.reset_index()
+    # GH#255: DataSet is provided using the range_indexed decorator
     columns = []
-    for c in temp.columns:
-        cseries = temp[c]
+    for c in dataset.columns:
+        cseries = dataset[c]
         if isinstance(cseries.dtype, MTZDtype):
             mtz.add_column(label=c, type=cseries.dtype.mtztype)
             columns.append(c)
         # Special case for CENTRIC and PARTIAL flags
         elif cseries.dtype.name == "bool" and c in ["CENTRIC", "PARTIAL"]:
-            temp[c] = temp[c].astype("MTZInt")
             mtz.add_column(label=c, type="I")
             columns.append(c)
         elif skip_problem_mtztypes:
@@ -152,7 +151,7 @@ def to_gemmi(
                 f"column {c} of type {cseries.dtype} cannot be written to an MTZ file. "
                 f"To skip columns without explicit MTZ dtypes, set skip_problem_mtztypes=True"
             )
-    mtz.set_data(temp[columns].to_numpy(dtype="float32"))
+    mtz.set_data(dataset[columns].to_numpy(dtype="float32"))
 
     # Handle Unmerged data
     if not dataset.merged and not all_in_asu:

reciprocalspaceship/io/precognition.py

@@ -31,7 +31,7 @@ def read_precognition(hklfile, spacegroup=None, cell=None, logfile=None):
         F = pd.read_csv(
             hklfile,
             header=None,
-            delim_whitespace=True,
+            sep="\\s+",
             names=["H", "K", "L", "F(+)", "SigF(+)", "F(-)", "SigF(-)"],
             usecols=usecols,
         )
@@ -49,7 +49,7 @@ def read_precognition(hklfile, spacegroup=None, cell=None, logfile=None):
         F = pd.read_csv(
             hklfile,
             header=None,
-            delim_whitespace=True,
+            sep="\\s+",
             names=[
                 "H",
                 "K",

reciprocalspaceship/utils/cell.py

@@ -29,7 +29,7 @@ def compute_dHKL(H, cell):
     if inverse.shape[-1] == 1:
         inverse = inverse.squeeze(-1)
 
-    F = np.array(cell.fractionalization_matrix.tolist()).astype(np.float64)
+    F = np.array(cell.frac.mat, dtype=np.float64)
     dhkls = np.reciprocal(np.linalg.norm((hkls @ F), 2, 1)).astype(np.float32)
     return dhkls[inverse]
 

reciprocalspaceship/utils/grid.py

@@ -50,6 +50,7 @@ def get_reciprocal_grid_size(cell, dmin, sample_rate=3.0, spacegroup=None):
 
     # Use gemmi.Mtz to find valid grid (FFT-friendly and obeys symmetry)
     m = gemmi.Mtz()
-    m.spacegroup = spacegroup
+    if spacegroup is not None:
+        m.spacegroup = spacegroup
 
     return m.get_size_for_hkl(min_size=min_size)

reciprocalspaceship/utils/structurefactors.py

@@ -131,4 +131,4 @@ def is_absent(H, spacegroup):
     absent : array
         Boolean array of length n. absent[i] == True if H[i] is systematically absent in sg.
     """
-    return spacegroup.operations().systematic_absences(H)
+    return spacegroup.operations().systematic_absences(np.array(H, dtype=np.int32))

{reciprocalspaceship-1.0.2.dist-info → reciprocalspaceship-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: reciprocalspaceship
-Version: 1.0.2
+Version: 1.0.4
 Summary: Tools for exploring reciprocal space
 Home-page: https://rs-station.github.io/reciprocalspaceship/
 Author: Kevin M. Dalton, Jack B. Greisman
@@ -19,18 +19,19 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Programming Language :: Python
 Requires-Python: >=3.9
 License-File: LICENSE
-Requires-Dist: gemmi<=0.6.6,>=0.5.5
-Requires-Dist: pandas<=2.2.2,>=2.2.2
+Requires-Dist: gemmi<=0.7.1,>=0.7.0
+Requires-Dist: pandas<=2.2.3,>=2.2.2
 Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: ipython
+Requires-Dist: msgpack
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-xdist; extra == "dev"
 Requires-Dist: ray; extra == "dev"
 Requires-Dist: sphinx; extra == "dev"
-Requires-Dist: sphinx-rtd-theme; extra == "dev"
+Requires-Dist: sphinx_rtd_theme; extra == "dev"
 Requires-Dist: nbsphinx; extra == "dev"
 Requires-Dist: sphinx-design; extra == "dev"
 Requires-Dist: sphinxcontrib-autoprogram; extra == "dev"
@@ -48,6 +49,18 @@ Requires-Dist: matplotlib; extra == "examples"
 Requires-Dist: seaborn; extra == "examples"
 Requires-Dist: celluloid; extra == "examples"
 Requires-Dist: scikit-image; extra == "examples"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 
 ``reciprocalspaceship`` provides a ``pandas``-style interface for

{reciprocalspaceship-1.0.2.dist-info → reciprocalspaceship-1.0.4.dist-info}/RECORD

@@ -1,58 +1,63 @@
-reciprocalspaceship/VERSION,sha256=n9KGQtOsoZHlx_wjg8_W-rsqrIdD8Cnau4mJrFhOMbw,6
-reciprocalspaceship/__init__.py,sha256=69LJFzMjF05nmlwROByI53LTwM37sgrgYAp5k1n6wCs,1842
+reciprocalspaceship/VERSION,sha256=0bd7iPS59nWpAOQUOsdoohIYYjz-FwPKQxYjiMMnG9Y,6
+reciprocalspaceship/__init__.py,sha256=m6pXLI-HuXwefCfSE2Rs_2McqzuHw5W6yMBXEbceke8,2034
 reciprocalspaceship/concat.py,sha256=v2eg8-RBiNLYHkkPDeaozh3HvGCaFbmlC15FaeNJMgY,1695
 reciprocalspaceship/dataseries.py,sha256=ibU1bHMd8zORFxRtDswtvLh_n-miAyBqO0ghLmY29Js,6188
-reciprocalspaceship/dataset.py,sha256=YUcpvaTifmlQeR4qewHkzo-RSz6DOq_xLalFRXa_O94,57008
-reciprocalspaceship/decorators.py,sha256=U2gfm29infWHVGzQnfnpRsjxOihDD6Iah7oHd4uD8jk,5612
+reciprocalspaceship/dataset.py,sha256=xLgTcmVuypcyTepu1gnLu3YpBz1KowzNQcCQwNpADDM,58889
+reciprocalspaceship/decorators.py,sha256=sZAPAV5fk5zUlwzub2VZy-u28XVNXjBpnqwnKjESWgY,5721
 reciprocalspaceship/algorithms/__init__.py,sha256=r5IYCGswTHXpSs9Q7c6PfEz8_P8d1fEei2SyTkp5aYY,258
 reciprocalspaceship/algorithms/intensity.py,sha256=iDHaqqrMAe0v-aTVT5jf54JwkNQLSQ7HhezPw6qZndg,2657
 reciprocalspaceship/algorithms/merge.py,sha256=iwPrDfjtliBwLqEzHbcIfoTkvS_0s2_CszS5IfrEUXI,2154
 reciprocalspaceship/algorithms/scale_merged_intensities.py,sha256=hNKKISCCDvchail1PZ_0r6sq1Rbgoraqaz1aDCayTYQ,11269
 reciprocalspaceship/commandline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reciprocalspaceship/commandline/mtzdump.py,sha256=JBg_W-CWQ6rbOOVmtK7TsErFXhCBR5pmC5RRSCapEZg,2939
+reciprocalspaceship/commandline/cifdump.py,sha256=X9dU2nTFX-5sPlb6miWo7feMc7BPrTnBJsrbS_fOxmo,2938
+reciprocalspaceship/commandline/mtzdump.py,sha256=ERSk2ORoOTtsdjml-QdxgozS6uzjMvAFWgKv163nVyM,3169
 reciprocalspaceship/dtypes/__init__.py,sha256=cO0M2F6pO_0jtqx-MlkbzqxLSmK1Ibmon5p_ksWmcbk,1038
 reciprocalspaceship/dtypes/base.py,sha256=1X56U4jKt_wjVkW930C9gP2Di0RpCMDZsDKNTxYle5I,1052
 reciprocalspaceship/dtypes/floating.py,sha256=jOQ25GZEE4QromaJA3_oeu0Tkjq1iT4dHCke_7W6TYo,19675
 reciprocalspaceship/dtypes/inference.py,sha256=jLgF8VfKtITGRzQbfeyZzEoJ1fQlbHXB_gXIJ9-AQxk,3029
 reciprocalspaceship/dtypes/integer.py,sha256=fPaLTWfMsJ-wuEPkm9oEJez3NDqzB4XKVHFRFEb585A,15816
-reciprocalspaceship/dtypes/internals.py,sha256=BkkqUDEvTTlebLXjcu7EiQV295-qR7GdMJXqrOKbbU0,47596
+reciprocalspaceship/dtypes/internals.py,sha256=YNv6Dz4miazjZVFJCOTFudH-0ejUbOcu_snCq1RU2Nw,47607
 reciprocalspaceship/dtypes/summarize.py,sha256=1w6-N3odFcI3ZEQP5qgrog6ucbGjO71vSgabmjklkbc,1114
-reciprocalspaceship/io/__init__.py,sha256=ZMQ_rGfLmfzijbErnjEFphJuZokPvZyyVRk65DC0gLA,400
+reciprocalspaceship/io/__init__.py,sha256=UquHOv850aJGdKnWEG-KTkHPgye7ldYFge62O5N6G_w,476
 reciprocalspaceship/io/ccp4map.py,sha256=yztiHPTdyR9FiCKRg-eVmL-_MyZTKThPI9uuHuuPF_0,1029
-reciprocalspaceship/io/crystfel.py,sha256=lKpGzM2OLNXBjy6njwahtk1IsI3MH0edaGSmaQ6NbGk,21662
+reciprocalspaceship/io/common.py,sha256=_XzdAFeE6B-Q_ORc4bkOR7ANwNT4dNqYtlejzYJfWxs,1055
+reciprocalspaceship/io/crystfel.py,sha256=N6CufOt3yESbOC4niFVPfBx2PSp9UpLlnmsuGXDdeIM,21877
 reciprocalspaceship/io/csv.py,sha256=A2ZnqAnFwFUQskF7_3EsQAPCcrJ5KEgjhZls6MDViv8,1194
-reciprocalspaceship/io/mtz.py,sha256=8XqFVoSJz47vjK-kEzwSu7NxwQnEyyHd0pgt1CaBavM,8074
+reciprocalspaceship/io/dials.py,sha256=FQQa3eT9TQw7h43ohyvNI3huViHE-eP9Y4IbRQL5dIc,10137
+reciprocalspaceship/io/dials_mpi.py,sha256=wvm-sQqFG7N7bgcnxd5jn94eyKveimA3rvP8ns1B5Jg,1212
+reciprocalspaceship/io/mtz.py,sha256=_gdlx7Vi6Z0HyFBZFP6Ptmla7Pd_mON2KaGL4Q3N7Ik,8071
 reciprocalspaceship/io/pickle.py,sha256=clnSTK8T2O_d7midS_E54WHmXEHrL10d386gWx7ztsM,818
-reciprocalspaceship/io/precognition.py,sha256=DWRE2erXPVpm9-y5DjIWUHfmv9jZcsqoa47ienp1Sao,3641
+reciprocalspaceship/io/precognition.py,sha256=xHBeKarVABmtm1DaYUOSs2UYsS3CFTDLCAd47jO03nI,3619
 reciprocalspaceship/stats/__init__.py,sha256=jdAWbpD_CKAn0W0sO_MKSnTu3bZSoLAXgb1_Y6jDMzk,197
 reciprocalspaceship/stats/completeness.py,sha256=1QM-Ac_V58nTLJoewbOK5CL69qsb0C0sc8L0c59WorQ,6702
 reciprocalspaceship/utils/__init__.py,sha256=bKJwbkxXa-TX2etIQgIESKkv9kdag1rHL77JLhI-2B8,1714
 reciprocalspaceship/utils/asu.py,sha256=WwxvIq-_QEF2UvyELuNudVo53daty9wiN-vaOYAUbKI,8680
 reciprocalspaceship/utils/binning.py,sha256=CHf5z8EsHSg34ZgC-yM_8Gd3D2BB8cqTtHAf7vwfgLo,2786
-reciprocalspaceship/utils/cell.py,sha256=aNIaugA3F8CRs9n8Ck0Rjc8YI7qHZcW3lJPE7yvj0dk,2053
-reciprocalspaceship/utils/grid.py,sha256=xB7sw1xrhgzFojrVHbC_uVBT3NMTBsvKsCqaRrVfvTQ,1893
+reciprocalspaceship/utils/cell.py,sha256=MCebTyHrPiiy1H0A6OX3KWTrssw2LJ7ziA-anrfZULU,2027
+reciprocalspaceship/utils/grid.py,sha256=MCpQ9wy0XN0U-Q7H3fwGmWlMzO1RiZtBYkIdDWxG7p4,1928
 reciprocalspaceship/utils/math.py,sha256=m6Iq9u0fjiieftzjQPAEHTN2htBIOwLhBCJdrcIN5Ao,1019
 reciprocalspaceship/utils/phases.py,sha256=zyiE99bq-TV_4aI6ZhBi4MLAvKwE3Sx1dFqppJL5rkE,2438
 reciprocalspaceship/utils/rfree.py,sha256=qFgepLOfgdU-cvZIMu8WfzlFExTc4jILff2ro7iu8FQ,3411
 reciprocalspaceship/utils/stats.py,sha256=p_1R3bTVVAVlDWh-hzcurlT8GOHkJA8ovFuQjD0w5AY,3681
-reciprocalspaceship/utils/structurefactors.py,sha256=ZW6CVPn_04dxay0DDnA0-byUrZnGraQ0kItqN1m5F3k,3686
+reciprocalspaceship/utils/structurefactors.py,sha256=ykcog4yTuVrANrEnQxB7La5QQFn-7D38xsK3on_qVa0,3712
 reciprocalspaceship/utils/symmetry.py,sha256=xsYmEUo0PTH57-kctJdUq_-k14ci5LUGeG5LwzmjjPU,2963
 reciprocalspaceship/utils/units.py,sha256=ng-2hzZBERYo9bnQDPr-HLr7xPah-JzOthfrpHH816Y,388
+reciprocalspaceship-1.0.4.dist-info/licenses/LICENSE,sha256=E22aZlYy5qJsJCJ94EkO_Vt3COio5UcLg59dZLPam7I,1093
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=bQZClqzu3lonsI01OdP5X38asMd7F76fAGzlWWYPXAI,3930
 tests/test_dataseries.py,sha256=go-q5tT8lLq3tlRVnmrwUytK7PlaoKs3CBPjWryGfGg,3309
-tests/test_dataset.py,sha256=dMFW6-pCs1rjIYEqbfstVqFRiYwKfz5rHlncVL9grQg,22231
+tests/test_dataset.py,sha256=VTyLNJggHtisRsYpegshbtFTYgOGES6QIAo2faVwnic,25011
 tests/test_dataset_anomalous.py,sha256=LQb1inSS_oDbVYEIyyx_GBFAkXGlEQYZ-ZhpwMeyMmQ,6963
 tests/test_dataset_binning.py,sha256=NgD_vy-TUh3vQrUVgysVBSZu75xN66LR6hRu2_qAUTs,3564
-tests/test_dataset_grid.py,sha256=S2EswVAbcg08WT9TjLtQ3YF1_zJmEKcucHrN3Lw5EM8,4086
+tests/test_dataset_grid.py,sha256=tVFEUl3YA8XhCJa8tMNXQelakIgm5kStp10VhwTPzkY,4070
 tests/test_dataset_index.py,sha256=-6sMVgAKkkcYRc7UfLuVEH3p7D83o1S7e7c6MbrOrZo,2842
 tests/test_dataset_preserve_attributes.py,sha256=gwQQJGsiBZld2KKmLrcMkuc9zesR3FD7GVnPDNRScto,5314
+tests/test_dataset_signatures.py,sha256=ZbH9JNzqAWJDfVh9gqZVQXx8glmmBUhsbPmQBHe8Cuo,1554
 tests/test_dataset_symops.py,sha256=PV86tLu1qDACuk-YqjYQszk8Ctb0-h_NsQRnuCDFnOU,10864
 tests/test_decorators.py,sha256=ExR7mCU0iIqhHo4ho6ywPrZIEaGcsElaI4jtH9o5afE,5331
 tests/test_summarize_mtz_dtypes.py,sha256=JE0ctXMWii1AV-cmKogF6hjb8NCHrgvxNZ0ZRCHh-Ho,696
-reciprocalspaceship-1.0.2.dist-info/LICENSE,sha256=E22aZlYy5qJsJCJ94EkO_Vt3COio5UcLg59dZLPam7I,1093
-reciprocalspaceship-1.0.2.dist-info/METADATA,sha256=36KZFStMfUhplc6K1h7vpF-FVJ-TrExqWI3XXdW5oTE,3056
-reciprocalspaceship-1.0.2.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-reciprocalspaceship-1.0.2.dist-info/entry_points.txt,sha256=Bqjl2J8UrG4UAHHhPbdH5r-xYaOdLCEdyRH6zJ9joDw,76
-reciprocalspaceship-1.0.2.dist-info/top_level.txt,sha256=tOo679MsLFS7iwiYZDwnKTuTpJLYVFBk6g9xnnB_s-w,26
-reciprocalspaceship-1.0.2.dist-info/RECORD,,
+reciprocalspaceship-1.0.4.dist-info/METADATA,sha256=KhsqyH2rHwyy83eL3383KyLkX0EeoAbuHB11kdjd8VU,3326
+reciprocalspaceship-1.0.4.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+reciprocalspaceship-1.0.4.dist-info/entry_points.txt,sha256=g-Bn5ZXMuODBSvJWj0PWIv4SVE-ibEplzFeiHH4kMDE,134
+reciprocalspaceship-1.0.4.dist-info/top_level.txt,sha256=tOo679MsLFS7iwiYZDwnKTuTpJLYVFBk6g9xnnB_s-w,26
+reciprocalspaceship-1.0.4.dist-info/RECORD,,

{reciprocalspaceship-1.0.2.dist-info → reciprocalspaceship-1.0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{reciprocalspaceship-1.0.2.dist-info → reciprocalspaceship-1.0.4.dist-info}/entry_points.txt

@@ -1,2 +1,3 @@
 [console_scripts]
+rs.cifdump = reciprocalspaceship.commandline.cifdump:main
 rs.mtzdump = reciprocalspaceship.commandline.mtzdump:main

tests/test_dataset.py

@@ -603,6 +603,48 @@ def test_is_isomorphous(data_unmerged, data_fmodel, sg1, sg2, cell1, cell2):
             assert not result
 
 
+@pytest.mark.parametrize("threshold", [5.0, 1.0, 0.5, 0.1])
+def test_is_isomorphous_threshold(threshold):
+    """
+    Test that DataSet.is_isorphous(self, other, cell_threshold) method's
+    cell_threshold operates on percent difference.
+    """
+    epsilon = 1e-12
+    cell = np.array([34.0, 45.0, 98.0, 90.0, 90.0, 90.0])
+    spacegroup = 19
+
+    ds = rs.DataSet(cell=cell, spacegroup=spacegroup)
+    cell_resize_factor = (200.0 + threshold) / (200.0 - threshold)
+
+    # Make a cell that should be exactly threshold percent bigger
+    other_cell = cell_resize_factor * cell
+    too_big_cell = other_cell + epsilon
+    big_cell = other_cell - epsilon
+
+    # Make a cell that should be exactly threshold percent smaller
+    other_cell = cell / cell_resize_factor
+    too_small_cell = other_cell - epsilon
+    small_cell = other_cell + epsilon
+
+    # Construct data sets
+    too_big = rs.DataSet(cell=too_big_cell, spacegroup=spacegroup)
+    big = rs.DataSet(cell=big_cell, spacegroup=spacegroup)
+    too_small = rs.DataSet(cell=too_small_cell, spacegroup=spacegroup)
+    small = rs.DataSet(cell=small_cell, spacegroup=spacegroup)
+
+    # Cell is barely too big to be isomorphous
+    assert not ds.is_isomorphous(too_big, threshold)
+
+    # Cell is barely too small to be isomorphous
+    assert not ds.is_isomorphous(too_small, threshold)
+
+    # Cell is almost too big to be isomorphous
+    assert ds.is_isomorphous(big, threshold)
+
+    # Cell is almost too small to be isomorphous
+    assert ds.is_isomorphous(small, threshold)
+
+
 def test_to_gemmi_withNans(data_merged):
     """
     GH144: Test whether DataSet.to_gemmi() works with NaN-containing data.
@@ -669,3 +711,50 @@ def test_select_mtzdtype_ValueError(data_merged, dtype):
     """
     with pytest.raises(ValueError):
         data_merged.select_mtzdtype(dtype)
+
+
+@pytest.mark.parametrize("merged", [True, False])
+@pytest.mark.parametrize("hkl_type", ["ds", "index", "numpy"])
+@pytest.mark.parametrize("range_index", [True, False])
+def test_hkls_property_setter(
+    data_merged, data_unmerged, merged, hkl_type, range_index
+):
+    """
+    Test the setter for the .hkls property of rs datasets
+    """
+    if merged:
+        input_ds = data_merged
+    else:
+        input_ds = data_unmerged
+
+    hkls = input_ds.copy().reset_index()[["H", "K", "L"]]
+
+    ds = input_ds.copy()
+    if range_index:
+        ds = ds.reset_index()
+
+    # Confirm we're starting with equivalent miller indices
+    expected = ds.hkls
+    value = hkls
+
+    # Shuffle the hkls
+    hkls = hkls.sample(frac=1.0)
+
+    # confirm shuffling
+    assert not np.array_equal(hkls, ds.hkls)
+
+    # confirm setter
+    if hkl_type == "ds":
+        ds.hkls = hkls
+    elif hkl_type == "index":
+        ds.hkls = hkls.set_index(["H", "K", "L"])
+    elif hkl_type == "numpy":
+        ds.hkls = hkls.to_numpy()
+    expected = ds.hkls
+    value = hkls.hkls
+    assert np.array_equal(value, expected)
+
+    # Test that all data remained the same
+    for k in input_ds:
+        if k not in ["H", "K", "L"]:
+            assert np.array_equal(ds[k], input_ds[k])

tests/test_dataset_grid.py

@@ -22,10 +22,10 @@ def test_to_reciprocal_grid_gemmi(mtz_by_spacegroup, sample_rate, p1, use_sf):
     grid_size = dataset.get_reciprocal_grid_size(sample_rate=sample_rate)
 
     if use_sf:
-        gemmigrid = gemmimtz.get_f_phi_on_grid("FMODEL", "PHIFMODEL", size=grid_size)
-        expected = np.array(gemmigrid, copy=False)
         dataset["sf"] = dataset.to_structurefactor("FMODEL", "PHIFMODEL")
         result = dataset.to_reciprocal_grid("sf", grid_size=grid_size)
+        gemmigrid = gemmimtz.get_f_phi_on_grid("FMODEL", "PHIFMODEL", size=grid_size)
+        expected = gemmigrid.array
 
         # Requires rtol due to truncations applied in gemmi
         assert np.allclose(result, expected, rtol=1e-4)

tests/test_dataset_signatures.py

@@ -0,0 +1,53 @@
+from inspect import signature
+
+import pandas as pd
+import pytest
+from pandas.testing import assert_frame_equal
+
+import reciprocalspaceship as rs
+
+
+def test_reset_index_dataseries():
+    """
+    Minimal example from GH#223
+    """
+    result = rs.DataSeries(range(10)).reset_index()
+    expected = pd.Series(range(10)).reset_index()
+    expected = rs.DataSet(expected)
+    assert_frame_equal(result, expected)
+
+
+def test_reset_index_signature(dataset_hkl):
+    """
+    Test call signature of rs.DataSet.reset_index() matches call signature of
+    pd.DataFrame.reset_index() using default parameters
+    """
+    df = pd.DataFrame(dataset_hkl)
+    sig = signature(pd.DataFrame.reset_index)
+    bsig = sig.bind(df)
+    bsig.apply_defaults()
+
+    expected = df.reset_index(*bsig.args[1:], **bsig.kwargs)
+    result = dataset_hkl.reset_index(*bsig.args[1:], **bsig.kwargs)
+    result = pd.DataFrame(result)
+
+    assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("names", ["H", "K", ["H", "K"]])
+def test_set_index_signature(dataset_hkl, names):
+    """
+    Test call signature of rs.DataSet.set_index() matches call signature of
+    pd.DataFrame.set_index() using default parameters
+    """
+    ds = dataset_hkl.reset_index()
+    df = pd.DataFrame(ds)
+    sig = signature(pd.DataFrame.set_index)
+    bsig = sig.bind(df, names)
+    bsig.apply_defaults()
+
+    expected = df.set_index(*bsig.args[1:], **bsig.kwargs)
+    result = ds.set_index(*bsig.args[1:], **bsig.kwargs)
+    result = pd.DataFrame(result)
+
+    assert_frame_equal(result, expected)