.cursorrules Python Django Best Practices

by @pskishere

You are an expert in Python, Django, and scalable web application development.

Key Principles

- Write clear, technical responses with precise Django examples.
- Use Django's built-in features and tools wherever possible to leverage its full capabilities.
- Prioritize readability and maintainability; follow Django's coding style guide (PEP 8 compliance).
- Use descriptive variable and function names; adhere to naming conventions (e.g., lowercase with underscores for functions and variables).
- Structure your project in a modular way using Django apps to promote reusability and separation of concerns.

Django/Python

- Use Django’s class-based views (CBVs) for more complex views; prefer function-based views (FBVs) for simpler logic.
- Leverage Django’s ORM for database interactions; avoid raw SQL queries unless necessary for performance.
- Use Django’s built-in user model and authentication framework for user management.
- Utilize Django's form and model form classes for form handling and validation.
- Follow the MVT (Model-View-Template) pattern strictly for clear separation of concerns.
- Use middleware judiciously to handle cross-cutting concerns like authentication, logging, and caching.

Error Handling and Validation

- Implement error handling at the view level and use Django's built-in error handling mechanisms.
- Use Django's validation framework to validate form and model data.
- Prefer try-except blocks for handling exceptions in business logic and views.
- Customize error pages (e.g., 404, 500) to improve user experience and provide helpful information.
- Use Django signals to decouple error handling and logging from core business logic.

Dependencies

- Django
- Django REST Framework (for API development)
- Celery (for background tasks)
- Redis (for caching and task queues)
- PostgreSQL or MySQL (preferred databases for production)

Django-Specific Guidelines

- Use Django templates for rendering HTML and DRF serializers for JSON responses.
- Keep business logic in models and forms; keep views light and focused on request handling.
- Use Django's URL dispatcher (urls.py) to define clear and RESTful URL patterns.
- Apply Django's security best practices (e.g., CSRF protection, SQL injection protection, XSS prevention).
- Use Django’s built-in tools for testing (unittest and pytest-django) to ensure code quality and reliability.
- Leverage Django’s caching framework to optimize performance for frequently accessed data.
- Use Django’s middleware for common tasks such as authentication, logging, and security.

Performance Optimization

- Optimize query performance using Django ORM's select_related and prefetch_related for related object fetching.
- Use Django’s cache framework with backend support (e.g., Redis or Memcached) to reduce database load.
- Implement database indexing and query optimization techniques for better performance.
- Use asynchronous views and background tasks (via Celery) for I/O-bound or long-running operations.
- Optimize static file handling with Django’s static file management system (e.g., WhiteNoise or CDN integration).

Key Conventions

1. Follow Django's "Convention Over Configuration" principle for reducing boilerplate code.
2. Prioritize security and performance optimization in every stage of development.
3. Maintain a clear and logical project structure to enhance readability and maintainability.

Refer to Django documentation for best practices in views, models, forms, and security considerations.

---
description: Guidelines for Django forms, focusing on form handling, validation, and model form usage.
globs: **/forms.py
---
- Utilize Django's form and model form classes for form handling and validation.
- Use Django's validation framework to validate form and model data.
- Keep business logic in models and forms; keep views light and focused on request handling.


---
description: Guidance on using Django middleware for cross-cutting concerns like authentication, logging, and caching.
globs: **/middleware.py
---
- Use middleware judiciously to handle cross-cutting concerns like authentication, logging, and caching.
- Use Django’s middleware for common tasks such as authentication, logging, and security.


---
description: Rules for Django models, emphasizing ORM usage, database interactions, and data validation.
globs: **/models.py
---
- Leverage Django’s ORM for database interactions; avoid raw SQL queries unless necessary for performance.
- Keep business logic in models and forms; keep views light and focused on request handling.


---
description: Rules for Django REST Framework serializers, focusing on JSON responses.
globs: **/serializers.py
---
- Use Django templates for rendering HTML and DRF serializers for JSON responses.


---
description: Configurations for Django settings file with the list of dependencies and conventions.
globs: **/settings.py
---
- Django
- Django REST Framework (for API development)
- Celery (for background tasks)
- Redis (for caching and task queues)
- PostgreSQL or MySQL (preferred databases for production)


---
description: Rules for Django templates, focusing on rendering HTML and following best practices.
globs: **/templates/**/*.html
---
- Use Django templates for rendering HTML and DRF serializers for JSON responses.


---
description: Guidelines for Django URL configurations, focusing on clear and RESTful URL patterns.
globs: **/urls.py
---
- Use Django’s URL dispatcher (urls.py) to define clear and RESTful URL patterns.


---
description: Specific guidelines for Django views, focusing on class-based vs. function-based views, error handling, and request handling.
globs: **/views.py
---
- Use Django’s class-based views (CBVs) for more complex views; prefer function-based views (FBVs) for simpler logic.
- Implement error handling at the view level and use Django's built-in error handling mechanisms.
- Keep business logic in models and forms; keep views light and focused on request handling.


---
description: Focus on performance optimization techniques in all files of the project.
globs: **/*.*
---
- Optimize query performance using Django ORM's select_related and prefetch_related for related object fetching.
- Use Django’s cache framework with backend support (e.g., Redis or Memcached) to reduce database load.
- Implement database indexing and query optimization techniques for better performance.
- Use asynchronous views and background tasks (via Celery) for I/O-bound or long-running operations.
- Optimize static file handling with Django’s static file management system (e.g., WhiteNoise or CDN integration).
- Prioritize security and performance optimization in every stage of development.


---
description: General Python and Django rules, focusing on coding style, error handling, and Django conventions across the project.
globs: **/*.py
---
- You are an expert in Python, Django, and scalable web application development.
- Write clear, technical responses with precise Django examples.
- Use Django's built-in features and tools wherever possible to leverage its full capabilities.
- Prioritize readability and maintainability; follow Django's coding style guide (PEP 8 compliance).
- Use descriptive variable and function names; adhere to naming conventions (e.g., lowercase with underscores for functions and variables).
- Structure your project in a modular way using Django apps to promote reusability and separation of concerns.
- Follow Django's "Convention Over Configuration" principle for reducing boilerplate code.


---
description: Apply security best practices across all files in the Django project.
globs: **/*.*
---
- Apply Django's security best practices (e.g., CSRF protection, SQL injection protection, XSS prevention).
- Prioritize security and performance optimization in every stage of development.

Django Web Application Development Toolkit

A collection of tools and platforms designed to build scalable and secure web applications using Django, focusing on e-commerce, education, social networking, and more.

Core Applications

Django E-commerce Platform:
A scalable e-commerce platform integrating payment gateways and leveraging Django’s ORM for product and user data management.
Online Learning Management System (LMS):
A Django-based LMS with course management, video streaming, and quizzes, using Django REST Framework for API integration.
Social Networking Site:
A social networking platform with user profiles, follow/unfollow features, and real-time notifications using Django signals.

Content & Job Platforms

Blogging Platform:
A feature-rich blogging platform with post management, comments, and background email notifications using Celery.
Job Portal:
A job portal application with job listings, resume submissions, and advanced search functionalities using Redis for caching.

Real Estate & Marketplace Solutions

Real Estate Listing Website:
A real estate platform with property listings, advanced search filters, and user authentication using Django forms and ORM.
Online Marketplace:
An online marketplace integrating with external APIs for shipping and payment, using Django’s admin panel for seller management.

Event & Forum Platforms

Event Management System:
An event management application allowing users to create, manage, and RSVP to events with Django’s templating system.
Online Forum:
An online forum platform enabling users to post topics, reply, and follow threads with activity notifications using Django signals and Celery.

Hospitality Solutions

Hotel Booking System:
A hotel booking application supporting room reservations, payment integration, and user reviews, optimized with Django’s caching framework.

Key Technologies:

Django
Django REST Framework
Celery
Redis
Caching Frameworks

Overview of .cursorrules prompt

The .cursorrules file outlines best practices and key principles for developing scalable web applications using Python and Django. It emphasizes clear and technical responses with precise examples, prioritizes readability and maintainability, and adheres to Django’s coding style guide. The file instructs on using Django’s built-in features, middleware, and ORM for database interactions, as well as implementing error handling and validation. It recommends specific dependencies like Django REST Framework for APIs and Celery for background tasks and lists preferred databases. The guidelines cover templates, business logic placement, URL definitions, and security best practices. Performance optimization techniques include query optimization, caching, and using asynchronous views. The file enforces Django’s “Convention Over Configuration” principle, stressing security, performance, and a maintainable project structure while referencing Django documentation for further best practices.

Updated: March 17, 2025

Developers building scalable web applications using Django and Python can use this prompt to ensure their code adheres to best practices for maintainability, performance, and security.

Usefull for: