reciprocalspaceship 1.0.2__tar.gz → 1.0.3__tar.gz

{reciprocalspaceship-1.0.2/reciprocalspaceship.egg-info → reciprocalspaceship-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reciprocalspaceship
-Version: 1.0.2
+Version: 1.0.3
 Summary: Tools for exploring reciprocal space
 Home-page: https://rs-station.github.io/reciprocalspaceship/
 Author: Kevin M. Dalton, Jack B. Greisman

reciprocalspaceship-1.0.3/reciprocalspaceship/VERSION

@@ -0,0 +1 @@
+1.0.3

{reciprocalspaceship-1.0.2 → reciprocalspaceship-1.0.3}/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-1.0.2 → reciprocalspaceship-1.0.3}/reciprocalspaceship/dataset.py

@@ -258,7 +258,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 +288,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 +330,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 +342,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 +423,7 @@ class DataSet(pd.DataFrame):
         """
         return cls(gemmiMtz)
 
+    @range_indexed
     def to_gemmi(
         self,
         skip_problem_mtztypes=False,
@@ -575,6 +593,7 @@ class DataSet(pd.DataFrame):
         result = super().join(*args, **kwargs)
         return result.__finalize__(self)
 
+    @range_indexed
     def write_mtz(
         self,
         mtzfile,
@@ -1158,7 +1177,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 +1214,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

{reciprocalspaceship-1.0.2 → reciprocalspaceship-1.0.3}/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-1.0.2 → reciprocalspaceship-1.0.3}/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-1.0.2 → reciprocalspaceship-1.0.3}/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-1.0.3/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-1.0.2 → reciprocalspaceship-1.0.3}/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-1.0.3/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-1.0.3/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-1.0.2 → reciprocalspaceship-1.0.3}/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-1.0.2 → reciprocalspaceship-1.0.3/reciprocalspaceship.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: reciprocalspaceship
-Version: 1.0.2
+Version: 1.0.3
 Summary: Tools for exploring reciprocal space
 Home-page: https://rs-station.github.io/reciprocalspaceship/
 Author: Kevin M. Dalton, Jack B. Greisman

{reciprocalspaceship-1.0.2 → reciprocalspaceship-1.0.3}/reciprocalspaceship.egg-info/SOURCES.txt

@@ -30,8 +30,11 @@ reciprocalspaceship/dtypes/internals.py
 reciprocalspaceship/dtypes/summarize.py
 reciprocalspaceship/io/__init__.py
 reciprocalspaceship/io/ccp4map.py
+reciprocalspaceship/io/common.py
 reciprocalspaceship/io/crystfel.py
 reciprocalspaceship/io/csv.py
+reciprocalspaceship/io/dials.py
+reciprocalspaceship/io/dials_mpi.py
 reciprocalspaceship/io/mtz.py
 reciprocalspaceship/io/pickle.py
 reciprocalspaceship/io/precognition.py
@@ -58,6 +61,7 @@ tests/test_dataset_binning.py
 tests/test_dataset_grid.py
 tests/test_dataset_index.py
 tests/test_dataset_preserve_attributes.py
+tests/test_dataset_signatures.py
 tests/test_dataset_symops.py
 tests/test_decorators.py
 tests/test_summarize_mtz_dtypes.py

{reciprocalspaceship-1.0.2 → reciprocalspaceship-1.0.3}/reciprocalspaceship.egg-info/requires.txt

@@ -1,8 +1,9 @@
-gemmi<=0.6.6,>=0.5.5
-pandas<=2.2.2,>=2.2.2
+gemmi<=0.6.7,>=0.5.5
+pandas<=2.2.3,>=2.2.2
 numpy
 scipy
 ipython
+msgpack
 
 [dev]
 pytest

{reciprocalspaceship-1.0.2 → reciprocalspaceship-1.0.3}/setup.py

@@ -74,11 +74,12 @@ setup(
     project_urls=PROJECT_URLS,
     python_requires=">=3.9",
     install_requires=[
-        "gemmi>=0.5.5, <=0.6.6",
-        "pandas>=2.2.2, <=2.2.2",
+        "gemmi>=0.5.5, <=0.6.7",
+        "pandas>=2.2.2, <=2.2.3",
         "numpy",
         "scipy",
         "ipython",
+        "msgpack",
     ],
     setup_requires=["pytest-runner"],
     tests_require=tests_require,

{reciprocalspaceship-1.0.2 → reciprocalspaceship-1.0.3}/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.

reciprocalspaceship-1.0.3/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)

reciprocalspaceship-1.0.2/reciprocalspaceship/VERSION

@@ -1 +0,0 @@
-1.0.2