Browse

Type Hints .cursorrules strategies

Filters

Tech

Clear

React

Tailwind CSS

Node.js

Tailwind

Shadcn UI

JavaScript

Python

Radix UI

Next.js

Vite

JSX

WebP

Zod

Docker

Next.js App Router

Supabase

CSS

PostgreSQL

Redis

FastAPI

HTML

Pydantic

pytest

Git

Jest

react-hook-form

Solidity

Vercel

SQLAlchemy

Tailwind Aria

Suspense

SvelteKit

Vue.js

GitHub Actions

Celery

ESLint

PHP

TailwindCSS

Pinia

PEP 8

asyncpg

TypeScript

SQL

Playwright

Svelte

Prettier

Radix

DaisyUI

Vitest

JSDoc

JSON

ARIA

Drizzle ORM

Vue Router

VueUse

Astro

Svelte 5

tRPC

Expo

CORS

aiomysql

GitLab CI

Django

Typescript

scikit-learn

pandas

GitHub

RabbitMQ

Java

WebP.

tanStackQuery

Phoenix LiveView

Ecto

File System Watcher

Plug

Finch

Gettext

Phoenix

Elixir

Jason

Phoenix LiveDashboard

Sobelow

ExCoveralls

DNS Cluster

ExUnit

Release Please

Swoosh

Credo

LeftHook

ES6

npm

Laravel

styled-components

RESTful API

Shadcn

Markdown

OpenZeppelin

Slither

Hardhat

Mythril

Clear

Web Development

Code Style

Frontend Development

Naming Conventions

Programming

Responsive Design

Testing

State Management

API Development

Code Optimization

Backend Development

Programming Best Practices

UI Design

Syntax and Formatting

Code Quality

Code Structure

Version Control

Database Management

TypeScript Best Practices

Best Practices

Accessibility

Software Engineering

Performance Optimization

Software Development

Security

Authentication

Code Readability

Internationalization

Coding Best Practices

Image Optimization

Data Fetching

TypeScript

performance optimization

Code Review

Deployment

Error Handling

UI Development

User Interface

JavaScript

Object-Oriented Programming

React

SEO

Modularization

Declarative Programming

Security Best Practices

Web Application Development

Coding Standards

Testing and Debugging

API Integration

JavaScript Frameworks

UI Components

Routing

UI and Styling

Game Development

error handling

functional programming

CI/CD

Functional Programming

Documentation

Code Modularity

Coding Style

Code Maintainability

Clean Code

Build and Deployment

Decentralized Applications

Artificial Intelligence

Form Validation

Blockchain

SEO Optimization

Smart Contracts

Dependency Injection

JavaScript Development

JavaScript Libraries

Test-Driven Development

Development Workflow

Design Patterns

Static Site Generation

Clean Code Practices

TypeScript Usage

Content Management

File Organization

Code Organization

Form Handling

Programming Guidelines

Coding Guidelines

Cloud Computing

Serverless Architecture

Next.js

Node.js

Full Stack Development

Code Documentation

dependency management

documentation

Python development

software architecture

AI Programming

Testing and Deployment

Machine Learning

Validation

Data Science

Show

5

rules

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

Flask-RESTful JWT RESTX .cursorrules prompt file

You are an expert in Python, Flask, and scalable API development.

Key Principles

Write concise, technical responses with accurate Python examples.
Use functional, declarative programming; avoid classes where possible except for Flask views.
Prefer iteration and modularization over code duplication.
Use descriptive variable names with auxiliary verbs (e.g., is_active, has_permission).
Use lowercase with underscores for directories and files (e.g., blueprints/user_routes.py).
Favor named exports for routes and utility functions.
Use the Receive an Object, Return an Object (RORO) pattern where applicable.
Python/Flask
Use def for function definitions.
Use type hints for all function signatures where possible.
Avoid unnecessary curly braces in conditional statements.
For single-line statements in conditionals, omit curly braces.
Use concise, one-line syntax for simple conditional statements (e.g., if condition: do_something()).
Error Handling and Validation
Prioritize error handling and edge cases:
- Handle errors and edge cases at the beginning of functions.
- Use early returns for error conditions to avoid deeply nested if statements.
- Place the happy path last in the function for improved readability.
- Avoid unnecessary else statements; use the if-return pattern instead.
- Use guard clauses to handle preconditions and invalid states early.
- Implement proper error logging and user-friendly error messages.
- Use custom error types or error factories for consistent error handling.
Dependencies
Flask
Flask-RESTful (for RESTful API development)
Flask-JWT-Extended (for JWT authentication)
Flask-Specific Guidelines
Use Flask application factories for better modularity and testing.
Organize routes using Flask Blueprints for better code organization.
Use Flask-RESTful for building RESTful APIs with class-based views.
Implement custom error handlers for different types of exceptions.
Use Flask's before_request, after_request, and teardown_request decorators for request lifecycle management.
Utilize Flask extensions for common functionalities (e.g., Flask-SQLAlchemy, Flask-Migrate).
Use Flask's config object for managing different configurations (development, testing, production).
Implement proper logging using Flask's app.logger.
Performance Optimization
Use Flask-Caching for caching frequently accessed data.
Use background tasks for time-consuming operations (e.g., Celery with Flask).
Key Conventions

Use Flask's application context and request context appropriately.
Prioritize API performance metrics (response time, latency, throughput).
Structure the application:
- Use blueprints for modularizing the application.
- Implement a clear separation of concerns (routes, business logic, data access).
- Use environment variables for configuration management.

Testing

Write unit tests using pytest.
Use Flask's test client for integration testing.
Implement test fixtures for database and application setup.
API Documentation
Use Flask-RESTX or Flasgger for Swagger/OpenAPI documentation.
Ensure all endpoints are properly documented with request/response schemas.
Deployment
Implement proper logging and monitoring in production.
Use environment variables for sensitive information and configuration.
Refer to Flask documentation for detailed information on Views, Blueprints, and Extensions for best practices.

stack: