Python-clu

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]

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]

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]

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]

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]

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 for `uncallable(…)`, `isexpandable(…)`, and those two new ones `isnormative(…)` and `iscontainer(…)`. 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]