python-clu 0.11.3__tar.gz → 0.11.5__tar.gz

{python_clu-0.11.3 → python_clu-0.11.5}/.bumpversion.toml

@@ -1,6 +1,6 @@
 
 [tool.bumpversion]
-current_version = "0.11.3"
+current_version = "0.11.5"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{python_clu-0.11.3 → python_clu-0.11.5}/Makefile

@@ -93,8 +93,7 @@ changelog: remove-changelog
 	gitchangelog > CHANGELOG.md
 
 repl:
-	python -m bpython --config=$(PROJECT_ROOT)/.config/bpython/config.py3 \
-			-i $(PROJECT_BASE)/clu/scripts/repl.py
+	python -m bpython --config=$(PROJECT_ROOT)/.config/bpython/config.py3 -i $(PROJECT_BASE)/clu/scripts/repl.py
 
 ipy:
 	python -m IPython --autoindent --pylab --colors=LightBG \

{python_clu-0.11.3 → python_clu-0.11.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-clu
-Version: 0.11.3
+Version: 0.11.5
 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

python_clu-0.11.5/clu/__version__.py

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

{python_clu-0.11.3 → python_clu-0.11.5}/clu/abstract.py

@@ -408,7 +408,7 @@ class ManagedContext(contextlib.AbstractContextManager):
 __all__ = ('Slotted', 'SlotMatch', 'NonSlotted',
            'UnhashableMeta', 'Unhashable',
            'Format', 'NonFormat', 'SlottedFormat', 'Sanitizer',
-           'Cloneable',
+           'Serializable', 'Cloneable',
            'ReprWrapper', 'SlottedRepr', 'MappingViewRepr',
            'evict_announcer',
            'BaseDescriptor', 'DataDescriptor', 'NamedDescriptor',

{python_clu-0.11.3 → python_clu-0.11.5}/clu/constants/data.py

@@ -211,6 +211,66 @@ banners['python3.x'] = """
                                                                              
 """
 
+banners['python3.15'] = """
+                  888    888                         .d8888b.       d888  888888888  
+                  888    888                        d88P  Y88b     d8888  888        
+                  888    888                             .d88P       888  888        
+88888b.  888  888 888888 88888b.   .d88b.  88888b.      8888"        888  8888888b.  
+888 "88b 888  888 888    888 "88b d88""88b 888 "88b      "Y8b.       888       "Y88b 
+888  888 888  888 888    888  888 888  888 888  888 888    888       888         888 
+888 d88P Y88b 888 Y88b.  888  888 Y88..88P 888  888 Y88b  d88P d8b   888  Y88b  d88P 
+88888P"   "Y88888  "Y888 888  888  "Y88P"  888  888  "Y8888P"  Y8P 8888888 "Y8888P"  
+888           888                                                                    
+888      Y8b d88P                                                                    
+888       "Y88P"                                                                     
+
+"""
+
+banners['python3.14'] = """
+                  888    888                         .d8888b.       d888      d8888  
+                  888    888                        d88P  Y88b     d8888     d8P888  
+                  888    888                             .d88P       888    d8P 888  
+88888b.  888  888 888888 88888b.   .d88b.  88888b.      8888"        888   d8P  888  
+888 "88b 888  888 888    888 "88b d88""88b 888 "88b      "Y8b.       888  d88   888  
+888  888 888  888 888    888  888 888  888 888  888 888    888       888  8888888888 
+888 d88P Y88b 888 Y88b.  888  888 Y88..88P 888  888 Y88b  d88P d8b   888        888  
+88888P"   "Y88888  "Y888 888  888  "Y88P"  888  888  "Y8888P"  Y8P 8888888      888  
+888           888                                                                    
+888      Y8b d88P                                                                    
+888       "Y88P"                                                                     
+
+"""
+
+banners['python3.13'] = """
+                  888    888                         .d8888b.       d888   .d8888b.  
+                  888    888                        d88P  Y88b     d8888  d88P  Y88b 
+                  888    888                             .d88P       888       .d88P 
+88888b.  888  888 888888 88888b.   .d88b.  88888b.      8888"        888      8888"  
+888 "88b 888  888 888    888 "88b d88""88b 888 "88b      "Y8b.       888       "Y8b. 
+888  888 888  888 888    888  888 888  888 888  888 888    888       888  888    888 
+888 d88P Y88b 888 Y88b.  888  888 Y88..88P 888  888 Y88b  d88P d8b   888  Y88b  d88P 
+88888P"   "Y88888  "Y888 888  888  "Y88P"  888  888  "Y8888P"  Y8P 8888888 "Y8888P"  
+888           888                                                                    
+888      Y8b d88P                                                                    
+888       "Y88P"                                                                     
+
+"""
+
+banners['python3.12'] = """
+                  888    888                         .d8888b.       d888    .d8888b.  
+                  888    888                        d88P  Y88b     d8888   d88P  Y88b 
+                  888    888                             .d88P       888          888 
+88888b.  888  888 888888 88888b.   .d88b.  88888b.      8888"        888        .d88P 
+888 "88b 888  888 888    888 "88b d88""88b 888 "88b      "Y8b.       888    .od888P"  
+888  888 888  888 888    888  888 888  888 888  888 888    888       888   d88P"      
+888 d88P Y88b 888 Y88b.  888  888 Y88..88P 888  888 Y88b  d88P d8b   888   888"       
+88888P"   "Y88888  "Y888 888  888  "Y88P"  888  888  "Y8888P"  Y8P 8888888 888888888  
+888           888                                                                     
+888      Y8b d88P                                                                     
+888       "Y88P"                                                                      
+
+"""
+
 banners['python3.11'] = """
                   888    888                         .d8888b.       d888    d888   
                   888    888                        d88P  Y88b     d8888   d8888   

{python_clu-0.11.3 → python_clu-0.11.5}/clu/fs/abc.py

@@ -136,12 +136,13 @@ class BaseFSName(collections.abc.Hashable,
             os.path.realpath(
             os.fspath(source or self.name)))
     
-    def parent(self):
+    def parent(self, followlinks=True):
         """ Sugar for `self.directory(os.path.abspath(os.path.dirname(self.name)))`
             …which, if you are curious, gets you the parent directory of the target
             instance, wrapped in a new `Directory` instance.
         """
-        return self.directory(os.path.abspath(os.path.dirname(self.name)))
+        realifier = followlinks and os.path.realpath or os.path.abspath
+        return self.directory(realifier(os.path.dirname(self.name)))
     
     def relparent(self, path):
         """ Relativize a path, relative to its directory parent, and return it

{python_clu-0.11.3 → python_clu-0.11.5}/clu/fs/filesystem.py

@@ -759,11 +759,8 @@ class Directory(BaseFSName,
         yield from os.walk(self.name, followlinks=followlinks)
     
     def walkback(self, followlinks=True):
-        """ Iterator over reverse-walked directories and files.
-            
-            N.B. Since I had to implement this myself, “followlinks”
-            doesn’t do anything yet. This is because I am lazy and
-            I lack intellectual rigor.
+        """ Iterator over reverse-walked directories and files. Use
+            the `followlinks=True` flag to do what you think it does.
             
             The return triple resembles that yielded by “os.walk(…)” –
             but unlike that function, modifying the directory listing
@@ -787,7 +784,7 @@ class Directory(BaseFSName,
                 yield directory, dirs, files
             if directory.name == ROOT_PATH:
                 break
-            directory = directory.parent()
+            directory = directory.parent(followlinks=followlinks)
     
     def flatten(self, destination, suffix=None, new_suffix=None):
         """ Copy the entire directory tree, all contents included, to a new
@@ -937,8 +934,9 @@ class Directory(BaseFSName,
             dirs[:] = list(filter(excluder, dirs))
             filenames = filter(excluder,
                         filter(searcher, files))
-            dotpaths.update(path_to_dotpath(os.path.join(root, filename),
-                                            relative_to=self.name)
+            dotpaths.update(path_to_dotpath(
+                            os.path.join(root, filename),
+                                         relative_to=self.name)
                             for filename in filenames)
         yield from sorted(dotpaths)
     

{python_clu-0.11.3 → python_clu-0.11.5}/clu/predicates.py

@@ -195,17 +195,18 @@ def try_items(itx, *things, default=NoDefault):
 
 # SOME COMMON SHORTCUTS:
 
-dunder_or   = lambda thing, atx: getpyattr(thing, atx, thing)
+dunder_or       = lambda thing, atx: getpyattr(thing, atx, thing)
 
-mro         = lambda thing: getpyattr(typeof(thing), 'mro')
-unwrap      = lambda thing: dunder_or(thing, 'wrapped')
-origin      = lambda thing: typeof(dunder_or(thing, 'origin'))
-rmro        = reverse(mro)
+mro             = lambda thing: getpyattr(typeof(thing), 'mro')
+unwrap          = lambda thing: dunder_or(thing, 'wrapped')
+origin          = lambda thing: typeof(dunder_or(thing, 'origin'))
+rmro            = reverse(mro)
 
-isancestor  = lambda cls, ancestor=object:   ancestor in mro(cls)
-isorigin    = lambda cls, originator=object: isancestor(origin(cls), ancestor=typeof(originator))
+isancestor      = lambda cls, ancestor=object:   ancestor in mro(cls)
+isorigin        = lambda cls, originator=object: isancestor(origin(cls), ancestor=typeof(originator))
 
-ispublic    = lambda string: not ispyname(string) and not ismifflin(string)
+ismarkedprivate = lambda string: string.startswith('_')
+ispublic        = lambda string: not ispyname(string) and not ismifflin(string)
 
 @export
 class Base(object):
@@ -566,6 +567,7 @@ export(unwrap,          name='unwrap',          doc="unwrap(thing) → Return ei
 export(origin,          name='origin',          doc="origin(thing) → Return either `typeof(thing).__origin__` or `typeof(thing)` for a given `thing`")
 export(isancestor,      name='isancestor',      doc="isancestor(thing, ancestor=object) → boolean predicate, True if `ancestor` is found in “mro(thing)”")
 export(isorigin,        name='isorigin',        doc="isorigin(thing, original=object) → boolean predicate, True if `original` is an ancestor of “origin(thing)”")
+export(ismarkedprivate, name='ismarkedprivate', doc="ismarkedprivate(string)) → boolean predicate, True if `string` doesn’t begin with an _underscore")
 export(ispublic,        name='ispublic',        doc="ispublic(string) → boolean predicate, True if `string` is neither in __dunder__ or _sunder_ (née “_mifflin_”) form")
 
 export(predicate_nop,   name='predicate_nop',   doc="predicate_nop(thing) → boolean predicate that always returns `None`")

{python_clu-0.11.3 → python_clu-0.11.5}/clu/repl/modules.py

@@ -7,6 +7,7 @@ import collections.abc
 import clu.abstract
 import clu.dicts
 import clu.all
+import importlib
 import pickle
 import sys
 
@@ -65,7 +66,7 @@ class ModuleMap(collections.abc.Mapping,
         if not isinstance(module, (type(self), types.Module)):
             raise TypeError("module instance required")
         self.module = getattr(module, 'module', module)
-        self.reload()
+        self.reload(reload_module=False)
     
     def __iter__(self):
         yield from self.dir
@@ -97,7 +98,9 @@ class ModuleMap(collections.abc.Mapping,
     def items(self):
         return clu.dicts.OrderedItemsView(self)
     
-    def reload(self):
+    def reload(self, reload_module=True):
+        if reload_module:
+            self.module = importlib.reload(self.module)
         self.dir = tuple(sorted(filter(notpyname, dir(self.module)), key=lowers))
         length = len(self.dir)
         if length < 1:
@@ -117,8 +120,12 @@ class ModuleMap(collections.abc.Mapping,
     def inner_repr(self):
         return repr(dict(self))
 
+clu_importall = clu.all.import_all_modules
+
 @cache
-def compare_module_lookups_for_all_things(*modules, **options):
+def compare_module_lookups_for_all_things(*modules,
+                                           module_function=clu_importall,
+                                         **options):
     """ Iterate through each exported item, for each exported module,
         and look up the original module of the exported item with both:
             
@@ -139,23 +146,24 @@ def compare_module_lookups_for_all_things(*modules, **options):
     appname       = options.get('appname',       consts.APPNAME)
     exporter_name = options.get('exporter_name', consts.EXPORTER_NAME)
     
-    idx = 0
     total = 0
-    mismatch_count = 0
+    item_idx = 0
+    module_idx = 0
+    mismatch_idx = 0
     mismatches = []
     results = []
     
-    clumodules = clu.all.import_all_modules(basepath,
-                                            appname,
-                                            exporter_name)
-    assert clumodules
+    loaded_modules = module_function(basepath, appname, exporter_name)
+    assert loaded_modules
     
     modulenames = tuple(modules or Exporter.modulenames())
     
     for modulename in modulenames:
         exports = Exporter[modulename].exports()
         total += len(exports)
-        results.append(Result(modulename, tuple(exports.keys()), idx))
+        results.append(Result(modulename,
+                        tuple(exports.keys()),
+                        module_idx))
         
         for name, thing in exports.items():
             whichmodule = pickle.whichmodule(thing, None)
@@ -167,17 +175,18 @@ def compare_module_lookups_for_all_things(*modules, **options):
                                            determination,
                                            modulename,
                                            nameof(thing),
-                                           mismatch_count))
-                mismatch_count += 1
-            idx += 1
+                                           mismatch_idx))
+                mismatch_idx += 1
+            item_idx += 1
+        module_idx += 1
     
     # In practice the failure rate seemed to be around 7.65 %
-    failure_rate = 100 * (float(mismatch_count) / float(total))
+    failure_rate = 100 * (float(mismatch_idx) / float(total))
     assert failure_rate < 10.0 # percent
     
-    return Results(idx,  modulenames, tuple(results)), \
-           Mismatches(mismatch_count, tuple(mismatches),
-                                            failure_rate)
+    return Results(item_idx,  modulenames, tuple(results)), \
+           Mismatches(mismatch_idx,        tuple(mismatches),
+                                                 failure_rate)
 
 export(notpyname,                   name='notpyname',       doc="notpyname(string) → boolean predicate, returns True unless string is a __dunder__ name, when it returns False")
 export(isplural,                    name='isplural',        doc="isplural(integer) → returns an 's' unless the integer argument is 1, in which case it returns an empty string")
@@ -196,31 +205,38 @@ def test():
     
     @inline.fixture
     def predicate_modules():
-        modules = ('predicates', 'typology', 'mathematics', 'naming')
+        modules = ('predicates', 'typology', 'mathematics', 'naming',
+                   'exporting', 'extending', 'all', 'enums')
         prefixd = tuple(f"clu.{nm}" for nm in modules)
         return prefixd
     
     @inline
-    def test_one():
+    def test_compare_all():
         """ Basic checks for compare_module_lookups_for_all_things(…) """
         results, mismatches = compare_module_lookups_for_all_things()
         
