In the Python ecosystem, there are many tools dealing with source code: linters, test coverage collection systems, and many others. Many of them use special comments, and as a rule, the style of these comments is very similar.
But you know what? There is no single standard for such comments. Seriously.
The internal implementation of reading such comments is also different. Someone uses regular expressions, someone uses even more primitive string processing tools, and someone uses full-fledged parsers, including the Python parser or even written from scratch.
This is exactly the problem that this library solves. It describes a simple and intuitive standard for action comments, and also offers a ready-made parser that creators of other tools can use.
Perhaps encoding such things in comments at all is the wrong approach? E.g. If my linter misbehaves, why can't I right click and ignore the red line in the IDE instead of encoding it into my source file.
Encoding it into your source file has positive externalities. If you're using source control, the comment controlling the linter is tracked alongside the rest of your code. You can track who added it and why. You can share this comment with other engineers on your team.
You could also imagine other representations of the same data (e.g. one large file which includes annotations, or a binary representation). But in this case you lose colocation with the code they're annotating, so it's more likely to drift.
I fully agree that there are probably better UX's out there for this flow, but the source annotation approach is popular for very good reasons.
Skelet is a new config storage/validation library for Python. The goal is to provide a minimal API for collecting settings in one place, while ensuring thread safety, transactionality, and type/value correctness. Configs can be loaded and validated from TOML, YAML, JSON, and environment variables.
Most libraries like pydantic-settings or dynaconf are great for model-based settings, but they aren’t thread-safe out of the box and don’t handle config mutation atomically. Skelet manages assignments under per-field mutexes (so you won’t see half-applied values or race conditions in concurrent apps), and it supports field-level docs, validation, secret fields (hiding any type), and hooks for value changes.
Meant for production scenarios where config safety matters (services, CLI tools, distributed systems), but also handy for scripts that need explicit config handling.
Many old Python libraries got their mirrored async reflections after the popularization of asynchrony. As a result, the entire Python ecosystem was duplicated. Superfunctions are the first solution to this problem, which allows you to partially eliminate code duplication by giving the client the opportunity to choose (similar to how it is done in Zig) whether to use the regular or asynchronous version of the function.
But AFAICT in Zig you don't have to have async and sync versions. Instead, the runtime may choose to interpret `try` as an async or as a synchronous call, the latter is equivalent to a future / promise that resolves before the next statement [1]. This is a sane approach.
Having separate sync / async versions that look like the same function is a great way to introduce subtle bugs.
You can use 2 different versions of the same library in the same program.
You can use incompatible libraries in the same project, as well as libraries with incompatible/conflicting dependencies.
It's easy to share written scripts. The script file becomes self-sufficient - the user does not need to install the necessary libraries.
The library does not leave behind "garbage". After the end of the program, no additional files remain in the system.
But you know what? There is no single standard for such comments. Seriously.
The internal implementation of reading such comments is also different. Someone uses regular expressions, someone uses even more primitive string processing tools, and someone uses full-fledged parsers, including the Python parser or even written from scratch.
This is exactly the problem that this library solves. It describes a simple and intuitive standard for action comments, and also offers a ready-made parser that creators of other tools can use.