FastAPI Guard v3.0 - Now with Security Decorators and AI-like Behavior Analysis

Hey r/Python!

So I've been working on my FastAPI security library (fastapi-guard) for a while now, and it's honestly grown way beyond what I thought it would become. Since my last update on r/Python (I wasn't able to post on r/FastAPI until today), I've basically rebuilt the whole thing and added some pretty cool features.

What My Project Does:

Still does all the basic stuff - IP whitelisting/blacklisting, rate limiting, penetration attempt detection, cloud provider blocking, etc. But now it's way more flexible and you can configure everything per route.

What's new:

The biggest addition is Security Decorators. You can now secure individual routes instead of just using the global middleware configuration. Want to rate limit just one endpoint? Block certain countries from accessing your admin panel? Done. No more "all or nothing" approach.

from fastapi_guard.decorators import SecurityDecorator

@app.get("/admin")
@SecurityDecorator.access_control.block_countries(["CN", "RU"])
@SecurityDecorator.rate_limiting.limit(requests=5, window=60)
async def admin_panel():
    return {"status": "admin"}

Other stuff that got fixed:

- Had a security vulnerability in v2.0.0 with header injection through X-Forwarded-For. That's patched now
- IPv6 support was broken, fixed that too
- Made IPInfo completely optional - you can now use your own geo IP handler.
- Rate limiting is now proper sliding window instead of fixed window
- Other improvements/enhancements/optimizations...

Been using it in production for months

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

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 description 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

**Description**: 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

**Description**: 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

**Description**: Create a script 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/1li2gwg

Run background tasks in Django with zero external dependencies. Here's an update on my library, django-async-manager.

Hey Django community!

I've posted here before about **django-async-manager**, a library I've been developing, and I wanted to share an update on its progress and features.

**What is django-async-manager?**

It's a lightweight, database-backed task queue for Django that provides a Celery-like experience without external dependencies. Perfect for projects where you need background task processing but don't want the overhead of setting up Redis, RabbitMQ, etc.

**✨ New Feature: Memory Management**

The latest update adds memory limit capabilities to prevent tasks from consuming too much RAM. This is especially useful for long-running tasks or when working in environments with limited resources.

# Task with Memory Limit

@background_task(memory_limit=512) # Limit to 512MB
def memory_intensive_task():
# This task will be terminated if it exceeds 512MB
large_data = process_large_dataset()
return analyze_data(large_data)

# Key Features

* **Simple decorator-based API** \- Just add `@background_task` to any function
* **Task prioritization** \- Set tasks as low, medium, high, or critical priority
* **Multiple queues** \- Route tasks to different workers
* **Task dependencies** \- Chain tasks together
* **Automatic retries** \- With configurable exponential backoff
* **Scheduled tasks** \- Cron-like scheduling for periodic tasks
* **Timeout control** \- Prevent tasks from running too long
* **Memory limits** \- Stop tasks from consuming

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

I made Flask-Squeeze which minifies and compresses responses!
https://github.com/mkrd/Flask-Squeeze

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

[P] I made a website to visualize machine learning algorithms + derive math from scratch

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

Fenix: I built an algorithmic trading bot with CrewAI, Ollama, and Pandas.

Hey r/Python,

I'm excited to share a project I've been passionately working on, built entirely within the Python ecosystem: Fenix Trading Bot. The post was removed earlier for missing some sections, so here is a more structured breakdown.

GitHub Link: https://github.com/Ganador1/FenixAI\_tradingBot

# What My Project Does

Fenix is an open-source framework for algorithmic cryptocurrency trading. Instead of relying on a single strategy, it uses a crew of specialized AI agents orchestrated by CrewAI to make decisions. The workflow is:

1. It scrapes data from multiple sources: news feeds, social media (Twitter/Reddit), and real-time market data.
2. It uses a Visual Agent with a vision model (LLaVA) to analyze screenshots of TradingView charts, identifying visual patterns.
3. A Technical Agent analyzes quantitative indicators (RSI, MACD, etc.).
4. A Sentiment Agent reads news/social media to gauge market sentiment.
5. The analyses are passed to Consensus and Risk Management agents that weigh the evidence, check against user-defined risk parameters, and make the final BUY, SELL, or HOLD decision. The entire AI analysis runs 100% locally using Ollama, ensuring privacy and zero API costs.

# Target Audience

This project is aimed at:

Python Developers & AI Enthusiasts: Who want to see a real-world, complex application of modern Python libraries like CrewAI, Ollama, Pydantic, and Selenium working together. It serves as a great case study for building multi-agent systems.
Algorithmic Traders & Quants: Who are looking for a flexible, open-source framework that goes beyond

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

sodalite - an open source media downloader with a pure python backend

Made this as a passion project, hope you'll like it :) If you did, please star it! did it as a part of a hackathon and l'd appreciate the support.

What my project does
It detects a link you paste from a supported service, parses it via a network request and serves the file through a FastAPI backend.

Intended audience
Mostly someone who's willing to host this, production ig?

Repo link
https://github.com/oterin/sodalite

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

pandas/python functions (pushing and calling dataframe)

Hello all,
I am fairly new to python and all so i am having difficulty managing next.
So i wanted to create a dim table in separate file, then push few columns to SQL, and allow somehow for few other columns to be allowed to be pulled in another python file, where i would merge it with that data-frame.(creating ID keys basically),
But i am having difficulties doing that,its giving me some long as error. (This part when i am calling in other file : (product_table= Orders_product() )
Could someone point me to right direction?

Product table:

import pandas as pd
from MySQL import getmysqlengine

#getting file
File=r"ExcelFilePath"
Sheet="Orders"
df=pd.readexcel(File, sheetname=Sheet)
productcolumns=["Product Category","Product Sub-Category","Product Container","Product Name"]

def Ordersproduct():
#cleaning text/droping duplicates

    dfproducts = df[productcolumns].copy()
    for productCol in productcolumns:
        dfproducts[productCol] = dfproducts[productCol].str.strip()
    dfproducts['ProductKeyJoin'] = dfproductsproduct_columns.agg('|'.join, axis=1)


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

I built a new package for processing documents for LLM applications: SplitterMR

Hi!

Over the past few months, I've been mulling over the idea of ​​making a Python library. I work as an AI engineer, and I was a little tired of having to reinvent the wheel every time I had to make an RAG to process documents: chunking, reading, image processing, etc.

So, I've started working on a personal project and developed a library to process files you pass in Markdown format and then easily chunk them. I have called it SplitterMR. This library uses several cool things: it has support for Docling, MarkItDown, and PDFPlumber; it can split tables, describe images using VLMs, split text recursively, or do it by tokens. It is very very simple to use!

It's still in development, and I need to keep working on it, but if you could take a look at it in the meantime and tell me how it goes, I'd appreciate it :)

The code repository is: https://github.com/andreshere00/Splitter\_MR/, and the PyPi package is published here: https://pypi.org/project/splitter-mr/

I've also posted a documentation server with several plug-and-play examples so you can try them out and take a look: https://andreshere00.github.io/Splitter\_MR/

And as I said, I'm here for anything. Let me know!

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

[Showcase] leetfetch – A CLI tool to fetch and organize your LeetCode submissions

**GitHub**: [https://github.com/Rage997/leetfetch](https://github.com/Rage997/leetfetch)
**Example output repo**: [https://github.com/Rage997/LeetCode](https://github.com/Rage997/LeetCode)

# What It Does

**leetfetch** is a command-line Python tool that downloads all your LeetCode submissions and problem descriptions using your browser session (no password or API key needed). It groups them by problem and language, and creates Markdown summaries.

# Target Audience

Anyone who solves problems on LeetCode and wants to:

* Back up their work
* Track progress locally or on GitHub

# How It’s Different

Compared to other tools, leetfetch:

* Uses the current GraphQL API
* Filters by accepted (or all) submissions
* Generates a clean, browsable folder structure

# Example Usage

# Download accepted Python3 submissions
python3 main.py --languages python3

# Download all submissions in all languages
python3 main.py --no-only-accepted --all-languages

# Only fetch problems not yet saved
python3 main.py --sync


No login needed – just need to be signed in with your browser.

Let me know what you think.

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

django-hstore-field, An easy to use postgres hstore field that is based on django-hstore-widget

Hello everyone,

Today i released django-hstore-field, an easy to use postgres hstore field that is based on `django-hstore-widget`.

This project is based on stencil.js framework and uses web-components

# 🧐 Usage:

# yourapp/models.py
from django.db import models
from django_hstore_field import HStoreField


class ExampleModel(models.Model):
    data = HStoreField()

# 🚀 Features:

Drop in replacement for `django.contrib.postgres.HStoreField`
It leverages postgres hstore to give developers a key:value widget in the admin field.
It includes a admin panel widget to input and visualize the data.
It has error detection, to prevent malformed json in the widget.
It has a fallback json textarera (same one shipped with django's default implementation)
The widgets have the same style as the admin panel.
Only one [file](https://github.com/baseplate-admin/django-hstore-field/blob/master/src/django_hstore_field/fields.py).

# ⚖ Comparison with other project:

django-postgres-extensions: As far as i checked, the postgres extensions does not offer the built in admin panel extension. Also this package dosen't align with my philosophy "do one thing and do it well".

# 😎 Example:

Picture:

Rendered using django-hstore-field

Thank you guys all, if you guys like the project a ⭐ please.

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

D Conceptually/On a Code Basis - Why does Pytorch work with CUDA out of the box, with minimal setup required, but tensorflow would require all sorts of dependencies?

Hopefully this question doesn't break rule 6.

When I first learned machine learning, we primarily used TensorFlow on platforms like Google Colab or cloud platforms like Databricks, so I never had to worry about setting up Python or TensorFlow environments myself.

Now that I’m working on personal projects, I want to leverage my gaming PC to accelerate training using my GPU. Since I’m most familiar with the TensorFlow model training process, I started off with TensorFlow.

But my god—it was such a pain to set up. As you all probably know, getting it to work often involves very roundabout methods, like using WSL or setting up a Docker dev container.

Then I tried PyTorch, and realized how much easier it is to get everything running with CUDA. That got me thinking: conceptually, why does PyTorch require minimal setup to use CUDA, while TensorFlow needs all sorts of dependencies and is just generally a pain to get working?

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

I made a FOSS feature rich Python template with SOTA tools, security, CI/CD, yet easy to use

## Introduction

Hey, created a FOSS Python library template with features I have never seen (especially in Python development) and which IMO is the most comprehensive, yet focused on usability (template setup is one click and one `pdm setup` command to setup locally, after that only `src`, `tests` and `pyproject.toml` should be of your concern), but I'll let you be the judge.

> GitHub repository: https://github.com/open-nudge/opentemplate

Feedback, questions, ideas, all are welcome, either here or on the GitHub's [discussions](https://github.com/open-nudge/opentemplate/discussions) or [issues](https://github.com/open-nudge/opentemplate/issues) (if you find some
bugs), thanks in advance!

- This was posted previously, but reposting as I think I did a very poor job describing what it does, hopefully I did a better job this time, but [here](https://www.reddit.com/r/Python/comments/1lelh8a/opentemplate_foss_python_template_focused_on/) it is anyway.
Also thanks to [u/wyattxdev](https://www.reddit.com/user/wyattxdev/) and his template [here](https://www.reddit.com/r/Python/comments/1lcz532/a_modern_python_project_cookiecutter_template/) for a great showcase how to present the project correctly!
- __This post is also featured on `r/cybersecurity` subreddit__ (focused more on the security side of things, but feel free to check it out if you are interested): https://www.reddit.com/r/cybersecurity/comments/1lim3k5/i_made_a_foss_python_template_with_cicd_security/

## TLDR Overview

- [__Truly open source__](https://open-nudge.github.io/opentemplate/template/about/philosophy): no tokens, no fees, no premium plans, open source software only
- [__State of the art__](https://open-nudge.github.io/opentemplate/template/details): best checkers for Python, YAML, Markdown, prose, and more unified
- [__Easy to use__](https://open-nudge.github.io/opentemplate/template/quickstart/usage): clone templated repo, run `pdm

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

R Reinforcement Learning Teachers of Test Time Scaling

TL;DR: The raw outputs of our new 7B RL model provide stronger distillation and cold-starting than the filtered and post-processed reasoning traces of orders-of-magnitude larger LMs such as DeepSeek-R1.

How did we achieve this result? We turned the RL task on its head. Rather than training to solve challenging problems from scratch, we optimize our models to generate clear, step-by-step "explanations" to "teach" their students, providing both the problem’s question and its solution already in their input prompt.

This makes the RL training task much easier and also directly aligned with downstream distillation, allowing us to train tiny 7B teachers, boosting the performance of even larger 32B students.

If you are interested to learn more, please check out our new work:

Paper: https://arxiv.org/abs/2506.08388

Blog: https://sakana.ai/rlt/

Open source code: https://github.com/SakanaAI/RLT

If you have any questions, please ask them below or feel free to get in touch, any discussion is more than welcome :)

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

How to implement multi-tenancy with django-tenants for my SaaS ?


Hey devs,

I'm building a SaaS healthcare CRM targeting small or solo medical practices. I want each clinic (tenant) to have its own isolated database schema using django-tenants.

So far, I’ve done the following:

Created a Clinic model using TenantMixin and set autocreateschema = True

Added a Domain model for routing using DomainMixin

Created a custom User model for each tenant

Installed and configured django-tenants


But I still have questions to clarify the right implementation:

1. How should I structure the signup process?
Should I register the tenant (clinic), then switch to that schema and create users?


2. Should the user model be shared (in the public schema) or be tenant-specific?
I need users (doctors/staff) to be isolated per clinic.


3. How can I make sure user login works correctly and is scoped to the right schema?


4. What's the best way to handle domain/subdomain routing for tenants (ex: clinic1.mycrm.com, clinic2.mycrm.com)?


5. Any example repo, best practices, or gotchas I should be aware of?



I’d love to get some feedback or code architecture examples from anyone who’s implemented a similar setup. My goal is to keep tenant data fully isolated and support a clean onboarding experience for new clinics.

Thanks a lot in advance!


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

If someone have pdf for django please send

I am learning django and yt tutorial are good but they explain less. While CBVs are considered best practices but many youtube tutorial are old or new just doesn't cover CBVs that much.if you have pdf please send me.

/r/djangolearning
https://redd.it/1lin4io