Uses steamcmd (a steam cli client, maintained by valve themselves) to download workshop items. Basically a simplifying wrapper for workshop item downloads.

Operates as a GUI program (hence the .pyw file) but perusing the code also gives a quick idea of how to implement it yourself as a more cli-oriented wrapper.

Python (and C++ and R) project management. Built on the conda dev environment, and is primarily aimed at ML, data science, scientific python.
Comes highly recommended by others.

The future of python package managers?

Does everything that poetry, pip, pipx, pyenv and more are doing, and does so fast. From the creators of ruff, written in rust.

A python library for interacting with Lemmy. Contribute to db0/pythorhead development by creating an account on GitHub.

Pretty close integration between python and lua through bindings. Call python functions and methods, import other files, create classes and more from lua; or call lua functions, require files, receive table values and more from python.

Ultimately pretty insane (some might say lunatic) but might come in handy at one point or another.

alternatives:

• wijnen/python-lua which allows using Python objects in lua and lua objects in python.
• scoder/lupa is one-way embedding of lua into python, but supports additional features such as coroutines, threading, iterating lua objects and so on.

Another md to AST (html, ...) converter. Purposes to be faster than mistletoe.

Generate a (commonmark compliant) markdown AST using this python library. Can also directly output as html, latex or return it to markdown.

Declarative package & configuration manager for Arch Linux.

Similar to 'pacdef' but written in python (not rust) and using python to define the declaration.

Primarily, that means two things:

a. the declaration language is super flexible and can be used for all kinds of advanced shenanigans. Essentially Nix-like without the steep functional learning curve if you already know python.
b. the bootstrapping process is a little more awkward as we first need to ensure the correct python interpreter (and potentially dependencies?) installed on the system. For a rust-based program you can more easily just use a specific binary.

Can also take care of systemD services and configuration files to some extent.

Simple (as async libraries go), easy and usable asyncio in python, making it more fun to write correct async routines

Very useful spatio-temporal analysis tools within the python / jupyter ecosystem.

Can do all sorts of spatial analysis and visualization, but also more specific things like spatial inequality computation (using e.g. Theil index, Gini, ...).

Large list of resources for accomplishing various degrees of functional programming in python.

Books, tutorials, talks, libraries.

Allows creating pandoc filters in python instead of lua.

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!