Or, as the polars docs recommend:

df = pl.DataFrame(
    {"abc": [-2.5, 5.0], "mno": ["hello", "world"], "xyz": [True, False]}
)
with pl.Config(
    tbl_formatting="ASCII_MARKDOWN",
    tbl_hide_column_data_types=True,
    tbl_hide_dataframe_shape=True,
):

Quickly generate visualizations from pandas dataframes, by drag and drop.

Can be really handy for exploratory data viz.

Make awesome display tables using Python.

A really nice, simple table package and can do impressive outcomes.
Not sure if it also works for docx/pdf or just html?

Nice to learn how to make pynvim and lua interoperate for neovim.

Directed acyclic graphs to take care of any data and resource inter-dependencies and just focus on having a stable output.

Basically similar to e.g. dagster or other high-fallutin' cloud offerings, and somewhat similar to targets for R.
Of primary interest here is the cache=True setting for a pipeline which ensures its underlying functions only get recomputed when they actually change (see the ipynb example Cache section).

Seems super nifty just because it's super lightweight and easy to get started - but is fairly new as of this moment.

An good example of how to lock the computer and send it to sleep on a timer.

Uses swaylock and wayidle, so primarily made for wayland.

A sort of 'meta'-approach to python project management.
You don't download any other tools before you start a project but you simply do a curl single liner:

curl -LO https://github.com/pyprojectx/pyprojectx/releases/latest/download/wrappers.zip && unzip wrappers.zip && rm -f wrappers.zip

to download and install the wrappers in the current dir.
You henceforth use the wrappers to do anything, e.g.:

./pw --add pdm,ruff,pre-commit,px-utils
./pw --install-context main
# invoke a tool via the wrapper script
./pw pdm --version
./pw ruff check src
# or activate the tool context
source .pyprojectx/main/activate
pdm --version
ruff check src

Seems a little cumbersome but also nice to test out a variety of project management setups for python applications.

Instantly convert any python cli programme made with click into a simple web frontend.
Design is not amazing but it is done in like 30 seconds and you have a frontend.
Wow!

Inject javascript into any running process (or python, or golang, or any of a bunch of other langauge bindings).

Can be used to hook into processes, run functions, send and receive messages, and a bunch more.
Essentially process injection on steroids - super cool.

It seems to even be able to inject itself to processes on other devices running connected to the machine? Not entirely sure how to implement but take a look at frida-ps ios example.

A quick reference for Python's strftime formatting directives.

Personally, I always forget strftime placeholders. This gives it to me concisely, and without fuss.

From a dude who knows how to explain. Aimed at mostly intermediate use (& a little advanced i suppose)

An open-source universal messaging library. Seems interesting as a concurrency tool. Implementations and bindings in many many languages.

Next Generation Taskwarrior Python API.

A simple fork of the stagnant taskw taskwarrior-python bindings.

Amazing concise guide for simple IO stream explanation. Good as a refresher for whenever I have to work with them.

Short and simple video lessons that start from scratch. Tools and thoughts that might make your professional life more enjoyable.

• Tools for checking your python code (pylint, precommit, pyinstrument, ...)
• scikit-learn
• visualization
• cli tools like entr, makefiles, typer, rich, ...

Neat!

Pulumi - Infrastructure as Code in any programming language. Build infrastructure intuitively on any cloud using familiar languages 🚀

Basically, bindings and clients to interact with Kubernetes, AWS, GCP, Azure to create infrastructure, containers, serverless functions, etc.

Using altair to visualize data, a book by jjallaire. Nice explanations, starts from the basics.

Grab data from websites (for now: has pre-made importers for Shaarli and Github Awesome- lists but can create your own), and do stuff with them.

Uses a variety of processors and exporters to shape, fix and transform the imported stuff. All based on yml 'pipeline' specifications. Essentially, it's a bit like setting up github actions/woodpecker CI for arbitrary pages.

Advanced 'print' function - enables simple debugging instead of littering code with 'print' statements everywhere while coding. Just add a decorator or context manager instead.

Conceptually somewhat similar to kikito's inspect for lua, or its vim.inspect neovim implementation in being in-between simple print statements and full blown debugging.

An academic publishing workflow with automatic doi -> citation processing and (I think?) writing in markdown then publishing as pdf/docx/html documents.

Similar to quarto in other words, but taking a bit of a different approach. Also has a sister-repository with an AI assistant for the publishing process which seems like a neat tool to try.