+        for idx, result in enumerate(results.result_records):
+            assert result.idx == idx
+        
         assert results.total > 100
         assert mismatches.total > 0
         assert mismatches.failure_rate < 10.0
     
     @inline
-    def test_two():
+    def test_compare_all_with_varargs():
         """ With-vararg checks for compare_module_lookups_for_all_things(…) """
         results, mismatches = compare_module_lookups_for_all_things(
                              *predicate_modules())
         
+        for idx, result in enumerate(results.result_records):
+            assert result.idx == idx
+        
         assert results.total > 100
         assert mismatches.total > 0
         assert mismatches.failure_rate < 10.0
     
     @inline
-    def test_three():
+    def test_modulemap_with_clu_consts():
         """ Basic checks for ModuleMap adapter """
         constmap = ModuleMap(consts)
         
@@ -240,8 +256,12 @@ def test():
         # doesn’t export any dunder-named things:
         assert frozenconsts.issuperset(constmap.keys())
         assert frozenconsts.issubset(constmap.keys())
+        
+        # Try reloading:
+        constmap.reload()
+        assert constmap.reload() == len(constmap)
     
-    return inline.test(50)
+    return inline.test(100)
 
 if __name__ == '__main__':
     sys.exit(test())

{python_clu-0.11.3 → python_clu-0.11.5}/clu/scripts/repl.py

@@ -35,23 +35,29 @@ from clu.all import import_clu_modules
 from clu.config.env import Environ
 from clu.constants import consts
 from clu.naming import nameof, qualified_import
-from clu.predicates import ispublic
+from clu.predicates import ispublic, ismarkedprivate, listify
 from clu.repl import columnize
 
+# Set up the __all__ tuple:
+__all__ = list()
+
+# predicate for star-importing:
+ok_for_star_import = lambda name: ispublic(name) and not ismarkedprivate(name)
+
 # MODULE EXPORT FUNCTIONS: given a module name, export
 # either the module or its contents into a given namespace:
-
-def star_export(modulename, namespace):
+def star_export(modulename, namespace, alltuple=__all__):
     """ Safely bind everything a module exports to a namespace. """
     try:
         module = qualified_import(modulename)
     except ValueError:
         module = importlib.import_module(modulename)
     for name in dir(module):
-        if ispublic(name):
+        if ok_for_star_import(name):
             namespace[name] = getattr(module, name)
+            alltuple += listify(name)
 
-def module_export(modulename, namespace):
+def module_export(modulename, namespace, alltuple=__all__):
     """ Safely bind a module to a namespace. """
     try:
         module = qualified_import(modulename)
@@ -59,14 +65,12 @@ def module_export(modulename, namespace):
         module = importlib.import_module(modulename)
     name = nameof(module)
     namespace[modulename] = namespace[name] = module
