CHANGELOG.md

Changelog

0.5.6-8+g4f32aa7 [SNAPSHOT]

Add

• Added “fast” ‘flatten(¬)’ implementation, about 400% speedier – ... good but not stellar. [Alexander Böhn]

Other

• Parity-check ‘twixt “clu.dicts.ChainMap” and “collections.ChainMap” ... surprisingly, without any extracurricular coaxing on my part, “eq(…)” works butter-smooth between both types, as does constructing a CLU ChainMap from a standard-library instance (although the opposite path remains unhiked for now, gah) [Alexander Böhn]

• OK this really isn’t bad, for a quick ‘n’ dirty bespoke-repr jalopy ... It needs it some special-casin’ kinda love but hey, it looks reasonably legible and non-shitty pretty much right out of the gates. What gates? The gates, I dunno. It was behind some gates and now those gates are open, dogg, I have no idea actually OK? OK anyway. [Alexander Böhn]

• Plugged in the faster “clu.dicts.merge*()” functions as warranted. [Alexander Böhn]

• Got rid of all the ineffective method reimplementations. [Alexander Böhn]

• Appears the “try_items(…)” predicate handily beats “item_search(…)” ... THE MORE YOU KNOW™ [Alexander Böhn]

• Tried a different “len()” implementation: it’s exactly the same ... speedwise at least. It’s more explicit, but also uglier (if you were to ask me, which you most certainly did not, but hey – c’est la guerre, no?) [Alexander Böhn]

• Made the inline testsuite for “clu.dicts” into a real actual thing ... and the verdict is, “clu.dicts.ChainMap.flatten()” is horribly inefficient but everything else is totally rad doggie. [Alexander Böhn]

v0.5.6 (2019-12-27)

Add

• Added weakref types to the typespace, and SimpleNamespace inline tests. [Alexander Böhn]

• Added the fixture-cache-stats diagnostic to “clu.config.defg” [Alexander Böhn]

• Added a diagnostic to print a report on the fixture cache stats. [Alexander Böhn]

• Added metafunction capabilities to “clu.testing.utils.InlineTester” [Alexander Böhn]

• Added unit tests for the boilerplate generation command. [Alexander Böhn]

Minutiae

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.5.5 → 0.5.6. [Alexander Böhn]

• Spicing up the bpython REPL with more datastructure samples ... pre-made and ready-to-eat!! [Alexander Böhn]

• Miniscule change in “clu.exporting” allows method docstring mutation ... !!! ... also, there are a bunch of docstring mutations in the namespace module ... aaaaaand the removal of that wack and horrible hacked-up “isnamespace(…)” predicate from “clu.predicates” – there is a real, non-hacky version in “clu.typespace.namespace” from here on out, ok? OK!! [Alexander Böhn]

• Docstring edits in “clu.importing” [Alexander Böhn]

• Dropped gratuitous “list(…)” from “Directory.importables(…)” innards. [Alexander Böhn]

• Changelog requirements include install requirements. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Fixed SimpleNamespace.dir(…)” and “SimpleNamespace.repr(…)” ... wbich were apparently broken?… WHOOOOOPS. [Alexander Böhn]

• Clarified the in-use syntax of our intermediate dataclass decorator. [Alexander Böhn]

• ModuleSpec instances are no longer considered packages by default. [Alexander Böhn]

• Fixing the report-format sizing… YET ONCE AGAIN. [Alexander Böhn]

• Gratuitous further simplification. [Alexander Böhn]

• Using the “clu.testing.utils.InlineTester” fixture dictionary ... instead of hardcoding, fuck yeah dogg. [Alexander Böhn]

• Slight performance gain made via pass-through-ing of some methods ... specifically the “keys(…)”, “items(…)” and “values(…)” methods; this is likely due to those having fallen back to the default implementations prior to the explicit pass-through, which meant that “clu.config.defg.Nested” proxies were using the classes for key/items/values views that did not take advantage of any of the “NamespaceWalker” machinery. [Alexander Böhn]

• Changed the internal weakref field name from “keymap” to “referent” ... which the former was both weirdly syntactically repetetive and amiguously confusing; the latter says what it actually is and isn’t the name of any other things already in use in general. [Alexander Böhn]

• Got rid of reasonable-looking but completely stupid clone() impl ... which would have created a weakref to a temporary, essentially ... UGH. [Alexander Böhn]

• Fixed generated docstrings on returned test functions ... FYI, docstrings with format components are, like, undefined behavior it looks like…?! [Alexander Böhn]

• Docstrings ‘n’ notes for the proxy-related inline metafunctions. [Alexander Böhn]

• Slightly less class-level clutter. [Alexander Böhn]

• Actually using the class method I just added. [Alexander Böhn]

• Truly a miniscule rearrangement of things. [Alexander Böhn]

• Many more inline tests for “clu.config.proxy” types. [Alexander Böhn]

• Made the “ExporterBase” use its instance registry as a cache ... so, like, “ExporterBase.new(…)” returns existing instances for dotpaths matching the invocation arguments. [Alexander Böhn]

• Minute updates to the bpython REPL script. [Alexander Böhn]

• I can’t believe I forgot to inherit Proxy from View, uggggh. [Alexander Böhn]

• Reverted the use of newer “KeyMap” classes in “FileBase” ancestors ... this was causing base-class layout conflicts when “weakref” slot members were added to the abstract bases at the root of the KeyMap class tower. I left the KeyMap imports in, commented out – when I get rid of all the old namespaced-mapping shit in favor of the all-new hottness this will be such a non-issue you will forget having even read this commit note, doggie, yeah. [Alexander Böhn]

• Moved “weakref” slot declaration down to “FrozenKeyMapBase” [Alexander Böhn]

• Initial inline tests for “KeyMapView” and “KeyMapProxy” [Alexander Böhn]

• You know, sometimes, resource allocation is initialization. [Alexander Böhn]

• Minor cleanup in “clu.testing.utils” [Alexander Böhn]

• Minor renames in “clu.testing.utils” [Alexander Böhn]

• Killed dead code. [Alexander Böhn]

• I ❤️ fstrings. [Alexander Böhn]

• Updated the “clu.testing.utils.InlineTester” docstring ... now the code sample illustrates returning POSIX status values. [Alexander Böhn]

• Changelog and git-ignore tweaks. [Alexander Böhn]

v0.5.5 (2019-12-24)

Other

• Bump version: 0.5.4 → 0.5.5. [Alexander Böhn]

• Integrating “gitchangelog” and taking it for a trial run. [Alexander Böhn]

• A fine Commit #1,000 as any: preservation of namespace insert-order ... happy order-of-magnitude-aversary, my dear CLU, and salud! [Alexander Böhn]

• Inline tests return POSIX exit status values and call “sys.exit(…)” ... also there is a command that copies the CLU boilerplate starter code right to YOUR CLIPBOARD!!!! Huzzah. [Alexander Böhn]

• First draft of “KeyMapView” and “KeyMapProxy” ... which those are ‘FrozenKeyMap’ and ‘KeyMap’ types, respectively, that wrap weakrefs to actual KeyMap instances and forward method calls to those instances down from the public API. ... includes a decorator “@selfcheck” that tests the Truthiness of the ‘self’ instance before the actual method invocation and raises a ‘ValueError’ for any and all unworthy instance values. ... tests and all that other hoohah to follow, after I veg out with the cats and some kombucha and watch me some YouTube. [Alexander Böhn]

• Generators beat constructed lists. [Alexander Böhn]

v0.5.4 (2019-12-24)

Add

• Added a “shortrepr(…)” method to show namespace info, sans newlines ... also added the “show-consts.py” and “show-modules.py” script invocations to the Makefile. [Alexander Böhn]

• Added a “clu.importing.PerApp.appspaces()” convenience function ... does precisely what you think it does. [Alexander Böhn]

• Added inline test for “clu.importing.ProxyModule” fallbacks. [Alexander Böhn]

• Addressing automated GitHub security alert. [Alexander Böhn]

Minutiae

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.5.3 → 0.5.4. [Alexander Böhn]

• How many commits are just, however circuitously, pushing whitespace? [Alexander Böhn]

• Inline fixture is inline-fixture’d. [Alexander Böhn]

• Trying to figure out if inline-testing instance methods is worth it. [Alexander Böhn]

• Fold my case. [Alexander Böhn]

• Using str.casefold() instead of str.lower() for comparison. [Alexander Böhn]

• Fixed a few assertions. [Alexander Böhn]

• Cleaned up the “clu.importing” inline testsuite a bit. [Alexander Böhn]

• Environment-var diagnostic printout function and fixture decorator ... among other additions to “clu.testing.utils.InlineTester” ... fixtures are memoized with “functools.lru_cache(…)” and stored in a dict in the “@inline” instance; maybe I will add automatic cache-warming as a precheck function, and/or a report on cache usage as a diagnostic… WHO KNOWS REALLY. [Alexander Böhn]

• Inline test harness support for preflight and diagnostic functions ... So, like, you can decorate things like so: [Alexander Böhn]

  @inline.precheck def preflight_function(): # …

  @inline.diagnostic
  def post_execution_function():
  	# …
  

  ... Functions decorated per the former will each run exactly once, before the main test run; those decorated as per the latter will each run exactly once, after the main test run. ... There are examples of these in a bunch of my inline test suites for you to peruse ... There was some internal abstraction and consolidation that happened in “clu.testing.utils.InlineTester” to support all of this – all good and fairly legible changes, I should say; the new things have docstrings and stuff. Yes!

• Computing lambda qualified name in lambda-repr test. [Alexander Böhn]

• Cleaned up some testing stuff, both inline and out. [Alexander Böhn]

• Proper index-labeling and ordering for inline test functions. [Alexander Böhn]

• Using the “flatdict()” fixture-ish function in KeyMap inline tests ... also killed some dead code in “clu.testing.utils” [Alexander Böhn]

• WTF HAX. [Alexander Böhn]

• Fixed a regression with hacky “isnamespace(…)” from “clu.predicates” [Alexander Böhn]

• Explicit > Implicit. [Alexander Böhn]

• Don’t trigger “missing(…)” during “ChainModuleMap” item access. [Alexander Böhn]

• Even more repr-related refactors. [Alexander Böhn]

• Miscellaneous repr-related tweaks and updates. [Alexander Böhn]

• I just worked really really hard… on fixing “Namespace.repr(…)” ... I mean “SimpleNamespace” had this copypasta from SO, and the ancestor “Namespace” used this super-janky thing that, like, called “pprint.pformat(…)” on the instance ‘dict’ and then opaquely regexed the results of that for some reason – ... sooooo I switched them to use “clu.abstract.ReprWrapper” and everything started exploding with outlandish infinite-recursion error supernovae; ... so I started playing around with “reprlib” – ... I first tried applying “@recursive_repr(…)” to “ReprWrapper” methods, which didn’t really help – ... I did a lot of fucking around and to make a long story short, there is now a “reprlib.Repr” subclass with recursion-friendly methods sitting in “clu.typespace.namespace” – ... There was way more recursion than just that tho: I battled recursive imports, recursive stringification, recursive fuckall and who the fuck knows… all really my own sloppy fault, I mean I haven’t updated “clu.typespace” in millenia, it feels like ... and THEN at the end of it all, when things worked, I spent even MORE time tweaking the stupid string-formatting for like an hour, making it JUUUUUUST RIIIIIIGHT ... blech! Fuck yes. [Alexander Böhn]

• Oh yeah… explicit is soooo much better than implicit – and thus. [Alexander Böhn]

• ¡IMPLICIT RECURSIVE NAMESPACES! [Alexander Böhn]

• Futzed with inline-test names, naming, and name-display. [Alexander Böhn]

• “clu.importing.PolymerType.add_module(…)” checks existing appspaces ... raises a ‘NameError’ should you attempt to add a module with an appspace that already exists. [Alexander Böhn]

• Allowing “clu.importing.ProxyModule” to target other ProxyModules ... when a ProxyModule is encountered while processing the list of targets, its existing contents are extracted, flattened out, and merged into the governing proxy’s internal ChainModuleMap. [Alexander Böhn]

• Extremely minor test docstring tweak. [Alexander Böhn]

• Docstring updates for “ProxyModule” and “ChainModuleMap” ... the callable/‘missing(…)’ stuff has had the shit documented out of it. [Alexander Böhn]

• “clu.importing.ProxyModule” knows about module ‘getattr(…)’ ... and “MappingType.missing(…)” too, and callables in general. [Alexander Böhn]

v0.5.3 (2019-12-17)

Add

• Additional sanity-check in “Environ.exit(…)” [Alexander Böhn]

• Added wildcard «‽» to the semantic-version regex “build” field. [Alexander Böhn]

• Additional testing to ensure that “FrozenEnv” is frozen. [Alexander Böhn]

• Added API to directly access the backing environment dictionary. [Alexander Böhn]

• Added proper error-handling when calling Git commands. [Alexander Böhn]

• Added “version” make target. [Alexander Böhn]

Other

• Bump version: 0.5.2 → 0.5.3. [Alexander Böhn]

• Ensuring no duplication occurs when initializing ProxyModules ... also, it seems I misunderstood the use of the “module” param accepted by “collections.namedtuple”… erm. [Alexander Böhn]

• As much as I appreciate this inadvertant neologism my OCD disallows it. [Alexander Böhn]

• Tailored non-logorrheic type-reprs for class-modules and friends ... also added a whole shitton of exemplary docstrings and assorted programmer notes ... and tweaked the exception-handling messaging in “ProxyModule”’s ‘getattr(¬)’ logic ... and added the first new beginning of a “clu.application” module (which right now is just copypasta from “clu.importing” that’ll get deleted in short order – but it’s something, which you will not is not nothing, is it not not?? [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• “typing.Mapping[…]” is more general than “typing.Dict[…]” [Alexander Böhn]

• Reordered the dataclass & the mapping, reflecting definition order. [Alexander Böhn]

• Shortcutting the @dataclass decorator in the name of legibility. [Alexander Böhn]

• Deduplicated the efforts between “initialize_{new_types,module}(…)” [Alexander Böhn]

• Fixed it! [Alexander Böhn]

• Go by the name you’ve been given, not just the one you’re called. [Alexander Böhn]

• Trimmed dead code. [Alexander Böhn]

• I should have done this a loooong time ago – ... that is to say: added a per-appname class registry for all the Finders, Loaders, individually-appspace’d Module subtypes… all that shit in “clu.importing” basically. [Alexander Böhn]

• Storing the app-named “Loader” class in its companion “Finder” [Alexander Böhn]

• Extremely minor/subtle logic nitpick in “Environ.exit(…)” [Alexander Böhn]

• Compensated for Falsey argument behavior. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Reverting unnecessary confusing complexification. [Alexander Böhn]

• WHOOOOOPS. [Alexander Böhn]

• Allow non-None but Falsey “environment” args in Nested’s constructor. [Alexander Böhn]

• Split inline testing data into two ‘pseudo-fixture’ functions. [Alexander Böhn]

• Narrowing the scope of the semantic-version regex. [Alexander Böhn]

• Git version inline tests now check Git output against CLU version. [Alexander Böhn]

• Find path to Git binary on “clu.version.git_version” module load. [Alexander Böhn]

• Amended the ProxyModule unit test by one assertion. [Alexander Böhn]

• Sequester the “targets” ProxyModule attribute rather than deleting. [Alexander Böhn]

• Neatened up some of ProxyModule’s parts: docstrings, init stuff, &c ... fleshed out an inline test or two in “clu.importing” as well. [Alexander Böhn]

• Renamed a related test function. [Alexander Böhn]

• Context-managed environment access for mutable “Environ” instances. [Alexander Böhn]

• Docstring labeling for inline KeyMap tests. [Alexander Böhn]

• Better test-function lexical grouping. [Alexander Böhn]

• Traded gratuitous test prints for generally real-er testing code. [Alexander Böhn]

• Out with pointless varargs, in with docstrings ... also in with DefaultDicts by, erm, default in the Nested types ... and also, in with key checking for mutable Nested type deletes ... and also other stuff. [Alexander Böhn]

• More inline-test formatting minutiae and speedups. [Alexander Böhn]

• Nitpicks on inline test output formatting. [Alexander Böhn]

• Copied ‘clu/main.py’ to ‘clu/version/main.py’ ... in anticipation of, you know, putting something real up in the package-level main file, doggie. [Alexander Böhn]

• Minor logic shortcut in new “FrozenNested.submap(…)” method ... in no way was implementing this the panacea of O(1)-ness I had assumed it’d be when I started, baaaah. [Alexander Böhn]

• Packed string compare beats iterative namespace chunk compare. [Alexander Böhn]

• Ooops – forgot to actually change directories. [Alexander Böhn]

• Ensure that “git_version_tags(…)” uses the project base directory. [Alexander Böhn]

v0.5.2 (2019-12-15)

Add

• Added a “clu.version.git_version” module and trivial functions ... simple shit to get the git tag version ... unlike the other stuff under “clu.version” which are pretty much entirely self-contained, “clu.version.git_version” uses standard CLU stuff (e.g. the Exporter, the inline test harness, et cetera) so WE’LL JUST SEE HOW THIS GOES NOW WON’T WE. [Alexander Böhn]

• Added ‘ValuesView’ and ‘ItemsView’ tailored for “NamespaceWalker” ... which these types each implement much faster, less circuitous versions of the “contains(…)” and “iter()” methods, utilizing the “walk()” method of their associated mappings ... the necessity for these was no gamble or – oddly enough in my personal case – wasn’t premature. No! I saw the need for speed reflected in the timing reports coming from my own new outfit for running inline tests – see all those recent changes to the “clu.testing.utils” module, specifically regarding “@inline” and friends. Yes!!!!! [Alexander Böhn]

• Added “iterlen(…)” to put an end to like e.g. “len(tuple(¬))” ... pretty much a straight-up ⌘-c ⌘-v from the “more-itertools” source – namely their function “ilen(…)” [Alexander Böhn]

• Added a bunch of ancestors to “clu.testing.utils.@inline” [Alexander Böhn]

• Added “@inline” decorator to bpython REPL script. [Alexander Böhn]

• Added note about executing test functions multiple times. [Alexander Böhn]

Minutiae

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.5.1 → 0.5.2. [Alexander Böhn]

• Updated “clu-version” to output a Git version tag, if present. [Alexander Böhn]

• Propagated the docstrings. [Alexander Böhn]

• Some revisions and streamlining to “clu.fs.filesystem.back_tick(…)” ... the verenable function had a few implicit shortcomings: only lists and tuples were valid as non-string command arguments; bytes-mode output decoding was being handled by some specious logic of mine, instead of by just using the “text” argument to the “subprocess.Popen” constructor; “shlex.split(…)” was called in “non-posix mode”, whatever the fuck that means; assorted other messiness also abounded. [Alexander Böhn]

• Tuneups to inline test information-printouts ... first off, a “verbose” kwarg flag keeps the decorator wrapper function from wasting time printing out information that is just going to get consumed by the stdout-redirector used during all run cycles after the first one; ... but then secondly, we retrieve the test functions’ docstring, and call the first stripped line of that docstring the “title”, and we stick that in the header printed for each test function. No use of this datum elsewhere (for the moment). [Alexander Böhn]

• Fast environment-specific “contains(…)” and “getitem(…)” ... key-prefix conversion is much much faster than “walk(…)” over the whole backend data source, doggie. [Alexander Böhn]

• Brought a filesystem test over to “clu.testing.utils” as an inline ... to ensure we’re testing “clu.testing.utils.countfiles” in the inline test suite. [Alexander Böhn]

• Rewrote the “NamespaceWalkerViewBase.len()” implementation ... to use “clu.typology.iterlen(…)” and a generator expression, rather than for-looping with an index variable (how gouche!) [Alexander Böhn]

• Further adventures in mature optimization ... this time it’s a corresponding “NamespaceWalkerKeysView” type, and a new intermediate abstract sub-base for all the new view types that provides a less näive “len()” method. [Alexander Böhn]

• Docstring for the internal “startswith_ns(…)” helper function. [Alexander Böhn]

• Sometimes, you want seperate “new(…)” and “init(…)” funcs. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Exporting the “clu.config.defg.envwalk(…)” helper function. [Alexander Böhn]

• Gratuitous logic simplification in inline-testing’s inline tests. [Alexander Böhn]

• Updating the primary “@inline” docstring. [Alexander Böhn]

• Revised the @inline test decorator mechanism ... to wit: it is now implemented as a class that is instanced automatically via module ‘getattr(…)’ each time it is requested for import ... this makes managing the stopwatch instances and the decorated functions, as instance attributes, way way easier ... plus it eliminates the need for the clunky “vars()” argument to all the “inline.test()” calls ... a few other revisions were made during these changes (most notably the elimination of the “collection phase” in the main stopwatch report – but that was kind of stupid anyway) [Alexander Böhn]

v0.5.1 (2019-12-10)

Add

• Added baseline environment-variable-access function API ... also differentiated the testing of the “old-style” Flat and Nested classes, versus the new shit. [Alexander Böhn]

• Added a “FrozenNested.mapwalk()” method, delegates to “mapwalk(…)” [Alexander Böhn]

• Added namespaced “KeyMap.pop(…)” and “KeyMap.clear(…)” [Alexander Böhn]

• Added a test illustrating “try_items(…)” particular behavior ... w/r/t DefaultDict factories and “getitem(…)” [Alexander Böhn]

Other

• Bump version: 0.5.0 → 0.5.1. [Alexander Böhn]

• Actual inline tests for @inline and friends. [Alexander Böhn]

• More inane dev-ish comments. [Alexander Böhn]

• Const-correct Craving. [Alexander Böhn]

• Developer-facing comments about what the fuck is going on. [Alexander Böhn]

• Fixed time reporting for one-off execution of @inline tests. [Alexander Böhn]

• Killed a lot of dead code. [Alexander Böhn]

• Integrated ‘dbx-stopwatch’ with the inline test framework ... including a custom report-formatting function, as theirs is awful (and not like this one is much better but the need is there, and it’s something, OK?) ... inline tests auto-collect and run via local-variable mapping hook ”inline.test(«vars», [runcount])” ... a number of inline test suites were converted over to the new auto-collection API ... tweaked the requirements accordingly (N.B. this still needs some winnowing) [Alexander Böhn]

• Reorganized the “clu.config” testsuite ... moved all KeyMap-related tests to their own test class. [Alexander Böhn]

• Enabling last inline test. [Alexander Böhn]

• Nitpickery. [Alexander Böhn]

• Killed dead code. [Alexander Böhn]

• Docstrings and miscellany. [Alexander Böhn]

• Pure, unfiltered minutiae. [Alexander Böhn]

• Total minutiae. [Alexander Böhn]

• Being explicit about the class we’re using in the KeyMap env tests. [Alexander Böhn]

• Initial tests with new KeyMap-based environment access are GO. [Alexander Böhn]

• Simplifying some internal string-only comparisons. [Alexander Böhn]

• The very first of passing test runs WITH the new KeyMaps installed! ... getting to green on this involved finding and fixing a big-ish bug in the “compare_ns(…)” helper, which we use in implementing “Nested.contains(…)” and “Nested.getitem(…)” – dropping in “itertools.zip_longest(…)” therein in leu of a “zip(…)” call was the fortunately simple fix, once the flaw was discovered. ... We are using the new KeyMap classes in “clu.config.filebase” and all of the format definition modules e.g. ‘tomlfile’ &c. ... We were able to explicitly swap KeyMap ancestors in on at least one test – ‘test_nested_and_flat(¬)’ – wholesale with no issues (after squashing the big-ish bug of course). ... So yeah, here’s to many more! 🥂 [Alexander Böhn]

• Updated the REPL scripts for the new “clu.config” hot shit. [Alexander Böhn]

• Allowing keyword updates in “Flat” and “Nested” constructors. [Alexander Böhn]

• Gratuitous recursion added to “KeyMap.update(…)” [Alexander Böhn]

• One less import is one more fuck-yes in the pot ... you know, the fuck-yes pot. We all have one, somewhere. [Alexander Böhn]

• Another slight name disambiguation. [Alexander Böhn]

• Rewrote it again with a set comprehension. [Alexander Böhn]

• Rewrote “FrozenKeyMap.namespaces()” to suck a lot less. [Alexander Böhn]

• Faster still for the logic of “get_ns(…)” [Alexander Böhn]

• Another gratuitous function rename. [Alexander Böhn]

• Like I said. [Alexander Böhn]

• Since we aren’t worried about interstitial sequences anymore… ... we won’t need to expand iterable keys during namespace packing, like duh. [Alexander Böhn]

• Got rid of any naming ambiguity regarding keys, nskeys, and such. [Alexander Böhn]

• Minor simplification in “get_ns(…)” logic. [Alexander Böhn]

• Simplified the logic behind “FrozenNested.namespaces()” [Alexander Böhn]

• Same slight simplification in “FrozenKeyMap.submap(…)” logic. [Alexander Böhn]

• Slight simplification of the “KeyMap.clear(…)” logic. [Alexander Böhn]

• Simplified “KeyMap.pop(…)” logic. [Alexander Böhn]

• Moving disabled code. [Alexander Böhn]

• Disabling (for now) sequence expansion in nested trees. [Alexander Böhn]

• More professionalism. [Alexander Böhn]

• Making “FrozenNested.mapwalk()” look professional. [Alexander Böhn]

• Un-abstracting the “KeyMap.reversed(…)” method. [Alexander Böhn]

• “contains(…)” and “iter(…)” are abstract methods of “KeyMapViewBase” [Alexander Böhn]

• More flat/nested conversion test coverage. [Alexander Böhn]

• Testing roundtrip flatten-to-nestify and nestify-to-flatten. [Alexander Böhn]

• Removed sequence literals from nested sample data. [Alexander Böhn]

• The “mapwalk(…)” function includes sequence indexes. [Alexander Böhn]

• Compatibility stuff across the board for the new KeyMap API. [Alexander Böhn]

• Aaaaand BUNCHA DOCSTRINGS ... say it like Eddie Izzard saying “BUNCHA FLOWERS” in that bit that he did. [Alexander Böhn]

• Reworded that nota-benne. [Alexander Böhn]

• Bespoke namespace iterator function for “Nested” [Alexander Böhn]

• OK so the immutable namespacey rewrite of “clu.config.Nested” works. [Alexander Böhn]

• Logic notes for new REPL script. [Alexander Böhn]

• Inline test is the inliniest, testiest ever before seen. [Alexander Böhn]

• I give up, the KeyMap class tower is now ‘clu.abstract.Slotted’ ... like if this is a problem down the line doggie just stick in a ‘dict’ slot somewhere and everything’ll be A-OK, guaranteed. [Alexander Böhn]

• Moved “namespaces(…)” method up into ‘FrozenKeyMap’ [Alexander Böhn]

• I got your module exports, right over here within my pants. [Alexander Böhn]

• Well fuck – that actually worked pretty much the first time ... happy birthday to me, I guess, rite?? For reals dogg December the Fifth is my real actual birthday, so thank you, me, for conforming to the Me Coding Guidelines. [Alexander Böhn]

• And so commenceth the Great Re-Naming Of The Things. [Alexander Böhn]

• Trimmed disabled unprefixed-key-related code alternatives. [Alexander Böhn]

• Keyword API accomodations for retrieving views of unprefixed keys. [Alexander Böhn]

• Re-enabling “Flat.nestify(…)” [Alexander Böhn]

• Map-Walker™ [Alexander Böhn]

• Redoing the foundations of “clu.config.abc.NamespacedMutableMapping” [Alexander Böhn]

• Also made “clu.config.fieldtypes.getattr(…)” quiet down. [Alexander Böhn]

• The “qualified_name(…)” and “qualified_import(…)” fns are quieter ... they were, like, unnecessarily chatty there for a long while. [Alexander Böhn]

• Remove insecure Django requirement. [Alexander Böhn]

• Further fleshing out REPL script. [Alexander Böhn]

• Getting started on new REPL environment script. [Alexander Böhn]

• Tweaked a method name in “clu.dicts.ChainMap” ... specifically it is now “mapcontaining” instead of “mapcontains” [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• One other spot where our ChainMaps and their ChainMaps may meet. [Alexander Böhn]

• Our ChainMap will take our ChainMaps and their ChainMaps too. [Alexander Böhn]

• Made “clu.naming.qualified_import(…)” work with just module names ... versus qualified-thing-names, which was what specifically it was expecting previously. [Alexander Böhn]

• I like “delattr(…)” more than “del «…»” [Alexander Böhn]

• WHOOOOPS. [Alexander Böhn]

• Setting importlib-metadata requirement in stone. [Alexander Böhn]

• Minor bpython REPL script update. [Alexander Böhn]

• HAAAAAACK ... until I summon the werewithall to do some kind of stem/leaf type of analysis or property or whatever the fuck – this total hackjob bullshit will do (and it actually is kind of totally effective for like the near-forseeable future actually, yeah) [Alexander Böhn]

• Iterchaining those “dir(…)” lists ahead-of-time ... Minimum waaaaaaaaaaage »¡HIYAAA!« [SFX: whip-crack] [Alexander Böhn]

• True paranoia ... I just remembered I read somewhere that “init(…)” methods are not guaranteed to run only once, and might run a couple of times just for shits ‘n’ giggles. [Alexander Böhn]

• Plugging yet another microsecond-in-diameter hole. [Alexander Böhn]

• Storing “dir(…)” results for ProxyModule’s “dir(…)” impl ... Also, I like ‘delattr(…)’ more than ‘del «thing»’ – the latter of which looks way too nondeterministic by association and also more problematically loosey-goosey like in general. [Alexander Böhn]

• Explicit, I am told, brings more general joy than (say) implicit ... I dunno whether premature optimization is better or more joyful or nicer or what-have-you than other kinds of optimization but you are getting those in this diff too whether you like it or not, doggie, OK? OK. [Alexander Böhn]

• Fixed possible race condition in “ProxyModule.getattr(…)” ... “ProxyModule._executed” could be True for like one or maybe two frames of interpreter execution during which the initialization mapping list “ProxyModule.target_dicts” still existed, which could short-circuit attribute-access for like half a frame more after calling for the deletion of the list – this is probably minute enough to qualify this diff as “premature optimization” – or “obsessive-compulsive flow control”, either-or – but I do not care as it is far more satisfying to have unfucked it than it’d be to leave it sitting there all fucked and such. [Alexander Böhn]

• Culling ‘sys.modules’ on “clu.importing.Registry.unregister(…)” ... fucking finally. [Alexander Böhn]

• Got rid of the ‘SubModule(…)’ class-module context-manager – ... it was waaaay more trouble than it was worth ... also stopped merging proxied modules’ exporters into the proxy module’s exporter – this was wreaking havoc with “nameof(…)” and “moduleof(…)” search-component mechanisms; ... INSTEAD we are simply leaving proxy-module exporters to work as they would normally – like e.g. on stuff explicitly defined therein – and using an overridden “ProxyModule.dir(…)” to get the job done. [Alexander Böhn]

• Module-importing “clu.constants.consts” instead of cherry-picking. [Alexander Böhn]

v0.5.0 (2019-11-27)

Add

• Added a “consts” fixture to the pytest plugin. [Alexander Böhn]

Other

• Bump version: 0.4.10 → 0.5.0. [Alexander Böhn]

• Made “clu.importint.ProxyModule” a real thing ... with tests (both inline and unitary), docstrings and notes, differentiated support functions and classes… YOU NAME IT ... !!!!!!!!!!!!!!!!!! FUCK YES !!!!!!!!!!!!!!!!!!! [Alexander Böhn]

• Further notations, errata, and error-message minutiae. [Alexander Böhn]

• Bespoke (aka hack-tastic) one-off proxy-module typename reporting. [Alexander Böhn]

• De-redundifying proxy-module “getattr(…)” error handling. [Alexander Böhn]

• Position one arg for module name, keyword-only arg for docstring. [Alexander Böhn]

• Docstring for experimental proxy-module “init(…)” call. [Alexander Böhn]

• Uncluttering proxy module namespace via function inlining. [Alexander Böhn]

• Trimming class-module instance methods in “execute()” [Alexander Böhn]

• Trimming intermediate target lists from proxy module internals. [Alexander Böhn]

• Threw in an additional assert in old test, just to be safe. [Alexander Böhn]

• Updated “clu.typology” assertion regarding “clu.extending” ancestry. [Alexander Böhn]

• Experimental class-based module-wrapper proxy thing in tests ... the meat of this currently resides in “test_importing.py”, q.v. test function ‘test_module_dict_proxy_idea’ supra. for the module-class proxy reference implementation, a working example subclass and example code that does not fail to run ... basically it’s a ChainMap for module attributes (like literally as this implementation uses “clu.dicts.ChainMap” internally) ... also internally, the sub-sub-sub-sub-metaclass base for all class-based modules inherits from “clu.extending.Extensible” – which that type itself inherits from “clu.abstract.NonSlotted” instead of plain ol’ ‘type’ ... the implementation classes for the “clu.extending.doubledutch” decorator – “DoubleDutchRegistry” and “DoubleDutchFunction” – now leverage a number of CLU- and standard-library-based ABCs. [Alexander Böhn]

• The “clumods” pytest fixture now depends on the “consts” fixture. [Alexander Böhn]

• Session-scoping the “greektext” pytest fixture. [Alexander Böhn]

• Moreso deployment of the new “consts” pytest fixture. [Alexander Böhn]

• Updated comment note on module inclusion criterion. [Alexander Böhn]

• Import shuffle. [Alexander Böhn]

• Killed trailing whitespace. [Alexander Böhn]

• Generalized and centralized import-all-modules logic ... created a new module “clu.all”, containing two functions: • “import_all_modules(basepath, appname)” → Imports all modules, both file-based and class-based, from the app «appname» within the package rooted at «basepath» • “import_clu_modules()” → Imports all CLU-specific modules – a convenience call for “import_all_modules(consts.BASEPATH, consts.PROJECT_NAME)” ... the “clu.testing.pytest.clumods” fixture now simply delegates to a call to “clu.all.import_clu_modules()” ... the clu-module-importing function in ye olde “show-modules.py” script has been replaced with “clu.all.import_all_modules(…)” ... no specific tests have been added because this shit is already super-100%-plus covered by existing test code, doggie. [Alexander Böhn]

• Re-instating “rm_rf(…)” usage in pytest plugin’s exit handle. [Alexander Böhn]

• Using “shutil.rmtree(…)” in “clu.fs.filesystem.rm_rf(…)” ... instead of all of my tortured bespoke logic that apparently did not quite work right. [Alexander Böhn]

• Noting possible one-liner for “installed_appnames()” impl. [Alexander Böhn]

v0.4.10 (2019-11-27)

Other

• Bump version: 0.4.9 → 0.4.10. [Alexander Böhn]

• Updated/refactored some of “clu.fs.pypath” ... “pypath.append_path(…)” has been renamed “pypath.add_path(…)”, and it now accepts a keyword-only argument ‘prepend=True’ to, y’know, prepend its payload to ‘sys.path’ instead of appending. ... “pypath.remove_invalid_paths()” calls ‘site.removeduppaths()’ before doing anything to ‘sys.path’ ... There’s a new convenience function “pypath.enhance(…)” which is basically sugar for calling “remove_invalid_paths()” ahead of calling “add_path(…)” – which as already noted now also includes a call to ‘site.removeduppaths()’ ... the REPL script imports “clu.fs.pypath” as a module, instead of picking through its exported functions ... many tests make use of new “clu.fs.pypath.enhance(…)” function. [Alexander Böhn]

• Moved the “pytester” requirement into the CLU pytest plugin proper. [Alexander Böhn]

• Testing and pytest support for “clu.dispatch” ... new “clu.constants.consts” item ‘USER’, value of the current users’ username ... rework of “clu.fs.filesystem.rm_rf(…)” logic ... The “clu.testing.pytest” plugin now implements a pytest hook function “pytest_sessionfinish(…)”, which in turn conditionally binds an exit handler – using “clu.dispatch.exithandle” – that deletes any stray pytest temporary-file artifacts left over upon interpreter shutdown … namely, anything in the directory $TMPDIR/pytest-of-$USER – which stubbornly would not remove itself and (according to the policy of pytest’s code for this, apparently) just keeps accumulating piles of cruft every time ‘pytest’ was executed ... All in aid, really, of the one new test, in “test_dispatch.py”, which makes use of the “pytester” built-in pytest plugin to cleanly test exit handlers; see the source of same for details. [Alexander Böhn]

• Updated the bpython REPL script for the ‘dispatch’ update. [Alexander Böhn]

• Moved “clu.shelving.dispatch” down to “clu.dispatch” ... as it is clearly bigger than just the nascent ‘shelving’ module. [Alexander Böhn]

• Made “clu.fs.filesystem.TemporaryFileWrapper” an explicit Iterable ... as in, it inherits from ‘collections.abc.Iterable’ ... also added 'pytester' to the test plugins loaded in conftest.py. [Alexander Böhn]

v0.4.9 (2019-11-26)

Add

• Added ‘has_appname’ to “clu.exporting.ExporterBase.dir(…)”’s filter. [Alexander Böhn]

Other

• Bump version: 0.4.8 → 0.4.9. [Alexander Böhn]

• Split off async parts of “clu.abstract.ManagedContext” ... into “clu.abstract.AsyncManagedContext” [duh] ... also added tests for the former. [Alexander Böhn]

• Exclude async methods on lower pythons from “clu.abstract.ManagedContext” [Alexander Böhn]

• Re-enabling test for qualified naming of constants. [Alexander Böhn]

• Elected to use context-managed exporting in “clu.exporting” itself. [Alexander Böhn]

• Trimmed and tweaked “clu.exporting” generally – ... moved “clu.exporting.rename” to “clu.naming” where arguably it has always belonged ... removed nearly all method-level imports in “clu.exporting” in favor of module-level; so far, so good ... made a couple minor tweaks to “clu.exporting.ExporterBase”, of which the most notable is that “clu.exporting.ExporterBase” is now a context manager; doing: [Alexander Böhn]

  exporter = Exporter(path=file)

  with exporter as export:

     @export
     def yodogg():
     	 ...
  
  … now works, and makes a certain amount of sense
  

• Removed old “Python 3”-specific REPL module. [Alexander Böhn]

• Removed old Bash REPL stub. [Alexander Böhn]

• Fixed docstring again pt. II. [Alexander Böhn]

• Fixed docstring again [Alexander Böhn]

• Use current if “importables(…)” called with Falsy subdirectory. [Alexander Böhn]

• Docstring minutiae. [Alexander Böhn]

• REPL script updates. [Alexander Böhn]

v0.4.8 (2019-11-22)

Other

• Bump version: 0.4.7 → 0.4.8. [Alexander Böhn]

• Typographic eratta en extremis. [Alexander Böhn]

v0.4.7 (2019-11-22)

Other

• Bump version: 0.4.6 → 0.4.7. [Alexander Böhn]

v0.4.6 (2019-11-22)

Add

• Added a “clu.shelving.dispatch.shutdown(…)” function ... like “clu.shelving.dispatch.trigger(…)” but with an actual call to ‘sys.exit(¬)’ at the end ... also more bells & whistles to “clu.shelving.redat.RedisConf” have been grafted on, somehow. [Alexander Böhn]

• Added a bunch of async shit I don’t quite understand. [Alexander Böhn]

Other

• Bump version: 0.4.5 → 0.4.6. [Alexander Böhn]

• SIG-WINCH!!!!! [Alexander Böhn]

• Logging format config manscaping. [Alexander Böhn]

• Trimmed dead code. [Alexander Böhn]

• Tweaking shutdown logic. [Alexander Böhn]

• Minor tweak to zipfile artifact save logic. [Alexander Böhn]

• Even more “clu.shelving.dispatch” minutiae. [Alexander Böhn]

• Exit handle functions execute properly from signal handlers. [Alexander Böhn]

• More tweaks to async signal-handler demo code. [Alexander Böhn]

v0.4.5 (2019-11-22)

Other

• Bump version: 0.4.4 → 0.4.5. [Alexander Böhn]

• Some minutiae in “clu.shelving.dispatch.test(…)” [Alexander Böhn]

• Rounded out “clu.shelving.dispatch” innards. [Alexander Böhn]

• No longer reversing the sequence in “functional_and.call(…)” [Alexander Böhn]

• Moved a bunch of stuff around. [Alexander Böhn]

• Many updates to “clu.shelving” and friends ... support for exit-handler functions in “clu.shelving.dispatch”, wherein multiple functions can be registered through the new “@exithandler” decorator, and ordered execution is guaranteed even if the process ends abruptly due to like e.g. SIGKILL or what have you ... exemplary exit-handler definitions are now in use within the “clu.shelving.redat” and “clu.app.redprocess” modules ... a new abstract type “clu.abstract.ManagedContext” fills in the special async and synchronous context-manager methods, based on “setup(…)” and “teardown(…)” function calls. [Alexander Böhn]

• CHAIN CHAIN CHAAAIIIN – CHAAAIN THE FOOOO-OOOL. [Alexander Böhn]

• Only checking the CLU app’s registered class-based modules. [Alexander Böhn]

• CLU-project module tests properly consider class-based modules. [Alexander Böhn]

• Fixed Redis class-module inline test. [Alexander Böhn]

• Managing Redis subprocess with a class-based module. [Alexander Böhn]

• More Redis-handle decoupling. [Alexander Böhn]

• Initially decoupling “redat.RedisConf” from “redat.RedRun” [Alexander Böhn]

• Sleeping in the proper place during Redis server process startup. [Alexander Böhn]

• De-duplicating “multidict” requirement. [Alexander Böhn]

• Clarified a few things in “clu.config.filebase” [Alexander Böhn]

v0.4.4 (2019-11-21)

Add

• Adding default Redis config file. [Alexander Böhn]

• Added a few diagnostic lines to the Redis inline test. [Alexander Böhn]

• Added some gratuitous asserts to the Redis inline test. [Alexander Böhn]

• Adding the Exporter to “clu.shelving.redat” [Alexander Böhn]

• Adding a “shelving” module and initial Redis process-handler. [Alexander Böhn]

Other

• Bump version: 0.4.3 → 0.4.4. [Alexander Böhn]

• Fixed “RedRun.repr(…)” when the configuration is inactive. [Alexander Böhn]

• Escaping a raw regex string. [Alexander Böhn]

• Fixed variable-shadow name bug in “clu.fs.misc” [Alexander Böhn]

• Fixed bug when calling “clu.fs.misc.re_excluder(…)” with no args. [Alexander Böhn]

• Getting rid of polyfill “walk(…)” and “scandir(…)” [Alexander Böhn]

• Minor touchups to “clu.fs.filesystem.back_tick(…)” [Alexander Böhn]

• Using @itervariadic with “clu.fs.misc.re_excluder(…)” [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Argument length check in “clu.fs.misc.re_excluder(…)” [Alexander Böhn]

• Abstracted the “exclude” bit from two “clu.fs.filesystem” methods ... namely: “clu.fs.filesystem.Directory.importables(…)” and its cousin, “clu.fs.filesystem.Directory.suffix_histogram(…)”, and stowed the logic of said bit in a function in “clu.fs.misc”. [Alexander Böhn]

• Git-ignoring Redis artifacts. [Alexander Böhn]

v0.4.3 (2019-11-14)

Add

• Adding conftest.py to MANIFEST.in. [Alexander Böhn]

• Adding one-liner “conftest.py” to load the pytest plugin module ... this re-enables running pytest just as ‘pytest’ – instead of having to be all like ‘python -m pytest -p clu.testing.pytest’ via make each and every time. [Alexander Böhn]

Minutiae

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.4.2 → 0.4.3. [Alexander Böhn]

• I keep thinking I fixed “clu.repl.ansi.print_ansi_centered(¬)…” ... and then it turns out there is yet another corner-case causing it to be off by one or two filler characters in some situation or another – likely one brought about by the last “fix” – but I really do think I’ve nailed it this time, famous last words, OK we shall see now won’t we doggie yeah. [Alexander Böhn]

• Much much miscellany -» Added “clu.fs.misc.extension(…)” and “clu.naming.suffix(¬)”, both of which return the extension (née “suffix”) from a file’s path – one is a lambda and the other is a function with a few more options. Both of these were deployed around and about the codebase at large -» Fixed a bug in “clu.importing.ModuleBase.dir()” that made itself known when ‘dir(…)’-ing “ModuleBase” subclass instances suffering from a lack of integral “clu.exporting.ExporterBase” properties; this pertained to “clu.predicates.union(…)” – which I am now starting to think is silly – and the fix was ro redo the implementation with “itertools.chain(…)” and a ‘frozenset’. -» Generally rejuggled the third-party imports in “clu.naming” and tidied up a few things in there while also adding in functions dealing with file suffixes, as aforementioned -» Removed the debug grace from “clu.testing.utils.getattr(…)” -» Fixed the “clu.typespace.types.package” property and tidied the imports in the “clu.typespace” packages’ “init.py” file -» Only requiring Pillow in non-PyPy envs when running tox due to PyPy remaining obstinately stupid about compiling it therein -» Additional tox-related OCD-ish tweaks and additional morsels. [Alexander Böhn]

• Trimmed outdated imports from “repl-bpython.py” [Alexander Böhn]

• Migrated “clu.extensible” inline tests to the testsuite. [Alexander Böhn]

• Trimming “clu.constants.polyfills” [Alexander Böhn]

• Removing old “clu.constants.terminalsize” hacks. [Alexander Böhn]

• Docstring tweak. [Alexander Böhn]

• Some import/export touchups ... the master exporter class-registry dictionary now uses weakrefs ... the filesystem root is now programmatically determined ... gratuitous super-call in “FinderBase.invalidate_caches()” has been removed. [Alexander Böhn]

• Got rid of MODNAMES once and for all ... FUCK YES. [Alexander Böhn]

• Finally we can eschew “clu.constants.data.MODNAMES”!… ... in favor of an actual programmatically-generated list of the project’s importable file-based submodules ... the current method “clu.fs.filesystem.Directory.importables(…)” is pretty comprehensive, for something hacked together quickly and out of frustration ... TODOs of course are: *) split that lambda off into some kind of reusable exclude-list shit in “clu.fs.misc”, and add some tests and sensible defaults and yadda-yadda; *) check to see if this has any value outside of this particular application; and other such shit ... YES!!! YES DOGG THIS WAS ON MY PERSONAL SHIT-LIST FOR A WHILE NOW SO I CAN START THE DAY HAPPY OKAY?? [Alexander Böhn]

v0.4.2 (2019-11-08)

Add

• Added “issingleton(…)” and “issingletonlist(…)” to “clu.typology” ... plus we’re using the former now in “clu.repr.strfield(…)” which is cleaner than what it was doing before (which was dirtier) [Alexander Böhn]

Other

• Bump version: 0.4.1 → 0.4.2. [Alexander Böhn]

• Properly set “_executed” flag on modules lacking an “execute()” [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Importing “clu.abstract” wholesale rather than piecemeal ... in both “clu.exporting” and “clu.importing” [Alexander Böhn]

• Removed unnecessary callable check in “clu.exporting.determine_name(…)” [Alexander Böhn]

• Getting “lru_cache” in “clu.exporting” directly from ‘functools’ [Alexander Böhn]

• One-character typo fix. [Alexander Böhn]

v0.4.1 (2019-11-07)

Add

• Added notes about caching where relevant to “clu.fs.misc” docstrings. [Alexander Böhn]

• Added a “clu.fs.misc” test for checking the users’ home directory. [Alexander Böhn]

• Added a “clu.fs.misc” test for checking the process’ umask values. [Alexander Böhn]

• Added tests for “clu.fs.misc.u8{bytes,str}(…)” functions. [Alexander Böhn]

• Added a test for “clu.fs.misc.suffix_searcher(…)” [Alexander Böhn]

• Added a test for “clu.fs.misc.swapext(…)” ... literally pulled right out of the functions’ docstring. [Alexander Böhn]

• Added a test for “clu.fs.misc.re_suffix(…)” [Alexander Böhn]

• Added a test for “clu.fs.misc.filesize(…)” [Alexander Böhn]

• Added some tests to the “clu.fs.misc” testsuite. [Alexander Böhn]

• Added walrus-operator-related nota-benne. [Alexander Böhn]

• Added “clu.importing.ModuleBase.execute()” hook method ... this allows class-module implementations to run code at the analogous point in the module lifecycle to, like, e.g. when a file-based modules’ code is run by the Python interpreter. ... There’s lots of explanatory docstrings and a working example in the testsuite, doggie, yes. [Alexander Böhn]

• Adding “setproctitle” to the dev requirements. [Alexander Böhn]

• Added another inline test to “clu.importing” using “importlib.import_module(…)” [Alexander Böhn]

• Added “clu.importing.SubModule” context-manager ... for creating temporary class-module subtypes, suitable for testing, among other things ... includes an inline test and a support predicate “newtype(…)” [Alexander Böhn]

• Added “clu.predicates.union(…)” as a shortcut for “set().union(…)” [Alexander Böhn]

Minutiae

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.4.0 → 0.4.1. [Alexander Böhn]

• Less precision is OK with me in this case. [Alexander Böhn]

• Fleshing out “clu.repr” tests and details. [Alexander Böhn]

• Simplified decorator usage in “clu.fs.misc” [Alexander Böhn]

• Tweaked “suffix_searcher(…)” test to explicitly check None operands. [Alexander Böhn]

• Another premature optimization in the testsuite. [Alexander Böhn]

• Further pairing down gratuitous filesystem work in some tests. [Alexander Böhn]

• Rolled the “clu.fs.misc.samesize(…)” test into its precedent. [Alexander Böhn]

• Fleshing out “clu.fs.misc” tests to check file-size functions. [Alexander Böhn]

• Avoiding gratuitous file-copy operations in some tests. [Alexander Böhn]

• Expand the “filesize(…)” test to check nonexistant file attributes. [Alexander Böhn]

• Allow “clu.exporting.determine_name(…)” to work on all wrappers – ... not just function-types (as defined with “def” or lambdas) but any callable types with a callable “wrapped” attribute. [Alexander Böhn]

• Ugh. [Alexander Böhn]

• Some of these tests are kind of circuitous. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• More “clu.abstract” unit tests – some adapted from existing tests. [Alexander Böhn]

• Test suites for metaclasses in “clu.abstract” [Alexander Böhn]

• Ported two “clu.importing” inline tests to the testsuite ... specifically it’s the two tests that exercize the code for the “clu.importing.SubModule” utility. [Alexander Böhn]

• All kinds of new tests. [Alexander Böhn]

• Moved “MappingViewRepr” to “clu.abstract” and documented it. [Alexander Böhn]

• Importing “clu.abstract” wholesale and not piecemeal in “clu.dicts” [Alexander Böhn]

• Updated some docstring references to “Slotted” and “Prefix” [Alexander Böhn]

• The “Prefix” metaclass has been moved to “clu.abstract” [Alexander Böhn]

• Using “clu.abstract” classes in “clu.dicts” [Alexander Böhn]

• Moved “wrap_value(…)”, “hoist(…)” and friends to “clu.predicates” ... also trying to trim some of the gratuitous no-op lambdas. [Alexander Böhn]

• Fleshed out some sensible-default base classes in “clu.abstract” ... like there is now an intermediate ancestor of the verenable “clu.abstract.ValueDescriptor” class called “Descriptor” that makes use of “clu.abstract.SlottedRepr” ... which that class, “SlottedWrapper” is itself derived from the “clu.abstract.ReprWrapper” class and uses ‘slots’ values across its inheritence chain to build its instances’ reprs through a call to “clu.repr.strfields(…)” (q.v. the latest few patches supra.) [Alexander Böhn]

• Moving “stringify(…)” and friends from “clu.fs.misc” to “clu.repr” ... made the change across the entire project ... still have to deal with a couple of dingleberries remaining in the “fs.misc” module – namely “wrap_value(…)”, “hoist(…)” etc. [Alexander Böhn]

• Refactored “clu.fs.misc.stringify(…)” ... it now consists of a sub-function, “strfields(…)” – and the internal type-switch repr helper is just called “strfield(…)”. ... this will allow it to be used with the nascent abstract type, “clu.abstract.ReprWrapper” ... also added new predicates: • “reverse(ƒ)” » returns a lambda that returns “reversed(ƒ)” • “rmro(cls)” » is basically “reverse(mro)” • “ancestral(atx, cls)” » like “attr_across(atx, *rmro(cls))” • “ancestral_union(atx, cls)” » basically this is an alias for “uniquify(chain.from_iterable(ancestral(…)))” [Alexander Böhn]

• “clu.testing.utils.countfiles(…)” can take strings, “pathlib.Path”¬ ... or anything that is “os.fspath(¬)”-able (whereas previously it called “target.walk()” on its primary argument, limiting its use to “clu.fs.filesystem.Directory” instances, pretty much) [Alexander Böhn]

• Simplified that “clu.fs.filesystem.TemporaryName.write(…)” call ... using a call to “TemporaryName.parent()” ... also added None checks to “Directory.{copy_all,flatten}(…)” [Alexander Böhn]

• Swapped a manual read of a “doc” attr for “inspect.getdoc(…)” ... also removed a call to “ensure_path_is_valid(…)” within the “clu.fs.filesystem” module, in favor of custom logic allowing for idempotency (as as it was, the existing logic would fail to write if a file existed, which why?) [Alexander Böhn]

• Changing all references to “Slotted” and the like to “clu.abstract” ... the “Slotted” metaclass and the “ValueDescriptor” read-only property class have been relocated to “clu.abstract”; ... The export machinery was removed from “clu.abstract” – enabling the types from that module to be used by “clu.exporting” itself ... “doctrim(…)” was also removed from “clu.exporting” – we are now using ‘importlib.cleandoc(…)’ generally in its stead ... other assorted updates to grease the wheels of this particular iota of progress were in fact made to shit in general, doggie. [Alexander Böhn]

• Lambda-ifying the “@cache” decorator in “clu.exporting” [Alexander Böhn]

• Using “inspect.getdoc(…)” instead of manually retrieving ‘doc’ [Alexander Böhn]

• Docstring manipulation fixes and touchups. [Alexander Böhn]

• Type checks in “clu.importing.SubModule.init(…)” [Alexander Böhn]

• Invalidating module-finder caches when unregistering a class-module. [Alexander Böhn]

• You really just can’t reuse class-module names now can you. [Alexander Böhn]

• Made “clu.importing.cache” a properly reusable decorator ... with – you guessed it dogg – a lambda-expression OH YOU KNOW ME BY NOW OKAY. [Alexander Böhn]

• Caching with “functools.lru_cache(…)” in “create_module(…)” [Alexander Böhn]

• Relocated the “clu.importing.LoaderBase.module_repr(…)” logic ... it is now in “clu.importing.Package.repr(…)”, which is the place in which it should be, considering the fact that that “module_repr(…)” abstract method was actually depreciated at some point during the massive amount of “importlib” API churn, at which I mercifully came in at the very tail end when I wrote all of this shit here doggie. [Alexander Böhn]

• Ensure module.qualname uses module.name (not ModuleClass.name) [Alexander Böhn]

• Per-app Finder subclasses are added based on installed appnames ... as opposed to previously, wherein it was depending on identity hashes of class objects, which was fundamentally flawed as each call to “initialize_types(…)” would always install a new Finder subclass regardless of the appname used. [Alexander Böhn]

• Killed dead code. [Alexander Böhn]

• Simplified “clu.importing.SubModule” using new class properties. [Alexander Böhn]

• Made class-module properties name/prefix/qualname work on classes ... by moving the property methods to the MetaModule metaclass, and then proxying property methods on the class – those that work on the instances – to class property access ... this was in aid of furnishing an “iter_modules(…)” class method on “clu.importing.FinderBase” which as the docstring notes is a quote-unquote non-standard API used by the “pkgutil” module ... other support shit for “iter_modules(…)” includes a function “clu.importing.modules_for_appname(…)” which that does pretty much what you think it does. [Alexander Böhn]

• Ensure class-moduyles’ exporter type is properly named. [Alexander Böhn]

• Testing deferred export of a class-module attribute. [Alexander Böhn]

• Silence the GitHub security alert for Pillow. [Alexander Böhn]

• Timing and pretty-print decorator for inline test functions ... available now in “clu.testing.utils” as “@inline” ... usage example in the docstring, plus it’s been added to a bunch of existing inline test functions. [Alexander Böhn]

• Testing module-level registry functions inline. [Alexander Böhn]

• Clarified now-module-level class-module registry functions. [Alexander Böhn]

• Moved “all_appnames()” and “all_modules()” into module-level ... and out of “clu.importing.MetaRegistry” where formerly they were @staticmethods ... this is in an attempt to unclutter the starting namespace of newly defined class-modules. [Alexander Böhn]

• Minor docstring manscaping. [Alexander Böhn]

v0.4.0 (2019-10-22)

Add

• Added method “clu.exporting.Registry.has_appname(…)” [Alexander Böhn]

Other

• Bump version: 0.3.9 → 0.4.0. [Alexander Böhn]

• Clarified “appname” parameters ... and, may I just say: I am really, really happy with the whole class-based module implementation that’s in “clu.importing”. If I can just say. Yes! [Alexander Böhn]

• Docstrings, tests, nitpicks, consolidations, and such. [Alexander Böhn]

• Integrated clu.exporting with clu.importing! ... to wit: class-module subclasses get built-in Exporter instances tied to their appname/appspace/name dotpath; ... said subclasses have a custom “@export” decorator injected into their namespace, so like when you’re doing, like: [Alexander Böhn]

  class YoDogg(Module):

    @export
          def iheard(self, wat):
        return f"I heard {wat}"
  
    @export
    def youlike(self, wat):
        return f"that you like {wat}"
  
  a) the “export” thingy has been predefined for that specific
     class namespace that you are working in, in that case, and
  b) you don’t need to manually import an ExporterBase subclass,
     instantiate it, and call its “decorator()” method before
     using “export” as long as it is used *only within that class
     block*
  

  ... still – awesome, tho, yes? I think yes.

• Directly using “collections.abc” in “clu.typespace.namespace” [Alexander Böhn]

v0.3.9 (2019-10-22)

Add

• Added docstring note about “slots” to ModuleBase. [Alexander Böhn]

• Added a nota benne about the instance/class name. [Alexander Böhn]

• Adding “clu.abstract” ABCs module and class-module tests. [Alexander Böhn]

• Added “array.ArrayType” to the typespace as “types.Array” [Alexander Böhn]

Other

• Bump version: 0.3.8 → 0.3.9. [Alexander Böhn]

• Caching module specs in “clu.importing” ... this works across all “clu.importing.FinderBase” subclasses – meaning for all defined appnames – short-circuting spec lookups within “sys.meta_path” to the first “FinderBase” subclass when the spec in question is in the cache. TAKE THAT, LATENCY. [Alexander Böhn]

• Killed gratuitous “chain()” in “clu.importing.ModuleBase.dir(…)” [Alexander Böhn]

• Clarified the “clu.importing.Package” docstring. [Alexander Böhn]

• Only split spec.name if it’s registered. [Alexander Böhn]

• Removed unused class-keyword argument check. [Alexander Böhn]

• Sorting registered appnames in “clu.importing” [Alexander Böhn]

• Removed read/write access code in “clu.importing.Registry” [Alexander Böhn]

• Disabled read/write access to the “clu.importing.Registry” data ... commented out, for now. [Alexander Böhn]

• Un-un-fixed inline test in “clu.importing” [Alexander Böhn]

• Nixed a bit of dead code. [Alexander Böhn]

• Class modules work with more than one appname ... for future generations: the bug was in the one comparison being done in “clu.importing.FinderBase.find_spec(…)”, FYI. [Alexander Böhn]

• Mostly fixed “clu.importing.LoaderBase.module_repr(…)” [Alexander Böhn]

• A docstring for “clu.importing.Package” [Alexander Böhn]

• Class modules also inherit from “clu.importing.Package” [Alexander Böhn]

• Actually let’s do it this way instead. [Alexander Böhn]

• Ensure intermediate module instances are packages ... as in, they have a “path” attribute containing a list. [Alexander Böhn]

• Docstring for “clu.importing.initialize_types(…)” [Alexander Böhn]

• Testing importing a member function of a class-module. [Alexander Böhn]

• Ensure DO_NOT_INCLUDEs aren’t included in “dir(module)” [Alexander Böhn]

• Basics of “clu.importing” – class-based modules. [Alexander Böhn]

• Miscellaneous predicates I wrote in the middle of the fucking night. [Alexander Böhn]

• Inserted module-local versions of a few lambdas into “exporting” ... in the name of breaking dependency cycles that these static type-checkers can’t reason their way around. [Alexander Böhn]

• Makefile and type-check setup tweaks. [Alexander Böhn]

• Gearing up for some basic type-checking. [Alexander Böhn]

• Catch SyntaxError as well as ImportError in “clu.constants.polyfills” [Alexander Böhn]

• Ensure the fake “lru_cache(¬)” uses a wrapped attribute. [Alexander Böhn]

• Trimmed dead code. [Alexander Böhn]

• Re-implemented “clu.predicates.finditem[s?]” ... now using searcher(…)/collator(…) instead of apply_to(…) [Alexander Böhn]

• Dispatch functions in “clu.extending” can all have the same name ... fucking finally. [Alexander Böhn]

• Major tuneups in “clu.extending” including annotation support! ... also the “clu.extending.DoubleDutchRegistry” classes’ “cache” attribute is now a real actual LRU cache (courtesy zict) and not just a copy of the dict it was supposedly caching ... also expanded renaming support in “clu.exporting” and added a related test or two. [Alexander Böhn]

• Full coverage for “clu.extending” in module inline tests. [Alexander Böhn]

• Updates for “clu.typology” metaclass support in “repl-bpython.py” [Alexander Böhn]

• Many additions to “clu.typology” including metaclass support ... predicates for checking metaclasses and dealing with metatype and ABC lists ... tests for these new additions ... refinements in “clu.extending” including new greek letters! ... miscellaneous updates in accordance with this awesome new shit. [Alexander Böhn]

• OMEGA MARKS THE END (by which I mean, the “pair(…)” tests run OK!!! [Alexander Böhn]

• Changes “clu.predicates.pyname(…)” to match “determine_name(…)” ... q.v. the previous commit note supra. w/r/t the “qualname” and “name” attributes. [Alexander Böhn]

• Exporter instances and subclasses can now be unregistered ... with tests for both that, and the new “wrapped”-function awareness logic ... in doing this we had to subtlely but fundamentally alter the logic within the verenable “clu.exporting.determine_name(…)” function – it now privileges “name” over “qualname” while going about its business. Tests seem to suggest this hasn’t perturbed anything, but that function is at the heart of the export system and so I wanted to make a note of the change here. [Alexander Böhn]

• A list comprehension should be faster than a “list(genexp)” ... right?… [Alexander Böhn]

• Since @export handles wrapped we can drop these manual exports ... also there is now a flag to make any function decorated with @itervariadic not iterate variadically, on like a case-by-case basis. [Alexander Böhn]

• Many rather significant updates: 1) The exporter will follow a “wrapped” attribute on a function to determine its name 2) Added “clu.predicates.itervariadic(…)”, a decorator to allow a function accepting (•args) to, when called with one iterable argument, to expand the iterable into “•args” when appropriate … “where appropriate” meaning it won’t do this by default on string/bytes/file-path-like arguments. 3) Updated the “iter()” methods of a bunch of things across the project to use “yield from” whenever possible, and to generally be less circuitous 4) Speaking of “wrapped”, that attribute is now set by at least one of my functional tools (I know “clu.fs.misc.wrap_value(…)” will do it but I forget the other one or two I updated RN). 5) Made some miscellaneous refinements in “clu.extending”. 6) The rest is A SURPRISE (because I forgot already – see the diff my fellow nerds, yes!) [Alexander Böhn]

• Trimmed dead code. [Alexander Böhn]

• Exporting Ω(a, b) as an alias for “clu.extending.pair(…)” [Alexander Böhn]

• The inlineiest and the testiest inline tests for “clu.extending” ... also another use of module “getattr(…)” – this time, it’s to initiate the… runtime adjuistment… of the testing utility module “pout” (which was writing all its shit to sys.stderr which in TextMate is this mass of godawful red text, plus I prefer sys.stdout for capturing and other shit, etc etc ok yeah OK). [Alexander Böhn]

• A little early Chanukkah present from RPython – ... check this crazy shit out; originally from here: https://bitbucket.org/pypy/pypy/src/default/rpython/tool/pairtype.py. [Alexander Böhn]

• Commenting in, commenting out. [Alexander Böhn]

• Formally requiring “pout” (for now) [Alexander Böhn]

• Ported most of the ChainMap unit tests to an inline function ... for introspectability. Strangely enough they don’t assert-fail in that context. I am beginning to worry that I have gone and done something very, very stupid somewhere in that testsuite… [Alexander Böhn]

• Tests of all sorts for “clu.dicts.ChainMap” [Alexander Böhn]

• I did a ChainMap. [Alexander Böhn]

• More ABC-reshuffling. [Alexander Böhn]

• Moved “clu.config.abc.ReprWrapper” around in the inheritance chain. [Alexander Böhn]

• Well pypy3 is •trying• to run the testsuite in tox. [Alexander Böhn]

v0.3.8 (2019-09-16)

Other

• Bump version: 0.3.7 → 0.3.8. [Alexander Böhn]

• Manual version adjust. [Alexander Böhn]

• Manual version adjust. [Alexander Böhn]

v0.3.7 (2019-09-16)

Other

• Bump version: 0.3.6 → 0.3.7. [Alexander Böhn]

v0.3.6 (2019-09-16)

Other

• Bump version: 0.3.5 → 0.3.6. [Alexander Böhn]

• Tweaked conditional-deepcopy logic ... now it uses “getattr(…)” which readers of the CLU source – if any exist besides myself – will note that I love that shit. [Alexander Böhn]

• Conditional deep-copying in “FlatOrderedSet”’s “clone(…)” logic. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• The “clu.config.abc.Clonable.clone(…)” method takes a “memo” param ... two birds with one abstract method, dogg. [Alexander Böhn]

• Allowing slots to percolate through select class stacks. [Alexander Böhn]

• Implemented better ReprWrapper and Cloneable ABCs. [Alexander Böhn]

• Trimmed dead code. [Alexander Böhn]

• Using “clu.predicates.item_search(…)” in “clu.dicts.merge_two(…)” ... also we’re using “clu.fs.misc.typename_hexid(…)” around some of the “clu.config” __repr__ implementations; ... aaaaaand there are one or two new predicates in “clu.typology”. [Alexander Böhn]

• Very corner-cased OCD-y adjustment to “clu.predicates.slots_for(…)” [Alexander Böhn]

• Checking for __mro__ internally instead of using “isclasstype(…)” [Alexander Böhn]

• AND THERE WAS MUCH NEGATION OF BOOLEAN PREDICATES. [Alexander Böhn]

• Using “clu.fs.misc.differentfile(…)” in “clu.fs.filesystem” [Alexander Böhn]

• One more teeny little refactoring in “clu.fs.misc.u8bytes(…)” [Alexander Böhn]

• Another micro-refactor in “clu.fs.misc.u8bytes(…)” [Alexander Böhn]

• Slight refactoring in “clu.fs.misc.u8bytes(…)” [Alexander Böhn]

• Rewrote and sort-of optimized “clu.fs.misc.stringify(…)” ... also did some more nitpickery with the “clu.config” ABCs and added more miscellany in general within “clu.fs.misc” as does befit its name. [Alexander Böhn]

• The tox settings had somehow become awry, so I un-awrized them. [Alexander Böhn]

v0.3.5 (2019-09-13)

Add

• Added “getstate(…)” and “setstate(…)” to “clu.config.base” ... specifically, the “clu.config.base.NamespacedMutableMapping” subclasses “Flat” and “Nested” [Alexander Böhn]

Other

• Bump version: 0.3.4 → 0.3.5. [Alexander Böhn]

• Moved config’s abstract bases into a new “clu.config.abc” module ... and all the myriad changes that go along with such. [Alexander Böhn]

• Some assorted housekeeping minutiae. [Alexander Böhn]

• EVERYBODY CHILL. [Alexander Böhn]

• Fixed that irritating off-by-one bug in “print_ansi_centered(…)” [Alexander Böhn]

• Easing iteration in “clu.exporting” ... using “yield from”, and ... removing gratuitous tuple-conversions. [Alexander Böhn]

• Removed wack function “predicates_for_types(…)” ... so uncivilized. [Alexander Böhn]

• Using “yield from” in “clu.exporting.ExporterBase” [Alexander Böhn]

• Using “yield from” in “clu.config.fieldtypes” [Alexander Böhn]

• Package-scoping the “clumods” fixture. [Alexander Böhn]

• Restoring entire os.environ mapping in “environment” test fixture. [Alexander Böhn]

• Removed empty test. [Alexander Böhn]

• Fixed “clu.config.filebase.FileBase” so file paths override searches ... previously, even specifying an explicit file path would not end up overriding the file path search, had the file path search found anything. [Alexander Böhn]

• “clu.fs.filesystem.Directory” is now reverse-iterable. [Alexander Böhn]

• Trimmed dead code. [Alexander Böhn]

• Further premature optimization. [Alexander Böhn]

• Hashed out gratuitous asserts in hot loop. [Alexander Böhn]

• Ensure sequence item keys are found in the directory instance. [Alexander Böhn]

• Iterating a “clu.fs.Directory” instance returns strings ... whereas before, it was returning raw DirEntry object instances, as emitted by “os.scandir(…)” – this has been corrected. [Alexander Böhn]

• The OrderedMappingViews in “clu.dicts” implement “collections.abc.Sequence” ... and they are now well-tested. [Alexander Böhn]

• Removed “call(…)” stub from “clu.fs.filesystem.Directory” [Alexander Böhn]

• Trimmed dead code in “clu.fs.filesystem” [Alexander Böhn]

• Renaming the “clu.dicts” testsuite module. [Alexander Böhn]

• Fixed “len(Directory(…))” which had been infinitely recursing ... also added some useful items/keys/values-views implementations in “clu.dicts” [Alexander Böhn]

• Starting on “clu.fs.sourcetree” module ... q.v. *.srctree files from the Cython test suite. [Alexander Böhn]

• I kind of hate “setattr(…)” and “getattr(…)” in every way. [Alexander Böhn]

• Almost there with namespaced field attribute access. [Alexander Böhn]

• Trimmed a bunch of dead code ... also wrote a docstring summarizing the “clu.naming” primary API. [Alexander Böhn]

• Halfway to namespaced field access as dotted attributes. [Alexander Böhn]

• Fixed a docstring copypasta typo. [Alexander Böhn]

• Getting rid of CLU-specific inline-test-ish code in “clu.config.filebase” [Alexander Böhn]

• Ensure sys.path entries pointing to files aren’t made into Directories. [Alexander Böhn]

• Clarified the parent module of “remove_invalid_paths(…)” [Alexander Böhn]

• Changing the PyYAML requirememt to tox-only ... also got rid of some unnecessary DepreciationWarning supressors. [Alexander Böhn]

v0.3.4 (2019-09-03)

Other

• Bump version: 0.3.3 → 0.3.4. [Alexander Böhn]

• Requiring PyYAML. [Alexander Böhn]

v0.3.3 (2019-09-03)

Other

• Bump version: 0.3.2 → 0.3.3. [Alexander Böhn]

• Including TOML files in MANIFEST.in. [Alexander Böhn]

v0.3.2 (2019-09-03)

Add

• Added new field types and spruced up the existing ones ... also began adding the new configuration schema stuff to the demo “yodogg” project found in tests/. [Alexander Böhn]

Minutiae

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.3.1 → 0.3.2. [Alexander Böhn]

• Bugfixes in “clu.config” – ... better None-checks in “clu.config.env” ... force-stringify arg in “clu.confiig.settings.Schema.nestify(…)” ... check type before length in “clu.config.fieldtypes.StringField” ... many updates and tweaks to the “clu.fs.appdirectories” module ... testing package EnvBase subclasses and custom schema classes in “test_config.py” ... miscellaneous changes to support all of the above shit. [Alexander Böhn]

• A large miscellany-roundup push, featuring: ... correct-er (i.e. more like the builtin) “update(…)” method’s logic, w/r/t iterable arguments; ... correct-er (i.e. not inconsistent) argument passing/checking in several of the “clu.config.fieldtypes.fields”; ... updates to “clu.config.filebase.FileName” allowing config files to optionally be located and used from “sys.path” directories ... fixes to the aforementioned “clu.config.filebase.FileName” to decouple it from CLU’s app name – config files should all now defer to the “clu.config.filebase.FileBase” respective subclass name information, across the board; ... Lots of docstring tweaks, corrections, and OCD-ish updates; ... The initialization logic of “clu.config.settings.Schema” now takes place in “new(…)” rather than “init(…)” – this lets subclassers forego calling up to the superclass if they define an “init(…)” and clearly separates the concerns; ... Some minor nitpicky updates to the way that the aforementioned “clu.config.settings.Schema” stringification methods work; ... Calling “clu.config.settings.Schema.validate()” returns True if all goes well… this may or may not be gratuitous as it’ll never return False – if validation goes awry at any point the call to “validate()” raises a ValidationError; ... The possible “replaceable endings” in “clu.exporting” are as automatically-generated as possible, and more comprehensive like in general; and finally ... the exporter tests now correctly locate, import, and examine the “yodogg” testing module’s exporter subclasses. [Alexander Böhn]

• WHOOOOPS. [Alexander Böhn]

• Fixing “clu.config.fieldtypes.TupleField” [Alexander Böhn]

• Removed “default” params from NamespacedFieldManager methods. [Alexander Böhn]

• Trimmed a whoooooole lot of dead code. [Alexander Böhn]

• Fixed container field types ... it wasn’t a pretty fix – it involves manually calling a field’s “set_name(…)” method – but it works. Blech! [Alexander Böhn]

• Moved file-format-related config stuff into “clu.config.formats” [Alexander Böhn]

• I feel docstring, oh so docstring – [Alexander Böhn]

• Docstrings for “clu.config.settings.Schema” [Alexander Böhn]

• Dead code trim, simplifications, greater helpfulness in exceptions… [Alexander Böhn]

• These tests, they are a-pass-in’ [Alexander Böhn]

• Beginnigs of repr logic for “clu.config.base.{Flat,Nested}” ... also fixes ensuring “clu.dicts.merge_two(…)” will actually work. [Alexander Böhn]

• More wide-ranging updates to the “clu.config” machinery ... Added a “clone()” method! ... Fixed “clu.dicts.merge_two(…)” to be properly generic, and thus support these new mapping types! ... cleaned the dead code out of “clu.config.tomlfile”! ... AND MORE!!!! [Alexander Böhn]

• Had to rename “clu.config.toml” as “clu.config.tomlfile” ... to avoid confusing import – like it was somehow doing py2-ish implict relative imports, “import toml” from within the file that defined “clu.config.toml” would yield “clu.config.toml” – what the fuuuuuuuuuuuck? So I changed it. [Alexander Böhn]

• Many updates to “clu.config” … ... docstrings abound! ... fixes for the “clu.config.base.Flat.{keys,values}(…)” methods! ... “Flat.nestify(…)” and “Nested.flatten(…)” allow reformatting namespaced-dictionary data losslessly between internal formats! ... Expanded the “find_file(…)” method and moved it and its many helper class-methods from “clu.config.filebase.FileBase” up to “clu.config.filebase.FileName” – the key difference being that the latter is a mixin class and can be reused outside of the FileBase implementation(s)! ... Most of the intermediate file-finding-related methods can take either additional or overriding parameters which will be great for testing!! ... other miscellaneous shit I am sure!!! [Alexander Böhn]

• Self-test introspection for the “clu.config.toml” module. [Alexander Böhn]

• Getting ever-closer – adding “clu.config.toml” [Alexander Böhn]

• Continuing apace on “clu.config.filebase” [Alexander Böhn]

• Fleshing out “clu.config.base”; staring on “clu.config.filebase” [Alexander Böhn]

• Start of the “clu.config” module. [Alexander Böhn]

• Moved a few enum-alias-related predicates into “clu.typology” [Alexander Böhn]

• First stab at slash-operators for Directory filesystem types. [Alexander Böhn]

• Trying to get the PyPy testenv to actually use PyPy, like it used to. [Alexander Böhn]

v0.3.1 (2019-08-16)

Add

• Adding “clu.constants.enums” to the hardcoded module list. [Alexander Böhn]

• Adding “clu.exporting.Exporter” to “clu.repl.columnize” [Alexander Böhn]

Minutiae

• Minutiae in the “show-modules.py” script. [Alexander Böhn]

Other

• Bump version: 0.3.0 → 0.3.1. [Alexander Böhn]

• Some tox.ini adjustments. [Alexander Böhn]

• Raising when calling “flatten(…)” on a nonexistant Directory. [Alexander Böhn]

• Confirming the new script directory location in the testsuite. [Alexander Böhn]

• Tweaks to the new display capacities of the “show-modules.py” script. [Alexander Böhn]

• Removed unused import. [Alexander Böhn]

• The “show-modules.py” script actually shows all the modules. [Alexander Böhn]

• Vendoring in a “columnize” implementation ... courtesy https://github.com/rocky/pycolumnize. [Alexander Böhn]

• Updating the hardcoded module list. [Alexander Böhn]

v0.3.0 (2019-08-15)

Other

• Bump version: 0.2.10 → 0.3.0. [Alexander Böhn]

• Test for “clu.fs.filesystem.script_path(…)” no longer xfails. [Alexander Böhn]

v0.2.10 (2019-08-15)

Add

• Added a stub clu/main.py file (all it does now is print the version) [Alexander Böhn]

Other

• Bump version: 0.2.9 → 0.2.10. [Alexander Böhn]

• Moved “scripts” directory into the CLU module base proper. [Alexander Böhn]

• F-strings in “clu/init.py. [Alexander Böhn]

v0.2.9 (2019-08-15)

Add

• Added a 'clu-boilerplate' console script entry point ... which echoes out the (mercifully very short) boilerplate you need to use CLU in a new Python module. [Alexander Böhn]

• Added the Exporter stuff to “clu.testing.utils” [Alexander Böhn]

• Added a “temporaryname” fixture-factory function to “clu.testing” [Alexander Böhn]

Minutiae

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.2.8 → 0.2.9. [Alexander Böhn]

• Stubbing out migration methods in “clu.keyvalue.CLUInterface” [Alexander Böhn]

• Enabled versioning by default in “clu.keyvalue.interface” [Alexander Böhn]

• Installing CSV-related lambdas from an earlier CLU iteration. [Alexander Böhn]

• Commented out hardcoded length-check lines in exporter tests. [Alexander Böhn]

• “weakref.WeakValueDictionary” is the new “collections.OrderedDict” ... as far as the “clu.fs.filesystem.TypeLocker” internal registry is concerned at least doggie. [Alexander Böhn]

• Revised the “clu.fs.filesystem.TypeLocker” registry metaclass ... got rid of the “prepare(…)” method that just returned an OrderedDict – it’s 2019 and our Python 3.7 dicts are more ordered than OrderedDict (and also less janky in the repr). ... Properly assign “name” and “qualname” – and also our own “lambda_name” – to each lazy-static “directory(…)” method that TypeLocker creates, using the same semantics and logic as “clu.exporting.ExporterBase.export(…)” ... Updated docstrings and nota-benne comments therein ... Also threw in some filesystem-module tests updates and other assorted miscellany. [Alexander Böhn]

• Renamed “suffix(…)” to “re_suffix(…)” to clarify things. [Alexander Böhn]

• Assorted touchups in “clu.exporting” ... to wit: a) made ValueDescriptor a proper data descriptor (if read-only) b) made both “class_getitem(…)” calls throw the same sorts of exceptions if they are passed the wrong shit c) added a proxied “clu.exporting.ExporterBase.items()” method d) something else nifty that I can’t remember just now, oh well. [Alexander Böhn]

• Reshuffle ... WHOOOOOOOOOOOPS. [Alexander Böhn]

• Including “.pyc” files in package index suffixes. [Alexander Böhn]

• Module-file suffixes for “path_to_dotpath(…)” come from “importlib” [Alexander Böhn]

• Stacking exports atop lru_cache decorators in “clu.fs.misc” [Alexander Böhn]

• Lowercasing all suffixes before comparison. [Alexander Böhn]

• Limiting function cache size on regex match/search functions. [Alexander Böhn]

• Caching “clu.fs.misc.re_{matcher,searcher}” functions ... using default-value “functools.lru_cache(…)” RN. [Alexander Böhn]

• Nitpick on the variable name inside the returned lambda ... within “clu.fs.misc.re_{matcher,searcher}” – it has, up to this point, been searching_for, which is wrong as this variable contains the string that itself is being searched; truncating the name to searching satisfies my OCD in this case (read it and you’ll see if you find this summary confusing, tensewise). [Alexander Böhn]

• Un-exporting two module constants in “clu.repl.banners” [Alexander Böhn]

• Un-exporting two module constants in “clu.enums” [Alexander Böhn]

• Un-exporting two module constants in “clu.fs.filesystem” ... get that comparison failure rate down doggie. [Alexander Böhn]

• Generalizing “clu.fs.misc.suffix_searcher(…)” [Alexander Böhn]

• Using “clu.fs.misc.gethomedir()” in “AppDirs” tests. [Alexander Böhn]

• Using new export “clu.fs.misc.gethomedir()” in the filesystem code. [Alexander Böhn]

• Nota benne. [Alexander Böhn]

• Moved one-off “gethomedir()” lambda to “clu.fs.misc” ... and exported it from there with a docstring and everything. [Alexander Böhn]

• Refactored the “clu.fs.filesystem.rm_rf(…)” test with “countfiles(…)” [Alexander Böhn]

• Passing through “parent” in the “temporaryname” fixture factory. [Alexander Böhn]

• Error-checking in “clu.fs.filesystem.TemporaryName.filesize(…)” [Alexander Böhn]

• Test fixture manscaping. [Alexander Böhn]

• One more “pth” → “path” changeover. [Alexander Böhn]

• Starting to normalize the argument names in “clu.fs.filesystem” ... tests still pass, so far…¬ [Alexander Böhn]

• Prevent leakage from the “clu.fs.filesystem.TypeLocker” metalclass ... specifically, all classes for which TypeLocker was their meta – we still need a good word for that – would receive a “types” attribute that was a reference to an OrderedDict full of all of those classes, as kept internally by TypeLocker for its own housekeeping purposes. That was a downside of its use, as this attribute was kind of hanging out in the open, using a fairly common name with no underscore-prefixing (something I kind of loathe, personally, but that’s me) or other indication of what it was or what it was for or how shit could break if it were to be improperly fucked with. ... This solves the problem by overshadowing the “types” attribute with a read-only “clu.exporting.ValueDescriptor” instance on all generated classes. [Alexander Böhn]

v0.2.8 (2019-08-12)

Other

• Bump version: 0.2.7 → 0.2.8. [Alexander Böhn]

• Rewrote “ls(…)” and “ls_la(…)” from “clu.fs.filesystem.Directory” ... to use the new less-cumbersomely-verbose modes of dealing with “clu.fs.misc.suffix_searcher(…)” [Alexander Böhn]

• Rewrote a lot of “clu.fs.filesystem.Directory.flatten(…)” ... as well as rewrites in “clu.fs.misc.suffix_searcher(…)” and “clu.testing.utils.countfiles(…)” – the latter of which now also takes a “suffix” argument to only count files matching a specific suffix, like duh ... expanded the “flatten(…)” method tests to cover all the new combos of using the suffix-related arguments and double-checked the output of everything and whatnot ... ALSO FIXED MANY BUUUUUUUGGS. [Alexander Böhn]

• Exporter checks in “clu.testing.pytest.clumods” and “show-modules.py” ... beforehand, there was a hardcoded list of “CLU modules” in a static tuple in “clu.constants.data” which really was a list of modules in CLU that used the “clu.exporting.Exporter” class to export their shit. ... now there still is; the difference is that that tuple can now contain any valid module in CLU and the two places where the tuple gets iterated also check to see if the module they’re exporting contains an exporter – if it doesn’t, whatever that bit of code returns won’t contain said module ... clearly this is a janky system but we currently need it to test that the Exporter registration system works in the first place; it could get pared down to like only being used in one or two instances, I feel like. [Alexander Böhn]

• Changed “followlinks=True” in “Directory.walk(…)” arguments ... plus some random updates and minutiae in “clu.fs.filesystem” and “clu.testing.utils” [Alexander Böhn]

• Confirming the counts of the flattened directory contents ... using a “countfiles(…)” function, which in itself isn’t really any type of anything – but its existence did necessitate the creation of a new “clu.testing.utils” module. [Alexander Böhn]

v0.2.7 (2019-08-09)

Other

• Bump version: 0.2.6 → 0.2.7. [Alexander Böhn]

• I think it’s irritating how .jpg and .jpeg are valid JPEG suffixes. [Alexander Böhn]

v0.2.6 (2019-08-09)

Other

• Bump version: 0.2.5 → 0.2.6. [Alexander Böhn]

• We now have a “Directory.flatten(…)” instance method ... plus a working test stub, plus helper methods (one of which let us rewrite some of “Directory.zip_archive(…)” to omit inlining the “relparent(…)” lambda). I wrote all of this up at the bar while standing up and drinking whiskey talking intermittently to other patrons so I am calling this effort NOT BAD AT ALL. [Alexander Böhn]

• Makefile rules for running pytest and tox ... I mean, it’s cool and all that the pytest fixture stuff is now a “plugin” module, with a setuptools endpoint and shit, instead of just a conftest.py file (which was working just fine by the way) but pytest, while a nice program and all, completely loses its fucking shit completely under certain conditions – one of which is, if somewhere or somehow during its utterly Byzantine loading/discovery/setup/config phase it is told to load one of these “plugin” modules more more than exactly once, it crashes like a fucking trainwreck and spews out what has to literally be the largest and most illegible traceback I have ever seen (and I worked with JSP and Servlets 1.0 in the fucking late 1990s). ... Anyway. So pytest isn’t all that bad aside from one or two of these occasional supernova-class exception belches every so often – once I sifted through the wreckage for the offending file I found the answer reading the pytest code, which was completely decent: legible, full of well-written comments and docstrings; aside from the plague of leading underscores that infects a lot of Pythonilinguists I thought it was great. So yeah I read it, figured out the fix (which itself wasn’t anything too nasty or circuitous) and that’s that. ... So yeah that’s the reason for this long-winded commit note: it’s so easy to talk shit about code and be like MOTHERFUCKER WHAT IN THE NAME OF LOVECRAFTIAN TWAT IS THIS AWFULNESS, WHO EVEN THINKS LIKE THAT and soforth; but so it’s necessary to point out when shit is not bad, and especially when shit is in fact somehow good. So yeah GOOD ON YOU, PYTEST, YOU GET A COOKIE!!! Indeed. [Alexander Böhn]

• The “clu.fs.filesystem.script_path()” function is poorly behaved ... particularly in normal sdist installs. Its test code has been branded with the shameful and dreaded X-FAIL for the moment. [Alexander Böhn]

v0.2.5 (2019-08-07)

Other

• Bump version: 0.2.4 → 0.2.5. [Alexander Böhn]

• Getting rid of root-level conftest.py, in favor of “clu.testing” [Alexander Böhn]

• A docstring! A docstring for this function straight away!!! ... if you say it in like a King Arthur voice it’s kinda funny. [Alexander Böhn]

• This is evidently how console-script endpoints should work. [Alexander Böhn]

v0.2.4 (2019-08-07)

Add

• Added a stupid little version-string script. [Alexander Böhn]

Other

• Bump version: 0.2.3 → 0.2.4. [Alexander Böhn]

• Made the stupid little version-string script a setuptools entrypoint. [Alexander Böhn]

v0.2.3 (2019-08-07)

Other

• Bump version: 0.2.2 → 0.2.3. [Alexander Böhn]

• Moving the pytest fixtures that use CLU formally into the project. [Alexander Böhn]

v0.2.2 (2019-08-07)

Other

• Bump version: 0.2.1 → 0.2.2. [Alexander Böhn]

• Fixed unlabeled keyword arg “default” in “slots_for(…)” internals. [Alexander Böhn]

• Tweaked and wrote tests for “clu.predicates.slots_for(…)” [Alexander Böhn]

• New accessors in “clu.predicates” using “inspect.getattr_static(…)” ... Which that function, “getattr_static(…)” retrieves attributes from things without setting off any of the “getattr(…)” or “getattribute(…)” logic insanity; this means that calling it (or any of my new and improved accessors based on it!!) will get you, like, e.g. a descriptor instance instead of to whatever the call to that instances’ “get(…)” method would’ve lead. ... So the new predicate attribute getter function things are all named “stattr(…)”, “stattrs(…)” – just like the versions sans the “st” prefixes (which it’s “st” for “static”, get it??) only the underlying calls use “getattr_static(…)” instead of calling “resolve(…)”… which calls “or_none(…)” which calls “getattr(…)” which calls a bajillion descriptor/class-dict/instance-dict/mro thingamabobs about whose inner workings I am always a bit hazy. ... SO YEAH ENJOY. Also I wrote tests for these, plus I simplified “getitem(…)” and also gave “clu.exporting.ValueDescriptor” a real “repr(…)” function for some reason. Yup. [Alexander Böhn]

v0.2.1 (2019-08-01)

Other

• Bump version: 0.2.0 → 0.2.1. [Alexander Böhn]

• Made the “clu.typespace.namespace.SimpleNamespace” type “hashable” [Alexander Böhn]

v0.2.0 (2019-08-01)

Other

• Bump version: 0.1.9 → 0.2.0. [Alexander Böhn]

• Clarified the “clu.naming.moduleof(…)” docstring. [Alexander Böhn]

• Ensured “determine_module(…)” will return any specified default value. [Alexander Böhn]

• Clarified the “clu.naming.nameof(…)” docstring. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

v0.1.9 (2019-07-27)

Add

• Added an actual export to the ExporterBase subclass test. [Alexander Böhn]

• Added a class_getitem method to “clu.exporting.Registry” ... and amended the relevant test accordingly. [Alexander Böhn]

• Added builtin exemplars to REPL env. [Alexander Böhn]

• Added “wheel” to the install requirements. [Alexander Böhn]

• Added “show-consts.py” and “show-modules.py” to the tox run ... I did this on a lark, to see if it would work and planning to revert it immediately – but it is actually really good to have these all print out, particularly in the PyPy environment (and perhaps others to come) which are not as readily inspectable. So these stay in. Yes!! [Alexander Böhn]

• Added pytest markers back in to tox.ini – ... I AM PLEASED TO ANNOUNCE TOX RUNS AND EVERYTHING PASSES! Except a bunch of Windows tests that get skipped. BUT OTHERWISE!!!! [Alexander Böhn]

Other

• Bump version: 0.1.8 → 0.1.9. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Made “clu.naming.{name,module}of(…)” truly universal ... to wit: they now search over the space of all registered instances of all registered subclasses of the base class “clu.exporting.ExporterBase” ... the logic is this: 1) First, try the instances’ attributes (either “qualname” or “name”, or either “module” or “package”, depending on what we’re doing). 2) Failing that, look up the name with each “ExporterBase” subclass in the registry, using ‘ExporterSubclass.nameof(…)’ or ‘ExporterSubclass.moduleof(…)’, depending. 3) If the instance isn’t found in any registered subclasses’ instance registry, try searching the system-wide module space using “clu.exporting.search_for_{name,module}(…)” 4) For module searches only, try one last search using the “pickle.whichmodule(…)” function before giving up. ... and you know, all tests pass – so fuck yes! [Alexander Böhn]

• Loading the “{attr,pyattr,item}_across(…)” predicates in the REPL. [Alexander Böhn]

• Fixed prefix in “yodogg” embedded test package. [Alexander Böhn]

• Filtering out class-registry function names in “ExporterBase.dir(…)” [Alexander Böhn]

• A little DRY in “clu.exporting” [Alexander Böhn]

• Object-identity comparisons in registered items work in tests. [Alexander Böhn]

• Some cheeky-ass motherfucking shit here. [Alexander Böhn]

• Made “path” a first-class keyword arg of “clu.exporting.ExportBase” [Alexander Böhn]

• Fixed a bug in “clu.fs.pypath.remove_paths(…)” and added some stuff ... namely “clu.fs.pypath.remove_invalid_paths(…)”, which removes anything in “sys.path” that doesn’t point anywhere; ... also added a module-private function “mutate_syspath(…)” used in both “remove_paths(…)” and “remove_invalid_paths(…)” to change the “sys.path” list in-place without randomly reordering it at the time. ... the new function is imported into the REPL environment and also called before the interactive interpreter starts, ensuring that the REPL environments’ “sys.path” is not bullshit in any way. [Alexander Böhn]

• Using “clu.naming.nameof(…)” instead of “clu.exporting.determine_name(…)” ... in “clu.typespace.namespace” [Alexander Böhn]

• One more assert in the ExporterBase subclass test. [Alexander Böhn]

• Extraordinarily minor tweak to docstring. [Alexander Böhn]

• Tweaked custom-subclass Exporter test. [Alexander Böhn]

• Simplified class-keyword logic in “ExporterBase” metaclasses. [Alexander Böhn]

• Avoiding namespace clash with “appnames” method and module-level set instance. [Alexander Böhn]

• Generalized “clu.exporting.PrefixDescriptor” as “ValueDescriptor” [Alexander Böhn]

• Class registry for ExporterBase derived types added. [Alexander Böhn]

• Split up ExportBase’s metaclass into “Slotted” and “Prefix” [Alexander Böhn]

• OCD-ish tweak to “clu.exporting.Prefix.new(…)” [Alexander Böhn]

• Moved PrefixDescriptor definition out of Prefix.new(…) [Alexander Böhn]

• Say that the new class will be slotted in the “new” docstring. [Alexander Böhn]

• Rewrote the “basepath” stuff in “clu.exporting.Exporter” ... using metaclasses. Now users of CLU can use the exporting stuff by creating a trivial subclass of “clu.exporting.ExporterBase” like so: [Alexander Böhn]

  class MyExporter(clu.exporting.ExporterBase, prefix="/my/prefix"): pass

  … so easy, like taking candy from a baby (but far less cruel
  and sadistic). Yes!
  

• ALWAYS DOUBLE-CHECK YOUR PROJECT-WIDE FIND-AND-REPLACE RESULTS ... there can be bogus side-effects that are silly at best (like this one) and devastating at worst – I am sure each and every one of you knows personally what I am talking about exactly. Yep. [Alexander Böhn]

• Renamed all those “thingname_xxx(…)” functions in “clu.exporting” ... also refined “clu.naming.{nameof,moduleof}” – coronating them as the new top-level user-facing interface to finding out what the fuck are the names for shit. Use of “determine_name(…)” was getting a bit creaky – that function was originally written as module-private, for use in the Exporter internals; now, it can basically keep that role (with a few reasonable exceptions) and “nameof(…)” and “moduleof(…)” can take over everywhere outside of the CLU exporting and name-discovery module internal code. ... Yes! [Alexander Böhn]

• “nameof(…)” is a real func instead of a “determine_name(…)” wrapper ... this involved: a) Moving all the module-search stuff out of “clu.naming” and into “clu.exporting”; b) Implementing module-search functions within exported modules as “Exporter.nameof(…)” and “Exporter.moduleof(…)” – using the generic “thingname(…)” function brought over from the “clu.naming” module; c) Rewiring “clu.naming.nameof(…)”, and its now-irritatingly incongruently-named cousin “clu.naming.determine_module(…)” to 1) first attempt attribute access, falling back on 2) the new “Exporter” class methods before 3) resorting to “determine_name(…)” or “thingname_search_by_id(…)” (which, at that point, will basically both do the same system-wide module search) – with “determine_module(…)” additionally trying to delegate out to “pickle.whichmodule(…)” before giving up entirely; d) Splitting dotpath elements in “nameof(…)” in case the final result ends up being an unwieldy qualified name e) Updating all the imports and exports and et cetera. [Alexander Böhn]

• More relativity. [Alexander Böhn]

• Relative-izing “path_to_dotpath(…)” to keep it non-CLU-specific. [Alexander Böhn]

• Fixed typo in requirements/dev.txt. [Alexander Böhn]

• Fleshed out the “dev” requirements. [Alexander Böhn]

• Removed irritating Makefile rule to clean up after pytest ... having already dealt with this with fixtures. [Alexander Böhn]

• Cleaned up tox.ini. [Alexander Böhn]

v0.1.8 (2019-07-23)

Add

• Added “scripts/show-modules.py” showing module-name nondeterminism ... it doesn’t really show all the modules, per se: it iterates over all of them but at the moment it only displays the results in which the results from the two calls “pickle.whichmodule(…)” and “clu.naming.determine_module(…)” are dissimilar. ... also I re-used the same ANSI formatting stuff as I used in the “show-consts.py” script (and they weren’t all that fleshed out, designwise, at any rate) so this thing could use some work. [Alexander Böhn]

• Adding submodule in “tests” for Exporter secondary-package setup. [Alexander Böhn]

• Added a “zict.LRU” buffer atop the ANSI code lookup caches. [Alexander Böhn]

Other

• Bump version: 0.1.7 → 0.1.8. [Alexander Böhn]

• Split off testing requirements into tox.txt. [Alexander Böhn]

• Requiring docopt in requirements/install.txt. [Alexander Böhn]

• I HATE VIRTUALENVS. [Alexander Böhn]

• Tweaking the REPL boostrap script. [Alexander Böhn]

• Shuffled imports in module naming test. [Alexander Böhn]

• Resolved double-export situation with SimpleNamespace and Namespace. [Alexander Böhn]

• Laid down a few pytest markers. [Alexander Böhn]

• Removed “Nondeterminism(…)” exception toss in naming test. [Alexander Böhn]

• Removing the last vestiges of the old xfail constants naming test. [Alexander Böhn]

• EXECUTIVE CALL: you have to import from “clu.constants” subpackages ... MEANING: you can’t do this shit anymore: [Alexander Böhn]

  from clu.constants import DEBUG, FilesystemError

  ... RATHER: you have to specify the subpackage:

  	from clu.constants.consts import DEBUG
  

  from clu.constants.exceptions import FilesystemError

  ... if that is annoying well TOO BAD. The source of a certain kind of nondeterminism in like e.g. “clu.naming.determine_module(…)” was the fact that these constants (it was always the constants, as they never have “module” or “package” properties) could be found by functions like “thingname_search_by_id(…)” in TWO SEPARATE AND DISTINCT PLACES. The nondeterminism comes from that, plus the fact that the module-load order (and thus, the natural-sort order of “sys.modules”) is itself nondeterministic fundamentally.

• Reshuffled the stuff in conftest.py. [Alexander Böhn]

• Moved list of XDG environment variables into “clu.constants.data” [Alexander Böhn]

• Repaired and updated the “determine_module(…)” test. [Alexander Böhn]

• It looks like this may solve the “xfail” naming test issue… [Alexander Böhn]

• Normalized the arguments for “clu.naming.nameof(…)” [Alexander Böhn]

• Class methods on “clu.exporting.Exporter” to retrieve modules ... So there are two new class methods: 1) Exporter.modulenames() → returns a list of the names of the Exporter instances in the registry – whose names are those of the module in which they’re ensconced; e.g. 'clu.enums', 'clu.fs.filesystem', etc. 2) Exporter.modules() → returns a dict keyed with the names from “Exporter.modulenames()” and populated with the actual modules these dotted paths indicate; this is done internally with “importlib.import_module(…)”. [Alexander Böhn]

• Converted an outlying ‘%’-style format string to an f-string. [Alexander Böhn]

• Exporting “clu.repl.ansi.evict_announcer(…)” in all the right places. [Alexander Böhn]

v0.1.7 (2019-07-23)

Add

• Added tests for “clu.naming.dotpath_to_prefix(…)” [Alexander Böhn]

• Added argument checking to “clu.naming.dotpath_to_prefix(…)” [Alexander Böhn]

• Added φ to represent the name of a Partial lambda-type ... which, you may ask, what the fuck does that mean? Allow me to explain: I had originally used a hack (by way of subclassing) to allow the Partial types returned from “apply_to(…)” to be given names and repr-string that matched lambda-type functions – that is to say, functions created with the “lambda” keyword – and in doing so, they’d all be treated the same as lambda-types by the “clu.exporting” mechanisms. This was handy because, as it turned out, “apply_to(…)” Partials were just as useful as typical lambda-type predicates, in like a whooole lot of the kinds of situations we get ourselves into, programmatically, here in the salt-mines of CLU coding. ... The problem arose just now, which while checking out some other recent (but unrelated) updates to the Partial-type structure, I saw that Partial instances retained a value for “module” that matched where the Partial class was defined (that is to say, “clu.predicates”) rather than wherever that specific Partial had been instantiated. ... I did not like that. This was due, of course, to the fact that lambda-types are created with a keyword, whereas Partial-types are just dumb ol’ instances, and these things obey different internal Python laws. ... To fix it, the Exporter again came to the rescue. This patch is mainly: a) The addition of the constant φ to represent the default name of the Partial-type – known as the “phi-type” here- after – and all the necessary support for a constant of this sort (it gets referenced in some GREEK_STUFF dict somewhere, etc etc). b) The embellishment of the Exporter’s “export” method to support the φ constant and the phi-type idea – which incedentally results in the “lambda_name” attribute actually being useful now, as it retains the naming information germane to what the thing originally was: lambda-type (“”) or phi-type (“”). c) The necessary tweaks to related functions to consider all of this (like e.g. the clu.typology predicate called “islambda(…)” considers both λ and φ when checking the value of “lambda_name”) d) Finally, and most crucially, the addition of logic – again in the Exporter – to alter the attribute value of “module” to the correct value whenever it encounters a phi-type in need of name-adjustment. This is doubly interesting (if you asked me) as it is the first use of the “dotpath” attribute the Exporter now sets, as a result of that recent edit wherein all Exporters are now initialized as “Exporter(path=file)” – the “path” value is used to compute the dotted module path, and lo, IT SEEMS TO WORK!!!!!!!!!!!!!!! Yeah dogg. [Alexander Böhn]

• Adding the new Directory subclasses to the REPL environment. [Alexander Böhn]

• Added two more Directory shortcut-subclasses in “clu.fs.filesystem” [Alexander Böhn]

• Added “predicate_none(…)” to clu.predicates using “negate(…)” ... also added tests for same and for the recently-added predicate “clu.typology.differentlength(…)” [Alexander Böhn]

• Added “differentlength” to clu.predicates ... this predicate isn’t a simple “negate(…)” of “samelength(…)” – it checks that its arguments are iterable in the same way as “samelength(…)” – so we define it here preemptively because of the fact that its negation is nontrivial. [Alexander Böhn]

• Added scripts/show-consts.py – a prettyprinter for clu.constants ... It’s adapted from the ad-hoc little inline const prettyprinter, “clu.constants.consts.print_all()” with a bunch of my own ANSI formatting sludge on top ... At this point it looks childish, but not too far off the final mark – it’s a weird medium in which to design, can I just say? ... Yeah like I would say 72-74% done, maybe ... Just go ahead, straight up python scripts/show-consts.py to execute it… you (meaning anyone besides me) might have to do some freaky PYTHONPATH shit first; I am virtualenv-ing all of this stuff right now but I’ll try and make these sort of things work OK, as like a example-code thing, an “Intro to CLU” type of deal, maybe. [Alexander Böhn]

• Added and filled a fixture graveyard at tests/obsolete_fixtures.py ... contains my spruced-up versions of the pytest-datadir fixture code, like for future reference of someshit I guess. [Alexander Böhn]

• Added a test for “resolve(…)” from clu.predicates. [Alexander Böhn]

• Added in instance checks for “metaclass(…)” tests. [Alexander Böhn]

• Added “iscallable(…)” and “iscallablelist(…)” to clu.typology ... and in so doing also tweaked “isfunction(…)” to return False for class types – all of which are callable – and any arbitrary instances of class types in posession of a __call__(…) method …the identification of which is now the domain of the brand-new “iscallable(…)” predicate. NOTE that this means “iscallable(…)” is VERRRRY DIFFERENT from the builtin “callable(…)” predicate, the likes of which is very eager call its operands callable if that is in any way vaguely the case. [Alexander Böhn]

• Adding to the “callable_types” typelist in clu.typology. [Alexander Böhn]

• Added a test for the collator-based accessors. [Alexander Böhn]

• Added “metaclass(…)” predicate and collator-based accessors ... all are found in clu.predicates; ... metaclass(thing) will retrieve either a) type(type(thing), b) type(thing), or c) thing, depending on whether “thing” is a metaclass, a class, or an instance. ... There are three new accessors: “attrs(…)”, “pyattrs(…)” and “items(…)”. These are all based on the new “collator(…)” apply- style basis function, which works like the “accessor(…)” and “searcher(…)” functions to apply one simple “getattr(…)”-type function to a thing, using a list of 1+ attribute or item names to compose its result. Unlike the other functions, which return the first viable result from the application list that gets returned, “collator(…)”-based accessors accumulate all results into an ordered tuple for return. WHICH MEANS: these accessors work like so: [Alexander Böhn]

  class YoDogg(object):

     yo = "Yo dogg,"
     dogg = "I heard you like"
     iheard = "irritating recursion"
  

  assert attrs(YoDogg, 'yo', 'dogg') == ("Yo Dogg,", "I heard you like") assert attrs(YoDogg, 'dogg', 'yo') == ("I heard you like", "Yo Dogg,") assert attrs(YoDogg, 'yo', 'wtf') == ("Yo Dogg,",) assert attrs(YoDogg, 'wtf', 'hax') == None

  ... I mean and you know the drill by now, “pyattrs(…)” is the same shit but for python reserved names, and “items(…)” of course is for getting items, like out of dicts and whatnot.

Minutiae

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.1.6 → 0.1.7. [Alexander Böhn]

• Tests for “clu.exporting.Exporter” instance registry. [Alexander Böhn]

• If a module wasn’t using the Exporter just then, it is now. [Alexander Böhn]

• Instance registry for all “clu.exporting.Exporter” objects. [Alexander Böhn]

• REPL script updates. [Alexander Böhn]

• Combined “path_to_dotpath(…)” and “dotpath_to_prefix(…)” ... and what do we get? why, “path_to_prefix(…)” of course, you doofus goober! ... threw in some quick addenda to the “dotpath_to_prefix(…)” test function to test this new shortcut. [Alexander Böhn]

• Trimmed dead code. [Alexander Böhn]

• F-STRINGS!!! F-STRINGS!!!!!!!!! F-STRINGS!!!!!!!!!!!!!! [Alexander Böhn]

• Rewrote “clu.predicates.getitem(…)” to not use a ‘get()’ function ... now it sticks to basic “getitem(…)” and “contains(…)” calls, which are fine ... also: started generally replacing the string-interpolate ‘%’ operator with f-strings (yay!!!!!) [Alexander Böhn]

• That empty-string default to “getattr(…)” was bugging me ... in “clu.exporting.Exporter.export(…)”, so I changed it up. [Alexander Böhn]

• Streamlining in the “clu.exporting.Exporter” initializer. [Alexander Böhn]

• Realigning “clu.exporting.Exporter” logic. [Alexander Böhn]

• Allow easy access to a Partial’s function and predicate arguments ... that is, “clu.predicates.Partial”, our custom module-local subclass of “functools.partial” that we use with “apply_to(…)” ... this “Partial” class is only ever returned from “apply_to(…)”; as such, we can kit it out for that purpose – as in this case, where we’ve added some properties for accessing the “function” and “predicate” arguments that were used to initialize this Partial instance. [Alexander Böhn]

• Ensure that copy operations in “clu.fs.filesystem” return booleans. [Alexander Böhn]

• Further simplifying the sequence predicates of “clu.typology” ... instead of manually checking the sequence argument in a lambda definition, we make all of the simple sequence predicates the partial-application result of “predicate_all(predicate)” which basically delegates the sequence argument handling to the “apply_to(…)” internals, which are like way more considerate than any ad-hoc stuff could possibly manage to be ... still, also added “isxtypelist(…)” intermediate (even though there was only one sequence-predicate corner-case that used a call to “istypelist(…)” rather than “issequence(…)” and that has since been redefined using the “predicate_all(…)” trick mentioned above, it’s helpful to look at if you’re thinking about doing something of that sort ... Yeah! Basically. [Alexander Böhn]

• Using an intermediate predicate to simplify the sequence predicates ... that are found in “clu.typology” ... added a “xlist(predicate, thinglist)” lambda, which basically is a shortcut for: [Alexander Böhn]

  issequence(thinglist) and predicate_all(predicate, thinglist)

  … which was getting to be a boilerplate-y repetetive refrain in
  all of those “clu.typology” sequence predicates
  

  ... used this new intermediate in “clu.mathematics” just basically to like kick the tires and soforth

• Simplified “lambda_repr(…)” definition in clu.predicates ... the “pyname(…)” shortcut lambda had been defined, like, a mere eleven LoC north of the offending definition… how embarrasing. [Alexander Böhn]

• Simplified the “predicate_none” test predicate. [Alexander Böhn]

• Importing “operator” in reply-bpython.py. [Alexander Böhn]

• Updated “clu.typology” testsuite function name. [Alexander Böhn]

• Fixed test function name, which was wrong, and needed fixing. [Alexander Böhn]

• Updated some filesystem tests to use the “temporarydir” fixture. [Alexander Böhn]

• Moved the huge greek-text dict to new module “clu.constants.data” ... Which OK yeah I know “data” is a lame-ass name for a module or anything like that – technically they all contain data so it is not that descriptive – but I wanted a catch-all junk-drawer module, and so. Yes! [Alexander Böhn]

• Removed dangling import. [Alexander Böhn]

• Trying package scope for the “dirname” fixture ... the latest pytest docs call package-scope “experimental” – so that’s what this is: like that time you drunkenly made out with your sophomore-year roommate and then never really talked about it afterward for like twenty years, I am “experimenting”. [Alexander Böhn]

• Split the “datadir” fixture into two fixtures, one module-scoped ... this way a) you can just get the "test/data" path wrapped in a Directory instance, if you like, and b) that part of all the fixture code only runs once per module, which that in theory might be vaguely faster, one day. [Alexander Böhn]

• Sometimes you have to just do it yourself to do it right ... I mean, no offense to the pytest-datadir author(s), or to the people behind pytest itself – but what the fuck, the datadir plugin has, you know, ONE JOB: mirror a data directory for use at test-function scope. And I mean, it was technically doing that job – but that’s all it was doing; its usage was causing copies of the mirrored directory contents to unceremoniously pile up in a $TMPDIR subfolder (hithertofore unknown to me) called “pytest-of-fish” (because that’s my local username, OK, “fish”)… like one copy every time the fucking testsuite ran. There are like a nontrivial stash of test images in there right now (and that is just like off the bat, it would only have gone up) and I was only using the fixture in like ONE fucking test, imagine had I been more zealous. ... So OK whatever, like I am sure all the other pytest programmers and plugin developers all have gigantic SANs and redundant SSDs in the biggest and storage-capacity-est laptops money can buy, or someshit – I do not, and after dealing with multitudinous secret stashes like e.g. “.pytest_cache” and “.tox” and others, I was not expecting this last heap of data to show up where it did, grow with reckless abandon until “rm -rf”-ed, without any further explanation. ... So! I looked at the fucking plugin and it was like 20 lines of code, in three fixture functions. I copypasta’ed it into clu’s “conftest.py” file, commented it (which like expanded its LoC count by at least 2.5x) and then wrote a new fixture that did what the original code was supposed to do – only a) correctly, b) using my own filesystem abstractions, which are fairly more featureful in a bunch of ways than “pathlib.Path” or othershit … «BRAGGGGG» yes erm ok – but and then c) using yield and managed context and assertions, because who the fuck wrote this original shit anyway?? I am sorry guys but your thing had ONE FUCKING JOB and while it technically did do this (like, without shooting uncaught exceptions everywhere or trashing my files, I guess) IT SUCKED. My shit rules, because it works, it’s legible, it’s commented and be-docstring’d and on GitHub – any one can use it of course – and it doesn’t have the ridiculous overblown sense of purpose to be like a whole plugin package and shit. YOURE JUST ANOTHER PART OF ME!! oh wait I shouldn’t be quoting that guy these days, how uncouth, sorry about that. [Alexander Böhn]

• Replaced “allof(…)” helper with “and” operator expressions ... the problem with using “allof(…)” within functional-style compositions is that it does not short-circuit, so you can’t really use it in situations like: [Alexander Böhn]

  yodogg = lambda a, b: allof(isiterable(a), isiterable(b), set(a).issuperset(set(b)))

  … which that looks like it might work, but if either “a” or “b”
  is actually not iterable – that is to say, one of the first two
  predicates being fed to “allof(…)” evaluates to False – then
  the last expression throws a TypeError at the point where it
  attempts to initialize a `set` with something non-iterable.
  
  … This lambda should be rewritten like this:
  
      yodogg = lambda a, b: isiterable(a) and \
       	 	      isiterable(b) and \
    	      set(a).issuperset(set(b))
  
  … Notice how all it takes is a backslash and some indentation
  here and there, and no one has to gripe about “waaaah Python
  lambdas’re only one line, whyyyyyy” or such shit. Yeah so the
  2nd form of the lambda works if you call “yodogg(None, None)” –
  that is, assuming returing False from such a call is within the
  definition of “works”. Frankly if you *want* exceptions (which
  generally I don’t, for normal operations) that is one case in
  which lambdas will definitely not assuage your issues, as you
  can’t really backslash your way through try/except blocks, I
  don’t think. Yep.
  

  ... Also in this commit: some miscellaneous import-juggling

• Minor simplification in the clu.exporting.Exporter constructor. [Alexander Böhn]

• Whitespace OCD. [Alexander Böhn]

• Simplified some of the collator tests’ assertions. [Alexander Böhn]

• Renamed “collator” to “acquirer” and rewrote “collator” ... as always this is all found in clu.predicates, my favorite module these days ... “collator” better refered to the operation that got all of the occurrences of something* across all of a list of things (as it is now), rather than the operation to get each occurrence of many somethings from a single thing (which is what “acquirer” now does); I like these names better as they are more apropos, what do you think? [Alexander Böhn]

• Got rid of “unicode” usage in clu.predicates. [Alexander Böhn]

• Exporting some oddly un-exported typelists from clu.typology. [Alexander Böhn]

• Test for “isunique(…)” and “samelength(…)” of clu.typology. [Alexander Böhn]

• I dunno dogg it just reads better this way I think. [Alexander Böhn]

• Rewrote “isunique(¬)” and added “samelength(¬)” in clu.typology. [Alexander Böhn]

• Import ordering OCD. [Alexander Böhn]

• Expanded “apply_to(…)” test to include exception-raising. [Alexander Böhn]

• Amended test function name. [Alexander Böhn]

• Tests for “subclasscheck(…)” and sundry callable-related predicates ... all from clu.typology, in the new typology test suite. [Alexander Böhn]

• Formatting and whitespace. [Alexander Böhn]

• Removed unnecessary call to “maketypelist(…)” in “subclasscheck(…)” ... that would be in clu.typology – in the function definition that is arguably the backbone of that whole module, actually. [Alexander Böhn]

• Finally, started a testcase suite for clu.typology. [Alexander Böhn]

• Trepidaciously starting to use “functools.wraps(…)” in “negate(…)” ... I can’t seem to get it to NOT update the function signature, as is displayed in e.g. bpython above the display of inline doc strings …!? [Alexander Böhn]

• Expanded classtype predicates test to cover “metaclass(…)” [Alexander Böhn]

• Fixed a docstring that was showing the wrong arity. [Alexander Böhn]

• Made “isfunction(…)” – née “ΛΛ(…)” – not use “callable(…)” [Alexander Böhn]

• Using an empty tuple as the collator’s default return value. [Alexander Böhn]

• Exporting “collator(…)” from clu.predicates. [Alexander Böhn]

• Using new collation accessor to build typelists in clu.typology. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Fixed SUNDER and DUNDER in clu.enums. [Alexander Böhn]

  Whoooooooooops

• Updated an old source notation in clu.typology. [Alexander Böhn]

• Swiped dotpath-attribute resolution function snipped from stdlib ... AND IT JUST WORKS. Tests just pass, everything is just fine. HOW IS THAT POSSIBLE… I am suspicious of course but if that were to be that, how awesome would that be??? Here’s the orig: [Alexander Böhn]

  https://docs.python.org/3/library/operator.html#operator.attrgetter

  ... YEAH!!!

v0.1.6 (2019-07-16)

Add

• Added some superfluous asserts on the numpy import. [Alexander Böhn]

• Added numpy import-or-skip to ensure the “array_types” assertion ... since 'MaskedArray' is hardcoded into the assertion, the test would theoretically fail if numpy was unavailable, since the typelist wouldn’t have been populated with any numpy types in the init phase of the clu.typology module; I know I can’t freakin imagine a world without numpy but that doesn’t mean there isn’t such a place somewhere, assuredly; hence this lil’ tweak right here, for the people who live in that spiritually- impovershed theoretical numpy-less flummoxing drugery, yes. [Alexander Böhn]

• Added “fields” and stringify(…)-based repr to clu.keyvalue. [Alexander Böhn]

• Added an “update(…)” dict-like method to the exporter. [Alexander Böhn]

• Added test checking the sum of three exporter instances. [Alexander Böhn]

Other

• Bump version: 0.1.5 → 0.1.6. [Alexander Böhn]

• All sorts of new numpy-related shizziach. [Alexander Böhn]

• Clu.repl.ansi.ansidoc(…) is now variadic ... call it with all the things, feel free ... or just use it with pythonpy: [Alexander Böhn]

  py 'clu.repl.ansi.ansidoc(clu.exporting.Exporter.export, clu.predicates.negate)' | less -R

  ... it’s THAT EASY.

• Using multiple format directives in ANSI “color” arguments. [Alexander Böhn]

• Trying to wrangle an “ansidoc(thing)” function ... which that putatively will do exactly what you think it will do, which is display docstrings for things in ANSI colors – LIKE HUU-DOYYY as Liz Lemon would put it during L.U.N.C.H. [Alexander Böhn]

• Made one of the numpy asserts more legibly attractive. [Alexander Böhn]

• Tests for sigma aliases: both “σ” and “Σ” from clu.mathematics. [Alexander Böhn]

• N.B. my love for Greek symbology is due to math and not frats. [Alexander Böhn]

• If we’re conditionally getting things, it needs to look good. [Alexander Böhn]

• Went mad with Greek math aliases, like a little, just a bit. [Alexander Böhn]

• How do you write this line and not think of that Family Guy guy ... the one who says that thing. [Alexander Böhn]

• Another day, another Makefile rule to clean up some shit somewhere. [Alexander Böhn]

• Reverted __bytes__(…) method changes in clu.fs.filesystem ... using “self.to_string()” would have had those methods return bytes-ified object repr strings, which we don’t actually want that, we want the fucking filesystem path in bytes-ized form. [Alexander Böhn]

• Removed some redundant stringify(…) calls in clu.fs.filesystem. [Alexander Böhn]

• Tidied up the imports in clu.repl.ansi. [Alexander Böhn]

• Check for “source” keyword in class kwargs before deleting it. [Alexander Böhn]

• This is the second time I’ve misplaced an “encoding” keyword arg ... specifically when inlining a bytes() or str() conversion – for some reason I keep passing the encoding argument into the call enclosing the conversion-op construction, instead of, you know, where it’s the fuck supposed to be. GAH. [Alexander Böhn]

• Corrected some ⌘ C-⌘ V kind of docstring mistakes. [Alexander Böhn]

• Spaces to tabs, when it comes to Makefiles. [Alexander Böhn]

• Fencing the Enum import in clu.predicates. [Alexander Böhn]

• Always None-initialized Exporter.dotpath if a path wasn’t passed. [Alexander Böhn]

• Wishful thinking. [Alexander Böhn]

• Exporters now accept a “path” kwarg for specifying their file [Alexander Böhn]

• Isolating imports in clu.naming. [Alexander Böhn]

• Trimming and compartmentalizing clu.exporting imports ... AGAIN I KNOW. [Alexander Böhn]

• Fully clarified the imports in clu.exporting. [Alexander Böhn]

• Going from pickle.whichmodule(…) to my own module-determiner ... which if we do this, it makes the one test marked as “xfail” in test_naming.py into a Heisenbug; that test now comes back as an “xpass” over 50% of the time, for some reason – but it still fails enough not to warrant unmarking it. Huh. [Alexander Böhn]

• Amended real-world exporter-combo tests to examine keysets. [Alexander Böhn]

• Renamed the module-level unnamed lambdas in the exporter test ... so as not to shadow or overwrite or otherwise fuck with things that had the same names, but had been defined local to their respective test methods in other places. [Alexander Böhn]

• Fixed the unnamed-lambda test in test_exporting.py ... in a hacky way I confess – I had to move the lambda definitions out of the test-case method and up to the module-level for the “thingname_search(…)” function to work on them. [Alexander Böhn]

• Travis tweak. [Alexander Böhn]

• MTV’s Make My File. [Alexander Böhn]

• Using “clu.fs.misc.stringify(…)” in “clu.fs.appdirectories.AppDirs” ... added some trivial sanity-check type lines in the test suite. [Alexander Böhn]

• Looking at the return value of Directory.zip_archive(…) in the test. [Alexander Böhn]

• Trimmed some dead code. [Alexander Böhn]

• Finally, a clu.fs.filesystem test for Zipfile archiving. [Alexander Böhn]

v0.1.5 (2019-07-15)

Add

• Added text fixture to provide long “Lorem Ipsum”-style texts; ... wrote a new key-value-store test using the Lorem Ipsum fixture; ... switched one of the filesystem tests to use our wrapped version of NamedTemporaryFile and in doing so, caught triaged and fixed an actual bug in that code -- which I believe is how this whole thing is supposed to work in the first place, right? Right. ... a few assorted touchups to the filesystem module have also made it in there, I do believe. [Alexander Böhn]

Other

• Bump version: 0.1.4 → 0.1.5. [Alexander Böhn]

• Fixed a bug in clu.fs.filesystem.Directory.zip_archive(…) ... the bug was actually in clu.fs.filesystem.TemporaryName.copy(…) which I had blindly refactored at some point in the somewhat recent past; anyway, I’m going to add a proper test which is why this commit also includes a gratuitous bunch of JPG and PNG binaries as “test data”, erm. [Alexander Böhn]

• We no longer have to delete things from modules ... lest anyone forget, that’s why we wrote all that exporter stuff. [Alexander Böhn]

• Moved “scandir” and “walk” imports to clu.constants.polyfills. [Alexander Böhn]

• Changed all my “graceful_issubclass(…)” refs to subclasscheck(…) ... it’s better-looking, less confusing, terse-er and an all-around improvement. Don’t you think? [Alexander Böhn]

• Using the clu.exporter machinery in clu.fs.{filesystem,misc} [Alexander Böhn]

• If we bring back clades, we’ll redo all this stuff. [Alexander Böhn]

• Made clu.predicates.Partial.__init__(…) not use an explicit check ... specifically it was testing “if PYPY” to decide whether to pass its variadic arguments up the super(…) call-chain; now, it just tries to pass, repeating the call without the variadics if anything gets raised. Because you know what that is? ITS MORE PYTHONIC, MOTHERFUCKERS, THAT IS WHAT THAT IS. [Alexander Böhn]

• More Makefile tweaks. [Alexander Böhn]

• Made the Makefile look slightly less like drunken spider footprints ... there is actually a “make test” target after all these years; there are separate rules to purge build and test artifacts (the latter of which have been piling up it would seem); some things make sense now to do before other things, blah blah ITS ANOTHER MAKEFILE COMMIT OKAY? You know EXACTLY what it is and YOU DON’T GIVE A FUUUUUUCK. Who can blame you? I’ll let you know when the diff is something of consequence in a language you like, okay my doggie? Fuck yes. [Alexander Böhn]

• Keeping Makefile tasks from wreaking mayhem with native extensions ... one rule, written for a Cython-based project, was going through and unceremoniously purging everything that had an *.so suffix, which in this case was not so much Cython artifacts as it was all the helpfully compiled bits of installed modules like oh you know NUMPY and all its friends dogg what the fuck! OK so fixed. Whooooooops. [Alexander Böhn]

v0.1.4 (2019-07-09)

Add

• Added “dict_types” to clu.typology ... fully clarified a few imports from clu.constants.polyfills too. [Alexander Böhn]

Other

• Bump version: 0.1.3 → 0.1.4. [Alexander Böhn]

• The clu.compilation.macros module had lost its ever-crucial TOKEN! ... It also had docstrings on one class but not the other, for some stupid reason – I evened that shit up and fixed it. [Alexander Böhn]

• Using the emoji-riddled inline code as the actual negate(…) docs. [Alexander Böhn]

• No longer defining the ANSI metaclass’ CacheDescriptor inline. [Alexander Böhn]

• MIGHT AS WELL FACE IT YOURE ADDICTED TO slots ATTRIBUTES. [Alexander Böhn]

• ANSI string-lookup caches now count their hits and misses. [Alexander Böhn]

• For some reason the “typing” module plays unnicely. [Alexander Böhn]

  ... with virtualenvs. Like it being installed makes nearly every attempt to start a Python program crash all over itself somewhere deep on some import from typing. Whatevs, I’m over it, go fuck yourself, typing module you fucking douche

• Moving development-environment REPL scriptlets into the codebase… [Alexander Böhn]

• Fleshed out clu.repl.ansi.ANSIFormat a bit ... meaning I stole a few of the best bits from VersionInfo (which is also a NamedTuple ancestor) and adapted them, particularly for construction ... tried to figure out WTF is with bpython and printing ANSI and got rather much nowhere ... All of the ANSI-enmeta’d enums – or OK pal what is •your• cool word for “classes that employt the indicated classtype as their metaclass” – now cache their “Type.for_name('string')” lookups, which were potentially doing linear scans of both internal dict sets (__members__ and __aliases__ motherfucker) and while I personally never experienced slow performance or behavior on this operation, the fact that it could have concievably been pathologically there sometime in the far-off future led me to choose this issue as my PREMATURE OPTIMIZATION OF THE WEEK!!!! [Alexander Böhn]

v0.1.3 (2019-07-09)

Add

• Added custom-bool method example in predicate builtin helper tests. [Alexander Böhn]

• Added another set of exemplary assertions to the helper tests. [Alexander Böhn]

• Added allof(…)/anyof(æ)/noneof(≠) variadic helper functions ... they’re in clu.predicates – their presence helps to clarify just why the fuck tuplize(…)/listify(≠) etc are there like to begin with: they’re all variadics instead of single-argument functions whose operand(s) must be iterable. Yes! [Alexander Böhn]

• Added hasattr(¬) negations: noattr(…) and nopyattr(…) [Alexander Böhn]

• Added “isenum(…)” pre-checks to the new enum dict-examining predicates. [Alexander Böhn]

• Added “negate(¬) function for negating boolean predicates. [Alexander Böhn]

• Added more Python versions to tox.ini. [Alexander Böhn]

• Added more fixtures and keyvalue tweaks ... Practical upshot is that the first test is done and runs. [Alexander Böhn]

• Added “version” and “update(…)” to the keyvalue API. [Alexander Böhn]

• Added PyPy compatibility check in clu.predicates.Partial.init(…) [Alexander Böhn]

Other

• Bump version: 0.1.2 → 0.1.3. [Alexander Böhn]

• Only using Python versions currently available locally in tox.ini. [Alexander Böhn]

• Docstring spit-and-polish in the clu.sanitize module. [Alexander Böhn]

• DOCSTRINGS!! DOCSTRINGS!!!!!!! DOCSTRINGS!!!!!!!!!!!!!!!!!!! [Alexander Böhn]

• Spiffed up the negate(…) docstring ... since yeah OK I confess, this function is basically like my new kitten right now, in terms of my feelings. [Alexander Böhn]

• Fixed a whoooooole lot of unreasonable docstrings in clu.predicates. [Alexander Böhn]

• Truly gratuitous callability checks in attr(…) accessor test. [Alexander Böhn]

• Bringing the negated hasattr(…) shortcuts into the testsuite. [Alexander Böhn]

• Used negate(function) to build noattrs(…) and nopyattrs(…) ... which those are shortcut hasattr(…) function shortcuts. [Alexander Böhn]

• WHOOOOPS ... forgot to pass on those predicate arguments now didn’t I there. [Alexander Böhn]

• Moved clu.repl.enums to clu.enums (deserving as it is of the top level) [Alexander Böhn]

• Got rid of the TOXENV stuff completely from Travis’ config. [Alexander Böhn]

• Updated the Travis CI config’s TOXENV matrix thing. [Alexander Böhn]

• Pointing tox.ini’s [deps] at the proper requirements file. [Alexander Böhn]

• Fully qualifying all non-relative imports with “clu.xxxxx…” [Alexander Böhn]

• Making “tox” run. [Alexander Böhn]

• Not recursing into the venv root. [Alexander Böhn]

• Better docstrings for some clu.repl.ansi functions. [Alexander Böhn]

• Moving the “environment” pytest fixture function to conftest.py. [Alexander Böhn]

• Warnings are fired off when setting up AppDirs with certain values ... to wit: “appauthor”, “roaming” and “multipath” are Windows-only options; we now warn if one tries to make use of them while on a non-Windows platform ... also refactored some of the AppDirs-based key-value ancestor type stuff. [Alexander Böhn]

• Fixed and added tests for clu.fs.script_path(…) [Alexander Böhn]

• Got rid of legacy Cython helpers in setup.py. [Alexander Böhn]

• Rehashing the keyvalue module. [Alexander Böhn]

• Removed “defaults” kwarg from ANSIFormatBase NamedTuple declaration ... this greased the wheels for PyPy compatibility, and it turns out to be totally unnecessary anyway, because the defaulting is taken care of in the subclass. [Alexander Böhn]

• N.B. “psutil” IS NOT OF OR IN THE STANDARD LIBRARY, DOGG. [Alexander Böhn]

• Removed “defaults” kwarg from ANSIFormatBase NamedTuple declaration ... this greased the wheels for PyPy compatibility, and it turns out to be totally unnecessary anyway, because the defaulting is taken care of in the subclass. [Alexander Böhn]

• MANIFEST.in includes only .py files from the tests/ directory. [Alexander Böhn]

• Noodled around with the project Makefile, pt. II. [Alexander Böhn]

• Noodled around with the project Makefile. [Alexander Böhn]

v0.1.2 (2019-07-02)

Add

• Adding XDG_RUNTIME_DIR to the list of verboten XDG env names. [Alexander Böhn]

• Added more tests for module functions in clu.fs.filesystem ... specifically: ensure_path_is_valud(…), write_to_path(…), which(…), back_tick(…) (in its simplest mode of operation), and rm_rf(…). [Alexander Böhn]

• Added isXXXXXlist(…) predicates to clu.typology ... this consists of two moving parts: a) Added an issequence(…) predicate to clu.typology ... this uses “collections.abc.Sequence” to check a given thing’s sequence-ness b) Added isXXXXXXlist(…) predicates, each composed as such: isXXXXXXlist = lambda thinglist: issequence(thinglist) and predicate_all(*thinglist) [Alexander Böhn]

  ... docstrings courtesy clu.exporting.Exporter

• Added/edited some apply_to(…)-related docstrings. [Alexander Böhn]

• Added try/except around dict-ification in Exporter.init(…) [Alexander Böhn]

• Added some method docstrings in clu.exporting.Exporter. [Alexander Böhn]

• Added “default” keyword args for accessor/searchers ... as in those from clu.predicates; tests were updated accordingly. [Alexander Böhn]

• Added tests for enum aliasing ... added an AliasingEnum subclass of Enum that makes use of the AliasingEnumMeta metaclass (largely for conveniences’ sake). [Alexander Böhn]

• Added init.py to scripts. [Alexander Böhn]

Minutiae

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.1.1 → 0.1.2. [Alexander Böhn]

• Amended clu.predicates accessor lambdas with call signatures. [Alexander Böhn]

• Corrected clu.predicates.pyname(…) docstring. [Alexander Böhn]

• Properly module-exporting some of the clu.repl.enum stuff. [Alexander Böhn]

• Trimmed inline assert from clu.repl.ansi. [Alexander Böhn]

• Using clu.exporting in clu.repl.ansi. [Alexander Böhn]

• Trimmed inline assert from clu.repl.banners. [Alexander Böhn]

• Using clu.exporting in clu.repl.banners. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Trimmed inline assert from clu.repl.enums. [Alexander Böhn]

• Using clu.exporting in clu.repl.enums. [Alexander Böhn]

• Getting System enum from fully-qualified module path. [Alexander Böhn]

• Got rid of crappy old unused memoization tools in clu.fs.msic. [Alexander Böhn]

• Tests (and tweaks) for clu.fs.filesystem.temporary(…) [Alexander Böhn]

• Pruned unused SYSTEM import from test_fs_appdirectories.py. [Alexander Böhn]

• Removed clu.fs.appdirectories inline test from clu.keyvalue. [Alexander Böhn]

• Put in stubbed Win32 clu.fs.appdirectories tests ... each of which ensures it gets skipped by immediately making a call to “pytest.importorskip(…)” with some win32 interop module as the operand. [Alexander Böhn]

• Checking type of convenience Directory properties. [Alexander Böhn]

• Proper tests for clu.fs.appdirectories (adapted from inline tests) ... THE GOOD NEWS: there’s a full test suite for the aforementioned clu.fs.appdirectories – namely the AppDirs class from same – that uses a py.test “fixture” to keep XDG_WHATEVS variables out of the picture; all systems except System.WIN32 get their test coverage; tests are properly parameterized for the user who is running them (i.e. it’ll work for someone who isn’t me) ... THE BAD NEWS: under some conditions – notably when running with py.test – the “self.system is System.DARWIN” (&c.) comparisons within the clu.fs.appdirectories module were failing, as the System enum looked like it came from a different place, module, or package (pick your fave) and so I had to implement a fucking __eq__(…) method in clu.constants.enums.System and change all the comparisons from “is” to “==” to get this shit to work – which kind-of totally defeats one of the great advantages of a fucking enum (namely that its instance members are singletons automatically and can be compared with “is”). ... THE UGLY NEWS: the same problem that affected the enums seems to also affect the use of clu.version.VersionInfo – so I had to stringify both sides in all the comparisons between those in all of the test methods, which we can all agree, that’s fucking ugly as shit, right? I mean it works and it’s legible and the functionality is being properly tested, yes, but AT WHAT COST. [Alexander Böhn]

• Trimmed inline assert from clu.sanitizer. [Alexander Böhn]

• Using clu.exporting in clu.sanitizer. [Alexander Böhn]

• Trimmed inline assert from clu.dicts. [Alexander Böhn]

• Using clu.exporting in clu.dicts. [Alexander Böhn]

• Test for in-place clu.exporting.Exporter add operator. [Alexander Böhn]

• Made clu.exporting.Exporter add-able and in-place-add-able ... updated tests accordingly ... stole logic from clu.typespace.namespace.Namespace. [Alexander Böhn]

• Renamed clu.predicates.partial_ex to clu.predicates.Partial. [Alexander Böhn]

• Juggled imports in clu.keyvalue relevant to inline test. [Alexander Böhn]

• Re-enabled the Exporter in clu.keyvalue. [Alexander Böhn]

• Exporting “lambda_repr(…)” from clu.predicates. [Alexander Böhn]

• Partials created by clu.predicates.apply_to(æ…) are repr-equivalent ... meaning: they don’t use the functools.partial.__repr__() like as-is off-the-shelf; apply_to(…) now uses a custom subclass of functools.partial overriding the __repr__() method and adding __name__ and __qualname__ attributes – such that all these partial objects look like lambda instances (at least as far as clu.exporting.Exporter.export(…) is concerned). ... This is in the category of “Circuitous and arguably stupid yet strangely satisfying hacks” – as it allows the exporter to rename apply_to(…) partials just as it does with lambdas, sans too much extra tweaking. We’ll see when the other shoe drops and it turns out that this change breaks everything in sight, okay. [Alexander Böhn]

• Socked away my lambda.repr–equivalent. [Alexander Böhn]

• Using clu.exporting in clu.mathematics. [Alexander Böhn]

• Further clu.predicates trimming. [Alexander Böhn]

• Trimmed inline assert from clu.predicates. [Alexander Böhn]

• Using the clu.exporter in clu.predicates. [Alexander Böhn]

• Trimmed inline assert from clu.typology. [Alexander Böhn]

• Using the clu.exporting.Exporter in clu.typology. [Alexander Böhn]

• Starter tests for clu.exporting ... which have already revealed some module-level-related problems with thingname_search(…) and friends ... also using clu.exporting.Exporter in clu.naming. [Alexander Böhn]

• Basic exporter working as clu.exporting.Exporter. [Alexander Böhn]

• Renamed instances of clu.version.VersionInfo to version_info ... because calling them “version” was causing a shadow situation to occur with the module clu.version. [Alexander Böhn]

• Trimming specious code from clu.exporting. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Niced up a few docstrings in clu.predicates. [Alexander Böhn]

• Corrected enumchoices(…) docstring. [Alexander Böhn]

• Rewrote clu.mathematics ... since it was just the one “clamp(…)” function, this was less crazy than you might think; it was still a complete overhaul tho, involving the generic-ization of “clamp(…)” and a new isdtype(…) predicate ... added tests for clu.mathematics as well ... tweaked the clu.naming tests to fail less and be less stupid ... tweaked some clu.typology innards too. [Alexander Böhn]

• Cleaned up some imports and moved pytuple(…) to clu.predicates. [Alexander Böhn]

• Many changes, most notably in the clu.naming tests ... those are now employing pytest’s “XFAIL” marker more reasonably ... in conjunction with all that, rather than use pytest.xfail(…) we’re still intercepting AssertionErrors when things’ll likely go sideways, but instead we’re raising a new custom exception subclass clu.constants.exceptions.Nondeterminism – because a bunch of these on-again, off-again failures seem to stem from e.g. the ordering of “sys.modules” and whatnot – and that shit is fucking nondeterministic as fuck ... did some more real beyond-basic cleanup in clu.exporter – not that you’d know (although the module will compile and import correctly, so there’s that) ... juggled some things between clu.naming and clu.predicates – largely with the goal of reducing dependencies; I think I’ve almost managed to decouple these two modules but for a few imports here and there (which is a big schmeal). ... AND MANY MOOOORRREE. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Rewrote clu.typology.graceful_issubclass(…) using predicate_any(…) ... which OK, fuck, phew: that function – while, ah, functional – had one of the messiest, ugliest, inscrutablest implementations it has ever been my displeasure to produce. I think I got hung up on having a signature that •looked• like issubclass(…) or isinstance(…) as much as possible; it had too much try/except shit in its flow control… blah blah blah. Now it looks awesome (albiet probably still inscrutable at first glance to some) but it’s clean as shit and uses my favorite new shit: apply_to(…) and its favorite child, predicate_any(…). They make doing these weird pseudo-functional generator-expression mashups a true fucking pleasure. Yes! [Alexander Böhn]

• Trying to import numpy in clu.constants.polyfills. [Alexander Böhn]

• Consolidated the custom exception and warning subclasses ... they all now live in clu.constants.exceptions. [Alexander Böhn]

• Expanded the enum alias class’ member_for_value(…) method. [Alexander Böhn]

• Made the enum alias class slightly less redundant. [Alexander Böhn]

• Minor additions and tweaks to the enum alias tests. [Alexander Böhn]

• Made clu.repl.enums.alias a slots class. [Alexander Böhn]

• Warnings for when a dotpath contains dashes. [Alexander Böhn]

• The path_to_dotpath(…) function was exported from the wrong place ... now it’s not, because I fixed it. [Alexander Böhn]

• Tweaked ever-so-slightly the print_all() thing in consts.py. [Alexander Böhn]

• Removed gratuitous module-level imports in predicate tests. [Alexander Böhn]

• Bringing back λ the ultimate. [Alexander Böhn]

• Nixed unnecessary “os.path.basename()” in clu.naming. [Alexander Böhn]

• Defined a constant BASEPATH, specifying the root directory ... I mean, we need this – you can see that we need this, n’est cé pas? Right? ... also now there is an inline module __name__ == "__main__" sort of dealie in clu.constants.consts that prints out all of the constant variables defined therein. Not an inline test – I swear I’m not going back to those – but a handy debugging thinamadoo, basically. [Alexander Böhn]

• Whitespace. [Alexander Böhn]

• Marked string as raw in clu/version/read_version.py. [Alexander Böhn]

• Removed old project egg-info directory name. [Alexander Böhn]

• Tweak fix to Makefile. [Alexander Böhn]

• Uncrustified and updated setup.py. [Alexander Böhn]

• Tweaked project name. [Alexander Böhn]

• Fixed unmarked raw string in regex. [Alexander Böhn]

• Tweak to .gitignore. [Alexander Böhn]

v0.1.1 (2019-06-26)

Add

• Added memberless Enum subclass to isenum(…) tests. [Alexander Böhn]

• Added tests for isenum(…) and enumchoices(…) ... and with that, I do believe we are approaching 100% coverage for the clu.predicates module, fuck yes. [Alexander Böhn]

• Added tests for clu.predicates.apply_to(…) ... also fixed a bug in the iscontainer(…) predicate (one of the internal-usage apply_to(…) preds) that was particularly prone to being triggered by operations on typelists (q.v. source code for clu.typology module supra.) as any iterable non-normative •type• would return True from the predicate, causing the logic of the function to attempt to iterate the type, which of course that would fail in like nearly almost all cases (enum types of course being the notable exception). So now iscontainer(…) checks for not isclasstype(…), as do several other predicates that were doing things like manually inspecting mro or some shit like that; everything is more consistent and nicer-looking now, yes. ... Also, most of the apply_to tests straight-up copy-paste-use the typelist stuff from clu.typology (Ibid.) [Alexander Böhn]

• Added isnormative(…) and iscontainer(…) predicates ... these are, like, refinements of isiterable(…) which matches string-ish and bytes-ish types, which sometimes you don’t want; so isnormative(…) matches all those string/bytes sorts of things, while iscontainer(–) is just a logical combination that does isiterable(…) and not isnormative(…). ... there are tests now for all the “apply_to(…)”-based logical predicate stuff e.g. predicate_{all,any,and,or,xor}(…)and also tests foruncallable(…), isexpandable(…), and those two new ones isnormative(…)andiscontainer(…)`. Fuck yeah. [Alexander Böhn]

• Added tests for all the getpyattr(…) and related accessors. [Alexander Böhn]

• Added NOp tests for clu.predicates. [Alexander Böhn]

• Added tests for isiterable(…) and ismergeable(…) ... also made the version stuff consistent in its import-ness ... and tweaked a few consts in clu.constants. [Alexander Böhn]

• Added predicate-logic functions and lambdas. [Alexander Böhn]

• Adding a few lines to .gitignore. [Alexander Böhn]

• Added support for alias() in Pythons lacking set_name [Alexander Böhn]

• Added a Makefile to do project-related tasks. [Alexander Böhn]

• Added tons of project-related meta-documents ... You know, stuff like: * .editorconfig * .landscape.yml * .travis.yml * appveyor.yml * setup.cfg * conftest.py * COPYING.md * MANIFEST.in ... and a few new legalese morsels in LICENSE.txt. [Alexander Böhn]

• Added tox.ini. [Alexander Böhn]

• Added note about the project name. [Alexander Böhn]

• Added some new constants; predicates in use in filesystem.py. [Alexander Böhn]

• Added filesystem, appdirs, and keyvalue modules ... plus some miscellaneous support functions for same. [Alexander Böhn]

• Added dicts, exporting, naming, sanitzer etc. [Alexander Böhn]

• Added header boilerplate to version.py. [Alexander Böhn]

• Added a bunch of basic project stuff ... .gitignore, .bumpversion.cfg; ... ABOUT.md, README.md, CODE_OF_CONDUCT.md ... init.py files in clu/ and test/ ... version.py and semantic-versioning code in version.py ... basic setup.py boilerplate. [Alexander Böhn]

Minutiae

• Minutiae II. [Alexander Böhn]

• Minutiae. [Alexander Böhn]

Other

• Bump version: 0.1.0 → 0.1.1. [Alexander Böhn]

• Updated .bumpversion.cfg ... thanks to read_version.py I no longer have to update a bajillion backup version strings, and so. [Alexander Böhn]

• Rearranging the deck chairs on the Titanic pt. LVII. [Alexander Böhn]

• Just found out that enums are “expandable” – ... as in, you can be like tuplize(*EnumSubclass) to get back a tuple containing all of the members of EnumSubclass, in order, with no problem. I restructured apply_to(¬) and the predicate isexpandable(…) accordingly. Side note, really – what makes things quote-unquote expandable, really? Why can I be all like “*EnumSubclass” but not “*generator_expression” ?? Help me dogg you’re my only hope. [Alexander Böhn]

• Asserting that \enum members are not enums. [Alexander Böhn]

• Tests added for those good ol’ utility helpers ... I am talking of course about tuplize(…), uniquify(…), and listify(…), the three of whom have been with us for like ever it feels like. [Alexander Böhn]

• More tests and more predicate overhauls! ... new predicates: haslength(…) checks for a “len” attr; uncallable(…) sees if a thing isn’t callable; thing_has(…), class_has(…), isslotted(…), isdictish(…), isslotdicty(¬) and others were completely rewritten to actually work – the first two of those now use the also-rewritten and extremely generally useful new apply_to(…) function; isexpandable(…) checks a thing against a list of types to see if you can do *thing to expand it – I don’t know the language lawyer rules for “asterisking” or tuple-expansion or whatever the fuck it is actually called so this may change; tests for haslength(…) and the “{thing/class}_has” and slot/dict predicates have been added and, erm, tested; predicate_nop(…) was moved out of clu.typology and into clu.predicates; some other NOp thingees and internal-use doohickeys were added and probably other shit as well (I always forget exactly what when I am editing these commit notes, bah). Yes! [Alexander Böhn]

• Using pytest.xfail() where nondeterminism might happen. [Alexander Böhn]

• Fixed some corner-cases in typology ... thanks, nacent test suite!! [Alexander Böhn]

• Migrated clu.naming tests from replutilities. [Alexander Böhn]

• Migrated dict/namespace merge tests from replutilities. [Alexander Böhn]

• Migrated predicates tests from replutilities. [Alexander Böhn]

• Migrated clu.version inline tests. [Alexander Böhn]

• Trimmed dead code from filesystem tests. [Alexander Böhn]

• Migrated clu.fs.filesystem inline tests. [Alexander Böhn]

• Finished writing that docstring. [Alexander Böhn]

• Fixed enum aliases. [Alexander Böhn]

• Typelist function tune-up ... and and overdue all/dir set for the clu.typology module. [Alexander Böhn]

• Moved the enums from clu.fs.appdirectories to clu.constants.enums. [Alexander Böhn]

• Moved aliasing enum stuff from clu.constants to clu.repl. [Alexander Böhn]

• Remove gratuitous OS check in clu.fs.NamedTemporaryFile. [Alexander Böhn]

• It’s probably overkill to fork() before umask()-ing ... but frankly the race condition inherent in trying to get the process’ current umask without perturbing the value is fucking stupid, it is exactly dumb shit like that that inflames my OCD and keeps me from telling everyone I know about how great the fucking POSIX API is (which really that is not a joke, I really actually generally like it except for warts like this one). [Alexander Böhn]

• Peppering in all and dir joyously and mirthfully ... also you wouldn’t know it but between this commit and the last one I completely replumbed all the .envrc and .direnvrc shit on my entire computer – apparently “loading” a source file in the direnv world (which up until recently I thought was a nice world that was good to live in) does not export bash aliases, functions, or anything else up to a certain point. ... So I hacked around that – but that was fine, no problem, a complete and total breeze compared to this bizarre bullshit nonsensical PYTHONPATH-related REPL freakout I was having prior to all that. I ended up using the virtualenv --verbose --clear command, which if you didn’t know, that second option flag is literally described like e.g. “blow away the entire virtualenv and start over from scratch” or something like that – after doing that and then blindly monkeying around with PATH-y stuff a while afterwards, I got my shit to work… that shit in this case would be the “replenv” stuff, upon which the whole CLU project is literally based. Blech. Anyway you can’t see any of that, because why would I check that nonsense into source control?? It’s not as if I am about to absently save right over all that irritatingly hard work and break it all again, only to find myself in a sea of inscrutable nonfunctionality, sans the ol’ reliable git bisect or anything else, hah. Yeah! [Alexander Böhn]

• Sorted out a ton of stuff w/r/t modes and permissions. [Alexander Böhn]

• Git-ignoring .tm_properties. [Alexander Böhn]

• ANSI text printing works on the command line. [Alexander Böhn]

• Fixed CSDIL enum’s index(…) method. [Alexander Böhn]

• ANSI metaclass name-lookup method now considers aliases. [Alexander Böhn]

• ZERO-COST ENUM MEMBER ALIASING, MOTHERFUCKERS. [Alexander Böhn]

• Tweaks in the ansi and typespace modules. [Alexander Böhn]

• Further OCD-ish CSDIL cleanup. [Alexander Böhn]

• Combined those two CSIDL dicts into an Enum ... also wrote a basic launchd plist generator for xdg-runtime.py. [Alexander Böhn]

• Fleshing out xdg-runtime.py. [Alexander Böhn]

• Cleaned up xdg-runtime.py script. [Alexander Böhn]

• S/typing/typology/g. [Alexander Böhn]

• So many many things. [Alexander Böhn]

• Vendoring in the excellent “read_version” – ... by one John Thorvald Wodder II (if that really is his name – I mean who cares dogg this code is tight but really that sounds more like a component of some kind of Winklevoss joke than an actual human name) who published it herein: [Alexander Böhn]

  • https://github.com/jwodder/read_version

• Ported over the “keyvalue” updates from Homage ... specifically the changes that make it play nice with the whole “appdirectories” all-singing all-dancing crapola – namely these commits: [Alexander Böhn]

  • https://git.io/fjVvR – “appdirs” → “appdirectories” • https://git.io/fjVvE – subsequent “keyvalue” refactoring

  ... indeeed dogg it’s not like it’s breakthrough lambda-calculus or a new kind of JIT thing or any of that, but you know, 50% of programming is coming up with names for shit; the other 50% is figuring out the names other people came up with for their shit; the fun stuff (matrix math, type-algebra, prematurely optimizing things, doing algorithms, generally trying new shit of any sort) are momentary rounding errors found ephemerally on serendipitous occasions somewhere betwen those two time-suck categories of what it is, doggie.

• Tweaked Makefile and rebased the travis config. [Alexander Böhn]

• A few tweaks to clu.fs.filesystem. [Alexander Böhn]

• Minor tweak to short project description. [Alexander Böhn]

• Fleshed out ABOUT.md and README.md. [Alexander Böhn]

• Snipped a dead code line. [Alexander Böhn]

• Fixes for clu.version.VersionInfo. [Alexander Böhn]