python-clu 0.8.5__tar.gz → 0.10.1__tar.gz

python_clu-0.10.1/.bumpversion.toml

@@ -0,0 +1,32 @@
+
+[tool.bumpversion]
+current_version = "0.10.1"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = true
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags = true
+tag_name = "v{new_version}"
+tag_message = "Bump version: {current_version} → {new_version}"
+allow_dirty = false
+commit = true
+message = "Bumped version: {current_version} → {new_version}"
+moveable_tags = []
+commit_args = ""
+setup_hooks = []
+pre_commit_hooks = []
+post_commit_hooks = []
+
+[[tool.bumpversion.files]]
+filename = "setup.py"
+search = """__version__ = '{current_version}'"""
+replace = """__version__ = '{new_version}'"""
+
+[[tool.bumpversion.files]]
+filename = "clu/__version__.py"
+search = """__version__ = '{current_version}'"""
+replace = """__version__ = '{new_version}'"""

{python-clu-0.8.5 → python_clu-0.10.1}/MANIFEST.in

@@ -1,6 +1,6 @@
 exclude *.pyc *~ *.so .DS_Store
 
-include .bumpversion.cfg
+include .bumpversion.toml
 include .coveragerc
 include .editorconfig
 include .gitchangelog.rc

{python-clu-0.8.5 → python_clu-0.10.1}/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.5 → python_clu-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-clu
-Version: 0.8.5
+Version: 0.10.1
 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
@@ -29,6 +29,41 @@ 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.1/clu/__version__.py

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

{python-clu-0.8.5 → python_clu-0.10.1}/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.5 → python_clu-0.10.1}/clu/config/keymap.py

@@ -71,11 +71,11 @@ class FrozenFlat(FrozenKeyMap, clu.abstract.ReprWrapper,
         if updates:
             self.dictionary.update(**updates)
     
-    def nestify(self, cls=None):
+    def nestify(self, cls=None, walker=flatwalk):
         """ Articulate a flattened KeyMap instance out into one that is nested. """
         if cls is None:
             cls = FrozenNested
-        return cls(tree=articulate(self.dictionary, walker=flatwalk))
+        return cls(tree=articulate(self.dictionary, walker=walker))
     
     def __iter__(self):
         yield from self.dictionary

{python-clu-0.8.5 → python_clu-0.10.1}/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.5 → python_clu-0.10.1}/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.5 → python_clu-0.10.1}/clu/exporting.py

