diffpy.structure 3.2.1rc1__tar.gz → 3.2.2rc0__tar.gz

{diffpy_structure-3.2.1rc1 → diffpy_structure-3.2.2rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diffpy.structure
-Version: 3.2.1rc1
+Version: 3.2.2rc0
 Summary: Crystal structure container and parsers for structure formats.
 Author-email: "Simon J.L. Billinge group" <simon.billinge@gmail.com>
 Maintainer-email: "Simon J.L. Billinge group" <simon.billinge@gmail.com>
@@ -27,7 +27,7 @@ License-File: LICENSE.rst
 License-File: LICENSE_DANSE.rst
 License-File: LICENSE_pymmlib.rst
 License-File: AUTHORS.rst
-Requires-Dist: numpy<2.0.0
+Requires-Dist: numpy
 Requires-Dist: pycifrw
 
 |Icon| |title|_

{diffpy_structure-3.2.1rc1 → diffpy_structure-3.2.2rc0}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools>=62.0", "setuptools-git-versioning<2"]
+requires = ["setuptools>=62.0", "setuptools-git-versioning>=2.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
@@ -45,7 +45,7 @@ dirty_template = "{tag}"
 [tool.setuptools.packages.find]
 where = ["src"]  # list of folders that contain the packages (["."] by default)
 include = ["*"]  # package names should match these glob patterns (["*"] by default)
-exclude = ["diffpy.structure.tests*"]  # exclude packages matching these glob patterns (empty by default)
+exclude = []  # exclude packages matching these glob patterns (empty by default)
 namespaces = false  # to disable scanning PEP 420 namespaces (true by default)
 
 [tool.setuptools.dynamic]

diffpy_structure-3.2.2rc0/requirements/run.txt

@@ -0,0 +1,2 @@
+numpy
+pycifrw

{diffpy_structure-3.2.1rc1 → diffpy_structure-3.2.2rc0}/src/diffpy/structure/atom.py

@@ -536,7 +536,7 @@ class _AtomCartesianCoordinates(numpy.ndarray):
         self._atom.xyz[:] = self._atom.lattice.fractional(self)
         return
 
-    def __array_wrap__(self, out_arr, context=None):
+    def __array_wrap__(self, out_arr, context=None, return_scalar=None):
         """Ensure math operations on this type yield standard numpy array."""
         return out_arr.view(numpy.ndarray)
 

{diffpy_structure-3.2.1rc1 → diffpy_structure-3.2.2rc0}/src/diffpy/structure/structure.py

@@ -711,8 +711,9 @@ class Structure(list):
     element = _linkAtomAttribute(
         "element",
         """Character array of `Atom` types. Assignment updates
-        the element attribute of the respective `Atoms`.""",
-        toarray=numpy.char.array,
+        the element attribute of the respective `Atoms`.
+        Set the maximum length of the element string to 5 characters.""",
+        toarray=lambda items: numpy.char.array(items, itemsize=5),
     )
 
     xyz = _linkAtomAttribute(
@@ -742,8 +743,9 @@ class Structure(list):
     label = _linkAtomAttribute(
         "label",
         """Character array of `Atom` names. Assignment updates
-        the label attribute of all `Atoms`.""",
-        toarray=numpy.char.array,
+        the label attribute of all `Atoms`.
+        Set the maximum length of the label string to 5 characters.""",
+        toarray=lambda items: numpy.char.array(items, itemsize=5),
     )
 
     occupancy = _linkAtomAttribute(

{diffpy_structure-3.2.1rc1 → diffpy_structure-3.2.2rc0}/src/diffpy.structure.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: diffpy.structure
-Version: 3.2.1rc1
+Version: 3.2.2rc0
 Summary: Crystal structure container and parsers for structure formats.
 Author-email: "Simon J.L. Billinge group" <simon.billinge@gmail.com>
 Maintainer-email: "Simon J.L. Billinge group" <simon.billinge@gmail.com>
@@ -27,7 +27,7 @@ License-File: LICENSE.rst
 License-File: LICENSE_DANSE.rst
 License-File: LICENSE_pymmlib.rst
 License-File: AUTHORS.rst
-Requires-Dist: numpy<2.0.0
+Requires-Dist: numpy
 Requires-Dist: pycifrw
 
 |Icon| |title|_

{diffpy_structure-3.2.1rc1 → diffpy_structure-3.2.2rc0}/src/diffpy.structure.egg-info/SOURCES.txt

@@ -44,4 +44,17 @@ src/diffpy/structure/parsers/p_rawxyz.py
 src/diffpy/structure/parsers/p_xcfg.py
 src/diffpy/structure/parsers/p_xyz.py
 src/diffpy/structure/parsers/parser_index_mod.py
-src/diffpy/structure/parsers/structureparser.py
+src/diffpy/structure/parsers/structureparser.py
+tests/test_atom.py
+tests/test_lattice.py
+tests/test_loadstructure.py
+tests/test_oldimports.py
+tests/test_p_cif.py
+tests/test_p_discus.py
+tests/test_p_pdffit.py
+tests/test_parsers.py
+tests/test_spacegroups.py
+tests/test_structure.py
+tests/test_supercell.py
+tests/test_symmetryutilities.py
+tests/test_version.py

diffpy_structure-3.2.2rc0/src/diffpy.structure.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+pycifrw

diffpy_structure-3.2.2rc0/tests/test_atom.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.structure  Complex Modeling Initiative
+#                   (c) 2016 Brookhaven Science Associates,
+#                   Brookhaven National Laboratory.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE.txt for license information.
+#
+##############################################################################
+
+"""
+Unit tests for the Atom class.
+"""
+
+
+import unittest
+
+import numpy
+
+from diffpy.structure.atom import Atom
+from diffpy.structure.lattice import Lattice
+
+# ----------------------------------------------------------------------------
+
+
+class TestAtom(unittest.TestCase):
+
+    def test___init__(self):
+        """check Atom.__init__()"""
+        a = Atom()
+        self.assertEqual("", a.element)
+        self.assertTrue((a.xyz == 0).all())
+        self.assertEqual("", a.label)
+        self.assertEqual(1.0, a.occupancy)
+        self.assertFalse(a.anisotropy)
+        self.assertTrue((a.U == 0).all())
+        self.assertTrue(a.lattice is None)
+        # check initialization with arguments
+        a1 = Atom("C", xyz=(1, 2, 3), Uisoequiv=0.005)
+        self.assertEqual("C", a1.element)
+        self.assertTrue(numpy.array_equal([1, 2, 3], a1.xyz))
+        self.assertFalse(a1.anisotropy)
+        self.assertEqual(0.005, a1.Uisoequiv)
+        # initialize with anisotropic displacement parameters
+        uani = numpy.identity(3, dtype=float) * numpy.array([1, 2, 3]) * 0.01
+        a2 = Atom("C", U=uani)
+        self.assertTrue(numpy.array_equal(uani, a2.U))
+        self.assertTrue(a2.anisotropy)
+        a3 = Atom("C", Uisoequiv=0.02, anisotropy=True)
+        self.assertTrue(a3.anisotropy)
+        self.assertEqual(a3.U[2, 2], 0.02)
+        self.assertRaises(ValueError, Atom, "C", Uisoequiv=0.02, U=uani)
+        return
+
+    #   def test_msdLat(self):
+    #       """check Atom.msdLat()
+    #       """
+    #       return
+    #
+    #   def test_msdCart(self):
+    #       """check Atom.msdCart()
+    #       """
+    #       return
+    #
+    #   def test___repr__(self):
+    #       """check Atom.__repr__()
+    #       """
+    #       return
+    #
+    #   def test___copy__(self):
+    #       """check Atom.__copy__()
+    #       """
+    #       return
+
+    def test_xyz_cartn(self):
+        """check Atom.xyz_cartn property"""
+        hexagonal = Lattice(1, 1, 1, 90, 90, 120)
+        a0 = Atom("C", [0, 0, 0], lattice=hexagonal)
+        a1 = Atom("C", [1, 1, 1], lattice=hexagonal)
+        self.assertTrue(all(a0.xyz_cartn == 0))
+        rc1 = numpy.array([0.75**0.5, 0.5, 1])
+        self.assertTrue(numpy.allclose(rc1, a1.xyz_cartn))
+        a1.xyz_cartn[2] = 0
+        self.assertTrue(numpy.allclose([1, 1, 0], a1.xyz))
+        a1.xyz_cartn[:2] = 0
+        self.assertTrue(all(a1.xyz == 0))
+        a3 = Atom("C", [1, 2, 3])
+        self.assertTrue(numpy.array_equal(a3.xyz, a3.xyz_cartn))
+        a3.xyz_cartn = 1.3
+        self.assertTrue(all(1.3 == a3.xyz_cartn))
+        self.assertTrue(all(1.3 == a3.xyz))
+        return
+
+
+#   def test__get_anisotropy(self):
+#       """check Atom._get_anisotropy()
+#       """
+#       return
+#
+#   def test__set_anisotropy(self):
+#       """check Atom._set_anisotropy()
+#       """
+#       return
+#
+#   def test__get_U(self):
+#       """check Atom._get_U()
+#       """
+#       return
+#
+#   def test__set_U(self):
+#       """check Atom._set_U()
+#       """
+#       return
+#
+#   def test__get_Uij(self):
+#       """check Atom._get_Uij()
+#       """
+#       return
+#
+#   def test__set_Uij(self):
+#       """check Atom._set_Uij()
+#       """
+#       return
+#
+#   def test__get_Uisoequiv(self):
+#       """check Atom._get_Uisoequiv()
+#       """
+#       return
+#
+#   def test__set_Uisoequiv(self):
+#       """check Atom._set_Uisoequiv()
+#       """
+#       return
+#
+#   def test__get_Bisoequiv(self):
+#       """check Atom._get_Bisoequiv()
+#       """
+#       return
+#
+#   def test__set_Bisoequiv(self):
+#       """check Atom._set_Bisoequiv()
+#       """
+#       return
+
+# End of class TestAtom
+
+# ----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    unittest.main()

diffpy_structure-3.2.2rc0/tests/test_lattice.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.structure  by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2006 trustees of the Michigan State University.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+
+"""Unit tests for Lattice class.
+"""
+
+import unittest
+
+import numpy
+import numpy.linalg as numalg
+
+from diffpy.structure import Lattice, LatticeError
+
+# ----------------------------------------------------------------------------
+
+
+class TestLattice(unittest.TestCase):
+    """test methods of Lattice class"""
+
+    def setUp(self):
+        self.lattice = Lattice()
+        self.places = 12
+        return
+
+    def test___init__(self):
+        """Check Lattice.__init__ processing of arguments."""
+        self.assertRaises(ValueError, Lattice, self.lattice, c=4)
+        self.assertRaises(ValueError, Lattice, base=self.lattice.base, baserot=self.lattice.baserot)
+        self.assertRaises(ValueError, Lattice, 1, 2, 3)
+        self.assertRaises(ValueError, Lattice, 1, 2, 3, 80, 90)
+        L0 = self.lattice
+        L0.setLatBase(L0.cartesian([[1, 1, 0], [0, 1, 1], [1, 0, 1]]))
+        L1 = Lattice(L0)
+        self.assertTrue(numpy.array_equal(L0.base, L1.base))
+        L2 = Lattice(base=L0.base)
+        self.assertTrue(numpy.array_equal(L0.base, L2.base))
+        self.assertTrue(numpy.array_equal(L0.isotropicunit, L2.isotropicunit))
+        L3 = Lattice(*L0.abcABG(), baserot=L0.baserot)
+        self.assertTrue(numpy.allclose(L0.base, L3.base))
+        self.assertTrue(numpy.allclose(L0.isotropicunit, L3.isotropicunit))
+        return
+
+    def test_setLatPar(self):
+        """check calculation of standard unit cell vectors"""
+        from math import cos, radians, sqrt
+
+        from numpy import dot
+
+        def norm(x):
+            return sqrt(sum([xi**2 for xi in x]))
+
+        def cosd(x):
+            return cos(radians(x))
+
+        self.lattice.setLatPar(1.0, 2.0, 3.0, 80, 100, 120)
+        base = self.lattice.base
+        self.assertAlmostEqual(1.0, norm(base[0]), self.places)
+        self.assertAlmostEqual(2.0, norm(base[1]), self.places)
+        self.assertAlmostEqual(3.0, norm(base[2]), self.places)
+        self.assertAlmostEqual(cosd(80.0), dot(base[1], base[2]) / (2 * 3), self.places)
+        self.assertAlmostEqual(cosd(100.0), dot(base[0], base[2]) / (1 * 3), self.places)
+        self.assertAlmostEqual(cosd(120.0), dot(base[0], base[1]) / (1 * 2), self.places)
+        return
+
+    def test_latpar_properties(self):
+        """check assignment to a, b, c, alpha, beta, gamma."""
+        lat = self.lattice
+        lat.a = 2
+        lat.b = 4
+        lat.c = 6
+        lat.alpha = 80
+        lat.beta = 100
+        lat.gamma = 120
+        lat1 = Lattice(2, 4, 6, 80, 100, 120)
+        self.assertAlmostEqual(-0.5, lat.cg, self.places)
+        self.assertTrue(numpy.array_equal(lat1.base, lat.base))
+        return
+
+    def test_readonly_properties(self):
+        """Check that read-only properties are indeed such."""
+        lat = self.lattice
+        lat.b = 2
+        lat.c = 6
+        self.assertEqual(1.0, lat.unitvolume)
+        self.assertRaises(AttributeError, setattr, lat, "unitvolume", 3.33)
+        self.assertEqual(12, lat.volume)
+        self.assertRaises(AttributeError, setattr, lat, "volume", 3.33)
+        self.assertEqual(0.0, lat.ca)
+        self.assertRaises(AttributeError, setattr, lat, "ca", 3.33)
+        self.assertEqual(0.0, lat.cb)
+        self.assertRaises(AttributeError, setattr, lat, "cb", 3.33)
+        self.assertEqual(0.0, lat.cg)
+        self.assertRaises(AttributeError, setattr, lat, "cg", 3.33)
+        self.assertEqual(1.0, lat.sa)
+        self.assertRaises(AttributeError, setattr, lat, "sa", 3.33)
+        self.assertEqual(1.0, lat.sb)
+        self.assertRaises(AttributeError, setattr, lat, "sb", 3.33)
+        self.assertEqual(1.0, lat.sg)
+        self.assertRaises(AttributeError, setattr, lat, "sg", 3.33)
+        self.assertEqual(1.0, lat.ar)
+        self.assertRaises(AttributeError, setattr, lat, "ar", 3.33)
+        self.assertEqual(0.5, lat.br)
+        self.assertRaises(AttributeError, setattr, lat, "br", 3.33)
+        self.assertAlmostEqual(1.0 / 6, lat.cr, self.places)
+        self.assertRaises(AttributeError, setattr, lat, "cr", 3.33)
+        self.assertEqual(90.0, lat.alphar)
+        self.assertRaises(AttributeError, setattr, lat, "alphar", 3.33)
+        self.assertEqual(90.0, lat.betar)
+        self.assertRaises(AttributeError, setattr, lat, "betar", 3.33)
+        self.assertEqual(90.0, lat.gammar)
+        self.assertRaises(AttributeError, setattr, lat, "gammar", 3.33)
+        self.assertEqual(0.0, lat.car)
+        self.assertRaises(AttributeError, setattr, lat, "car", 3.33)
+        self.assertEqual(0.0, lat.cbr)
+        self.assertRaises(AttributeError, setattr, lat, "cbr", 3.33)
+        self.assertEqual(0.0, lat.cgr)
+        self.assertRaises(AttributeError, setattr, lat, "cgr", 3.33)
+        self.assertEqual(1.0, lat.sar)
+        self.assertRaises(AttributeError, setattr, lat, "sar", 3.33)
+        self.assertEqual(1.0, lat.sbr)
+        self.assertRaises(AttributeError, setattr, lat, "sbr", 3.33)
+        self.assertEqual(1.0, lat.sgr)
+        self.assertRaises(AttributeError, setattr, lat, "sgr", 3.33)
+        return
+
+    def test_setLatBase(self):
+        """check calculation of unit cell rotation"""
+        base = numpy.array([[1.0, 1.0, 0.0], [0.0, 1.0, 1.0], [1.0, 0.0, 1.0]])
+        self.lattice.setLatBase(base)
+        self.assertAlmostEqual(self.lattice.a, numpy.sqrt(2.0), self.places)
+        self.assertAlmostEqual(self.lattice.b, numpy.sqrt(2.0), self.places)
+        self.assertAlmostEqual(self.lattice.c, numpy.sqrt(2.0), self.places)
+        self.assertAlmostEqual(self.lattice.alpha, 60.0, self.places)
+        self.assertAlmostEqual(self.lattice.beta, 60.0, self.places)
+        self.assertAlmostEqual(self.lattice.gamma, 60.0, self.places)
+        detR0 = numalg.det(self.lattice.baserot)
+        self.assertAlmostEqual(detR0, 1.0, self.places)
+        # try if rotation matrix works
+        self.assertEqual(numpy.all(base == self.lattice.base), True)
+        self.lattice.setLatPar(alpha=44, beta=66, gamma=88)
+        self.assertNotEqual(numpy.all(base == self.lattice.base), True)
+        self.lattice.setLatPar(alpha=60, beta=60, gamma=60)
+        self.assertTrue(numpy.allclose(base[0], self.lattice.base[0]))
+        self.assertTrue(numpy.allclose(base[1], self.lattice.base[1]))
+        self.assertTrue(numpy.allclose(base[2], self.lattice.base[2]))
+        # try base checking
+        self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [1, 0, 0], [0, 0, 1]])
+        self.assertRaises(LatticeError, self.lattice.setLatBase, [[1, 0, 0], [0, 0, 1], [0, 1, 0]])
+        return
+
+    def test_reciprocal(self):
+        """check calculation of reciprocal lattice."""
+        r1 = self.lattice.reciprocal()
+        self.assertEqual((1, 1, 1, 90, 90, 90), r1.abcABG())
+        L2 = Lattice(2, 4, 8, 90, 90, 90)
+        r2 = L2.reciprocal()
+        self.assertEqual((0.5, 0.25, 0.125, 90, 90, 90), r2.abcABG())
+        rr2 = r2.reciprocal()
+        self.assertTrue(numpy.array_equal(L2.base, rr2.base))
+        return
+
+    def test_dot(self):
+        """check dot product of lattice vectors."""
+        L = self.lattice
+        L.setLatPar(gamma=120)
+        self.assertAlmostEqual(-0.5, L.dot([1, 0, 0], [0, 1, 0]), self.places)
+        va5 = numpy.tile([1.0, 0.0, 0.0], (5, 1))
+        vb5 = numpy.tile([0.0, 1.0, 0.0], (5, 1))
+        self.assertTrue(numpy.array_equal(5 * [-0.5], L.dot(va5, vb5)))
+        self.assertTrue(numpy.array_equal(5 * [-0.5], L.dot(va5[0], vb5)))
+        self.assertTrue(numpy.array_equal(5 * [-0.5], L.dot(va5, vb5[0])))
+        return
+
+    def test_norm(self):
+        """check norm of a lattice vector."""
+        self.assertEqual(1, self.lattice.norm([1, 0, 0]))
+        u = numpy.array([[3, 4, 0], [1, 1, 1]])
+        self.assertTrue(numpy.allclose([5, 3**0.5], self.lattice.norm(u)))
+        self.lattice.setLatPar(gamma=120)
+        self.assertAlmostEqual(1, self.lattice.norm([1, 1, 0]), self.places)
+        return
+
+    def test_rnorm(self):
+        """check norm of a reciprocal vector."""
+        L = self.lattice
+        L.setLatPar(1, 1.5, 2.3, 80, 95, 115)
+        r = L.reciprocal()
+        hkl = [0.5, 0.3, 0.2]
+        self.assertAlmostEqual(r.norm(hkl), L.rnorm(hkl), self.places)
+        hkl5 = numpy.tile(hkl, (5, 1))
+        self.assertTrue(numpy.allclose(5 * [r.norm(hkl)], L.rnorm(hkl5)))
+        return
+
+    def test_dist(self):
+        """check dist function for distance between lattice points."""
+        L = self.lattice
+        L.setLatPar(1, 1.5, 2.3, 80, 95, 115)
+        u = [0.1, 0.3, 0.7]
+        v = [0.3, 0.7, 0.7]
+        d0 = numalg.norm(L.cartesian(numpy.array(u) - v))
+        self.assertAlmostEqual(d0, L.dist(u, v), self.places)
+        self.assertAlmostEqual(d0, L.dist(v, u), self.places)
+        u5 = numpy.tile(u, (5, 1))
+        v5 = numpy.tile(v, (5, 1))
+        self.assertTrue(numpy.allclose(5 * [d0], L.dist(u, v5)))
+        self.assertTrue(numpy.allclose(5 * [d0], L.dist(u5, v)))
+        self.assertTrue(numpy.allclose(5 * [d0], L.dist(v5, u5)))
+        return
+
+    def test_angle(self):
+        """check angle calculation between lattice vectors."""
+        from math import acos, degrees
+
+        L = self.lattice
+        L.setLatPar(1, 1.5, 2.3, 80, 95, 115)
+        u = [0.1, 0.3, 0.7]
+        v = [0.3, 0.7, 0.7]
+        uc = L.cartesian(u)
+        vc = L.cartesian(v)
+        a0 = degrees(acos(numpy.dot(uc, vc) / (numalg.norm(uc) * numalg.norm(vc))))
+        self.assertAlmostEqual(a0, L.angle(u, v), self.places)
+        self.assertAlmostEqual(a0, L.angle(v, u), self.places)
+        u5 = numpy.tile(u, (5, 1))
+        v5 = numpy.tile(v, (5, 1))
+        self.assertTrue(numpy.allclose(5 * [a0], L.angle(u, v5)))
+        self.assertTrue(numpy.allclose(5 * [a0], L.angle(u5, v)))
+        self.assertTrue(numpy.allclose(5 * [a0], L.angle(v5, u5)))
+        return
+
+    def test_repr(self):
+        """check string representation of this lattice"""
+        r = repr(self.lattice)
+        self.assertEqual(r, "Lattice()")
+        self.lattice.setLatPar(1, 2, 3, 10, 20, 30)
+        r = repr(self.lattice)
+        r0 = "Lattice(a=1, b=2, c=3, alpha=10, beta=20, gamma=30)"
+        self.assertEqual(r, r0)
+        base = [[1.0, 1.0, 0.0], [0.0, 2.0, 2.0], [3.0, 0.0, 3.0]]
+        self.lattice.setLatBase(base)
+        r = repr(self.lattice)
+        self.assertEqual(r, "Lattice(base=%r)" % self.lattice.base)
+
+
+# End of class TestLattice
+
+# ----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    unittest.main()

diffpy_structure-3.2.2rc0/tests/test_loadstructure.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+
+"""Unit tests for the loadStructure factory.
+"""
+
+import unittest
+
+import pytest
+
+from diffpy.structure import PDFFitStructure, Structure, loadStructure
+from diffpy.structure.structureerrors import StructureFormatError
+
+
+##############################################################################
+class TestLoadStructure(unittest.TestCase):
+    @pytest.fixture(autouse=True)
+    def prepare_fixture(self, datafile):
+        self.datafile = datafile
+
+    def test_xcfg(self):
+        """check loading of atomeye xcfg format"""
+        f = self.datafile("BubbleRaftShort.xcfg")
+        stru = loadStructure(f)
+        self.assertTrue(type(stru) is Structure)
+        self.assertRaises(StructureFormatError, loadStructure, f, "xyz")
+        return
+
+    def test_discus(self):
+        """check loading of discus file format"""
+        f = self.datafile("Ni-discus.stru")
+        stru = loadStructure(f)
+        self.assertTrue(type(stru) is PDFFitStructure)
+        return
+
+    def test_cif(self):
+        """check loading of CIF file format"""
+        f = self.datafile("PbTe.cif")
+        stru = loadStructure(f)
+        self.assertTrue(isinstance(stru, Structure))
+        self.assertFalse(isinstance(stru, PDFFitStructure))
+        return
+
+    def test_badfile(self):
+        """check loading of CIF file format"""
+        f = self.datafile("Ni-bad.stru")
+        self.assertRaises(StructureFormatError, loadStructure, f)
+        return
+
+    def test_goodkwarg(self):
+        """check loading of CIF file and passing of parser keyword argument."""
+        f = self.datafile("graphite.cif")
+        stru = loadStructure(f, eps=1e-10)
+        self.assertEqual(8, len(stru))
+        return
+
+    def test_badkwarg(self):
+        """check loading of xyz file format with invalid keyword argument"""
+        f = self.datafile("bucky.xyz")
+        self.assertRaises(TypeError, loadStructure, f, eps=1e-10)
+        return
+
+
+# End of class TestLoadStructure
+
+# ----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    unittest.main()

diffpy_structure-3.2.2rc0/tests/test_oldimports.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.structure  Complex Modeling Initiative
+#                   (c) 2017 Brookhaven Science Associates,
+#                   Brookhaven National Laboratory.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE.txt for license information.
+#
+##############################################################################
+
+"""
+Unit tests for imports of old camel-case names.
+"""
+
+
+import importlib
+import sys
+import unittest
+import warnings
+
+import diffpy
+
+# ----------------------------------------------------------------------------
+
+
+class TestOldImports(unittest.TestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        "Uncache any already-imported old modules."
+        for modname in tuple(sys.modules):
+            if modname.startswith("diffpy.Structure"):
+                del sys.modules[modname]  # pragma: no cover
+        return
+
+    def test_00TopImport(self):
+        """check import of diffpy.Structure"""
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", category=DeprecationWarning)
+            import diffpy.Structure as m0
+        self.assertIs(diffpy.structure, m0)
+        # second import should raise no warning
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+            import diffpy.Structure as m1
+        self.assertIs(diffpy.structure, m1)
+        return
+
+    def test_O1SubmoduleImport(self):
+        """check import of diffpy.Structure submodules."""
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always", category=DeprecationWarning)
+            import diffpy.Structure.SymmetryUtilities as symutil
+
+            self.assertIs(DeprecationWarning, w[0].category)
+        self.assertIs(diffpy.structure.symmetryutilities, symutil)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always", category=DeprecationWarning)
+            import diffpy.Structure.Parsers.P_cif as pcif
+
+            self.assertIs(DeprecationWarning, w[0].category)
+        self.assertIs(diffpy.structure.parsers.p_cif, pcif)
+        self.assertRaises(ImportError, importlib.import_module, "diffpy.Structure.SSpaceGroups")
+        return
+
+
+# End of class TestOldImports
+
+# ----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    unittest.main()