python-clu 0.11.4__tar.gz → 0.11.6__tar.gz

{python_clu-0.11.4 → python_clu-0.11.6}/.bumpversion.toml

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

{python_clu-0.11.4 → python_clu-0.11.6}/CLASSIFIERS.txt

@@ -1,5 +1,4 @@
 Development Status :: 5 - Production/Stable
-License :: OSI Approved :: MIT License
 Framework :: Pytest
 Intended Audience :: Developers
 Topic :: Software Development

{python_clu-0.11.4 → python_clu-0.11.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-clu
-Version: 0.11.4
+Version: 0.11.6
 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
@@ -10,7 +10,6 @@ License: MIT
 Keywords: command utilities clu fish2000 command-line modules predicates REPL tools
 Platform: any
 Classifier: Development Status :: 5 - Production/Stable
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development

python_clu-0.11.6/clu/__version__.py

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

{python_clu-0.11.4 → python_clu-0.11.6}/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.4 → python_clu-0.11.6}/clu/exporting.py

@@ -14,7 +14,7 @@ import importlib
 import inspect
 import itertools
 import shelve
-import sys, os
+import sys, os, re
 import warnings
 import weakref
 
@@ -106,9 +106,9 @@ def search_by_id(thingID):
         `sys.modules.values()` (which is potentially completely
         fucking enormous).
         
-        This function implements `search_for_name(…)` – q.v.
+        This function helps implement `search_for_name(…)` – q.v.
         the calling function code sub., and is also used in the
-        implementation of `determine_module(…)`, - also q.v.
+        implementation of `search_for_module(…)`, - also q.v.
         the calling function code sub.
         
         Caching courtesy the `functools.lru_cache(…)` decorator.
@@ -232,6 +232,9 @@ def determine_name(thing, name=None, try_repr=False):
     # up returning None:
     return search_for_name(thing)
 
+# Regexp for matching dashes in dotpaths:
+dash_re = re.compile("\-")
+
 # N.B. Items in the “replaceable_endings” tuple that
 # possibly contain other such items should appear
 # *before* the items that they contain, e.g.:
@@ -246,14 +249,16 @@ replaceable_endings  = tuple(f"{pre}{suf}" \
                                                   ending_suffixes))
 replaceable_endings += ending_suffixes
 
-def path_to_dotpath(path, relative_to=None):
+def path_to_dotpath(path, relative_to=None,
+                          convert_dashes=True):
     """ Convert a file path (e.g. “/yo/dogg/iheard/youlike.py”)
         to a dotpath (á la “yo.dogg.iheard.youlike”) in what I
         would call a “quick and dirty” fashion.
         
         Issues a BadDotpathWarning if the converted path contains
-        dashes – I don’t quite know what to do about something
-        like that besides warn, so erm. There you go.
+        dashes, and the “convert_datshes” flag is set to False
+        – I don’t quite know what to do about something like that
+        besides warn, so erm. There you go.
     """
     # Garbage in, garbage out:
     if path is None:
@@ -274,11 +279,15 @@ def path_to_dotpath(path, relative_to=None):
     while dotpath.startswith(QUALIFIER):
         dotpath = dotpath[1:]
     
-    # Warn before returning, if the converted path
-    # should contain dashes:
     if '-' in dotpath:
-        warnings.warn(f"Dotpath contains dashes: “{dotpath}”",
-                        BadDotpathWarning, stacklevel=2)
+        if convert_dashes:
+            # Substitute underscores for any dashes found:
+            dotpath = dash_re.subn('_', dotpath)[0]
+        else:
+            # Warn before returning, if the converted path
+            # should contain dashes:
+            warnings.warn(f"Dotpath contains dashes: “{dotpath}”",
+                            BadDotpathWarning, stacklevel=2)
     
     return dotpath
 
@@ -310,11 +319,12 @@ class Registry(abc.ABC, metaclass=clu.abstract.Slotted):
     def __init_subclass__(cls, appname=None, **kwargs):
         if not appname:
             appname = determine_name(cls)
-        if appname in classes:
-            raise TypeError(f"appname already registered: {appname}")
-        appnames.add(appname)
-        classes[appname] = cls
-        super(Registry, cls).__init_subclass__(**kwargs) # type: ignore
+        else:
+            if appname in classes:
+                raise TypeError(f"appname already registered: {appname}")
+            appnames.add(appname)
+            classes[appname] = cls
+        super().__init_subclass__(**kwargs) # type: ignore
         cls.instances = weakref.WeakValueDictionary()
         cls.appname = clu.abstract.ValueDescriptor(appname)
     
@@ -860,7 +870,7 @@ class ExporterBase(collections.abc.MutableMapping,
                                                      'has_appname',
                                                      'for_appname',
                                                      'unregister'),
-                           super(ExporterBase, self).__dir__()))
+                           super().__dir__()))
 
 class Exporter(ExporterBase, basepath=BASEPATH, appname=APPNAME):
     

{python_clu-0.11.4 → python_clu-0.11.6}/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.4 → python_clu-0.11.6}/clu/fs/filesystem.py

@@ -614,12 +614,12 @@ class Directory(BaseFSName,
             setattr(self, 'old', old)
             setattr(self, 'new', old)
             return self
-        setattr(self, 'old', old is not None and old or self.target)
+        setattr(self, 'old', old or self.target)
         setattr(self, 'new', self.target)
         delattr(self, 'target')
         return self
     
-    def ctx_prepare(self):
+    def ctx_prepare(self, old=None):
         """ Prepares the member values of the Directory instance according
             to a requisite `self.target` directory-path value; the primary
             logic performed by this function determines whether or not it
@@ -635,7 +635,8 @@ class Directory(BaseFSName,
             cause invincibly undebuggable behavioral oddities to crop up
             in a variety of circumstances. 
         """
-        self.ctx_set_targets(old=os.getcwd())
+        if not self.prepared:
+            self.ctx_set_targets(old=old or os.getcwd())
         if os.path.isdir(self.new):
             self.will_change = differentfile(self.old, self.new)
         else:
@@ -759,11 +760,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 +785,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 +935,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.4 → python_clu-0.11.6}/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.4 → python_clu-0.11.6}/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.4 → python_clu-0.11.6}/clu/scripts/repl.py

@@ -35,12 +35,15 @@ 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, listify
+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, alltuple=__all__):
@@ -50,7 +53,7 @@ def star_export(modulename, namespace, alltuple=__all__):
     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)
 
@@ -134,7 +137,6 @@ 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
@@ -184,6 +186,7 @@ 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
@@ -207,7 +210,7 @@ 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(ispublic, user_script_globals.keys()))
+        __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')

{python_clu-0.11.4 → python_clu-0.11.6}/python_clu.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-clu
-Version: 0.11.4
+Version: 0.11.6
 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
@@ -10,7 +10,6 @@ License: MIT
 Keywords: command utilities clu fish2000 command-line modules predicates REPL tools
 Platform: any
 Classifier: Development Status :: 5 - Production/Stable
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development

{python_clu-0.11.4 → python_clu-0.11.6}/setup.py

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

python_clu-0.11.4/clu/__version__.py

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