@@ -555,7 +555,7 @@ class ExporterBase(collections.abc.MutableMapping,
             path = self.datafile()
         
         # Yield out a proper shelving database instance:
-        with shelve.open(os.fspath(path), writeback=True) as shelving:
+        with contextlib.closing(shelve.open(os.fspath(path), writeback=True)) as shelving:
             yield shelving
     
     def exports(self):

{python-clu-0.8.5 → python_clu-0.10.1}/clu/extending.py

@@ -12,8 +12,8 @@ import zict # type: ignore
 
 iterchain = chain.from_iterable
 
-from clu.constants.consts import CPYTHON, pytuple
-from clu.predicates import typeof, tuplize, attr
+from clu.constants.consts import CPYTHON, QUALIFIER, pytuple
+from clu.predicates import typeof, tuplize, attr, pyattr
 from clu.exporting import Exporter
 
 exporter = Exporter(path=__file__)
@@ -148,15 +148,12 @@ class DoubleDutchRegistry(clu.abstract.ReprWrapper,
     
     def funcname(self, key):
         function = self.cache[key]
-        name = attr(function, '__qualname__', '__name__')
-        signature = inspect.signature(function)
+        name = pyattr(function, 'name', 'qualname')
+        signature = str(inspect.signature(function)).strip('[]').split(QUALIFIER)[0]
         return f"{name!s}{signature!s}"
     
     def inner_repr(self):
-        from pprint import pformat
         most = max(len(self.keyname(key)) for key in self)
-        # cacheout = { self.keyname(key) : self.cache[key] for key in self }
-        # return "\n%s" % pformat(cacheout, indent=4)
         out = ""
         for key in self:
             out += "    %s : %s \n" % (self.keyname(key).ljust(most),
@@ -260,25 +257,24 @@ __all__, __dir__ = exporter.all_and_dir()
 
 def test():
     
-    from clu.config.abc import FlatOrderedSet as FOSet
-    from clu.config.base import NamespacedMutableMapping as NaMutMap
+    from clu.config.abc import KeyMap, FlatOrderedSet as FOSet
     from clu.testing.utils import pout, inline
     
     @inline
-    def test_one():
+    def test_pairs_and_products():
         pair = []
         product = []
         
-        for tup in ω(FOSet, NaMutMap):
-            pair.append(tuple(str(el) for el in tup))
+        for mro_tuple in ω(FOSet, KeyMap):
+            pair.append(tuple(str(element) for element in mro_tuple))
         
-        for itp in dot_product(FOSet.__mro__, NaMutMap.__mro__):
-            product.append(tuple(str(el) for el in itp))
+        for mro_tuple in dot_product(FOSet.__mro__, KeyMap.__mro__):
+            product.append(tuple(str(element) for element in mro_tuple))
         
         # pout.v(pair[:10], product[:10])
         
-        sorter = lambda t: ''.join(iterchain(t))
-        retros = lambda t: ''.join(reversed(list(iterchain(t))))
+        sorter = lambda two_tuple: ''.join(iterchain(two_tuple))
+        retros = lambda two_tuple: ''.join(reversed(list(iterchain(two_tuple))))
         
         assert sorted(pair, key=sorter) == sorted(product, key=sorter)
         assert sorted(pair, key=retros) == sorted(product, key=retros)
@@ -286,9 +282,9 @@ def test():
         assert pair == product
     
     @inline
-    def test_two():
-        pairs    = list(ω(FOSet, NaMutMap))
-        products = list(dot_product(FOSet.mro(), NaMutMap.mro()))
+    def test_pair_mro():
+        pairs    = list(ω(FOSet, KeyMap))
+        products = list(dot_product(FOSet.mro(), KeyMap.mro()))
         
         print()
         print("PAIRS    »", len(pairs))
@@ -297,14 +293,14 @@ def test():
         assert set(pairs) == set(products) # REALLY.
     
     @inline
-    def test_three():
+    def test_extend_pairtype():
         
         class __extend__(ΩΩ(int, int)): # type: ignore
             
             __name__ = "Coordinate"
             
-            def ratio(xy):
-                x, y = xy
+            def ratio(point_tuple):
+                x, y = point_tuple
                 return x / y
         
         assert Ω(2, 3).ratio() == 2 / 3
@@ -313,14 +309,14 @@ def test():
             
             __name__ = "NamespacedKey"
             
-            def pack(tup):
-                ns, key = tup
+            def pack(two_tuple):
+                ns, key = two_tuple
                 return f"{ns}:{key}"
         
         assert Ω('yo', 'dogg').pack() == "yo:dogg"
     
     @inline
-    def test_four():
+    def test_doubledutch_function():
         
         @doubledutch
         def yodogg(x, y):
@@ -334,6 +330,8 @@ def test():
         def yodogg(x, y): # pragma: no cover
             return f"WAT: {x}, {y}"
         
+        assert yodogg('yo', 'dogg').startswith("WAT")
+        
         assert yodogg.remove(str)
         assert not yodogg.remove(complex)
         
@@ -345,12 +343,14 @@ def test():
         def yodogg(x: float, y: float):
             return f"FLTS: {x}, {y}"
         
-        print(yodogg(10, 20))
-        print(yodogg('yo', 'dogg'))
-        print(yodogg(3.14, 2.78))
-        print("DEFAULTING »", yodogg(object(), object()))
+        default_return = yodogg(object(), object())
+        assert default_return is None
+        assert yodogg(10, 20).startswith("INTS")
+        assert yodogg('yo', 'dogg').startswith("STRS")
+        assert yodogg(3.14, 2.78).startswith("FLTS")
         
         print()
+        
         regcount = len(yodogg.registry)
         print(f"REGISTRY ({regcount} items) »", repr(yodogg.registry))
     

{python-clu-0.8.5 → python_clu-0.10.1}/clu/fs/filesystem.py

@@ -676,12 +676,11 @@ class Directory(BaseFSName,
             Specify an optional “suffix” parameter to filter the list by a
             particular file suffix (leading dots unnecessary but unharmful).
         """
-        if not self.exists:
-            return tuple()
-        with os.scandir(self.realpath(source)) as iterscan:
-            return tuple(filter(suffix_searcher(suffix),
-                         filter(non_dotfile_matcher,
-                        (direntry.name for direntry in iterscan))))
+        if self.exists:
+            with os.scandir(self.realpath(source)) as iterscan:
+                yield from filter(suffix_searcher(suffix),
+                           filter(non_dotfile_matcher,
+                                 (direntry.name for direntry in iterscan)))
     
     def ls_la(self, suffix=None, source=None):
         """ List all files, including files whose name starts with a dot.
@@ -697,11 +696,10 @@ class Directory(BaseFSName,
             commands I ever learned, and it reads better than `ls_a()` which
             I think looks awkward and goofy.)
         """
-        if not self.exists:
-            return tuple()
-        with os.scandir(self.realpath(source)) as iterscan:
-            return tuple(filter(suffix_searcher(suffix),
-                        (direntry.name for direntry in iterscan)))
+        if self.exists:
+            with os.scandir(self.realpath(source)) as iterscan:
+                yield from filter(suffix_searcher(suffix),
+                                 (direntry.name for direntry in iterscan))
     
     def subpath(self, subpath, source=None, requisite=False):
         """ Returns the path to a subpath of the instances’ target path. """
@@ -731,13 +729,12 @@ class Directory(BaseFSName,
             Specify an optional “pattern” parameter to filter the list
             by a particular regex pattern, as applied to directory names.
         """
-        if not self.exists:
-            return tuple()
-        with os.scandir(self.realpath(source)) as iterscan:
-            return tuple(map(lambda dirname: self.directory(dirname),
-                         filter(re_searcher(pattern),
-                        (direntry.name for direntry in iterscan \
-                                        if direntry.is_dir()))))
+        if self.exists:
+            with os.scandir(self.realpath(source)) as iterscan:
+                yield from map(lambda dirname: self.directory(dirname),
+                               filter(re_searcher(pattern),
+                                     (direntry.name for direntry in iterscan \
+                                                     if direntry.is_dir())))
     
     def makedirs(self, subpath=None, mode=0o755):
         """ Creates any parts of the target directory path that don’t
@@ -943,7 +940,7 @@ class Directory(BaseFSName,
             dotpaths.update(path_to_dotpath(os.path.join(root, filename),
                                             relative_to=self.name)
                             for filename in filenames)
-        return sorted(dotpaths)
+        yield from sorted(dotpaths)
     
     def suffix_histogram(self, subdir=None,
                                source=None,

{python-clu-0.8.5 → python_clu-0.10.1}/clu/importing/base.py

@@ -13,6 +13,7 @@ import abc
 import collections.abc
 import clu.abstract
 import clu.dicts
+import copy
 import importlib
 import importlib.abc
 import importlib.machinery
@@ -288,8 +289,8 @@ class ArgumentSink(collections.abc.Callable,
             and/or keyword arguments
         """
         instance = super().__new__(cls)
-        instance.args = args
-        instance.kwargs = kwargs
+        instance.args = copy.deepcopy(args)
+        instance.kwargs = copy.deepcopy(kwargs)
         return instance
     
     def __call__(self, function):

{python-clu-0.8.5 → python_clu-0.10.1}/clu/keyvalue.py

@@ -58,7 +58,7 @@ class CLUInterface(AppDirs):
                 self.migrate_from_previous()
         
         # Configure zicts for key-value I/O:
-        self.zfile = zict.File(str(self.datadir), mode='a')
+        self.zfile = zict.File(str(self.datadir))
         self.zutf8 = zict.Func(dump=attr(plistlib, 'dumps', 'writePlistToString'),
                                load=attr(plistlib, 'loads', 'readPlistFromString'),
                                d=self.zfile)
@@ -125,15 +125,15 @@ class CLUInterface(AppDirs):
     
     def keys(self):
         """ Return an iterable with all of the keys in this key-value store. """
-        return self.zfunc.keys()
+        yield from self.zfunc.keys()
     
     def values(self):
         """ Return an iterable with all of the values in this key-value store. """
-        return self.zfunc.values()
+        yield from self.zfunc.values()
     
     def items(self):
         """ Return an iterable yielding (key, value) for all items in this key-value store. """
-        return self.zfunc.items()
+        yield from self.zfunc.items()
     
     def as_dict(self):
         """ Return a plain dict with the key-value stores’ contents. """
@@ -245,17 +245,17 @@ def update(dictish=NoDefault, **updates):
 @export
 def keys():
     """ Return an iterable with all of the keys in the key-value store. """
-    return interface.keys()
+    yield from interface.keys()
 
 @export
 def values():
     """ Return an iterable with all of the values in the key-value store. """
-    return interface.values()
+    yield from interface.values()
 
 @export
 def items():
     """ Return an iterable yielding (key, value) for all items in the key-value store. """
-    return interface.items()
+    yield from interface.items()
 
 # NO DOCS ALLOWED:
 export(interface,           name='interface')

{python-clu-0.8.5 → python_clu-0.10.1}/clu/repl/ansi.py

@@ -25,8 +25,6 @@ from clu.exporting import Exporter
 exporter = Exporter(path=__file__)
 export = exporter.decorator()
 
-# colorama.init()
-
 print_separator = lambda filler='-': print(filler * SEPARATOR_WIDTH)
 
 @export