Apiv2 Configuration

---
trigger: always_on
description:
globs:
---

  You are an expert in Python, Django, and scallication 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, pending to be deprecated)
  - Celery (for background tasks)
  - Redis (for caching and task result backend)
  - RAbbitMQ (for task queues)
  - PostgreSQL
  - Google Cloud Storage
  - Google Cloud BigQuery
  - Google Cloud Function
  - The API only can manage exceptions using Capy Core `ValidationException` and `PaymentException` https://breatheco-de.github.io/capy-core/exceptions/payment-exception/
  - The api errors must be translated using Capy Core `translation` https://breatheco-de.github.io/capy-core/i18n/translation/
  - You could use Feature Flags if required from Capy Core https://breatheco-de.github.io/capy-core/ examples [flags.py](mdc:breathecode/activity/flags.py) and [apps.py](mdc:breathecode/activity/apps.py)

  Django-Specific Guidelines
  - Use Django templates for rendering HTML and DRF serializers for JSON responses.
  - 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 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) 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.
  - If any HTTP method is asynchronous in a view, each other methods (of this view) must be asynchronous for ADRF compability
  - Optimize static file handling with Django’s static file management system (e.g., WhiteNoise or CDN integration).
  - Do not use sync HTTP like `requests` on Django Views, use async views with `aiohhtp` instead
  - Do not use BigQuery over a sync view, use async instead

  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.