Browse

fastapi-limiter .cursorrules prompt files

fastapi-limiter is a rate limiting middleware for FastAPI applications that helps control the number of API requests, enhancing security and performance by preventing abuse and overload.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

OpenAPI

Grid

API

async/await

Grafana

ELK Stack

Memcached

Prometheus

SWR

SVG

OpenAI

SOLID

Chainlink VRF

Mythril

Hardhat

Slither

Firebase

Vercel AI SDK

Express.js

Daisy UI

Next.js 14

Viem

Wagmi

npm

LeftHook

Credo

Swoosh

Release Please

ExUnit

DNS Cluster

ExCoveralls

Sobelow

Phoenix LiveDashboard

Jason

Phoenix

Gettext

Finch

Plug

File System Watcher

Ecto

Phoenix LiveView

next-safe-action

WebP.

Kafka

Go

MySQL

Azure

logging

Tauri

seaborn

matplotlib

Django

Langchain

Ruff

aiomysql

AVIF

SVGO

Passport.js

OpenAI API

ES6+

Typer

anyhow

tokio

Convex

useEffect

Joi

pnpm

React Hook Form

ShadCN UI

Web Vitals

f-strings

CSV

Microsoft Word

Google Docs

CSS3

Java Collections Framework

Stream API

Jenkins

LangGraph

BEM

Ollama

Vue.js 3

Pothos

Project Reactor

Optional

RxJava

ExecutorService

SLF4J

ASCII

CaveatEnforcer

Flutter

PascalCase

Dart

filter

getIt

Riverpod

camelCase

Nuqs

ERC20

SQLModel

Categories

Clear

TypeScript Interfaces

Software Architecture

Logging and Monitoring

Maintainable Code

Jupyter Notebook

Data Science

Machine Learning

Testing and Deployment

RESTful API Design

AI Programming

software architecture

modular programming

documentation

dependency management

Pytest

Pydantic

GitHub Actions

GitLab CI

Ruff

Pytest-Recording

Loguru

Discord.py

Langchain

CliRunner

VCRPy

Typer

CSS variables

Application development

estimate generation

dashboards

UI components

invite-only security

feedback mechanism

dynamic pricing

hosting

database

role-based access control

multi-tenant architecture

notification system

calendar integration

communication

automated reminders

deep learning

knowledge base

rating and review system

analytics dashboard

visual graph representation

theming

subscription management

authorization

marketing

high concurrency support

client self-assessment

code quality

payment processing

Plugin Architecture

Custom Hooks

Elixir Libraries

CSS

Obsidian Plugin Development

Functional Components

Readable Code

Secure Code

ES6+ Features

Plugin Insertion Patterns

Animation

Analytical Methodology

Performance Enhancement

Optimization

Static site generation

Navigation

Syntax and formatting

Cross-browser compatibility

UI design

Go templates

Content management

Naming conventions

Data Processing

Python Programming

Authorization

Type-Safe Programming

Integration Testing

Micro Frontends

End-to-End Testing

Code Quality and Reviews

Collaborative Development

CSS Guidelines

Modern JavaScript Practices

Linters and Tools

Prisma Usage

Polaris and Tailwind CSS Integration

Shopify API Best Practices

styling

react components

Audio Processing

PEP 8 Style Guidelines

Image Processing

Low-Spec Hardware Compatibility

Raspberry Pi

Hardware Integration

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

Python 3.12 FastAPI Best Practices .cursorrules prompt file

Here are some best practices and rules you must follow:

- You use Python 3.12

- Frameworks:

- pydantic
- fastapi
- sqlalchemy

- You use poetry for dependency management
- You use alembic for database migrations
- You use fastapi-users for user management
- You use fastapi-jwt-auth for authentication
- You use fastapi-mail for email sending
- You use fastapi-cache for caching
- You use fastapi-limiter for rate limiting
- You use fastapi-pagination for pagination

1. **Use Meaningful Names**: Choose descriptive variable, function, and class names.
2. **Follow PEP 8**: Adhere to the Python Enhancement Proposal 8 style guide for formatting.
3. **Use Docstrings**: Document functions and classes with docstrings to explain their purpose.
4. **Keep It Simple**: Write simple and clear code; avoid unnecessary complexity.
5. **Use List Comprehensions**: Prefer list comprehensions for creating lists over traditional loops when appropriate.
6. **Handle Exceptions**: Use try-except blocks to handle exceptions gracefully.
7. **Use Virtual Environments**: Isolate project dependencies using virtual environments (e.g., `venv`).
8. **Write Tests**: Implement unit tests to ensure code reliability.
9. **Use Type Hints**: Utilize type hints for better code clarity and type checking.
10. **Avoid Global Variables**: Limit the use of global variables to reduce side effects.

These rules will help you write clean, efficient, and maintainable Python code.

stack: