# Start Django shell
python manage.py shell

# Expected output:
# Python 3.11.5 (main, Aug 24 2023, 15:18:16) [Clang 14.0.3 ] on darwin
# Type "help", "copyright", "credits" or "license" for more information.
# (InteractiveConsole)
# >>>

# Install IPython for better shell experience
pip install ipython

# Start shell (automatically uses IPython if available)
python manage.py shell

# Features with IPython:
# - Syntax highlighting
# - Tab completion
# - Magic commands
# - Better error formatting
# - History navigation

# Install django-extensions
pip install django-extensions

# Add to INSTALLED_APPS
INSTALLED_APPS += ['django_extensions']

# Start enhanced shell
python manage.py shell_plus

# Features:
# - Auto-imports all models
# - Imports common Django modules
# - Better formatting
# - Additional utilities

# Django shell automatically provides:
# - All Django modules and functions
# - Your project's settings
# - Database connection
# - All installed apps and their models

# Check available imports
>>> import django
>>> django.get_version()
'4.2.7'

>>> from django.conf import settings
>>> settings.DEBUG
True

>>> from django.contrib.auth.models import User
>>> User.objects.count()
5

# Import your models
>>> from myapp.models import Post, Category
>>> from django.contrib.auth.models import User

# Create objects - Method 1: Using create()
>>> user = User.objects.create_user(
...     username='john',
...     email='john@example.com',
...     password='secure_password'
... )

>>> category = Category.objects.create(
...     name='Technology',
...     slug='technology'
... )

>>> post = Post.objects.create(
...     title='My First Post',
...     content='This is the content of my first post.',
...     author=user,
...     category=category
... )

# Create objects - Method 2: Using save()
>>> post = Post(
...     title='Another Post',
...     content='More content here.',
...     author=user,
...     category=category
... )
>>> post.save()

# Bulk create for efficiency
>>> posts = [
...     Post(title=f'Post {i}', content=f'Content {i}', author=user, category=category)
...     for i in range(1, 11)
... ]
>>> Post.objects.bulk_create(posts)

# Basic queries
>>> Post.objects.all()
<QuerySet [<Post: My First Post>, <Post: Another Post>, ...]>

>>> Post.objects.count()
12

>>> Post.objects.first()
<Post: My First Post>

>>> Post.objects.last()
<Post: Post 10>

# Filtering
>>> Post.objects.filter(author=user)
<QuerySet [<Post: My First Post>, <Post: Another Post>, ...]>

>>> Post.objects.filter(title__icontains='first')
<QuerySet [<Post: My First Post>]>

>>> Post.objects.filter(created_at__year=2024)
<QuerySet [<Post: My First Post>, ...]>

# Excluding
>>> Post.objects.exclude(title__icontains='first')
<QuerySet [<Post: Another Post>, ...]>

# Get single object
>>> post = Post.objects.get(id=1)
>>> post.title
'My First Post'

# Get or create
>>> post, created = Post.objects.get_or_create(
...     title='Unique Post',
...     defaults={'content': 'Default content', 'author': user, 'category': category}
... )
>>> created
True

# Update single object
>>> post = Post.objects.get(id=1)
>>> post.title = 'Updated Title'
>>> post.save()

# Update multiple objects
>>> Post.objects.filter(author=user).update(status='published')
3

# Update with F expressions (database-level operations)
>>> from django.db.models import F
>>> Post.objects.filter(author=user).update(view_count=F('view_count') + 1)

# Update or create
>>> post, created = Post.objects.update_or_create(
...     id=1,
...     defaults={'title': 'Updated or Created Post'}
... )

# Delete single object
>>> post = Post.objects.get(id=1)
>>> post.delete()
(1, {'myapp.Post': 1})

# Delete multiple objects
>>> Post.objects.filter(status='draft').delete()
(5, {'myapp.Post': 5})

# Soft delete (if implemented)
>>> Post.objects.filter(id=1).update(is_deleted=True)

from django.db.models import Q, F, Count, Avg, Sum
from django.utils import timezone
from datetime import timedelta

# Q objects for complex conditions
>>> recent_posts = Post.objects.filter(
...     Q(created_at__gte=timezone.now() - timedelta(days=7)) &
...     (Q(status='published') | Q(status='featured'))
... )

# Annotations
>>> posts_with_comment_count = Post.objects.annotate(
...     comment_count=Count('comments')
... ).filter(comment_count__gt=5)

# Aggregations
>>> stats = Post.objects.aggregate(
...     total_posts=Count('id'),
...     avg_comments=Avg('comments__count'),
...     total_views=Sum('view_count')
... )
>>> stats
{'total_posts': 10, 'avg_comments': 3.5, 'total_views': 1250}

# Subqueries
>>> from django.db.models import Subquery, OuterRef
>>> latest_comments = Comment.objects.filter(
...     post=OuterRef('pk')
... ).order_by('-created_at')

>>> posts_with_latest_comment = Post.objects.annotate(
...     latest_comment_date=Subquery(latest_comments.values('created_at')[:1])
... )

# Select related (for foreign keys)
>>> posts = Post.objects.select_related('author', 'category').all()
>>> for post in posts:
...     print(f"{post.title} by {post.author.username}")  # No additional queries

# Prefetch related (for reverse foreign keys and many-to-many)
>>> posts = Post.objects.prefetch_related('comments', 'tags').all()
>>> for post in posts:
...     print(f"{post.title} has {post.comments.count()} comments")  # No additional queries

# Only/defer for field selection
>>> posts = Post.objects.only('title', 'created_at').all()  # Only these fields
>>> posts = Post.objects.defer('content').all()  # All fields except content

# Values and values_list for dictionaries/tuples
>>> post_data = Post.objects.values('title', 'author__username')
>>> list(post_data)
[{'title': 'My First Post', 'author__username': 'john'}, ...]

>>> post_titles = Post.objects.values_list('title', flat=True)
>>> list(post_titles)
['My First Post', 'Another Post', ...]

# Raw queries
>>> posts = Post.objects.raw('SELECT * FROM myapp_post WHERE created_at > %s', [timezone.now() - timedelta(days=7)])
>>> list(posts)
[<Post: Recent Post 1>, <Post: Recent Post 2>]

# Direct database connection
>>> from django.db import connection
>>> cursor = connection.cursor()
>>> cursor.execute('SELECT COUNT(*) FROM myapp_post')
>>> cursor.fetchone()
(10,)

# Named cursor for complex queries
>>> with connection.cursor() as cursor:
...     cursor.execute("""
...         SELECT p.title, u.username, COUNT(c.id) as comment_count
...         FROM myapp_post p
...         JOIN auth_user u ON p.author_id = u.id
...         LEFT JOIN myapp_comment c ON p.id = c.post_id
...         GROUP BY p.id, p.title, u.username
...         ORDER BY comment_count DESC
...     """)
...     results = cursor.fetchall()
>>> results
[('Popular Post', 'john', 15), ('Another Post', 'jane', 8), ...]

# Get database connection info
>>> from django.db import connection
>>> connection.vendor
'postgresql'

>>> connection.settings_dict
{'ENGINE': 'django.db.backends.postgresql', 'NAME': 'myproject', ...}

# Introspect tables
>>> tables = connection.introspection.table_names()
>>> tables
['auth_user', 'myapp_post', 'myapp_category', ...]

# Get table description
>>> desc = connection.introspection.get_table_description(connection.cursor(), 'myapp_post')
>>> [(row.name, row.type_code) for row in desc]
[('id', 23), ('title', 1043), ('content', 25), ...]

# Check indexes
>>> indexes = connection.introspection.get_indexes(connection.cursor(), 'myapp_post')
>>> indexes
{'myapp_post_author_id_idx': {'columns': ['author_id'], 'unique': False}, ...}

from django.db import transaction

# Atomic decorator/context manager
>>> with transaction.atomic():
...     user = User.objects.create_user(username='testuser')
...     post = Post.objects.create(title='Test Post', author=user, category=category)
...     # If any operation fails, all are rolled back

# Manual transaction control
>>> transaction.set_autocommit(False)
>>> try:
...     user = User.objects.create_user(username='manual_user')
...     post = Post.objects.create(title='Manual Post', author=user, category=category)
...     transaction.commit()
... except Exception:
...     transaction.rollback()
... finally:
...     transaction.set_autocommit(True)

# Savepoints
>>> with transaction.atomic():
...     user = User.objects.create_user(username='savepoint_user')
...     sid = transaction.savepoint()
...     try:
...         # Risky operation
...         Post.objects.create(title='', author=user, category=category)  # This might fail
...     except Exception:
...         transaction.savepoint_rollback(sid)
...     else:
...         transaction.savepoint_commit(sid)

# Test model methods
>>> post = Post.objects.first()
>>> post.get_absolute_url()
'/posts/1/'

>>> post.is_published()
True

>>> post.get_related_posts()
<QuerySet [<Post: Related Post 1>, <Post: Related Post 2>]>

