# Serializing querysets to JSON
from django.core import serializers
from myapp.models import Article

# Serialize all articles
articles = Article.objects.all()
json_data = serializers.serialize('json', articles)

# Serialize specific fields only
json_data = serializers.serialize('json', articles, fields=('title', 'author', 'pub_date'))

# Serialize with natural foreign keys
json_data = serializers.serialize('json', articles, use_natural_foreign_keys=True)

# Pretty print JSON
import json
json_data = serializers.serialize('json', articles, indent=2)

# Deserializing data
from django.core import serializers

json_data = '[{"model": "myapp.article", "pk": 1, "fields": {"title": "Hello"}}]'

for obj in serializers.deserialize('json', json_data):
    # obj.object is the deserialized model instance
    obj.save()  # Save to database

# Deserialize without saving
for obj in serializers.deserialize('json', json_data):
    article = obj.object
    # Work with article without saving
    print(article.title)

# JSON is the most common format
from django.core import serializers

# Basic JSON serialization
data = serializers.serialize('json', Article.objects.all())

# With options
data = serializers.serialize('json', Article.objects.all(),
    indent=4,
    use_natural_foreign_keys=True,
    use_natural_primary_keys=True
)

# Writing to file
with open('articles.json', 'w') as f:
    serializers.serialize('json', Article.objects.all(), stream=f)

# XML format
xml_data = serializers.serialize('xml', Article.objects.all())

# Example output:
# <?xml version="1.0" encoding="utf-8"?>
# <django-objects version="1.0">
#   <object model="myapp.article" pk="1">
#     <field name="title" type="CharField">Hello World</field>
#     <field name="pub_date" type="DateTimeField">2023-01-01T12:00:00</field>
#   </object>
# </django-objects>

# YAML format (requires PyYAML)
yaml_data = serializers.serialize('yaml', Article.objects.all())

# Example output:
# - model: myapp.article
#   pk: 1
#   fields:
#     title: Hello World
#     pub_date: 2023-01-01 12:00:00

# models.py
class Author(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(unique=True)
    
    class Meta:
        unique_together = [['name', 'email']]
    
    def natural_key(self):
        return (self.name, self.email)

class AuthorManager(models.Manager):
    def get_by_natural_key(self, name, email):
        return self.get(name=name, email=email)

class Article(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    
    objects = AuthorManager()
    
    def natural_key(self):
        return (self.title,) + self.author.natural_key()
    natural_key.dependencies = ['myapp.author']

# Serialization with natural keys
data = serializers.serialize('json', Article.objects.all(),
    use_natural_foreign_keys=True,
    use_natural_primary_keys=True
)

# Output uses natural keys instead of PKs:
# {
#   "model": "myapp.article",
#   "fields": {
#     "title": "My Article",
#     "author": ["John Doe", "john@example.com"]
#   }
# }

# Creating custom serializers
from django.core.serializers.json import Serializer as JSONSerializer

class CustomJSONSerializer(JSONSerializer):
    def get_dump_object(self, obj):
        data = super().get_dump_object(obj)
        # Add custom fields
        data['custom_field'] = 'custom_value'
        # Modify existing fields
        if 'pub_date' in data['fields']:
            data['fields']['pub_date'] = data['fields']['pub_date'].isoformat()
        return data

# Register custom serializer
from django.core import serializers
serializers.register_serializer('custom_json', 'myapp.serializers.CustomJSONSerializer')

# Use custom serializer
data = serializers.serialize('custom_json', Article.objects.all())

# serializers.py
from rest_framework import serializers
from myapp.models import Article, Author

class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name', 'email']

class ArticleSerializer(serializers.ModelSerializer):
    author = AuthorSerializer(read_only=True)
    author_id = serializers.IntegerField(write_only=True)
    
    class Meta:
        model = Article
        fields = ['id', 'title', 'content', 'author', 'author_id', 'pub_date']
        read_only_fields = ['pub_date']
    
    def validate_title(self, value):
        if len(value) < 5:
            raise serializers.ValidationError("Title must be at least 5 characters")
        return value

# views.py
from rest_framework.views import APIView
from rest_framework.response import Response

class ArticleListView(APIView):
    def get(self, request):
        articles = Article.objects.all()
        serializer = ArticleSerializer(articles, many=True)
        return Response(serializer.data)
    
    def post(self, request):
        serializer = ArticleSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)

# Creating fixtures
python manage.py dumpdata myapp.Article --indent 2 > articles.json

# Loading fixtures
python manage.py loaddata articles.json

# Fixtures in tests
from django.test import TestCase

class ArticleTestCase(TestCase):
    fixtures = ['articles.json', 'authors.json']
    
    def test_article_count(self):
        self.assertEqual(Article.objects.count(), 10)

# Optimize serialization with select_related and prefetch_related
articles = Article.objects.select_related('author').prefetch_related('tags')
data = serializers.serialize('json', articles)

# Serialize only needed fields
data = serializers.serialize('json', articles, fields=('id', 'title'))

# Stream large datasets
with open('large_export.json', 'w') as f:
    serializers.serialize('json', Article.objects.iterator(), stream=f)

from django.http import JsonResponse

def article_list_api(request):
    articles = Article.objects.all()
    data = serializers.serialize('json', articles)
    return JsonResponse(json.loads(data), safe=False)

from django.http import HttpResponse

def export_articles(request):
    response = HttpResponse(content_type='application/json')
    response['Content-Disposition'] = 'attachment; filename="articles.json"'
    
    serializers.serialize('json', Article.objects.all(), stream=response)
    return response

# Export from old system
old_data = serializers.serialize('json', OldModel.objects.all())

# Transform and import to new system
for obj in serializers.deserialize('json', old_data):
    new_obj = NewModel(
        title=obj.object.old_title,
        content=obj.object.old_content
    )
    new_obj.save()