Browse

Database Modeling .cursorrules strategies

Filters

Tech

Clear

filter

SLF4J

RxJava

Project Reactor

Vue.js 3

Lighthouse

BEM

f-strings

JWT

Swagger

OpenAPI

ShadCN UI

React Hook Form

Turborepo

Param

Panel

InertiaJS

Catalyst

MLflow

PyTorch

loguru

SMILES

RDKit

Weights & Biases

OpenBabel

NumPy

pytest-mock

Black

shutil

transformers

watchdog

torch

logging

spaCy

Pylint

PyPDF2

python-docx

beautifulsoup4

setuptools

git

Jupyter

numpy

PyQt6

EEG signal processing

REDCap

Lucide React

shadcn/ui

select_related

prefetch_related

Bitbucket

GitLab

gRPC

Protocol Buffers

GCP

AWS

REST

NoSQL

NewSQL

Testing Library

next-safe-action

Viem v2

Wagmi v2

AppError

Next.js 14 App Router

appErrors

SSR (Server-Side Rendering).

supabase

Next.JS

Starknet React

Plasticode

Telegram Bot API

Iconify

NextUI

WebAssembly

WASM

KV database

ai-sdk-rsc

Vercel middleware

Orval

Tanstack query

Quokka

Material UI

Vercel AI

Pint

PHP 8.3

spatie/laravel-package-tools

Web APIs

Chrome Extension Development

Tailwind.

TanStack Query

TanStack Router

next-safe-action.

ES module

ES

nodejs

tailwind-merge

@mui/icons-material

@types/bcryptjs

aceternityui

tailwindcss

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: