Browse

dependency injection .cursorrules prompt files

Filters

Tech

Clear

SEO

React.js

Mongoose ODM

JSON Web Tokens

Dusk

Livewire

Alpine.js

PHPUnit

Paraglide.js

WordPress

Sass

MDX

Less

Netlify

Linux

Framer Motion

Formik

next/image

poetry

Ruby

node-gyp

uuid

mime-types

js-yaml

Istio

CSS frameworks

Expo Router

React Query

Server Components

Sentry

Server Actions

RSC

fetch

React Native Testing Library

Detox

HTTPS

expo-localization

ServeMux

Deno

eslint

microservices architecture

AWS API Gateway

OAuth2

Azure Functions

RQ

AWS CloudWatch

AWS Lambda

Kong

Hono

dataclasses

SQLModel

ERC20

Nuqs

camelCase

Riverpod

getIt

filter

Dart

PascalCase

Flutter

CaveatEnforcer

ASCII

SLF4J

ExecutorService

RxJava

Optional

Project Reactor

Pothos

Vue.js 3

Ollama

BEM

LangGraph

Jenkins

Stream API

Java Collections Framework

CSS3

Google Docs

Microsoft Word

CSV

f-strings

Web Vitals

ShadCN UI

React Hook Form

pnpm

Joi

useEffect

Convex

tokio

anyhow

Typer

ES6+

OpenAI API

Passport.js

SVGO

AVIF

Param

Panel

InertiaJS

Catalyst

MLflow

FastAPI .cursorrules prompt file guide

Code Style and Structure:

Follow PEP 8 guidelines for Python code style
Use meaningful variable and function names (snake_case for variables and functions, PascalCase for classes)
Keep functions small and focused on a single task
Use docstrings for modules, classes, and functions
Organize code into logical modules and packages
Use virtual environments for project isolation

Python-specific Conventions:

Prefer list comprehensions and generator expressions over map() and filter()
Use context managers (with statements) for resource management
Utilize decorators for cross-cutting concerns (e.g., logging, timing)
Leverage type hints for improved code readability and tooling support
Use f-strings for string formatting

Framework and API Development:

Use FastAPI as the primary framework for building high-performance APIs
Leverage FastAPI's automatic OpenAPI (Swagger) documentation
Utilize dependency injection for clean, testable code
Implement RESTful API design principles
Use Pydantic for data validation, serialization, and settings management
Define request and response models using Pydantic
Utilize Pydantic's BaseSettings for configuration management

Database and Data Modeling:

Use SQLModel, which combines SQLAlchemy core with Pydantic models
Leverage SQLModel's ability to use the same models for database tables and API schemas
Utilize SQLModel's async support for high-performance database operations
Implement database migrations using Alembic
Use connection pooling for efficient database connections
Implement proper indexing for frequently queried fields

Authentication and Security:

Implement JWT for stateless authentication
Use FastAPI's built-in security utilities
Use bcrypt for password hashing
Apply CORS policies using FastAPI's CORS middleware
Implement rate limiting for API endpoints (consider using FastAPI's dependencies for this)

Error Handling and Logging:

Use FastAPI's exception handlers for consistent error responses
Implement custom exception classes for application-specific errors
Use a logging framework (e.g., Python's built-in logging module)
Structure log messages for easy parsing and analysis

Frontend Development:

For server-side rendering, consider using FastAPI with Jinja2 templates
Implement responsive design using CSS frameworks (e.g., Bootstrap)
For single-page applications, use a JavaScript framework (e.g., React, Vue.js) that consumes your FastAPI backend

Testing:

Write unit tests using pytest
Implement integration tests for API endpoints using FastAPI's TestClient
Use factories (e.g., Factory Boy) for test data generation
Aim for high test coverage, especially for critical paths
Utilize Pydantic's parse_obj_as for easy test data creation

Asynchronous Processing:

Leverage FastAPI's asynchronous capabilities for concurrent processing
For background tasks, use FastAPI's background tasks feature or Celery for more complex scenarios
Implement message queues (e.g., RabbitMQ, Redis) for task management if needed

Deployment and DevOps:

Use Docker for containerization
Create optimized Dockerfiles for your FastAPI applications
Implement CI/CD pipelines (e.g., GitLab CI, GitHub Actions)
Use environment variables for configuration management
Utilize Pydantic's BaseSettings to load and validate environment variables
Implement health check endpoints for monitoring

Performance Optimization:

Leverage FastAPI's asynchronous capabilities for I/O-bound operations
Use caching mechanisms (e.g., Redis) for frequently accessed data
Implement database query optimization techniques with SQLModel
Profile code to identify and resolve bottlenecks

API Documentation:

Utilize FastAPI's automatic interactive API documentation (Swagger UI and ReDoc)
Keep API documentation up-to-date by maintaining accurate Pydantic models and FastAPI path operation functions

Version Control:

Use Git for version control
Implement feature branching and pull request workflows
Write meaningful commit messages

Dependencies Management

Use pip and requirements.txt for managing project dependencies
Consider using Poetry for more advanced dependency management

Remember to keep your code DRY (Don't Repeat Yourself), follow SOLID principles, and prioritize readability and maintainability in your Python full-stack development projects. Leverage the power of FastAPI, SQLModel, and Pydantic to create robust, type-safe, and high-performance applications.

stack: