# Check these indicators:
# - Last commit date (< 6 months is good)
# - Open issues vs. closed issues ratio
# - Response time to issues
# - Regular releases
# - Django version compatibility

# settings.py
INSTALLED_APPS = [
    # ...
    'rest_framework',
]

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.TokenAuthentication',
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ],
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 100,
    'DEFAULT_FILTER_BACKENDS': [
        'django_filters.rest_framework.DjangoFilterBackend',
        'rest_framework.filters.SearchFilter',
        'rest_framework.filters.OrderingFilter',
    ],
}

# api/serializers.py
from rest_framework import serializers
from myapp.models import Article

class ArticleSerializer(serializers.ModelSerializer):
    author_name = serializers.CharField(source='author.get_full_name', read_only=True)
    
    class Meta:
        model = Article
        fields = ['id', 'title', 'content', 'author', 'author_name', 'created_at']
        read_only_fields = ['created_at']

# api/views.py
from rest_framework import viewsets, filters
from rest_framework.decorators import action
from rest_framework.response import Response
from django_filters.rest_framework import DjangoFilterBackend

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.select_related('author')
    serializer_class = ArticleSerializer
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_fields = ['author', 'status']
    search_fields = ['title', 'content']
    ordering_fields = ['created_at', 'title']
    
    @action(detail=True, methods=['post'])
    def publish(self, request, pk=None):
        article = self.get_object()
        article.status = 'published'
        article.save()
        return Response({'status': 'article published'})

# settings.py
CELERY_BROKER_URL = 'redis://localhost:6379/0'
CELERY_RESULT_BACKEND = 'redis://localhost:6379/0'
CELERY_ACCEPT_CONTENT = ['json']
CELERY_TASK_SERIALIZER = 'json'
CELERY_RESULT_SERIALIZER = 'json'
CELERY_TIMEZONE = 'UTC'

# Celery Beat schedule for periodic tasks
CELERY_BEAT_SCHEDULE = {
    'send-daily-digest': {
        'task': 'myapp.tasks.send_daily_digest',
        'schedule': crontab(hour=8, minute=0),
    },
}

# myproject/celery.py
import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

app = Celery('myproject')
app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()

# myapp/tasks.py
from celery import shared_task
from django.core.mail import send_mail
from django.contrib.auth import get_user_model

User = get_user_model()

@shared_task(bind=True, max_retries=3)
def send_welcome_email(self, user_id):
    try:
        user = User.objects.get(id=user_id)
        send_mail(
            'Welcome!',
            f'Hello {user.first_name}, welcome to our platform!',
            'noreply@example.com',
            [user.email],
            fail_silently=False,
        )
    except Exception as exc:
        raise self.retry(exc=exc, countdown=60)

@shared_task
def process_large_dataset(file_path):
    # Long-running task
    import pandas as pd
    df = pd.read_csv(file_path)
    # Process data...
    return {'rows_processed': len(df)}

# settings.py
INSTALLED_APPS = [
    # ...
    'django.contrib.sites',
    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    'allauth.socialaccount.providers.google',
    'allauth.socialaccount.providers.github',
]

SITE_ID = 1

AUTHENTICATION_BACKENDS = [
    'django.contrib.auth.backends.ModelBackend',
    'allauth.account.auth_backends.AuthenticationBackend',
]

ACCOUNT_EMAIL_REQUIRED = True
ACCOUNT_USERNAME_REQUIRED = False
ACCOUNT_AUTHENTICATION_METHOD = 'email'
ACCOUNT_EMAIL_VERIFICATION = 'mandatory'
SOCIALACCOUNT_AUTO_SIGNUP = True

SOCIALACCOUNT_PROVIDERS = {
    'google': {
        'SCOPE': [
            'profile',
            'email',
        ],
        'AUTH_PARAMS': {
            'access_type': 'online',
        }
    }
}

# urls.py
urlpatterns = [
    path('accounts/', include('allauth.urls')),
]

# Install
pip install django-extensions

# Useful commands:
python manage.py shell_plus  # Enhanced shell with auto-imports
python manage.py show_urls   # List all URLs
python manage.py graph_models -a -o models.png  # Generate model diagram
python manage.py runserver_plus  # Enhanced dev server with Werkzeug debugger
python manage.py clean_pyc   # Remove .pyc files
python manage.py reset_db    # Reset database

# settings.py
INSTALLED_APPS = [
    # ...
    'django_extensions',
]

# Use TimeStampedModel base class
from django_extensions.db.models import TimeStampedModel

class Article(TimeStampedModel):
    # Automatically adds created and modified fields
    title = models.CharField(max_length=200)
    content = models.TextField()

# settings.py (development only)
if DEBUG:
    INSTALLED_APPS += ['debug_toolbar']
    MIDDLEWARE += ['debug_toolbar.middleware.DebugToolbarMiddleware']
    INTERNAL_IPS = ['127.0.0.1']

DEBUG_TOOLBAR_CONFIG = {
    'SHOW_TOOLBAR_CALLBACK': lambda request: DEBUG,
    'SHOW_TEMPLATE_CONTEXT': True,
}

# urls.py
if settings.DEBUG:
    import debug_toolbar
    urlpatterns = [
        path('__debug__/', include(debug_toolbar.urls)),
    ] + urlpatterns

# 1. Research and evaluate
pip search django-package-name

# 2. Check compatibility
pip show django-package-name

# 3. Install in development
pip install django-package-name

# 4. Test thoroughly
python manage.py test

# 5. Update requirements
pip freeze > requirements.txt
# Or better, use requirements.in with pip-tools

# settings/base.py - Shared settings
INSTALLED_APPS = [
    'django.contrib.admin',
    # ... core apps
]

THIRD_PARTY_APPS = [
    'rest_framework',
    'django_filters',
    'corsheaders',
]

LOCAL_APPS = [
    'myapp',
    'accounts',
]

INSTALLED_APPS += THIRD_PARTY_APPS + LOCAL_APPS

# settings/development.py
from .base import *

DEBUG = True

INSTALLED_APPS += [
    'debug_toolbar',
    'django_extensions',
]

MIDDLEWARE += ['debug_toolbar.middleware.DebugToolbarMiddleware']

# settings/production.py
from .base import *

DEBUG = False

INSTALLED_APPS += [
    'storages',  # S3 storage
]

# requirements/base.txt
Django==4.2.7
psycopg2-binary==2.9.9

# API
djangorestframework==3.14.0
django-filter==23.3
django-cors-headers==4.3.0

# Background tasks
celery==5.3.4
redis==5.0.1

# Storage
django-storages==1.14.2
boto3==1.29.7

# requirements/development.txt
-r base.txt

# Development tools
django-debug-toolbar==4.2.0
django-extensions==3.2.3
ipython==8.17.2

# Testing
pytest-django==4.7.0
factory-boy==3.3.0
faker==20.0.3

# requirements/production.txt
-r base.txt

# Monitoring
sentry-sdk==1.38.0

# Performance
gunicorn==21.2.0

# Use pip-tools for reproducible builds
# requirements.in
Django>=4.2,<5.0
djangorestframework>=3.14
celery[redis]>=5.3

# Generate locked requirements
# pip-compile requirements.in
# Creates requirements.txt with exact versions

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'corsheaders.middleware.CorsMiddleware',  # CORS before CommonMiddleware
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'debug_toolbar.middleware.DebugToolbarMiddleware',  # Debug toolbar last
]

# urls.py - Order matters!
urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('api.urls')),  # Specific paths first
    path('accounts/', include('allauth.urls')),
    path('', include('pages.urls')),  # Catch-all last
]

# settings/production.py
INSTALLED_APPS += ['storages']

