immlib 1.0.0.dev2__py3-none-any.whl

immlib/test/iolib/test_core.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+################################################################################
+# immlib/test/iolib/test_core.py
+
+"""Tests for the core iolib submodule in immlib: i.e., tests for the code in
+the `immlib.iolib._core` module.
+"""
+
+
+# Dependencies #################################################################
+
+import gzip
+from io       import StringIO, BytesIO
+from unittest import TestCase
+from tempfile import TemporaryDirectory
+
+from ...pathlib import *
+from ...iolib   import *
+from ...util    import is_str
+
+
+# Tests ########################################################################
+
+text_example = """
+   Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis molestie, nisl
+   eget volutpat interdum, ex tortor suscipit ipsum, at aliquam justo neque in
+   enim. In eu sollicitudin nunc. Integer egestas consequat nibh, ut pretium ex
+   accumsan ornare. Fusce et nisl laoreet, aliquet felis ac, fermentum
+   ipsum. Pellentesque at velit condimentum, auctor enim quis, ultrices
+   libero. Praesent efficitur posuere orci, id pretium nunc iaculis
+   id. Vestibulum varius massa in magna iaculis scelerisque. Etiam fermentum
+   condimentum orci, eget volutpat elit faucibus vestibulum. Mauris nec
+   imperdiet urna.
+"""
+json_example = {
+    'a': [1, 'test_2', {'b': 3, 'c': 4}, 5],
+    'x': {'y': [10, 20.01, 30], 'z': [40, 50.01, 60]},
+    'q': 100.5,
+    'n': None,
+    'bools': [True, False]
+}
+
+class TestIOLibCore(TestCase):
+    """Tests for the core module of the immlib.iolib subpackage.
+    """
+
+    def test_save(self):
+        """Tests the immlib.save interface."""
+        # We'll start by saving to StringIO and BytesIO objects.
+        s = save(StringIO(), text_example, "str")
+        self.assertEqual(s.getvalue(), text_example)
+        s = save(StringIO(), text_example, "text")
+        self.assertEqual(s.getvalue(), text_example)
+        # For JSON and YAML, easiest to check for equality after deserializing.
+        s = save(StringIO(), json_example, "json")
+        d = load(StringIO(s.getvalue()), "json")
+        self.assertEqual(json_example, d)
+        s = save(StringIO(), json_example, "yaml")
+        d = load(StringIO(s.getvalue()), "yaml")
+        self.assertEqual(json_example, d)
+        # We should also be able to save to a path.
+        with TemporaryDirectory() as tmpdir:
+            p = path(tmpdir) / "test.json"
+            # Should auto-detect the format from extension.
+            save(p, json_example)
+            d = load(p)
+            self.assertEqual(json_example, d)
+            # Also test the ability to load from CloudPaths.
+            p = osfpath("osf://bw9ec", local_cache_dir=tmpdir)
+            lns = load(p / "analysis.m", "text")
+            self.assertEqual(len(lns), 94)
+            self.assertTrue(all(is_str(ln) for ln in lns))
+            # Gzip objects should also work fine.
+            p_gz = path(tmpdir) / "test.json.gz"
+            save(p_gz, json_example)
+            d = load(p_gz)
+            self.assertEqual(json_example, d)
+            # We should be able to use the gzip module to load this also.
+            with gzip.open(p_gz, 'rt') as fl:
+                d = load(fl, "json")
+            self.assertEqual(json_example, d)

immlib/test/pathlib/__init__.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+################################################################################
+# pimms/test/pathlib/__init__.py
+
+"""Test module for the pimms.pathlib submodule."""
+
+# Import tests
+from .test_core import TestPathlibCore
+from .test_osf  import TestPathlibOSF
+
+