# Test model properties
>>> post.word_count
1250

>>> post.reading_time
'5 minutes'

# Test model validation
>>> post.full_clean()  # Raises ValidationError if invalid

from django.test import Client
from django.urls import reverse

# Create test client
>>> client = Client()

# Test GET requests
>>> response = client.get('/posts/')
>>> response.status_code
200

>>> response = client.get(reverse('post_detail', kwargs={'pk': 1}))
>>> response.context['post'].title
'My First Post'

# Test POST requests
>>> response = client.post('/posts/create/', {
...     'title': 'Shell Test Post',
...     'content': 'Created from shell',
...     'category': category.id
... })
>>> response.status_code
302  # Redirect after successful creation

# Test with authenticated user
>>> client.login(username='john', password='secure_password')
True
>>> response = client.get('/admin/')
>>> response.status_code
200

# Object inspection
>>> post = Post.objects.first()
>>> vars(post)
{'_state': <django.db.models.base.ModelState object>, 'id': 1, 'title': 'My First Post', ...}

>>> post._meta.fields
(<django.db.models.fields.AutoField: id>, <django.db.models.fields.CharField: title>, ...)

>>> post._meta.get_field('title')
<django.db.models.fields.CharField: title>

# Query inspection
>>> qs = Post.objects.filter(author__username='john')
>>> str(qs.query)
'SELECT "myapp_post"."id", ... FROM "myapp_post" INNER JOIN "auth_user" ON ("myapp_post"."author_id" = "auth_user"."id") WHERE "auth_user"."username" = john'

# Connection queries (with DEBUG=True)
>>> from django.db import connection
>>> len(connection.queries)
5
>>> connection.queries[-1]
{'sql': 'SELECT ...', 'time': '0.001'}

import time
from django.db import connection, reset_queries

# Reset query log
>>> reset_queries()

# Time operations
>>> start_time = time.time()
>>> posts = list(Post.objects.select_related('author').all())
>>> end_time = time.time()
>>> print(f"Query time: {end_time - start_time:.4f}s")
>>> print(f"Number of queries: {len(connection.queries)}")

# Analyze slow queries
>>> for query in connection.queries:
...     if float(query['time']) > 0.01:  # Queries taking more than 10ms
...         print(f"Slow query ({query['time']}s): {query['sql'][:100]}...")

# Load fixture data
>>> from django.core.management import call_command
>>> call_command('loaddata', 'sample_data.json')

# Create fixture from current data
>>> call_command('dumpdata', 'myapp.Post', indent=2, output='posts.json')

import csv
from io import StringIO

# Export to CSV
>>> output = StringIO()
>>> writer = csv.writer(output)
>>> writer.writerow(['Title', 'Author', 'Created'])
>>> for post in Post.objects.select_related('author'):
...     writer.writerow([post.title, post.author.username, post.created_at])
>>> csv_data = output.getvalue()

# Import from CSV
>>> csv_data = """Title,Content,Author
... "Test Post 1","Content 1","john"
... "Test Post 2","Content 2","jane"
... """
>>> reader = csv.DictReader(StringIO(csv_data))
>>> for row in reader:
...     author = User.objects.get(username=row['Author'])
...     Post.objects.create(
...         title=row['Title'],
...         content=row['Content'],
...         author=author,
...         category=category
...     )

import json

# Export to JSON
>>> posts_data = []
>>> for post in Post.objects.select_related('author', 'category'):
...     posts_data.append({
...         'title': post.title,
...         'content': post.content,
...         'author': post.author.username,
...         'category': post.category.name,
...         'created_at': post.created_at.isoformat()
...     })
>>> json_output = json.dumps(posts_data, indent=2)

# Import from JSON
>>> json_data = '[{"title": "JSON Post", "content": "From JSON", "author": "john"}]'
>>> data = json.loads(json_data)
>>> for item in data:
...     author = User.objects.get(username=item['author'])
...     Post.objects.create(
...         title=item['title'],
...         content=item['content'],
...         author=author,
...         category=category
...     )

# Bulk update
>>> Post.objects.filter(created_at__year=2023).update(status='archived')

# Bulk delete
>>> Post.objects.filter(status='draft', created_at__lt=timezone.now() - timedelta(days=30)).delete()

# Bulk create with ignore conflicts
>>> posts = [Post(title=f'Bulk Post {i}', content='Content', author=user, category=category) for i in range(100)]
>>> Post.objects.bulk_create(posts, ignore_conflicts=True)

# Bulk update with bulk_update
>>> posts = Post.objects.filter(status='draft')[:10]
>>> for post in posts:
...     post.status = 'published'
>>> Post.objects.bulk_update(posts, ['status'])

# Find and fix data issues
>>> posts_without_category = Post.objects.filter(category__isnull=True)
>>> default_category = Category.objects.get_or_create(name='Uncategorized')[0]
>>> posts_without_category.update(category=default_category)

# Validate all objects
>>> invalid_posts = []
>>> for post in Post.objects.all():
...     try:
...         post.full_clean()
...     except ValidationError as e:
...         invalid_posts.append((post, e))
>>> len(invalid_posts)
0

# Remove duplicates
>>> from django.db.models import Count
>>> duplicates = Post.objects.values('title', 'author').annotate(
...     count=Count('id')
... ).filter(count__gt=1)
>>> for dup in duplicates:
...     posts = Post.objects.filter(title=dup['title'], author=dup['author'])
...     posts.exclude(id=posts.first().id).delete()

# scripts/shell_script.py
import os
import django

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

from myapp.models import Post, Category
from django.contrib.auth.models import User

def create_sample_data():
    """Create sample data for development."""
    user, created = User.objects.get_or_create(
        username='admin',
        defaults={'email': 'admin@example.com', 'is_staff': True, 'is_superuser': True}
    )
    
    category, created = Category.objects.get_or_create(
        name='Sample Category',
        defaults={'slug': 'sample-category'}
    )
    
    for i in range(10):
        Post.objects.get_or_create(
            title=f'Sample Post {i}',
            defaults={
                'content': f'This is sample content for post {i}',
                'author': user,
                'category': category
            }
        )
    
    print(f"Created sample data: {Post.objects.count()} posts")

if __name__ == '__main__':
    create_sample_data()

python scripts/shell_script.py

# settings/development.py
SHELL_PLUS_PRE_IMPORTS = [
    ('myapp.utils', 'helper_function'),
    ('django.utils', 'timezone'),
    ('datetime', 'datetime', 'timedelta'),
]

SHELL_PLUS_MODEL_ALIASES = {
    'User': 'django.contrib.auth.models.User',
    'Post': 'myapp.models.Post',
}

SHELL_PLUS_PRINT_SQL = True
SHELL_PLUS_PRINT_SQL_TRUNCATE = 1000

# Custom shell startup script
SHELL_PLUS_STARTUP_SCRIPT = """
print("Welcome to Django Shell Plus!")
print(f"Available models: {', '.join([m.__name__ for m in apps.get_models()])}")
"""

# Time execution
>>> %timeit Post.objects.count()
100 loops, best of 3: 2.5 ms per loop

# Profile code
>>> %prun Post.objects.select_related('author').all()

# Debug on exception
>>> %pdb on
>>> # Now any exception will drop into debugger

# Load external script
>>> %load scripts/data_analysis.py

# Save session history
>>> %save session_history.py 1-50

# System commands
>>> !ls -la
>>> !git status

# SQL magic (with ipython-sql)
>>> %load_ext sql
>>> %sql SELECT COUNT(*) FROM myapp_post;

# Start with imports
>>> from myapp.models import *
>>> from django.contrib.auth.models import User
>>> from django.utils import timezone
>>> from datetime import timedelta

# Set up common variables
>>> user = User.objects.first()
>>> category = Category.objects.first()

# Use meaningful variable names
>>> recent_posts = Post.objects.filter(created_at__gte=timezone.now() - timedelta(days=7))
>>> published_posts = Post.objects.filter(status='published')

# Save complex queries for reuse
>>> def get_popular_posts(days=30, min_views=100):
...     return Post.objects.filter(
...         created_at__gte=timezone.now() - timedelta(days=days),
...         view_count__gte=min_views
...     ).order_by('-view_count')

# Always use get_or_create for unique objects
>>> user, created = User.objects.get_or_create(
...     username='unique_user',
...     defaults={'email': 'user@example.com'}
... )

# Use transactions for related operations
>>> from django.db import transaction
>>> with transaction.atomic():
...     user = User.objects.create_user(username='transactional_user')
...     post = Post.objects.create(title='Safe Post', author=user, category=category)

# Validate before saving
>>> post = Post(title='', content='Invalid post')
>>> try:
...     post.full_clean()
... except ValidationError as e:
...     print(f"Validation error: {e}")

# Use exists() for boolean checks
>>> if Post.objects.filter(title='Specific Title').exists():
...     print("Post exists")

# Limit querysets when exploring
>>> Post.objects.all()[:10]  # Only fetch first 10