# S3 Configuration
AWS_ACCESS_KEY_ID = env('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = env('AWS_SECRET_ACCESS_KEY')
AWS_STORAGE_BUCKET_NAME = env('AWS_STORAGE_BUCKET_NAME')
AWS_S3_REGION_NAME = 'us-east-1'
AWS_S3_CUSTOM_DOMAIN = f'{AWS_STORAGE_BUCKET_NAME}.s3.amazonaws.com'

# Static files
STATICFILES_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
STATIC_URL = f'https://{AWS_S3_CUSTOM_DOMAIN}/static/'

# Media files
DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
MEDIA_URL = f'https://{AWS_S3_CUSTOM_DOMAIN}/media/'

# routers.py
class AuthRouter:
    """Route auth models to separate database"""
    
    route_app_labels = {'auth', 'contenttypes', 'sessions'}
    
    def db_for_read(self, model, **hints):
        if model._meta.app_label in self.route_app_labels:
            return 'auth_db'
        return None
    
    def db_for_write(self, model, **hints):
        if model._meta.app_label in self.route_app_labels:
            return 'auth_db'
        return None

# settings.py
DATABASES = {
    'default': {...},
    'auth_db': {...},
}

DATABASE_ROUTERS = ['myproject.routers.AuthRouter']

# setup.py for your package
from setuptools import setup, find_packages

setup(
    name='django-mypackage',
    version='0.1.0',
    packages=find_packages(),
    include_package_data=True,
    license='MIT',
    description='A Django package for...',
    long_description=open('README.md').read(),
    long_description_content_type='text/markdown',
    url='https://github.com/yourusername/django-mypackage',
    author='Your Name',
    author_email='your.email@example.com',
    classifiers=[
        'Environment :: Web Environment',
        'Framework :: Django',
        'Framework :: Django :: 4.2',
        'Intended Audience :: Developers',
        'License :: OSI Approved :: MIT License',
        'Operating System :: OS Independent',
        'Programming Language :: Python',
        'Programming Language :: Python :: 3.10',
        'Programming Language :: Python :: 3.11',
    ],
    install_requires=[
        'Django>=4.2',
    ],
    python_requires='>=3.10',
)

django-mypackage/
├── mypackage/
│   ├── __init__.py
│   ├── models.py
│   ├── views.py
│   ├── urls.py
│   ├── admin.py
│   ├── templates/
│   │   └── mypackage/
│   │       └── base.html
│   ├── static/
│   │   └── mypackage/
│   │       └── style.css
│   └── migrations/
├── tests/
│   ├── __init__.py
│   ├── test_models.py
│   └── test_views.py
├── docs/
├── README.md
├── LICENSE
├── setup.py
├── MANIFEST.in
└── tox.ini

# Bad - too many dependencies
INSTALLED_APPS = [
    'package1',  # Only used once
    'package2',  # Could write yourself
    'package3',  # Unmaintained
]

# Good - essential packages only
INSTALLED_APPS = [
    'rest_framework',  # Core API functionality
    'celery',  # Complex async handling
]

# Check for outdated packages
pip list --outdated

# Use pip-review for interactive updates
pip install pip-review
pip-review --interactive

# Or use dependabot/renovate for automated PRs

# tests/test_package_compatibility.py
import pytest
from django.test import TestCase

class PackageCompatibilityTest(TestCase):
    def test_rest_framework_version(self):
        import rest_framework
        # Ensure we're on a compatible version
        assert rest_framework.VERSION >= (3, 14, 0)

# docs/packages.md
"""
# Third-Party Packages

## Django REST Framework
- Version: 3.14.0
- Purpose: API development
- Configuration: settings/base.py
- Documentation: https://www.django-rest-framework.org/

## Celery
- Version: 5.3.4
- Purpose: Background task processing
- Configuration: myproject/celery.py
- Documentation: https://docs.celeryproject.org/
"""

# config/rest_framework.py
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [...],
    'DEFAULT_PERMISSION_CLASSES': [...],
}

# config/celery.py
CELERY_BROKER_URL = 'redis://localhost:6379/0'
CELERY_RESULT_BACKEND = 'redis://localhost:6379/0'

# settings.py
from .config.rest_framework import REST_FRAMEWORK
from .config.celery import *