python-clu 0.8.4__tar.gz → 0.10.0__tar.gz

{python-clu-0.8.4 → python_clu-0.10.0}/CLASSIFIERS.txt

@@ -12,7 +12,6 @@ Operating System :: POSIX
 Operating System :: Unix
 Programming Language :: Python
 Programming Language :: Python :: 3
-Programming Language :: Python :: 3.7
-Programming Language :: Python :: 3.8
+Programming Language :: Python :: 3.10
 Programming Language :: Python :: Implementation :: CPython
 Programming Language :: Python :: Implementation :: PyPy

{python-clu-0.8.4 → python_clu-0.10.0}/Makefile

@@ -47,10 +47,10 @@ twine-upload: cython sdist wheel
 	twine upload -s $(PROJECT_BASE)/dist/*
 
 bump:
-	bump2version --verbose patch
+	bump-my-version bump patch --verbose
 
 bigbump:
-	bump2version --verbose minor
+	bump-my-version bump minor --verbose
 
 check: clean-test-artifacts
 	check-manifest -v

{python-clu-0.8.4 → python_clu-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-clu
-Version: 0.8.4
+Version: 0.10.0
 Summary: CLU - Common Lightweight Utilities, or Command-Line Utilities (your pick)
 Home-page: https://github.com/fish2000/clu
 Download-URL: https://github.com/fish2000/clu/zipball/master
@@ -23,13 +23,47 @@ Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 License-File: COPYING.md
+Requires-Dist: Click>=7.0
+Requires-Dist: colorama>=0.4.0
+Requires-Dist: dataclasses>=0.6; python_version < "3.7"
+Requires-Dist: dbx-stopwatch>=1.6
+Requires-Dist: enum34>=1.1.0; python_version < "3.4"
+Requires-Dist: heapdict>=1.0.0
+Requires-Dist: humanize>=1.0.0
+Requires-Dist: importlib-metadata>=1.4.0; python_version < "3.8"
+Requires-Dist: mock>=4.0.0
+Requires-Dist: multidict>=4.7.0
+Requires-Dist: packaging
+Requires-Dist: pout>=0.8.13
+Requires-Dist: pygments>=2.0.0
+Requires-Dist: PyYAML>=5.3.0
+Requires-Dist: redis>=3.4.0
+Requires-Dist: setuptools>=30.0.0
+Requires-Dist: six>=1.10.0
+Requires-Dist: termcolor>=1.1.0
+Requires-Dist: toml>=0.10.0
+Requires-Dist: wheel>=0.34.0
+Requires-Dist: zict>=0.1.2
+Requires-Dist: zipp>=2.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: summary
 
 CLU – Common Lightweight Utilities (née Command-Line Utilities)
 ==================================================

python_clu-0.10.0/clu/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.10.0'

{python-clu-0.8.4 → python_clu-0.10.0}/clu/abstract.py

@@ -30,6 +30,33 @@ class Slotted(abc.ABCMeta):
                                                         attributes,
                                                       **kwargs)
 
+class SlotMatch(Slotted):
+    
+    """ A metaclass that ensures its classes, and all subclasses,
+        will be slotted types with “__match_args__” set to the
+        sum of the “__slots__” values for this and all ancestors.
+    """
+    
+    def __new__(metacls, name, bases, attributes, **kwargs):
+        """ Override for `abc.ABCMeta.__new__(…)` setting up a
+            derived slotted class with “__match_args__” set.
+        """
+        from clu.predicates import slots_for
+        
+        # Ensure the new class will have a “__match_args__” attribute
+        if '__match_args__' not in attributes:
+            attributes['__match_args__'] = tuple()
+        
+        # Create the new class via “super(…)” – calling “Slotted.__new__(…)”
+        cls = super(SlotMatch, metacls).__new__(metacls, name, # type: ignore
+                                                         bases,
+                                                         attributes,
+                                                       **kwargs)
+        
+        # Set “__match_args__” using “slots_for(…)” and return
+        cls.__match_args__ = slots_for(cls)
+        return cls
+
 class NonSlotted(abc.ABCMeta):
     
     """ A metaclass that ensures its classes, and all subclasses,
@@ -369,30 +396,7 @@ class ManagedContext(contextlib.AbstractContextManager):
         self.teardown()
         return exc_type is None
 
-if consts.PYTHON_VERSION >= 3.7: # pragma: no cover
-    
-    class AsyncManagedContext(ManagedContext,
-                              contextlib.AbstractAsyncContextManager):
-        
-        async def __aenter__(self):
-            self.setup()
-            if hasattr(self, '__await__'):
-                if callable(self.__await__):
-                    await self
-            return self
-        
-        async def __aexit__(self, exc_type=None,
-                                  exc_val=None,
-                                  exc_tb=None):
-            self.teardown()
-            return exc_type is None
-
-else:
-    
-    class AsyncManagedContext(ManagedContext):
-        pass
-
-__all__ = ('Slotted', 'NonSlotted',
+__all__ = ('Slotted', 'SlotMatch', 'NonSlotted',
            'UnhashableMeta', 'Unhashable',
            'Format', 'NonFormat', 'SlottedFormat', 'Sanitizer',
            'Cloneable',
@@ -401,6 +405,6 @@ __all__ = ('Slotted', 'NonSlotted',
            'BaseDescriptor', 'DataDescriptor', 'NamedDescriptor',
            'CacheDescriptor', 'Descriptor', 'ValueDescriptor',
            'BasePath', 'AppName',
-           'ManagedContext', 'AsyncManagedContext')
+           'ManagedContext')
 
 __dir__ = lambda: list(__all__)

{python-clu-0.8.4 → python_clu-0.10.0}/clu/config/filebase.py

@@ -9,8 +9,7 @@ import sys
 abstract = abc.abstractmethod
 
 from clu.constants.enums import System, SYSTEM
-# from clu.config.abc import FrozenKeyMap
-from clu.config.base import NamespacedMutableMapping
+from clu.config.keymap import Nested
 from clu.fs.appdirectories import AppDirs
 from clu.fs.filesystem import TemporaryName, Directory
 from clu.fs.misc import extension, filesize
@@ -138,7 +137,7 @@ class FileName(clu.abstract.AppName, metaclass=abc.ABCMeta):
         return Directory(root_dir.realpath()).subpath(file_name)
 
 @export
-class FileBase(NamespacedMutableMapping, FileName): # type: ignore
+class FileBase(Nested, FileName): # type: ignore
     
     """ The FileBase abstract base class furnishes two methods:
         

{python-clu-0.8.4 → python_clu-0.10.0}/clu/config/keymap.py

@@ -75,7 +75,7 @@ class FrozenFlat(FrozenKeyMap, clu.abstract.ReprWrapper,
         """ Articulate a flattened KeyMap instance out into one that is nested. """
         if cls is None:
             cls = FrozenNested
-        return cls(tree=articulate(self.dictionary))
+        return cls(tree=articulate(self.dictionary, walker=flatwalk))
     
     def __iter__(self):
         yield from self.dictionary
@@ -118,10 +118,14 @@ class Flat(FrozenFlat, KeyMap):
         del self.dictionary[nskey]
 
 @export
-def dictify(treeish):
-    """ Recursively convert a possibly nested mapping to standard dicts. """
+def dictify(treeish, cls=dict):
+    """ Recursively convert a possibly nested mapping to dicts.
+        
+        Standard Python dicts will be created by default; specify
+        a custom class with the “cls” argument to use your own.
+    """
     if ismapping(treeish):
-        return { key : dictify(value) for key, value in treeish.items() }
+        return cls({ key : dictify(value, cls=cls) for key, value in treeish.items() })
     return treeish
 
 @export
@@ -164,9 +168,18 @@ class FrozenNested(NamespaceWalker, clu.abstract.ReprWrapper,
             tree = getattr(tree, 'tree')
         elif hasattr(tree, 'nestify'):
             tree = getattr(tree.nestify(), 'tree')
-        self.tree = dictify(dict(tree or {}))
+        self.tree = dictify(dict(tree or {}), cls=dict)
         if updates:
-            self.tree.update(**updates)
+            for nskey, value in updates.items():
+                key, namespaces = unpack_ns(nskey)
+                d = self.tree
+                for namespace in namespaces:
+                    try:
+                        d = d[namespace]
+                    except KeyError:
+                        d[namespace] = {}
+                        d = d[namespace]
+                d[key] = value
     
     def walk(self):
         """ Iteratively walk the nested KeyMap’s tree of dicts. """
@@ -387,12 +400,12 @@ def test():
     @inline
     def test_frozennested_contains():
         """ FrozenNested contains namespaced key """
-        nested = FrozenNested(tree=nestedmaps(), **arbitrary())
+        nested = FrozenNested(tree=nestedmaps())
         
         for mappingpath in mapwalk(nested.tree):
             *namespaces, key, value = mappingpath
             nskey = pack_ns(key, *namespaces)
-            assert nskey in nested or nskey in arbitrary()
+            assert nskey in nested
     
     @inline
     def test_nested_contains():

{python-clu-0.8.4 → python_clu-0.10.0}/clu/config/ns.py

@@ -188,82 +188,14 @@ __all__, __dir__ = exporter.all_and_dir()
 def test():
     
     from clu.testing.utils import inline
-    from clu.config.keymap import Flat
+    from clu.config.keymap import Flat, Nested
+    from clu.config.keymap import nestedmaps, flatdict, arbitrary
     from clu.fs.filesystem import which
     from pprint import pprint
     import os, re, textwrap
     
-    flat = Flat()
-    
-    javaprop_re = re.compile(r"^(?P<name>[\w\.]+): “(?P<value>.*)”", re.IGNORECASE | re.MULTILINE)
-    java_source = textwrap.dedent("""
-    package ost.%s;
-    
-    import java.util.Enumeration;
-    import java.util.Properties;
-    
-    public class ShowJavaSystemProperties {
-    
-        public static void main(String... args) {
-            Properties properties = System.getProperties();
-            Enumeration names = properties.propertyNames();
-            while (names.hasMoreElements()) {
-                String name = (String) names.nextElement();
-                String value = properties.getProperty(name);
-                System.out.println(name + ": “" + value + "”");
-            }
-        }
-    
-    }
-    """ % exporter.dotpath)
-    
-    @inline.precheck
-    def load_java_system_properties():
-        """ Load the Java JDK’s system properties """
-        from clu.fs.filesystem import back_tick, TemporaryName
-        from clu.naming import dotpath_to_prefix
-        
-        with TemporaryName(prefix="show-java-system-properties-",
-                           suffix="java",
-                           randomized=True) as java_file:
-            java_file.write(java_source)
-            java_path = java_file.realpath()
-            output = back_tick(f"java {java_path}")
-        
-        assert not java_file.exists
-        
-        for line in output.splitlines():
-            match = javaprop_re.match(line)
-            if match:
-                # BEWARE: dotpath_to_prefix(…) does a casefold():
-                name = dotpath_to_prefix(match.group('name'),
-                                         sep=NAMESPACE_SEP, end='')
-                value = match.group('value')
-                flat[name] = value
-        
-        pprint(flat)
-    
-    @inline.precheck
-    def show_java_system_properties():
-        """ Show namespaced Java system properties """
-        count = flat.namespace_count()
-        plural = count == 1 and '' or 's'
-        
-        print(f"* {count} namespace{plural} total:")
-        print()
-        
-        for namespace in flat.namespaces():
-            namespaces = split_ns(namespace)
-            print(f"+ {namespace}:")
-            for nskey, value in flat.items(*namespaces):
-                bare_key = strip_ns(nskey)
-                key = nskey.replace(prefix_for(*namespaces), '', 1)
-                print(f"    {key} : “{value}”")
-                assert key.endswith(bare_key)
-            print()
-        
-        print("- «unprefixed»:")
-        pprint(flat.submap(unprefixed=True), indent=4)
+    flat = Flat(flatdict())
+    nested = Nested(nestedmaps())
     
     @inline
     def test_flat_validate_ns():
@@ -277,6 +209,18 @@ def test():
         for namespace in flat.freeze().namespaces():
             assert validate_ns(*split_ns(namespace))
     
+    @inline
+    def test_nested_validate_ns():
+        """ Validate a Nested keymap’s namespaces """
+        for namespace in nested.namespaces():
+            assert validate_ns(*split_ns(namespace))
+    
+    @inline
+    def test_frozennested_validate_ns():
+        """ Validate a FrozenNested keymap’s namespaces """
+        for namespace in nested.freeze().namespaces():
+            assert validate_ns(*split_ns(namespace))
+    
     @inline
     def test_validate_ns_errors():
         """ Check “validate_ns(…)” error conditions """
@@ -290,9 +234,84 @@ def test():
         except ValueError as exc:
             assert "namespace contains separator" in str(exc)
     
-    if not which('java'):
-        print("[WARNING] skipping `clu.config.ns` tests – `java` executable not found")
-        return os.EX_OK
+    namespaces = ('yo', 'dogg')
+    key = 'iheard'
+    nskey = "yo:dogg:iheard"
+    value = "you like this sort of thing"
+    
+    @inline
+    def test_concatenate_ns():
+        assert concatenate_ns(*namespaces) == "yo:dogg"
+    
+    @inline
+    def test_prefix_for():
+        assert prefix_for(*namespaces) == "yo:dogg:"
+    
+    @inline
+    def test_strip_ns():
+        assert strip_ns(nskey) == "iheard"
+    
+    @inline
+    def test_split_ns():
+        assert tuple(split_ns(nskey)) == ('yo', 'dogg', 'iheard')
+        assert split_ns(nskey) == ['yo', 'dogg', 'iheard']
+    
+    @inline
+    def test_startswith_ns():
+        assert startswith_ns(namespaces, ('yo', 'dogg'))
+    
+    @inline
+    def test_unpack_ns():
+        assert unpack_ns(nskey) == (key, list(namespaces))
+        assert unpack_ns(nskey) == ('iheard', ['yo', 'dogg'])
+    
+    @inline
+    def test_pack_ns():
+        assert pack_ns(key, *namespaces) == nskey
+        assert pack_ns(key, *namespaces) == "yo:dogg:iheard"
+    
+    @inline
+    def test_get_ns():
+        assert get_ns(nskey) == "yo:dogg"
+    
+    @inline
+    def test_get_ns_and_key():
+        assert get_ns_and_key(nskey) == ("yo:dogg", 'iheard')
+    
+    @inline
+    def test_compare_ns():
+        assert compare_ns(namespaces, ('yo', 'dogg'))
+    
+    appname = 'testing'
+    envkey = "TESTING_YO_DOGG_IHEARD"
+    
+    @inline
+    def test_concatenate_env():
+        assert concatenate_env(*namespaces) == "YO_DOGG"
+        assert concatenate_env(*chain(tuplize(appname), namespaces)) == "TESTING_YO_DOGG"
+        assert concatenate_env(*chain(tuplize(appname), namespaces, tuplize(key))) == "TESTING_YO_DOGG_IHEARD"
+    
+    @inline
+    def test_prefix_env():
+        assert prefix_env(appname, *namespaces) == "TESTING_YO_DOGG_"
+    
+    @inline
+    def test_pack_env():
+        assert pack_env(appname, key, *namespaces) == "TESTING_YO_DOGG_IHEARD"
+    
+    @inline
+    def test_unpack_env():
+        assert unpack_env(envkey) == (appname, key, list(namespaces))
+        assert unpack_env(envkey) == ('testing', 'iheard', ['yo', 'dogg'])
+    
+    @inline
+    def test_nskey_from_env():
+        assert nskey_from_env(envkey) == (appname, pack_ns(key, *namespaces))
+        assert nskey_from_env(envkey) == ('testing', "yo:dogg:iheard")
+    
+    @inline
+    def test_nskey_to_env():
+        assert nskey_to_env(appname, nskey) == "TESTING_YO_DOGG_IHEARD"
     
     return inline.test(100)
 

{python-clu-0.8.4 → python_clu-0.10.0}/clu/config/proxy.py

@@ -162,7 +162,7 @@ def test():
     
     from clu.testing.utils import inline
     from clu.config.ns import unpack_ns
-    from clu.config.keymap import FrozenFlat, Flat
+    from clu.config.keymap import FrozenFlat, Flat, Nested
     from clu.config.keymap import nestedmaps, flatdict
     from pprint import pprint
     
@@ -311,19 +311,19 @@ def test():
         return test_fn
     
     # Add inline test functions using the metafunction test generators:
-    inline.add_function(test_one_fn(FrozenFlat, KeyMapView,  flatdict),   'test_one')
-    inline.add_function(test_two_fn(FrozenFlat, KeyMapView,  flatdict),   'test_two')
-    inline.add_function(test_one_fn(Flat,       KeyMapView,  flatdict),   'test_three')
-    inline.add_function(test_one_fn(Flat,       KeyMapProxy, flatdict),   'test_three_point_five')
+    inline.add_function(test_one_fn(FrozenFlat, KeyMapView,  flatdict),   'test_one_frozenflat_keymapview')
+    inline.add_function(test_two_fn(FrozenFlat, KeyMapView,  flatdict),   'test_two_frozenflat_keymapview')
+    inline.add_function(test_one_fn(Flat,       KeyMapView,  flatdict),   'test_one_flat_keymapview')
+    inline.add_function(test_one_fn(Flat,       KeyMapProxy, flatdict),   'test_one_flat_keymapproxy')
     inline.add_function(test_two_fn(Flat,       KeyMapProxy, flatdict,
-                                                KeyMapView),              'test_four')
+                                                KeyMapView),              'test_two_flat_keymapproxy')
     
     # N.B. These two take FUCKING FOREVER to run:
-    # inline.add_function(test_one_fn(Nested,     KeyMapView,  nestedmaps), 'test_five')
-    # inline.add_function(test_one_fn(Nested,     KeyMapProxy, nestedmaps), 'test_five_point_five')
+    inline.add_function(test_one_fn(Nested,     KeyMapView,  nestedmaps), 'test_one_nested_keymapview')
+    inline.add_function(test_one_fn(Nested,     KeyMapProxy, nestedmaps), 'test_one_nested_keymapproxy')
     
     @inline
-    def test_six():
+    def test_view_proxy_exceptions():
         """ View/Proxy error conditions """
         try:
             KeyMapView(None)

{python-clu-0.8.4 → python_clu-0.10.0}/clu/config/settings.py

@@ -23,7 +23,7 @@ from clu.exporting import Exporter
 exporter = Exporter(path=__file__)
 export = exporter.decorator()
 
-NEED_NAME = PYTHON_VERSION < 3.6
+NEED_NAME = PYTHON_VERSION < "3.6"
 
 class Nestifier(abc.ABC):
     

{python-clu-0.8.4 → python_clu-0.10.0}/clu/constants/consts.py

@@ -17,6 +17,9 @@ else:
     if not callable(path):  # pragma: no cover
         path = sys.intern
 
+# Get VersionInfo from clu.version:
+from clu.version import VersionInfo
+
 # Define the “pytuple” shortcut lambda:
 pytuple = lambda *attrs: tuple(f'__{atx}__' for atx in attrs)
 
@@ -132,9 +135,9 @@ PY3 = sys.version_info.major > 2
 # Determine if we’re on PyPy:
 PYPY = hasattr(sys, 'pypy_version_info')
 
-# A float representation of the Python version:
-PYTHON_VERSION = float("%s%s%s" % (sys.version_info.major, os.extsep,
-                                   sys.version_info.minor))
+# The current Python major/minor version:
+PYTHON_VERSION = VersionInfo("%s%s%s" % (sys.version_info.major, os.extsep,
+                                         sys.version_info.minor))
 
 # Qualifier for qualified-name operations:
 QUALIFIER = sys.intern(os.extsep)
@@ -206,11 +209,20 @@ VERBOTEN += ('Namespace', 'SimpleNamespace')
 # Regex for picking up whitespace:
 WHITESPACE = re.compile(r'\s+')
 
-class NoDefault(object):
+class MetaNoDefault(type):
+    """ A metaclasss to make a type Falsey. """
+    def __bool__(cls):
+        return False
+
+class NoDefault(metaclass=MetaNoDefault):
     """ A singleton object to signify a lack of an argument. """
     __slots__ = tuple() # type: tuple
+    
     def __new__(cls, *args, **kwargs): # pragma: no cover
         return cls
+    
+    def __bool__(self):
+        return False
 
 # Manually rename `pytuple(…)` per mechanism of “clu.exporting.Exporter”:
 pytuple.__lambda_name__ = λ # type: ignore

{python-clu-0.8.4 → python_clu-0.10.0}/clu/exporting.py

@@ -9,9 +9,11 @@ import clu.abstract
 import collections
 import collections.abc
 import contextlib
+import hashlib
 import importlib
 import inspect
 import itertools
+import shelve
 import sys, os
 import warnings
 import weakref
@@ -21,7 +23,7 @@ chain = itertools.chain
 iterchain = itertools.chain.from_iterable
 
 from clu.constants.consts import (λ, φ, # type: ignore
-                                  APPNAME, BASEPATH, BUILTINS,
+                                  APPNAME, BASEPATH, BUILTINS, ENCODING,
                                   EXPORTER_NAME, QUALIFIER, ROOT_PATH,
                                   NoDefault, pytuple)
 from clu.constants.exceptions import BadDotpathWarning, ExportError, ExportWarning
@@ -31,7 +33,6 @@ cache = lambda function: lru_cache(maxsize=128, typed=False)(function)
 
 # Not what you are looking for
 NotYourThing = object()
-# NotYourID = id(NotYourThing)
 
 def itermodule(module):
     """ Get an iterable of `(name, thing)` tuples for all things
@@ -182,6 +183,13 @@ def search_modules(thing, *modules):
                     return module, key
     return None, None
 
+@cache
+def stringhash(string):
+    """ Expediently hash a string to another string """
+    digester = hashlib.sha256()
+    digester.update(bytes(string, encoding=ENCODING))
+    return digester.hexdigest()
+
 def determine_name(thing, name=None, try_repr=False):
     """ Private module function to find a name for a thing. """
     # Shortcut everything if a name was explictly specified:
@@ -512,6 +520,44 @@ class ExporterBase(collections.abc.MutableMapping,
                 else:
                     self.__exports__.update(d)
     
+    def hash(self):
+        """ Return a stringified hash value corresponding to this
+            particular exporter instances’ dotpath.
+        """
+        return self.dotpath and stringhash(self.dotpath) or None
+    
+    def datafile(self):
+        """ Return a unique filename for this instance """
+        from clu.fs.appdirectories import AppDirs
+        from clu.constants.exceptions import FilesystemError
+        
+        # Initialize an AppDirs instance:
+        appdirs = AppDirs(appname=type(self).appname)
+        
+        # Ensure the user config directory exists:
+        try:
+            appdirs.user_config.makedirs()
+        except FilesystemError:
+            pass
+        
+        # Construct database filename:
+        selfhash = self.hash()
+        if not selfhash:
+            raise AttributeError("Could not hash the exporter instances’ dotpath")
+        return Path(appdirs.user_config / selfhash + ".pkl")
+    
+    @contextlib.contextmanager
+    def data(self, path=NoDefault):
+        """ Context manager for opening a shelving database, corresponding
+            to this particular exporter instances’ dotpath.
+        """
+        if path is NoDefault:
+            path = self.datafile()
+        
+        # Yield out a proper shelving database instance:
+        with contextlib.closing(shelve.open(os.fspath(path), writeback=True)) as shelving:
+            yield shelving
+    
     def exports(self):
         """ Get a new dictionary instance filled with the exports. """
         out = {} # type: dict
@@ -864,6 +910,7 @@ with exporter as export:
     export(search_for_name)
     export(search_for_module)
     export(search_modules)
+    export(stringhash)
     export(determine_name)
     export(path_to_dotpath)
     export(thismodule, name='thismodule', doc="thismodule() → return the name of the module in which the `thismodule()` function was called")
@@ -948,11 +995,40 @@ def test():
         format_environment_module = search_for_module(utils.format_environment)
         assert utils == format_environment_module
     
+    @inline
+    def test_hash():
+        """ Test the string-hashing of the exporters’ dotpath """
+        expo = Exporter(path=__file__)
+        assert expo.hash() == exporter.hash()
+        print(expo.hash())
+    
+    @inline
+    def test_shelving():
+        """ Test the arbitrary data-shelving context manager """
+        from clu.fs.filesystem import TemporaryName
+        
+        with TemporaryName(randomized=True, suffix='pkl') as tempfile:
+            tempname = tempfile.name
+            with exporter.data(path=tempfile.name) as database:
+                database['yo'] = 'dogg'
+                database['i_heard'] = 'you like dicts'
+            with exporter.data(path=tempfile.name) as database:
+                assert database['yo'] == 'dogg'
+                assert database['i_heard'] == 'you like dicts'
+                assert len(database) == 2
+        
+        assert not os.path.exists(tempname)
+    
     @inline.diagnostic
     def show_search_by_id_cache_info():
         print("SEARCH-BY-ID CACHE INFO:")
         print(Exporter.cache_info())
     
+    @inline.diagnostic
+    def show_stringhash_cache_info():
+        print("STRINGHASH CACHE INFO:")
+        print(stringhash.cache_info())
+    
     return inline.test(100)
 
 if __name__ == '__main__':