immlib/test/pathlib/test_core.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+################################################################################
+# immlib/test/pathlib/test_core.py
+
+"""Tests for the core pathlib submodule in immlib: i.e., tests for the code in
+the `immlib.pathlib._core` module.
+"""
+
+
+# Dependencies #################################################################
+
+from unittest import TestCase
+from tempfile import TemporaryDirectory
+from pathlib  import (Path, WindowsPath)
+
+from cloudpathlib import (CloudPath, AzureBlobPath, S3Path, GSPath)
+
+from ...pathlib import *
+
+
+# Tests ########################################################################
+
+# Some example path strings to use.
+# Unfortunately, AzureBlobPaths require credentials, so we do not test these
+# paths in the GitHub Actions automated testing (for now). These are tested by
+# the cloudpathlib library, but the wrapper functions are not completely tested.
+pathstrs = [
+    "/etc/ssh/",
+    "file://immlib/pathlib/__init__.py",
+    #"az://storageaccount.blob.core.windows.net/container/blob/path",
+    "osf://bw9ec/analysis.m",
+    "s3://openneuro.org/ds003787/derivatives/",
+    "gs://gcp-public-data-landsat/LC08/01/044/034/"]
+pathtypes = [
+    Path,
+    Path,
+    #AzureBlobPath,
+    OSFPath,
+    S3Path,
+    GSPath]
+pathfns = {
+    Path:          (filepath, is_filepath, like_filepath),
+    AzureBlobPath: (None,     is_azpath,   like_azpath),
+    OSFPath:       (osfpath,  is_osfpath,  like_osfpath),
+    S3Path:        (s3path,   is_s3path,   like_s3path),
+    GSPath:        (gspath,   is_gspath,   like_gspath)}
+
+# The test class.
+class TestPathlibCore(TestCase):
+    """Tests the immlib.pathlib._core module."""
+
+    def cleanup_cache(self, p):
+        """Given a path with a temporary directory, calls its cleanup routine.
+        """
+        if isinstance(p, CloudPath):
+            cl = p.client
+            if cl and cl._cache_tmp_dir:
+                cl._cache_tmp_dir.cleanup()
+    def test_pathstr(self):
+        """Tests the `path` and `pathstr` functions."""
+        # Path strings for basic strings should remain unchanged.
+        for p in pathstrs:
+            self.assertIs(p, pathstr(p))
+        # Path strings for path objects should equal the original strings.
+        paths = [path(p) for p in pathstrs]
+        for (p, tt) in zip(paths, pathtypes):
+            self.assertIsInstance(p, tt)
+        # Note that Path strips trailing slashes while CloudPath does not.
+        for (p,ps,pt) in zip(paths, pathstrs, pathtypes):
+            s = pathstr(p)
+            if isinstance(p, Path):
+                ps = ps.rstrip('/')
+            # if ps starts with file:// that will get stripped on a normal path.
+            if ps.startswith('file://'):
+                ps = ps[7:]
+            if isinstance(p, WindowsPath):
+                ps = ps.replace('/', '\\')
+            self.assertEqual(pathstr(p), ps)
+        # Adding to the path preserves a reasonable string:
+        correct_path = "/etc/ssh/sshd_config"
+        if isinstance(paths[0], WindowsPath):
+            correct_path = correct_path.replace('/', '\\')
+        self.assertEqual(pathstr(paths[0] / "sshd_config"), correct_path)
+        # The path and pathstr functions should fail for non-string inputs.
+        with self.assertRaises(TypeError):
+            path(10)
+        with self.assertRaises(TypeError):
+            pathstr(10)
+        # Before we exit, it's good form to cleanup the temporary directories
+        # that we created.
+        for p in paths:
+            self.cleanup_cache(p)
+    def test_pathfns(self):
+        """Tests the various path-related functions for each path type."""
+        from tempfile import TemporaryDirectory
+        # We make a single temporary directory for this whole test.
+        with TemporaryDirectory() as tempdir:
+            # We'll now go through each of the path types and check their
+            # functions using the pathstrs and pathtypes.
+            for (ps, pt) in zip(pathstrs, pathtypes):
+                (make, test, like) = pathfns[pt]
+                if make is None:
+                    continue
+                if pt is Path:
+                    p = make(ps)
+                    pp = path(ps)
+                else:
+                    p = make(ps, local_cache_dir=tempdir)
+                    pp = path(ps, local_cache_dir=tempdir)
+                # The paths made with either method should be equivalent.
+                self.assertEqual(pathstr(p), pathstr(pp))
+                self.assertIs(type(p), type(pp))
+                self.assertTrue(test(p))
+                self.assertFalse(test(ps))
+                self.assertTrue(like(p))
+                self.assertTrue(like(ps))
+                # If we get the local cache paths, they should also be equal;
+                # (if p is a filepath, then this just returns their pathstrs).
+                self.assertEqual(pathstr(filepath(p)), pathstr(filepath(pp)))
+                # This path should be an instance of its own path type.
+                self.assertIsInstance(p, pt)
+                if '://' in ps:
+                    # If there's a sheme at the beginning of the path, then it
+                    # should fail to construct via other path functions.
+                    for (k,(mk,tt,lk)) in pathfns.items():
+                        if k is pt or k is Path:
+                            continue
+                        if mk is not None:
+                            with self.assertRaises(Exception):
+                                mk(ps, local_cache_dir=tempdir)
+                        self.assertFalse(tt(p))
+                        self.assertFalse(tt(ps))
+                        self.assertFalse(lk(p))
+                        self.assertFalse(lk(ps))
+    def test_misc(self):
+        from immlib.pathlib import (is_path, like_path, pathdict, path)
+        import immlib as il
+        p = path('osf://tery8/')
+        self.assertTrue(is_path(p))
+        self.assertTrue(like_path(p))
+        self.assertFalse(is_path(10))
+        self.assertFalse(like_path('blarg://nothing'))
+        d = pathdict(path(il.__file__).parent)
+        for k in ('util', 'doc', 'types', 'workflow'):
+            self.assertIn(k, d)
+        self.assertTrue(path(d['util']['__init__.py']).is_file())