+    alltuple += listify(name)
 
 # Warm up sys.modules and friends:
-
 import_clu_modules()
 
-# Set up the GLOBAL namespace and the __all__ tuple:
-
-__all__ = tuple()
+# Set up the GLOBALS namespace:
 GLOBALS = globals()
 
 starmods = ('clu.repl.ansi',
@@ -132,20 +136,19 @@ for mod in mods:
 
 # Additionals and corner-cases – imports requiring their own
 # bespoke import-statement forms:
-
 import collections.abc
-from PIL import Image
 from pprint import pprint, pformat
 
 pp = pprint
 ppt = lambda thing: pprint(tuple(thing))
 
 # These two imports trigger module-level __getattr__ actions:
-
 from clu.testing.utils import pout, inline
 
-# Not quite sure where to put this, for now:
+# Append to __all__:
+__all__ += ['pout', 'inline', 'pp', 'ppt']
 
+# Not quite sure where to put this, for now:
 _explain = lambda thing=None: print(columnize(dir(thing),
                                     display_width=consts.SEPARATOR_WIDTH,
                                             ljust=True))
@@ -183,12 +186,13 @@ def explain(thing, width=None):
                   ljust=True))
 
 try:
+    from PIL import Image
     from instakit.utils.static import asset
 except (ImportError, SyntaxError, TypeError): # pragma: no cover
     pass
 else:
     # Extend `__all__`:
-    __all__ += ('asset', 'image_paths', 'catimage')
+    __all__ += ['asset', 'image_paths', 'catimage']
     # Prepare a list of readily open-able image file paths:
     image_paths = list(map(
         lambda image_file: asset.path('img', image_file),
@@ -197,7 +201,7 @@ else:
     catimage = Image.open(image_paths[0])
 
 # Access CLU app environment variables:
-cluenv = Environ(appname='clu')
+cluenv = Environ(appname=consts.APPNAME)
 
 # If you, the user, set up a CLU_USER_SCRIPT environment variable
 # before running this repl script, you can have it executed herein:
@@ -206,17 +210,20 @@ if 'user:script' in cluenv:
     if os.path.exists(user_script_path):
         user_script_globals = runpy.run_path(user_script_path)
         GLOBALS.update(user_script_globals)
+        __all__ += list(filter(ok_for_star_import, user_script_globals.keys()))
     else:
         message = "CLU_USER_SCRIPT needs to point to a Python file"
         warnings.simplefilter('always')
         warnings.warn(stacklevel=2, message=message)
 
-# Remove duplicate and invalid sys.paths:
 
+# Adjust __all__ again:
+__all__ += ['_explain', 'explain', 'cluenv']
+
+# Remove duplicate and invalid sys.paths:
 pypath.remove_invalid_paths()
 
 # Print the Python banner and/or warnings, messages, and other tripe:
-
 if __name__ == '__main__':
     # In theory, this will *not* run when repl.py
     # is loaded into a REPL using a “-i” flag:

{python_clu-0.11.3 → python_clu-0.11.5}/python_clu.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-clu
-Version: 0.11.3
+Version: 0.11.5
 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

{python_clu-0.11.3 → python_clu-0.11.5}/setup.py

@@ -91,7 +91,7 @@ try:
             '__version__.py')).read(),
             '__version__.py', 'exec'))
 except:
-    __version__ = '0.11.3'
+    __version__ = '0.11.5'
 
 # PROJECT DESCRIPTION
 LONG_DESCRIPTION = project_content('ABOUT.md')

python_clu-0.11.3/clu/__version__.py

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