kanban-tui , customizable cross platform kanban/task manager in your terminal

* **What My Project Does**

Kanban-Tui is a CLI tool that gives you a visual board with moveable tasks in the terminal.

With the newest release v0.4.0, you can create multiple boards with individual columns.
More Customization like creating task categories for tasks or change the column visibility is also possible.
It also utilizes plotext to give you an overview about several metrics (created/completed/started tasks).


For a quick demo you can use uvx to create a temporary database and config files with: `uvx --from kanban-tui ktui demo`
They get deleted after you close the application. For detailed instructions and features you can check the Readme on github.

Source Code on github: [Link](https://github.com/Zaloog/kanban-tui)


* **Target Audience** 

Terminal affine developers who do not want to miss a nice graphical experience.

* **Comparison** 

Its similar to kanban-python, which I created before before this project but less minimal and the interaction with the tasks is faster more convenient.
I.e with the TUI one is able to utilize vim-like motions to move cards around, which comes closer to the feeling of actually moving physical cards.



If you find bugs or are missing a feature, please dont hesitate to open an [issue](https://github.com/Zaloog/kanban-tui/issues).

/r/Python
https://redd.it/1h4aagg

Monday Daily Thread: Project ideas!

# Weekly Thread: Project Ideas 💡

Welcome to our weekly Project Ideas thread! Whether you're a newbie looking for a first project or an expert seeking a new challenge, this is the place for you.

## How it Works:

1. **Suggest a Project**: Comment your project idea—be it beginner-friendly or advanced.
2. **Build & Share**: If you complete a project, reply to the original comment, share your experience, and attach your source code.
3. **Explore**: Looking for ideas? Check out Al Sweigart's ["The Big Book of Small Python Projects"](https://www.amazon.com/Big-Book-Small-Python-Programming/dp/1718501242) for inspiration.

## Guidelines:

* Clearly state the difficulty level.
* Provide a brief denoscription and, if possible, outline the tech stack.
* Feel free to link to tutorials or resources that might help.

# Example Submissions:

## Project Idea: Chatbot

**Difficulty**: Intermediate

**Tech Stack**: Python, NLP, Flask/FastAPI/Litestar

**Denoscription**: Create a chatbot that can answer FAQs for a website.

**Resources**: [Building a Chatbot with Python](https://www.youtube.com/watch?v=a37BL0stIuM)

# Project Idea: Weather Dashboard

**Difficulty**: Beginner

**Tech Stack**: HTML, CSS, JavaScript, API

**Denoscription**: Build a dashboard that displays real-time weather information using a weather API.

**Resources**: [Weather API Tutorial](https://www.youtube.com/watch?v=9P5MY_2i7K8)

## Project Idea: File Organizer

**Difficulty**: Beginner

**Tech Stack**: Python, File I/O

**Denoscription**: Create a noscript that organizes files in a directory into sub-folders based on file type.

**Resources**: [Automate the Boring Stuff: Organizing Files](https://automatetheboringstuff.com/2e/chapter9/)

Let's help each other grow. Happy

/r/Python
https://redd.it/1h4hhn4

D Simple Questions Thread

Please post your questions here instead of creating a new thread. Encourage others who create new posts for questions to post here instead!

Thread will stay alive until next one so keep posting after the date in the noscript.

Thanks to everyone for answering questions in the previous thread!

/r/MachineLearning
https://redd.it/1h46e6j

Want to contribute to django projects.

Hi everyone,

I want to contribute on some django projects. if any one are willing to suggest me some applications please feel free to reply to this post.

Thanks.

/r/django
https://redd.it/1h4kbga

Advanced Python Development Workflow in Emacs

Hey everyone!

Lately, I’ve been spending more time reading code than writing it, but I still code every now and then, mostly in Python. My daily editor — for both coding and just about everything else — has been Emacs for several years now.

Recently, I decided to dig into how the Language Server Protocol (LSP) and Debug Adapter Protocol (DAP) work in Emacs, how they can be integrated, and what minimal configuration is needed to get started. As I explored, I took notes for myself, and eventually, those notes turned into a blog post.

It ended up being quite a long read, but I’m really happy with the result. The more I researched and wrote, the further I drifted from my original goal of creating a quick and minimal Emacs setup guide. I rewrote the introduction a few times before landing on something I felt good about, and now I’m ready to share it with you.

The article isn’t perfect — there are still some rough edges and gaps I plan to address soon. For example:

* I haven’t covered tree-sitter integration.
* Navigation between code elements feels a bit underexplored.
* Some parts are more superficial than I’d like.

But it’s in a good enough state

/r/Python
https://redd.it/1h45hl7

Kitten Mixer: A Fun Tool to Combine Cat Images with AI

Hello Python community,

My name is Dylan, and I’m a data scientist. I recently developed a fun little project called [Kitten Mixer](https://mezclador-gatitos.streamlit.app/), and I’d love to share it with you and hear your feedback!

# What My Project Does

Kitten Mixer is a Python-based web app that uses Variational Autoencoders (VAEs) to generate smooth image interpolations of cats. By combining the power of AI with some adorable cat pictures, the app creates unique and visually fascinating blends between different cat images.

# Key Features

* **Image Interpolations:** Combine two cat images and explore their latent-space interpolations.
* **Latent Space Exploration:** Visualize how the neural network represents cat images in a 2D latent space.
* **Interactive Web App:** The app is built with Streamlit for an intuitive and easy-to-use interface.

# Target Audience

* **Who It’s For:** Python enthusiasts, AI hobbyists, and cat lovers looking for an entertaining and educational use of machine learning.
* **Intended Use:** Great for learning about Variational Autoencoders, showcasing AI-generated content, or just having fun creating unique cat images.

# How It Works

1. The project uses a Variational Autoencoder (VAE) implemented in PyTorch to encode and decode cat images.
2. By interpolating in the latent space of the VAE, the app generates smooth transitions between any two selected cat images.
3. The app runs interactively

/r/Python
https://redd.it/1h43i92

Do you deploy your own databases or use any paid database service like neon

I am trying to launch my web app and I am very confused . I have very less budget because it a side project my web app is made on top of django help me with this.

/r/django
https://redd.it/1h46ryh

Why Do REST Frameworks Use Their Own Auth Layers Instead of Django’s Auth Backends?

I've been exploring REST frameworks like Django REST Framework (DRF) and Django Ninja, and I noticed that they both introduce their own layers for authentication.

DRF does it in the base class of all REST views.
Django Ninja does it in the router that wraps the views.

This creates separate libraries, like djangorestframework-simplejwt for DRF and django-ninja-simplejwt for Django Ninja.

But Django already has a good auth system with backends that work for all views. Why don’t these frameworks just use Django’s auth backends and a middleware?

Is Django’s auth system missing something, or do these frameworks need extra features that Django doesn’t provide?

/r/django
https://redd.it/1h4rcx1

Best PDF library for extracting text from structured templates

Hello All,

I am currently working on a project where I have to extract data from around 8 different structured templates which together spans 12 Million + pages across 10K PDF Documents.

I am using a mix of Regular Expression and bounding box approach where by 4 of these templates are regular expression friendly and for the rest I am using bounding box to extract the data. On testing the extraction works very well. There are no images or tables, but simple labels and values.

The library that I am currently using is PDF Plumber for data extraction and PyPDF for splitting the documents in small chunks for better memory utilization(PDF Plumber sometimes throws an error when the page count goes above 4000 pages, hence splitting them into smaller chunks temporarily). However this approach is taking 5 seconds per page which is a bit too much considering that I have to process 12M pages.

I did take a look at the different other libraries mentioned in the below link but I am not sure which one to choose as I would love to work with an open source library that is having a good maintenance history and better performance .

/r/Python
https://redd.it/1h4pqqh

Is there an easy to use CI/CD solution for deployment? My usecase below.

As of now, I have a VPS on hetzner (I had it on Digital Ocean previously, but I migrated to hetzner).

I use apache to host it, all media files and static files along with database are hosted on the same VPS, and I have a bunch of cron jobs to run some background jobs...

As of now, I make changes locally, and push them, then ssh into the VPS, pull the changes, check permissions for each directory, restart apache and all the hassle...

I've also used Digital Ocean's app platform, so when I push to github, it will redeploy the project, but then, I'd to host the database and media files seperately, otherwise they will be gone after the re-deployment. Plus background tasks are pain, and the costs getting higher and higher.

I am looking for similar solution, but maybe somewhere else and not on Digital Ocean. Please suggest me the easiest options, or tricks to do the same on a VPS.

I really need some help.

Thank you very much..

/r/django
https://redd.it/1h4oaub

ComputeLite - A true serverless tool

What My Project Does:

ComputeLite is a true serverless tool that leverages the power of WebAssembly (WASM) and SQLite OPFS to ensure that all data and code remain securely in the browser, with no server dependencies or external storage. Right now it supports Python (powered by Pyodide) and SQL( powered by SQLITE)

So you can write all your python code and use Pyodide supported or pure python packages right away in browser without any need to install anything.

Target Audience:

Students, Developers, Could be used for noscripting

Comparison:

It can be compared with PyScript but user can create different models which could include noscripts with relative imports and packages listed in requirements.txt file

Link: https://computelite.com/

GitHub: https://github.com/computelite/computelite



/r/Python
https://redd.it/1h4spi7

Better, Faster Python Projects: A Deep Dive into uv
https://www.saaspegasus.com/guides/uv-deep-dive/

/r/django
https://redd.it/1h4vak9

Iris Templates: A Modern Python Templating Engine Inspired by Laravel Blade


What My Project Does

As a Python developer, I’ve always admired the elegance and power of Laravel’s Blade templating engine. Its intuitive syntax, flexible directives, and reusable components make crafting dynamic web pages seamless. Yet, when working on Python projects, I found myself longing for a templating system that offered the same simplicity and versatility. Existing solutions often felt clunky, overly complex, or just didn’t fit the bill for creating dynamic, reusable HTML structures.

That’s when Iris Templates was born—a lightweight, modern Python template engine inspired by Laravel Blade, tailored for Python developers who want speed, flexibility, and an intuitive way to build dynamic HTML.

# 🧐 Why I Developed Iris Templates (Comparison)

When developing Python web applications, I noticed a gap in templating solutions:

Jinja2 is great but can feel verbose for straightforward tasks.
Django templates are tied closely to the Django framework.
Many templating engines lack the modularity and extendability I needed for larger projects.

Iris Templates was created to bridge this gap. It's:

Framework-agnostic: Use it with FastAPI, Flask, or even standalone noscripts.
Developer-friendly: Intuitive syntax inspired by Blade for faster development.
Lightweight but Powerful: Built for efficiency without sacrificing flexibility.

# 🌟 Key Features of Iris Templates

1. "extends" and "section" for Layout Inheritance; Create a base layout and extend it effortlessly.
2.

/r/Python
https://redd.it/1h4zfnr

Git and Jupyter Notebooks: The Ultimate Guide
https://www.reviewnb.com/git-jupyter-notebook-ultimate-guide

/r/IPython
https://redd.it/1h4v1n9

Best practice for autocomplete on a ModelChoiceField with ~10'000 entries

Dear Django community,

I am using the modern standard of Django + HTMX + Crispy. As part of a form, I would like the user to select one of 10'000 clients. The user should type in a few letters of either the first name or the last name and then get a dropdown of matching clients and be able to click on one of them.

So far, I explored and considered the following options:
1. I could build it from scratch in pure HTMX. Would work, but it's work traveling back and forth, doesn't seemingly integrate with the rest of my form and I'd need to travel to the backend for each letter the user types.

2. I could pass the entire client list to the frontend and do in Javanoscript, but I don't like to code stuff in javanoscript.

3. I implemented this video: django-crispy-forms & ModelChoiceFields / Select2 Integration for Searchable Form Fields, which does it as a standard Django field and then puts Select2 over it. However, the page load is too slow and I don't like the dependency on jquery.

4. I considered django-autocomplete-light, however, at first sight, it seems quite heavy with dependencies on multiple libraries. Further it

/r/django
https://redd.it/1h4zbyn

Best practice for self deployable open source Django project

Hi all,

I am working on a simple Django app for monitoring the progress of Snakemake workflows. For context, Snakemake is a workflow manager, largely targeted towards life sciences (bioinformatics, genomics, etc). It is run on the command line and currently lacks a good way to monitor the progress of your workflows (they can run for weeks in some cases).

I have experience building Django webapps and deploying them for myself. However with this, I would like to make the whole webapp a pip installable package such that users can just install via pip and spin up the server. This is extremely important, as in order for this to be a useful tool, the barrier to entry should be very low for users with little technical experience.

I have already worked out how the workflows will communicate with the running Django server. My general idea is this:

1. User starts the server
2. User starts snakemake workflow, gives server address
3. As workflow runs user can view progress on browser

Where I have questions is how to handle deployment and migrations:

1. For the database, I'll use sqlite since thats easy and I don't expect high traffic. I'm not sure how to apply migrations to a project

/r/django
https://redd.it/1h54h76

One-Click Deployment tool for Docker Apps (First Stable Release 0.2.0)

Hey Django devs! 👋

I'm excited to share Leverans, a deployment tool I've been working on that makes getting your apps online stupid simple. Here's why you might love it:

🚀 Key Features:

* Deploy ANY Docker-based app with a single command
* No vendor lock-in
* Works on minimal hardware (just 0.5 vCPU, 500 MB RAM)
* CLI-based with super simple config
* No need for SSH, external services, or complex setups

Why I built this: Deploying apps is a pain. Existing tools are either too complex or too restrictive. Leverans fixes that.

For example, this is all you need to describe a simple Django project:

\`\`\`yaml

project: django



apps:

main:

domain: [your-domain.com](http://your-domain.com)

port: 8000

volumes:

django-sqlite: /data

\`\`\`


And run the \`lev deploy\` command. And that's it, your application is online. On your own private VPS server.



Docs: [https://leverans.dev](https://leverans.dev)

GitHub Examples: [https://github.com/ethanhamilthon/leverans/tree/main/examples](https://github.com/ethanhamilthon/leverans/tree/main/examples)


This is v0.2.0 - our first stable release. Would love your feedback and a ⭐ on GitHub if you find it useful!



/r/django
https://redd.it/1h50zfj

I don't know how set SECRET_KEY

Which of the two ways is correct?

SECRET_KEY = os.environ.get('SECRET_KEY') or 'myKey'

or

SECRET_KEY = os.environ.get('SECRET_KEY') or os.urandom(24)

/r/flask
https://redd.it/1h532hk

Tuesday Daily Thread: Advanced questions

# Weekly Wednesday Thread: Advanced Questions 🐍

Dive deep into Python with our Advanced Questions thread! This space is reserved for questions about more advanced Python topics, frameworks, and best practices.

## How it Works:

1. **Ask Away**: Post your advanced Python questions here.
2. **Expert Insights**: Get answers from experienced developers.
3. **Resource Pool**: Share or discover tutorials, articles, and tips.

## Guidelines:

* This thread is for **advanced questions only**. Beginner questions are welcome in our [Daily Beginner Thread](#daily-beginner-thread-link) every Thursday.
* Questions that are not advanced may be removed and redirected to the appropriate thread.

## Recommended Resources:

* If you don't receive a response, consider exploring r/LearnPython or join the [Python Discord Server](https://discord.gg/python) for quicker assistance.

## Example Questions:

1. **How can you implement a custom memory allocator in Python?**
2. **What are the best practices for optimizing Cython code for heavy numerical computations?**
3. **How do you set up a multi-threaded architecture using Python's Global Interpreter Lock (GIL)?**
4. **Can you explain the intricacies of metaclasses and how they influence object-oriented design in Python?**
5. **How would you go about implementing a distributed task queue using Celery and RabbitMQ?**
6. **What are some advanced use-cases for Python's decorators?**
7. **How can you achieve real-time data streaming in Python with WebSockets?**
8. **What are the

/r/Python
https://redd.it/1h59v6z

Feedback for project creating conversational agents using a Finite State Machine (FSM) and LLMs

Hi r/Python community!

I've been working on a project combining Finite State Machines and Large Language Models.

What My Project Does
This project provides a framework for building conversational agents using a Finite State Machine (FSM) powered by LLMs like OpenAI GPT. It aims to create structured tools like step-by-step teaching systems, customer support bots, and multi-step memory games while addressing issues like hallucinations, loss of context, and unpredictability. I have a few example usages in the repo.

Target Audience
This is currently an experimental setup, and also part of a research project I am doing for university. For now it is meant for developers and experimenters mainly. Requires an OpenAI API key (currently tested on gpt-4o-mini).

Comparison
Unlike typical LLM-based chatbots, this combines FSM with LLMs to enforce structured, predictable conversations, making it ideal for use cases requiring adherence to predefined paths.

If anyone is interested I would love to hear your feedback and thoughts! The repo is here: https://github.com/jsz-05/LLM-State-Machine

Cheers!

/r/Python
https://redd.it/1h594wc

Building native Python desktop application with Pyloid and Gradio

Let's build a desktop chat application that streams responses from an LLM. We'll use three key libraries that work beautifully together:

- **[Pyloid](https://github.com/pyloid/pyloid)**: Creates native desktop applications -- like Electron but with Python
- **[Gradio](https://gradio.app)**: Builds the chat interface
- **[Promptic](https://github.com/knowsuchagency/promptic)**: Handles LLM interactions

Source Code: https://github.com/knowsuchagency/pyloid-chat-demo

## Prerequisites

Before running the application, you'll need:
- An OpenAI API key ([get one here](https://platform.openai.com/api-keys))
- [uv](https://github.com/astral-sh/uv) for Python package management
- [just](https://github.com/casey/just) command runner

## The Chat Interface

First, let's create the chat interface. This is where Gradio and Promptic work together:

```python
import gradio as gr
from promptic import llm

@llm(memory=True, stream=True)
def assistant(message):
"""{message}"""

def predict(message, history):
partial_message = ""
for chunk in assistant(message):
partial_message += str(chunk)
yield partial_message

with gr.ChatInterface(
fn=predict,
noscript="Chat Demo",
) as chat_interface:
chat_interface.chatbot.clear(assistant.clear)
```

The code above:
- Uses Promptic's `@llm` decorator to handle LLM interactions
- Implements streaming responses using a generator
- Creates a chat interface with Gradio
- By passing `memory=True`, Promptic will manage conversation history

## Making It a Desktop App

Now, let's wrap our chat interface in a native window using Pyloid:

```python
from pyloid import Pyloid
import threading
import time
import socket
from contextlib import contextmanager

HOST = "127.0.0.1"
PORT =

/r/Python
https://redd.it/1h5a26x