immlib/test/pathlib/test_osf.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+################################################################################
+# immlib/test/pathlib/test_osf.py
+
+"""Tests for the OSF components of the pathlib submodule in immlib: i.e.,
+tests for the code in the `immlib.pathlib._osf` module.
+"""
+
+
+# Dependencies #################################################################
+
+from unittest import TestCase
+from tempfile import TemporaryDirectory
+
+from ...pathlib import *
+
+
+# Tests ########################################################################
+
+class TestPathlibOSF(TestCase):
+    """Tests the immlib.pathlib._osf module."""
+
+    def test_osf(self):
+        """Tests the OSFPath type."""
+        # We'll do everything in a single temporary directory.
+        with TemporaryDirectory() as tmpdir:
+            # Create an OSFPath.
+            p0 = osfpath("osf://bw9ec/", local_cache_dir=tmpdir)
+            # Test out a few subpaths...
+            p = p0 / "analysis.m"
+            # This one is a file.
+            self.assertTrue(p.is_file())
+            # We should be able to read it.
+            with p.open('rt') as f:
+                lns = f.readlines()
+            # This particular file has 94 lines in it.
+            self.assertEqual(len(lns), 94)
+            # This is the first line:
+            self.assertEqual(
+                lns[0],
+                ('% This script shows how analyzePRF_HCP7TRET was used'
+                 ' to analyze the\n'))
+            # Here's a directory.
+            p = p0 / "rotatingsurfaces"
+            self.assertTrue(p.is_dir())
+            # We should be able to list the contents.
+            ls = {fl.name: fl for fl in p.iterdir()}
+            # There are 12 files in this particular directory; here are a few
+            # of them:
+            self.assertEqual(len(ls), 12)
+            # Here's one example:
+            f = p / "rh-angle.mov"
+            self.assertEqual(f, ls["rh-angle.mov"])
+            self.assertTrue(f.is_file())

immlib/test/types/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+################################################################################
+# immlib/test/types/test_core.py
+
+from .test_core import TestTypesCore

immlib/test/types/test_core.py

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+################################################################################
+# immlib/test/types/test_core.py
+
+"""Tests of the core types module in immlib: i.e., tests for the code in the
+immlib.types._core module.
+"""
+
+
+# Dependencies #################################################################
+
+from unittest import TestCase
+
+import numpy as np
+
+
+# Tests ########################################################################
+
+class TestTypesCore(TestCase):
+    """Tests the immlib.types._core module."""
+    
+    def test_metaobject(self):
+        "Tests the MetaObject class."
+        from ...types import MetaObject
+        from pcollections import ldict
+        # We can make objects with metadata (and the metadata get saved as
+        # persistent dictionaries).
+        o = MetaObject(metadata={'a': 1, 'b': 2})
+        self.assertIsInstance(o.metadata, ldict)
+        self.assertEqual(o.metadata, dict(a=1, b=2))
+        # We can add and subtract from these metadata maps.
+        oo = o.withmeta(c=3)
+        self.assertEqual(oo.metadata, dict(a=1, b=2, c=3))
+        ooo = oo.dropmeta('a')
+        self.assertEqual(ooo.metadata, dict(b=2, c=3))
+        # The original object must stay the same through all this.
+        self.assertEqual(o.metadata, dict(a=1, b=2))
+        self.assertEqual(oo.metadata, dict(a=1, b=2, c=3))
+        # We can also set the metadata directly.
+        oo = o.set_metadata(dict(e=5, f=6))
+        self.assertEqual(oo.metadata, dict(e=5, f=6))
+        self.assertIsInstance(oo.metadata, ldict)
+        # Finally we ca clear the metadata.
+        self.assertEqual(o.clear_metadata().metadata, dict())
+    def test_immutable(self):
+        "Test the Immutable type."
+        from ...types import Immutable
+        class immtest(Immutable):
+            __slots__ = ('a', 'b')
+            def __init__(self, a, b):
+                self.a = a
+                self.b = b
+        immobj = immtest(1, 2)
+        self.assertEqual(immobj.a, 1)
+        self.assertEqual(immobj.b, 2)
+        with self.assertRaises(TypeError):
+            immobj.a = 10
+        with self.assertRaises(TypeError):
+            immobj.b = 20
+        with self.assertRaises(TypeError):
+            del immobj.b
+    def test_array_index(self):
+        "Tests the ArrayIndex type."
+        from ...types import ArrayIndex
+        # Test with basic integers.
+        arr = np.reshape(np.arange(2*3*4), (2,3,4))
+        ai = ArrayIndex(arr)
+        for num in arr.flat:
+            self.assertEqual(arr[ai.find(num)], num)
+        # We can also find multiple elements at once:
+        els = [2,5,9]
+        self.assertTrue(np.array_equal(arr[ai.find(els)], els))
+        # Default values can be provided when not found:
+        self.assertEqual(ai.find(100, default=-1, ravel=True), -1)
+        # Otherwise, if we look for something not there, we get a KeyError:
+        with self.assertRaises(KeyError):
+            ai.find(100)
+        # The index freezes its array.
+        self.assertFalse(ai.array.flags['WRITEABLE'])
+        # But we can instruct the array to stay writeable if desired.
+        ai = ArrayIndex(arr, freeze=False)
+        self.assertTrue(ai.array.flags['WRITEABLE'])
+        # Tests with strings instead of integers.
+        lorem = '''Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed
+            do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
+            enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi
+            ut aliquip ex ea commodo consequat. Duis aute irure dolor in
+            reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
+            pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
+            culpa qui officia deserunt mollit anim id est laborum.'''
+        words = lorem.split()[:24]
+        arr = np.reshape(words, (4,3,2))
+        ai = ArrayIndex(arr)
+        for word in words:
+            self.assertEqual(arr[ai.find(word)], word)
+        els = [words[k] for k in [2,5,9]]
+        self.assertTrue(np.array_equal(arr[ai.find(els)], els))
+        # ArrayIndex objects are immutable.
+        with self.assertRaises(TypeError):
+            del ai.flatdata
+        with self.assertRaises(TypeError):
+            del ai[0]
+        with self.assertRaises(TypeError):
+            ai.flatdata = ()
+        with self.assertRaises(TypeError):
+            ai[0] = 0
+        # They raise some other errors too:
+        with self.assertRaises(TypeError):
+            ai.find(0, xyz=10)
+

immlib/test/util/__init__.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+################################################################################
+# immlib/test/util/__init__.py
+
+"""Tests of the immlib.util module."""
+
+
+from .test_core     import TestUtilCore
+from .test_numeric  import TestUtilNumeric
+from .test_quantity import TestUtilQuantity
+from .test_url      import TestUtilURL