python-clu 0.12.13__tar.gz → 0.12.14__tar.gz

{python_clu-0.12.13 → python_clu-0.12.14}/.bumpversion.toml

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

{python_clu-0.12.13 → python_clu-0.12.14}/CHANGELOG.md

@@ -1,7 +1,187 @@
 # Changelog
 
 
-## 0.12.12:pre12+gf9e1a9f [SNAPSHOT]
+## 0.12.13:pre32+g85452ed [SNAPSHOT]
+
+### Add
+
+* Added stub description of `clu.trie` to `README.md` [Alexander Böhn]
+
+  Just leaving this right here, like for later
+
+* Adding the beginnings of a new `clu.trie` basic library. [Alexander Böhn]
+
+  … seeing where this goes. This is in aid of parsing keymap namespaced
+    keys faster or more betterer, depending, so we will see where this
+    goes. AS ALWAYS, PULLS ARE WELCOME!!!!! 🥰
+
+* Added a link in `README.md` to the new `clu.config.utils` module. [Alexander Böhn]
+
+* Addressing some unexpected issues with KeyMap views and config files. [Alexander Böhn]
+
+  … I mean, the tests run OK………………… butttt………………
+
+### Other
+
+* Ensure the valorous `clu.constants.consts.NoDefault` class looks good. [Alexander Böhn]
+
+  … meaning its class-based and instance-based repr methods return
+    nothing but “NoDefault”, now and forever. There is only a single
+    NoDefault class ever, out there; its only instance is itself.
+
+    *** NoDefault Stands Alone ***
+
+  … Erm, yes. Yes!
+
+* Better living through your functional friends: `filter`, `map`, and `reduce` [Alexander Böhn]
+
+* At long last, `clu.predicates.@itervariadic(…)` passes keyword args. [Alexander Böhn]
+
+  … fucking FINALLY. It did not do this for like ever and, I’ll just
+    tell you, I was totally scared to fuck with it; like maybe I had
+    tried to get it to do kwargs at some point and AT THAT VERY EXACT
+    MOMENT my aunt’s ferret died, which scarred me for life and forged
+    a very inexplicable but nonetheless quite strong mental link in
+    my mind, between passing kwargs in @itervariadic and the death
+    that we all face. Maybe (I have no aunts tho) but something.
+
+* Fixed wrong-function call in `allsimilar(…)`’s unhashable-input branch. [Alexander Böhn]
+
+  … N.B. need to ensure tests cover all lambdas, and both code branches
+    for these; also ensure @itervariadic’s niceties are assuaged
+
+* New `clu.typology` functions for checking an iterable’s contents. [Alexander Böhn]
+
+  … like: “allthesame(iterable)” works with hashable OR non-hashable
+    contents!! HOW DID HE DO THAT??? you ask. Check the code, it was
+    a good time!
+  … similarly “allsimilar(iterable[, xform=casefold]) will basically
+    do when ‘allthesame(…)’ does but after applying some convenience
+    item-transformer function
+  … Both of these use @itervariadic, are documented, and export all
+    their (equally well-documented) constituent lambdas
+
+  Indeed yes!
+
+* Providing a slightly more invariant `__hash__` for frozen keymaps. [Alexander Böhn]
+
+* All-new, all-singing all-dancing recursive ordered expansion!!! [Alexander Böhn]
+
+  … Specifically:
+    • Our verenable and yet lovely “clu.config.abc.FlatOrderedSet”
+      alongside our exotic, experimental “clu.dicts.ChainMapPlusPlus”
+      now have recursive expansion iterator initialization functions!!
+    • WHAT DOES THAT MEAN?!? you ask (nay, demand) to know? Well. Both
+      of those classes each can accept an arbitrary bunch of *things*
+      when initializing their respective instances. Idiomatically, that
+      arbitrary bunch can contain instances of the very class being
+      initialized!
+    • Up until like just now, pretty much, both of those classes would
+      expand such instances in-place and in-order when they came across
+      them during initialization. Sorta. I mean, they kind-of clumsily
+      did like some if/thens and would expand instances, but only one
+      level deep for sure. It was unreliable fragile shit even when it
+      did work – but I loved both these true-CLU containers when they
+      were functional!
+    • But now they are, like totally – they are quickly and recursively
+      each using an “expand(…)” method to both expand and uniquify all
+      things in the list they end up containing. You should read this
+      code because I am proud of it and it is cool. It’s documented,
+      too, so yeah you’re welcome!!
+
+  … of course some other ancillary things were tweaked for this; as of
+    this time, all tests have gone green. So in conclusion: fuck yes.
+
+* Scrapped a few *really* old `clu.config` tests whose meaning is lost. [Alexander Böhn]
+
+  … like they were only testing inoperative legacy shit – the likes
+    of which, while aspirational in its day, is all something I’d
+    enjoy completely forgetting about as soon as is biologically
+    advisable. In essence. Yes!
+
+* Trying to squeeze more speed out of `clu.config.abc.FlatOrderedSet` [Alexander Böhn]
+
+  … I love that class, I’ll have you know – warts and all, I do love
+    that motherfucking thing
+
+* Tweaks in the clu.config.abc.FlatOrderedSet initialization. [Alexander Böhn]
+
+  … basically I love using “filter(¬)” whenever possible
+
+* Such a minor optimization it may just be premature. [Alexander Böhn]
+
+* Minor changes to `clu.config.keymap.FrozenNested::submap(…)` [Alexander Böhn]
+
+  … AGAIN. I know. These are minor, yes, but they clarify things too
+
+* An inline test and a fixture for `clu.tree` [Alexander Böhn]
+
+  … it’s something, OK? Gimme like five minutes, unless your kids are
+    on fire or something of similar urgency. THANK YOU.
+
+* Fixed a few uncaught errors there in `clu.trie.Trie` [Alexander Böhn]
+
+  … time for inline tests here in this new module, ay wot, wot, wot?
+
+* Split the gratuitous `clu.trie.Trie` methods off from the essentials. [Alexander Böhn]
+
+  … maybe this makes things go faster, even with slots, when memory
+    is the thing at issue? I know not. But I am not above doing this,
+    clearly as we can see
+
+* Fixed a few dangling references to `config.utils` [Alexander Böhn]
+
+  Q.v. commit supra.
+
+* An extremely minor clarification. [Alexander Böhn]
+
+  … namely, the first arg for that lambda is always a class instance,
+    not a regular-instance instance, erm. So instead it says “cls”,
+    now, and not “self”, and I consider myself at least clarified
+    (if not edified).
+
+* Renaming `clu.config.utils` to `clu.config.keymaputils` [Alexander Böhn]
+
+  … There are waaaaaaaaay too many “utils.py” modules out there in
+    the world, if you asked me. I’m doing *my* part.
+
+* Fixed another `README.md` glitch. [Alexander Böhn]
+
+  … there was a problematic set of superscript HTML tags that were
+    being literally rendered.
+
+* Dealt with the download link in `README.md` [Alexander Böhn]
+
+  … as in, it will (or at least, *should*) always be current now
+
+* Various and sundry semantic renamings. [Alexander Böhn]
+
+* OK SO. I had to revert some things. [Alexander Böhn]
+
+  … namely I got reaaeeaaaalllll clever with those namespaced-walker
+    keymap view “__iter__(…)” methods – as it turns out, because of
+    all that reeeaaaaaalllll clever shiit I pulled with the submaps
+    being all properly of the right class, oh ho ho, yadda yadda,
+    but that did NOT WORK. Namely iterating a keymap submap can trigger
+    some crazy recursive shit in some cases, e.g. with the “Environ”
+    maps and other such things.
+
+  … soooooo. Until I unfuck this, the rule is “do not iterate submaps
+    within NamespacedWalker views’ ‘__iter__(…)’ methods – in fact,
+    probably don’t fucking iterate them at all in this context, OK?”
+
+  … yeah. OK yeah.
+
+* Simplify, and Exclude. [Alexander Böhn]
+
+* More `clu.config.keymap` nitpicks like simians endlessly grooming. [Alexander Böhn]
+
+* Ooooo I hate turning generators back into stupid returns. [Alexander Böhn]
+
+* Some (no doubt premature) optimizations in `clu.config.keymapview` [Alexander Böhn]
+
+
+## v0.12.13 (2025-06-13)
 
 ### Add
 
@@ -9,6 +189,10 @@
 
 ### Other
 
+* Bumped version: 0.12.12 → 0.12.13. [Alexander Böhn]
+
+* [make] New changelog added. [Alexander Böhn]
+
 * Nixed `clu.dicts.ChainMap.__eq__(…)` for the moment. [Alexander Böhn]
 
   … because I have reason to believe that, at this time, it may suck.

{python_clu-0.12.13 → python_clu-0.12.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-clu
-Version: 0.12.13
+Version: 0.12.14
 Summary: Python-CLU: Common Lightweight Utilities
 Home-page: https://github.com/fish2000/clu
 Download-URL: https://github.com/fish2000/clu/zipball/master
@@ -152,7 +152,8 @@ So do have a look around. Here’s an abridged breakdown of some things within:
     
     … and there are plenty of tools for rolling your own `KeyMap`s in [`clu.config`][clu.config]: the
     [`proxy`][clu.config.proxy] subpackage has a `KeyMap` proxy class, [`ns`][clu.config.ns] has utility functions
-    for manipulating namespace strings, [`keymapview`][clu.config.keymapview] has a class tower for
+    for manipulating namespace strings, [`keymaputils`][clu.config.keymaputils] has more general utility functions (right now
+    the `freeze`/`thaw` functions live there), [`keymapview`][clu.config.keymapview] has a class tower for
     [`KeyMap`][clu.config.keymap] key/value/item views, and [`abc`][clu.config.abc] has, as you’d expect, all
     the abstract base classes upon which our [`KeyMap`s][clu.config.keymap] are built, for your perusal and
     eventual enjoyment.
@@ -252,9 +253,9 @@ So do have a look around. Here’s an abridged breakdown of some things within:
     [`types.ModuleType`][types.ModuleType] is to be found in `typespace.types.Module`, [`types.FunctionType`][types.FunctionType]
     is `typespace.types.Function`, et cetera, ad nauseum, so you can just do `from clu.typespace import types`
     to lose the redundant “Type” naming suffix – which I don’t know about you but that annoys me, I mean we all know
-    that these things are types because they are in the fucking [`types`][types] module and don’t need those overly verbose extra four characters
-    there at the end. ALSO, there are additional useful types, from Python’s standard library and common packages,
-    in the [`types` namespace][clu.typespace.namespace]. YOU’RE WELCOME!!
+    that these things are types because they are in the fucking [`types`][types] module and don’t need those overly
+    verbose extra four characters there at the end. ALSO, there are additional useful types, from Python’s standard
+    library and common packages, in the [`types` namespace][clu.typespace.namespace]. YOU’RE WELCOME!!
 
 * [`enums`][clu.enums]: Furnishes  `alias(…)` – which, spoiler alert, let you create aliases within your enums!
     Oh yes. Like so:
@@ -434,6 +435,13 @@ So do have a look around. Here’s an abridged breakdown of some things within:
 * [`sanitizer`][clu.sanitizer]: functions for cleaning up unicode. Right now there is just a list-based `sanitize(…)`
     function that tones down anything with high-value code points to the point where it can be safely `ascii`-ified. 
 
+* [`trie`][clu.trie]: A relative newcomer, [`clu.trie`][clu.trie] is a toolkit for building trie-search type custom
+    systems for parsing specific things, i.e. error strings, program output… [`clu.config.keymap`][KeyMap keys] maybe,
+    who knows. It’s all shiny and new (meaning: the current contents will fail to blow your mind); if tries and/or other
+    similar tree-search dark arts are, like, your thing: do hit me up with suggestions or samples, or PULL REQUESTS!!
+    How do I love pull requests. I’ll toast your name for life, if you were to send me one good PR. On this or anything
+    else (you’re heartily invited to nitpick my abundantly horrid spelling errors too if you are into that). Yes!
+  
 * [`typology`][clu.typology]: This is like [`clu.predicates`][clu.predicates] but with more predicates, many of which are
     based on typelists. The module is full of typelists and it uses them extensively in its predicates, via `isinstance(…)`,
     `issubclass(…)` and a custom version of same called `subclasscheck(…)` which tries very hard to work with
@@ -445,7 +453,7 @@ So do have a look around. Here’s an abridged breakdown of some things within:
     primitives amongst other things. The (skeletal) [`git_version`][clu.version.git_version] subpackage has a
     couple of [Git-related][git-link] functions, but what you really want is in [`read_version`][clu.version.read_version]
     – therein you’ll find a `read_version_file(…)` function that uses the `ast` module to read one of those
-    `__version__.py` files I know you have lying around. Yes![<sup>†</sup>](#dagger)
+    `__version__.py` files I know you have lying around. Yes[<sup>†</sup>](#dagger)!
 
 * [The `pytest` testsuite][clu-testsuite]: CLU has a full set of [`pytest`][pytest-link]-compatible unit tests.
     In addition to copious module-specific [CLU inline tests][clu.testing], you can run this test suite using
@@ -471,7 +479,7 @@ So do have a look around. Here’s an abridged breakdown of some things within:
 
 <!--- LINKS! LINKS! LINKS! -->
 [pypi-link]: https://pypi.org/project/python-clu/
-[download-link]: https://files.pythonhosted.org/packages/3e/af/4b0dfabe816cee7802cf6981f7f79770c4f05f8df4ac64fc6984789baaaa/python_clu-0.12.3.tar.gz
+[download-link]: https://github.com/fish2000/CLU/archive/refs/heads/master.zip
 [homage-replutilities-link]: https://github.com/fish2000/homage/blob/master/.script-bin/replutilities.py
 [clu-tron-link]: https://tron.fandom.com/wiki/Clu
 
@@ -498,6 +506,7 @@ So do have a look around. Here’s an abridged breakdown of some things within:
 [clu.config.keymapview]: https://github.com/fish2000/CLU/tree/master/clu/config/keymapview.py
 [clu.config.ns]: https://github.com/fish2000/CLU/tree/master/clu/config/ns.py
 [clu.config.proxy]: https://github.com/fish2000/CLU/tree/master/clu/config/proxy.py
+[clu.config.keymaputils]: https://github.com/fish2000/CLU/tree/master/clu/config/keymaputils.py
 
 [clu.constants]: https://github.com/fish2000/CLU/tree/master/clu/constants
 [clu.constants.consts]: https://github.com/fish2000/CLU/tree/master/clu/constants/consts.py
@@ -558,6 +567,7 @@ So do have a look around. Here’s an abridged breakdown of some things within:
 [clu.repr]: https://github.com/fish2000/CLU/tree/master/clu/repr.py
 [clu.sanitizer]: https://github.com/fish2000/CLU/tree/master/clu/sanitizer.py
 [clu.stdio]: https://github.com/fish2000/CLU/tree/master/clu/stdio.py
+[clu.trie]: https://github.com/fish2000/CLU/tree/master/clu/trie.py
 [clu.typology]: https://github.com/fish2000/CLU/tree/master/clu/typology.py
 
 [instakit]: https://github.com/fish2000/instakit

{python_clu-0.12.13 → python_clu-0.12.14}/README.md

@@ -82,7 +82,8 @@ So do have a look around. Here’s an abridged breakdown of some things within:
     
     … and there are plenty of tools for rolling your own `KeyMap`s in [`clu.config`][clu.config]: the
     [`proxy`][clu.config.proxy] subpackage has a `KeyMap` proxy class, [`ns`][clu.config.ns] has utility functions
-    for manipulating namespace strings, [`keymapview`][clu.config.keymapview] has a class tower for
+    for manipulating namespace strings, [`keymaputils`][clu.config.keymaputils] has more general utility functions (right now
+    the `freeze`/`thaw` functions live there), [`keymapview`][clu.config.keymapview] has a class tower for
     [`KeyMap`][clu.config.keymap] key/value/item views, and [`abc`][clu.config.abc] has, as you’d expect, all
     the abstract base classes upon which our [`KeyMap`s][clu.config.keymap] are built, for your perusal and
     eventual enjoyment.
@@ -182,9 +183,9 @@ So do have a look around. Here’s an abridged breakdown of some things within:
     [`types.ModuleType`][types.ModuleType] is to be found in `typespace.types.Module`, [`types.FunctionType`][types.FunctionType]
     is `typespace.types.Function`, et cetera, ad nauseum, so you can just do `from clu.typespace import types`
     to lose the redundant “Type” naming suffix – which I don’t know about you but that annoys me, I mean we all know
-    that these things are types because they are in the fucking [`types`][types] module and don’t need those overly verbose extra four characters
-    there at the end. ALSO, there are additional useful types, from Python’s standard library and common packages,
-    in the [`types` namespace][clu.typespace.namespace]. YOU’RE WELCOME!!
+    that these things are types because they are in the fucking [`types`][types] module and don’t need those overly
+    verbose extra four characters there at the end. ALSO, there are additional useful types, from Python’s standard
+    library and common packages, in the [`types` namespace][clu.typespace.namespace]. YOU’RE WELCOME!!
 
 * [`enums`][clu.enums]: Furnishes  `alias(…)` – which, spoiler alert, let you create aliases within your enums!
     Oh yes. Like so:
@@ -364,6 +365,13 @@ So do have a look around. Here’s an abridged breakdown of some things within:
 * [`sanitizer`][clu.sanitizer]: functions for cleaning up unicode. Right now there is just a list-based `sanitize(…)`
     function that tones down anything with high-value code points to the point where it can be safely `ascii`-ified. 
 
+* [`trie`][clu.trie]: A relative newcomer, [`clu.trie`][clu.trie] is a toolkit for building trie-search type custom
+    systems for parsing specific things, i.e. error strings, program output… [`clu.config.keymap`][KeyMap keys] maybe,
+    who knows. It’s all shiny and new (meaning: the current contents will fail to blow your mind); if tries and/or other
+    similar tree-search dark arts are, like, your thing: do hit me up with suggestions or samples, or PULL REQUESTS!!
+    How do I love pull requests. I’ll toast your name for life, if you were to send me one good PR. On this or anything
+    else (you’re heartily invited to nitpick my abundantly horrid spelling errors too if you are into that). Yes!
+  
 * [`typology`][clu.typology]: This is like [`clu.predicates`][clu.predicates] but with more predicates, many of which are
     based on typelists. The module is full of typelists and it uses them extensively in its predicates, via `isinstance(…)`,
     `issubclass(…)` and a custom version of same called `subclasscheck(…)` which tries very hard to work with
@@ -375,7 +383,7 @@ So do have a look around. Here’s an abridged breakdown of some things within:
     primitives amongst other things. The (skeletal) [`git_version`][clu.version.git_version] subpackage has a
     couple of [Git-related][git-link] functions, but what you really want is in [`read_version`][clu.version.read_version]
     – therein you’ll find a `read_version_file(…)` function that uses the `ast` module to read one of those
-    `__version__.py` files I know you have lying around. Yes![<sup>†</sup>](#dagger)
+    `__version__.py` files I know you have lying around. Yes[<sup>†</sup>](#dagger)!
 
 * [The `pytest` testsuite][clu-testsuite]: CLU has a full set of [`pytest`][pytest-link]-compatible unit tests.
     In addition to copious module-specific [CLU inline tests][clu.testing], you can run this test suite using
@@ -401,7 +409,7 @@ So do have a look around. Here’s an abridged breakdown of some things within:
 
 <!--- LINKS! LINKS! LINKS! -->
 [pypi-link]: https://pypi.org/project/python-clu/
-[download-link]: https://files.pythonhosted.org/packages/3e/af/4b0dfabe816cee7802cf6981f7f79770c4f05f8df4ac64fc6984789baaaa/python_clu-0.12.3.tar.gz
+[download-link]: https://github.com/fish2000/CLU/archive/refs/heads/master.zip
 [homage-replutilities-link]: https://github.com/fish2000/homage/blob/master/.script-bin/replutilities.py
 [clu-tron-link]: https://tron.fandom.com/wiki/Clu
 
@@ -428,6 +436,7 @@ So do have a look around. Here’s an abridged breakdown of some things within:
 [clu.config.keymapview]: https://github.com/fish2000/CLU/tree/master/clu/config/keymapview.py
 [clu.config.ns]: https://github.com/fish2000/CLU/tree/master/clu/config/ns.py
 [clu.config.proxy]: https://github.com/fish2000/CLU/tree/master/clu/config/proxy.py
+[clu.config.keymaputils]: https://github.com/fish2000/CLU/tree/master/clu/config/keymaputils.py
 
 [clu.constants]: https://github.com/fish2000/CLU/tree/master/clu/constants
 [clu.constants.consts]: https://github.com/fish2000/CLU/tree/master/clu/constants/consts.py
@@ -488,6 +497,7 @@ So do have a look around. Here’s an abridged breakdown of some things within:
 [clu.repr]: https://github.com/fish2000/CLU/tree/master/clu/repr.py
 [clu.sanitizer]: https://github.com/fish2000/CLU/tree/master/clu/sanitizer.py
 [clu.stdio]: https://github.com/fish2000/CLU/tree/master/clu/stdio.py
+[clu.trie]: https://github.com/fish2000/CLU/tree/master/clu/trie.py
 [clu.typology]: https://github.com/fish2000/CLU/tree/master/clu/typology.py
 
 [instakit]: https://github.com/fish2000/instakit
@@ -504,4 +514,4 @@ So do have a look around. Here’s an abridged breakdown of some things within:
 [types.FunctionType]: https://docs.python.org/3/library/types.html#types.FunctionType
 [types.SimpleNamespace]: https://docs.python.org/3/library/types.html#additional-utility-classes-and-functions
 [zipfile]: https://docs.python.org/3/library/zipfile.html
-[dicts]: https://docs.python.org/3/tutorial/datastructures.html#dictionaries
+[dicts]: https://docs.python.org/3/tutorial/datastructures.html#dictionaries

python_clu-0.12.14/clu/__version__.py

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

{python_clu-0.12.13 → python_clu-0.12.14}/clu/config/abc.py

@@ -15,7 +15,7 @@ from clu.config.ns import unpack_ns, pack_ns, get_ns, compare_ns
 from clu.config.keymapview import KeyMapKeysView, KeyMapItemsView, KeyMapValuesView
 from clu.config.keymapview import NamespaceWalkerKeysView, NamespaceWalkerItemsView
 from clu.config.keymapview import NamespaceWalkerValuesView
-from clu.config.utils import freeze_class
+from clu.config.keymaputils import freeze_class
 
 from clu.naming import qualified_import, qualified_name, nameof
 from clu.predicates import (typeof,
@@ -202,7 +202,7 @@ class FrozenKeyMap(FrozenKeyMapBase):
         return KeyMapValuesView(self, *namespaces)
     
     def __hash__(self):
-        return hash(tuple(self.values()))
+        return hash(tuple(self.keys())) ^ len(self)
     
     def _get_namespace_foset(self):
         return FlatOrderedSet(get_ns(nskey) for nskey in sorted(self) if NAMESPACE_SEP in nskey)
@@ -415,17 +415,17 @@ class NamespaceWalker(FrozenKeyMap):
     
     def __contains__(self, nskey):
         key, fragments = unpack_ns(nskey)
-        for *ns, k, value in self.walk():
+        for *frags, k, value in self.walk():
             if k == key:
-                if compare_ns(ns, fragments):
+                if compare_ns(frags, fragments):
                     return True
         return False
     
     def __getitem__(self, nskey):
         key, fragments = unpack_ns(nskey)
-        for *ns, k, value in self.walk():
+        for *frags, k, value in self.walk():
             if k == key:
-                if compare_ns(ns, fragments):
+                if compare_ns(frags, fragments):
                     return value
         raise KeyError(nskey)
 
@@ -481,35 +481,64 @@ class FlatOrderedSet(collections.abc.Set,
     
     @classmethod
     def is_a(cls, instance):
+        """ Check to see if a thing – an instance, whatever – is, like,
+            close enough to what “this class” is to be a viable enough
+            thing that way. Erm. Like it can be a FlatOrderedSet or whatever
+            for our purposes (which is, while initialization, just something
+            that is ordered and may or may not have other FlatOrderedSets
+            all up inside it). That probably doesn’t help. I’ll rewrite
+            this docstring and rename the function later, yes.
+        """
         return isinstance(instance, (cls, FlatOrderedSet)) or \
                isinstance(getattr(instance, 'things', None),
                                   collections.abc.Iterable)
     
+    @classmethod
+    def expand(cls, *things, seen=None, predicate=always):
+        """ Go through a list-like containerful of things, and if any of
+            those is a container just like we are, expand it in place –
+            recursively, of course, so everything can be nested as fuck
+            for all we care (q.v. “FlatOrderedSet::is_a(…)” doc supra).
+            
+        """
+        # Set up a set of everything “seen”, which we pass forward
+        # into recursive calls:
+        thingseen = seen or set()
+        
+        # Step through the non-None things we were given, preserving
+        # their order:
+        for thing in filter(None, things):
+            if cls.is_a(thing):
+                # Are they “us”? If so, recursively expand them:
+                yield from cls.expand(*thing, seen=thingseen, predicate=predicate)
+            
+            elif predicate(thing):
+                # If they are not us, does our predicate test OK
+                # against, ah, “them”? If it does, add them to the
+                # seen-set and yield them out:
+                if thing not in thingseen:
+                    thingseen.add(thing)
+                    yield thing
+    
     def __init__(self, *things, predicate=always):
         """ Initialize a new FlatOrderedSet instance with zero or more things.
             
             Optionally, a unary boolean function “predicate” may be specified
             to filter the list of things.
         """
+        # Make sure the predicate is not garbage:
         if uncallable(predicate):
             raise ValueError("FlatOrderedSet requires a callable predicate")
-        thinglist = []
+        
+        # Budget knock-off of the logic from “clu.predicates.itervariadic”:
         if len(things) == 1:
             if isexpandable(things[0]):
                 things = things[0]
             elif iscontainer(things[0]) and not ismapping(things[0]):
                 things = tuple(things[0])
-        for thing in things:
-            if thing is not None:
-                if type(self).is_a(thing):
-                    for other in thing.things:
-                        if predicate(other):
-                            if other not in thinglist:
-                                thinglist.append(other)
-                elif predicate(thing):
-                    if thing not in thinglist:
-                        thinglist.append(thing)
-        self.things = tuple(thinglist)
+        
+        # Install a flat, uniquified version of what we were passed
+        self.things = tuple(self.expand(*things, predicate=predicate))
         self.predicate = predicate
     
     def __iter__(self):
@@ -535,6 +564,9 @@ class FlatOrderedSet(collections.abc.Set,
     def __bool__(self):
         return len(self.things) > 0
     
+    def _hash(self):
+        return hash(self.things)
+    
     def __hash__(self):
         return self._hash()
     
@@ -594,7 +626,7 @@ class FlatOrderedSet(collections.abc.Set,
     
     def to_dict(self):
         """ Used by `clu.config.codecs` to serialize FlatOrderedSets """
-        return { 'things'    : self.things,
+        return { 'things'    : copy.copy(self.things),
                  'predicate' : qualified_name(self.predicate) }
     
 

{python_clu-0.12.13 → python_clu-0.12.14}/clu/config/formats/tomlfile.py

@@ -68,6 +68,9 @@ class TomlFile(TomlFileBase, appname=toml_appname,
     """
     pass
 
+# FrozenTomlFile = TomlFile
+# export(FrozenTomlFile,  name='FrozenTomlFile',  doc="Equivalent to “clu.config.formats.TomlFile”")
+
 # Assign the modules’ `__all__` and `__dir__` using the exporter:
 __all__, __dir__ = exporter.all_and_dir()
 

{python_clu-0.12.13 → python_clu-0.12.14}/clu/config/keymap.py

@@ -1,20 +1,17 @@
 # -*- coding: utf-8 -*-
 from __future__ import print_function
-from functools import lru_cache
 
 import clu.abstract
 import copy
 import sys, re
 
 from clu.config import abc, ns
-from clu.config.utils import thaw_name, thaw_class, freeze_name, freeze_class
+from clu.config.keymaputils import thaw_name, thaw_class, freeze_name, freeze_class
 from clu.constants import consts
 from clu.predicates import tuplize, typeof
 from clu.typology import ismapping
 from clu.exporting import Exporter, sysmods, itermodule
 
-cache = lambda function: lru_cache(maxsize=16, typed=False)(function)
-
 exporter = Exporter(path=__file__)
 export = exporter.decorator()
 
@@ -196,13 +193,14 @@ class FrozenNested(abc.NamespaceWalker, clu.abstract.ReprWrapper,
     def thaw(self):
         return thaw_class(type(self))(tree=copy.deepcopy(self.tree))
     
-    def submap(self, *namespaces, unprefixed=False):
+    def submap(self, *namespaces, unprefixed=False, cls=False):
         """ Return a flattened mapping, if possible a mutable one,
             containing only items with keys matching the specified
             namespaces (as namespaced:key:paths).
         """
         # We’ll need this later:
-        cls = freeze_class(type(self))
+        if not cls:
+            cls = freeze_class(type(self))
         
         # Short-circuit for returning unprefixed top-level items:
         if unprefixed:
@@ -212,14 +210,14 @@ class FrozenNested(abc.NamespaceWalker, clu.abstract.ReprWrapper,
         # If it’s not unprefixed, and we have no namespaces,
         # we cough up a new instance with our data:
         if not namespaces:
-            return cls(self)
+            return cls(self.tree)
         
         # Our namespaces, their output data:
-        ours = tuple(self.namespaces())
-        theirs = dict()
+        ours = frozenset(self._get_namespace_foset().things)
+        theirs = {}
         
-        # Go through the namespaces we were given, and copy anything
-        # we have that matches those namespaces into a new output dict,
+        # Go through the namespaces we were passed, and copy anything
+        # we have that matches those namespaces into a new output dict –
         # wholesale and sans any namespaced-key prefixes:
         for namespace in namespaces:
             if namespace not in ours:
@@ -227,11 +225,11 @@ class FrozenNested(abc.NamespaceWalker, clu.abstract.ReprWrapper,
             d = self.tree
             for fragment in ns.split_ns(namespace):
                 d = d[fragment]
-            theirs.update({ namespace : d })
+            theirs[namespace] = d
         
         # Return a (possibly frozen) instance containing the specified
         # namespaced data, as a namespaced instance:
-        return cls(**theirs)
+        return cls(theirs)
     
     def inner_repr(self):
         return repr(self.tree)
@@ -374,16 +372,17 @@ def flatdict():
     """ Flat-dictionary fixture function """
     out = {}
     for mappingpath in mapwalk(nestedmaps()):
-        *namespaces, key, value = mappingpath
-        nskey = ns.pack_ns(key, *namespaces)
+        *fragments, key, value = mappingpath
+        nskey = ns.pack_ns(key, *fragments)
         out[nskey] = value
     return out
 
 @inline.fixture
-def frozenclasses(check=True):
+def frozenclasses():
     """ Scan `sys.modules` for “frozen”-looking types """
     from clu.naming import qualified_name
     seen = set()
+    out = list()
     for module in sysmods():
         for key, value in itermodule(module):
             if key.startswith("rozen", 1):
@@ -392,13 +391,16 @@ def frozenclasses(check=True):
                     modname = qualified_name(module)
                     if modname == '__main__':
                         modname = exporter.dotpath
-                    yield (key, value, modname, thaw_name(key))
+                    out.append((key, value, modname, thaw_name(key)))
+    return tuple(out)
 
 @inline.fixture
 def frozenclassnames():
     """ Same as the `frozenclasses()` fixture but with just the names """
-    for quadruple in tuple(frozenclasses(check=True)):
-        yield (quadruple[0], quadruple[2], quadruple[3])
+    out = list()
+    for quadruple in frozenclasses():
+        out.append((quadruple[0], quadruple[2], quadruple[3]))
+    return tuple(out)
 
 @inline.fixture
 def arbitrary():
@@ -600,4 +602,4 @@ def test():
     return inline.test(100)
 
 if __name__ == '__main__':
-    sys.exit(test())
+    sys.exit(test())

python_clu-0.12.13/clu/config/utils.py → python_clu-0.12.14/clu/config/keymaputils.py

@@ -83,7 +83,7 @@ def thaw_name(name):
 @cache
 def freeze_name(name):
     """ Private function, to cache “frozen” class names """
-    if name.startswith("rozen", 1):
+    if name.startswith("rozen", 1) or name.endswith('File'):
         return name
     if name.islower():
         return f"frozen{name}"