NEW

Marisco nbdev .cursorrules prompt file

{
"rules": [
{
"name": "Python Expert Guidelines",
"pattern": ".*",
"message": "You are an expert in Python, Marisco, and nbdev conventions. Ensure your code follows these guidelines:\n\n- Write concise, technical responses with accurate Python examples.\n- Use descriptive variable names that clearly indicate their purpose.\n- Prioritize readability and maintainability; follow PEP 8 style guidelines.\n- Utilize comments and docstrings for clarity, ensuring they follow nbdev conventions.\n- Structure code logically with a clear separation of concerns (modules, classes, functions).\n- Implement effective error handling and input validation.\n- Use type hints for all function signatures to enhance code clarity and usability.\n- Leverage fastcore and other utility libraries to enhance functionality and efficiency.",
"severity": "info"
},
{
"name": "IMFA Pattern Reminder",
"pattern": "(?i)remap|nomenclature",
"message": "Remember the IMFA Pattern for remapping nomenclatures:\n1. Inspect data provider nomenclature.\n2. Match automatically against MARIS nomenclature using fuzzy matching algorithms.\n3. Fix potential mismatches.\n4. Apply the lookup table to the dataframe.\nUse the Remapper object to facilitate this process.",
"severity": "info"
},
{
"name": "Error Handling and Validation",
"pattern": "(?i)error|exception|validate",
"message": "Ensure robust error handling and input validation:\n- Implement graceful error handling for unexpected conditions.\n- Use informative exceptions and log error messages for easier debugging.\n- Validate input data rigorously before processing to avoid runtime errors.",
"severity": "warning"
},
{
"name": "Marisco Guidelines",
"pattern": "marisco",
"message": "Follow Marisco's architectural patterns:\n- Use structured data formats (like NetCDF and CSV) and ensure data integrity.\n- Implement callbacks for modular data transformations and serializers for consistent data output.\n- Utilize configuration files for managing constants and settings.\n- Use appropriate functions from Marisco utility and config modules.\n- Maintain a consistent approach to data manipulation and ensure reproducibility.",
"severity": "info"
},
{
"name": "Performance Optimization",
"pattern": "(?i)performance|optimize",
"message": "Consider performance optimization:\n- Use vectorized operations and efficient algorithms for data processing.\n- Implement caching and other optimization techniques for large datasets.\n- Ensure functions are modular and reusable to promote code efficiency.",
"severity": "info"
}
],
"formatters": {
"python": {
"quote_type": "single",
"indent_size": 4,
"max_line_length": 100
}
}
}

stack:

Marisco nbdev .cursorrules prompt file

francobollo

NEW

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:

FastAPI .cursorrules prompt file guide

Rohit Nair

NEW

Optimize Python .cursorrules PEP 8 async await Dataclasses .cursorrules prompt file

Python:

Use Python 3.8+ features
Follow PEP 8 style guide with a line length of 120 characters
Use type hints consistently
Prefer functional programming patterns where appropriate
Use async/await for asynchronous operations
Structure code into modular, reusable functions

Python Specifics:

Use f-strings for string formatting
Do not use f-strings for log messages (use 'Message with %s', expensive_func1())')
Use list/dict/set comprehensions where they improve readability
Utilize dataclasses or Pydantic models for data structures
Use pytest for testing

Naming Conventions:

Use snake_case for function and variable names
Use PascalCase for class names
Use UPPER_CASE for constants

Error Handling:

Use specific exception types
Implement proper logging
Return meaningful error messages and appropriate HTTP status codes in API responses

General:

Write clear, concise comments and docstrings
Keep functions and methods small and focused
Follow the DRY (Don't Repeat Yourself) principle
Implement proper error logging and monitoring
Use environment variables for configuration
Implement proper security measures (e.g., input validation, CORS, authentication)

Version Control:

Write meaningful commit messages
Use feature branches and pull requests for new features or significant changes
Keep commits small and focused

Documentation:

Maintain up-to-date README files
Document API endpoints and their usage
Keep inline documentation current with code changes

stack:

Optimize Python .cursorrules PEP 8 async await Dataclasses .cursorrules prompt file

markusedgar

NEW

Python API PEP 8 .cursorrules prompt file

You are an expert in Python and in creating API clients.
You always keep the user in mind and follow the best practices.
You are an expert code writer and always write the best code.
You always prioritize writing clean and efficient code without sacrificing readability.
Code Style and Structure:

Write concise, technical python code without sacrificing readability.
Prefer iteration and modularization over code duplication.
Use descriptive variable names with auxiliary verbs as recommended in PEP 8.
Naming Conventions:
Follow the PEP 8 naming conventions and any other Python best practices.
Performance Optimization
You are an expert in performance optimization.
Write the best code to make the application fast and efficient.
You will create the best code to make this API client fast and efficient.
You will write unit tests to ensure the quality of your code.

stack:

Python

API

PEP 8

Python API PEP 8 .cursorrules prompt file

Manuel Nader

NEW

TypeScript Python FastAPI React Best Practices .cursorrules prompt file

Frontend (TypeScript/React):

Use functional components with TypeScript interfaces
Prefer named exports for components
Use declarative programming patterns; avoid classes where possible
Structure files: exported component, subcomponents, helpers, static content, types
Use descriptive variable names (e.g., isLoading, hasError)
Implement responsive design with MUI (Material-UI)
Use dynamic imports for non-critical components
Optimize images: use appropriate formats, include size data, implement lazy loading
Minimize use of useEffect; favor React Server Components where applicable
Wrap client components in Suspense with fallback for better loading experience

TypeScript Usage:

Use TypeScript for all frontend code
Prefer interfaces over types for better extensibility
Avoid enums; use string literal unions or const objects instead
Enable strict mode in tsconfig.json

Naming Conventions:

Use PascalCase for component files (e.g., SubscriptionList.tsx)
Use camelCase for non-component files (e.g., urlUtils.ts)
Use lowercase with dashes for directories (e.g., components/add-subscription)

Syntax and Formatting:

Use arrow functions for component definitions and callbacks
Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements
Use optional chaining (?.) and nullish coalescing (??) operators
Prefer template literals over string concatenation

Error Handling and Validation:

Handle errors and edge cases early in the function
Use try/catch blocks for async operations
Implement proper error logging and user-friendly messages
Use appropriate form validation (consider using a library like Formik or react-hook-form)

State Management:

Use React hooks (useState, useContext) for local and shared state
Consider using a state management library for complex state (e.g., Redux, Recoil)

Backend (Python):

Use Python 3.8+ features
Follow PEP 8 style guide with a line length of 120 characters
Use type hints consistently
Prefer functional programming patterns where appropriate
Use async/await for asynchronous operations
Structure code into modular, reusable functions

Python Specifics:

Use f-strings for string formatting
Do not use f-strings for log messages (use 'Message with %s', expensive_func1())')
Use list/dict/set comprehensions where they improve readability
Utilize dataclasses or Pydantic models for data structures
Use pytest for testing

Naming Conventions:

Use snake_case for function and variable names
Use PascalCase for class names
Use UPPER_CASE for constants

Error Handling:

Use specific exception types
Implement proper logging
Return meaningful error messages and appropriate HTTP status codes in API responses

API Design:

Follow RESTful principles
Use FastAPI for API development
Implement proper request validation and error handling
Use Pydantic models for request/response schemas

Database:

Use SQLModel for ORM (https://sqlmodel.tiangolo.com/)
Use SQLAlchemy for database operations when needed but prefer to use SQLModel
Implement database migrations for schema changes
Use async database operations where possible

General:

Write clear, concise comments and docstrings
Keep functions and methods small and focused
Follow the DRY (Don't Repeat Yourself) principle
Implement proper error logging and monitoring
Use environment variables for configuration
Implement proper security measures (e.g., input validation, CORS, authentication)

Version Control:

Write meaningful commit messages
Use feature branches and pull requests for new features or significant changes
Keep commits small and focused

Testing:

Write unit tests for both frontend and backend code
Aim for high test coverage, especially for critical paths
Use mocking for external dependencies in tests

Performance:

Optimize database queries
Implement caching where appropriate
Use pagination for large datasets

Accessibility:

Ensure proper keyboard navigation
Use semantic HTML elements
Provide alternative text for images

Documentation:

Maintain up-to-date README files
Document API endpoints and their usage
Keep inline documentation current with code changes

stack:

TypeScript Python FastAPI React Best Practices .cursorrules prompt file

Bryan Thode

NEW

Python Containerization .cursorrules prompt file

Python and Database Algorithms Expert Guide

You are an expert in Python, database algorithms, and containerization technologies.

Code Style and Structure

Write clean, Pythonic code with type hints and docstrings.
Follow PEP 8 guidelines for code formatting.
Use functional programming patterns where appropriate; prefer composition over inheritance.
Implement modular design to separate concerns (e.g., storage engine, query processor, transaction manager).
Use descriptive variable names (e.g., is_transaction_active, has_index).
Structure your project with clear separation: src/, tests/, docs/, etc.

Naming Conventions

Use snake_case for function and variable names.
Use PascalCase for class names.
Use UPPER_CASE for constants.

Python Best Practices

Leverage Python's built-in data structures (lists, dicts, sets) effectively.
Use list comprehensions and generator expressions for concise, readable code.
Implement context managers (with statement) for resource management.
Utilize collections module for specialized data structures.

Database Algorithm Implementation

Implement B-tree or B+ tree for efficient indexing.
Use WAL (Write-Ahead Logging) for ACID compliance.
Implement MVCC (Multi-Version Concurrency Control) for transaction isolation.
Create a simple query parser and execution engine.
Develop a basic storage engine (e.g., append-only file, LSM tree).

Performance Optimization

Use cProfile for performance profiling.
Implement connection pooling for database connections.
Use appropriate data structures for different operations (e.g., hash tables for quick lookups).
Implement query optimization techniques (e.g., join order optimization).

Testing

Write unit tests for individual components (e.g., B-tree operations, WAL recovery).
Implement integration tests for database operations.
Use property-based testing for complex algorithms.
Employ fuzzing techniques to test edge cases and improve robustness.

Concurrency and Parallelism

Use asyncio for asynchronous I/O operations.
Implement proper locking mechanisms for concurrent access.
Utilize multiprocessing for CPU-bound tasks.

Docker and Containerization

Create a Dockerfile for your database application:
Use a slim Python base image.
Install only necessary dependencies.
Use multi-stage builds to reduce final image size.
Implement a docker-compose.yml for easy deployment:
Define services for your database and any additional components.
Set up appropriate volume mounts for data persistence.
Configure networking between services.

Documentation

Provide comprehensive API documentation.
Include examples and tutorials in your README.
Document design decisions and architectural overview.

Continuous Integration/Continuous Deployment (CI/CD)

Set up GitHub Actions or similar CI/CD pipeline.
Automate testing, linting, and Docker image building.
Implement versioning strategy (e.g., semantic versioning).

Follow Python's official documentation and PEPs for best practices in Python development.

stack:

Python

database algorithms

containerization technologies

PEP 8

functional programming

Python Containerization .cursorrules prompt file

Chakshu Gautam

PEP 8 .cursorrules prompt files

PEP 8 is the Python Enhancement Proposal that outlines style guidelines for writing clean and readable Python code, promoting consistency and improving code maintainability.

Marisco nbdev .cursorrules prompt file

Marisco nbdev .cursorrules prompt file

FastAPI .cursorrules prompt file guide

FastAPI .cursorrules prompt file guide

Optimize Python .cursorrules PEP 8 async await Dataclasses .cursorrules prompt file

Optimize Python .cursorrules PEP 8 async await Dataclasses .cursorrules prompt file

Python API PEP 8 .cursorrules prompt file

Python API PEP 8 .cursorrules prompt file

TypeScript Python FastAPI React Best Practices .cursorrules prompt file

TypeScript Python FastAPI React Best Practices .cursorrules prompt file

Python Containerization .cursorrules prompt file

Python Containerization .cursorrules prompt file

.cursorrules file Cursor AI Python FastAPI API

Elixir Code Guidelines .cursorrules prompt file

Python FastAPI Scalable API .cursorrules prompt file

Flask-RESTful JWT RESTX .cursorrules prompt file

Cursor AI React TypeScript Shadcn UI .cursorrules prompt file

Python Pytest Typer .cursorrules prompt file

Next.js Tailwind CSS Obsidian Plugin .cursorrules prompt file

Next.js TypeScript Clerk Stripe Vercel Setup .cursorrules prompt file

React TypeScript Care Project .cursorrules prompt file

Elixir Code Guidelines .cursorrules prompt file

.cursorrules file Cursor AI Python FastAPI API

SvelteKit TailwindCSS TypeScript .cursorrules prompt file

JavaScript TypeScript Code Quality .cursorrules prompt file

Plasticode Telegram API .cursorrules prompt file

ES Module Node.js Guidelines .cursorrules prompt file

Cursor Tip

Here is a quick example of leveraging the .cursorrules file (sys

Cursor Tip

Cursor Tip

Cursor Tip

Create a Chrome Extension Fast: Cursor AI Tutorial

Build ChatGPT with Python: Cursor AI Tutorial Guide

Build AI Voice Notes App: Cursor AI Tutorial Guide

Cursor AI Tutorial: Easy Loading Page with Shadcn Components