Model Fields

class AutoSlugField(SlugField):
    def __init__(
        self,
        populate_from=None,
        separator='-',
        overwrite=False,
        overwrite_on_add=True,
        allow_duplicates=False,
        slugify_function=None,
        max_unique_query_attempts=100,
        **kwargs
    ):
        """
        AutoSlugField that automatically populates from other fields.
        
        Parameters:
        - populate_from: Field name, list of fields, or callable to populate from
        - separator: String used to separate slug components (default: '-')
        - overwrite: If True, regenerate slug on every save (default: False)
        - overwrite_on_add: If True, generate slug when adding new instances (default: True)
        - allow_duplicates: If True, allow duplicate slugs (default: False)
        - slugify_function: Custom function for slugification (default: django.template.defaultfilters.slugify)
        - max_unique_query_attempts: Maximum attempts to find unique slug (default: 100)
        """

from django.db import models
from django_extensions.db.fields import AutoSlugField

class Article(models.Model):
    title = models.CharField(max_length=200)
    slug = AutoSlugField(populate_from='title')

class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    # Populate from multiple fields
    slug = AutoSlugField(populate_from=['title', 'author'], separator='_')

class CustomSlugModel(models.Model):
    name = models.CharField(max_length=100)
    
    def custom_slugify(self, content):
        return content.replace(' ', '_').lower()
    
    slug = AutoSlugField(populate_from='name', slugify_function=custom_slugify)

class CreationDateTimeField(DateTimeField):
    def __init__(self, **kwargs):
        """
        DateTimeField that automatically sets creation datetime.
        
        Sets editable=False, blank=True, auto_now_add=True by default.
        Value is set once when object is first created.
        """

class ModificationDateTimeField(DateTimeField):
    def __init__(self, **kwargs):
        """
        DateTimeField that automatically updates modification datetime.
        
        Sets editable=False, blank=True, auto_now=True by default.
        Value is updated every time object is saved.
        
        Respects the 'update_modified' attribute on model instances.
        If update_modified=False, the field won't be updated on save.
        """

from django.db import models
from django_extensions.db.fields import CreationDateTimeField, ModificationDateTimeField

class TimestampedModel(models.Model):
    created = CreationDateTimeField()
    modified = ModificationDateTimeField()
    
    def save_without_timestamp_update(self, *args, **kwargs):
        # Prevent modification timestamp from updating
        self.update_modified = False
        self.save(*args, **kwargs)

class RandomCharField(CharField):
    def __init__(
        self,
        length=None,
        unique=False,
        lowercase=False,
        uppercase=False,
        include_alpha=True,
        include_digits=True,
        include_punctuation=False,
        keep_default=False,
        max_unique_query_attempts=100,
        **kwargs
    ):
        """
        CharField that generates random character strings.
        
        Parameters:
        - length: Required. Length of random string to generate
        - unique: If True, ensure uniqueness in database (default: False)
        - lowercase: If True, force lowercase alpha characters (default: False)
        - uppercase: If True, force uppercase alpha characters (default: False)
        - include_alpha: Include alphabetic characters (default: True)
        - include_digits: Include numeric digits (default: True)
        - include_punctuation: Include punctuation characters (default: False)
        - keep_default: Keep initial value if already set (default: False)
        - max_unique_query_attempts: Max attempts to find unique value (default: 100)
        
        Note: lowercase and uppercase are mutually exclusive
        """

from django.db import models
from django_extensions.db.fields import RandomCharField

class APIKey(models.Model):
    key = RandomCharField(length=32, unique=True)

class Token(models.Model):
    # Only uppercase letters and digits
    token = RandomCharField(
        length=16, 
        unique=True,
        uppercase=True,
        include_punctuation=False
    )

class SessionID(models.Model):
    # Include punctuation for stronger randomness
    session_id = RandomCharField(
        length=40,
        unique=True,
        include_punctuation=True
    )

class UUIDFieldMixin:
    def __init__(
        self,
        auto=True,
        version=4,
        node=None,
        clock_seq=None,
        namespace=None,
        uuid_name=None,
        **kwargs
    ):
        """
        Mixin for UUID field functionality.
        
        Parameters:
        - auto: Automatically generate UUID if not provided (default: True)
        - version: UUID version (1, 3, 4, 5) - version 2 not supported (default: 4)
        - node: Node value for UUID version 1
        - clock_seq: Clock sequence for UUID version 1
        - namespace: Namespace UUID for versions 3 and 5
        - uuid_name: Name for versions 3 and 5 (defaults to field name)
        """

class ShortUUIDField(UUIDFieldMixin, CharField):
    def __init__(self, **kwargs):
        """
        Generates concise (22 characters), unambiguous, URL-safe UUIDs.
        
        Requires 'shortuuid' package: pip install shortuuid
        Uses base57 encoding to create shorter UUID representations.
        """

from django.db import models
from django_extensions.db.fields import ShortUUIDField
import uuid

class Document(models.Model):
    # Standard UUID4 field (requires manual import)
    id = models.UUIDField(primary_key=True, default=uuid.uuid4)

class ShortDocument(models.Model):
    # Short UUID field (22 characters instead of 36)
    id = ShortUUIDField(primary_key=True)

# For other UUID versions, you would typically use Django's built-in UUIDField
# with custom default functions

class JSONField(TextField):
    def __init__(self, **kwargs):
        """
        TextField that neatly serializes/deserializes JSON objects.
        
        Automatically handles conversion between Python objects and JSON strings.
        Uses DjangoJSONEncoder for serialization.
        Default value is empty dict ({}).
        
        Returns JSONDict for dict objects and JSONList for list objects
        to ensure proper fixture serialization.
        """
        
class JSONDict(dict):
    def __repr__(self):
        """Returns JSON representation for fixture compatibility."""

class JSONList(list):
    def __repr__(self):
        """Returns JSON representation for fixture compatibility."""

from django.db import models
from django_extensions.db.fields.json import JSONField

class Configuration(models.Model):
    name = models.CharField(max_length=100)
    settings = JSONField()  # Defaults to empty dict
    
    def save(self, *args, **kwargs):
        # Data is automatically serialized to JSON
        if not self.settings:
            self.settings = {'default': True}
        super().save(*args, **kwargs)

# Usage
config = Configuration.objects.create(
    name='app_config',
    settings={
        'debug': True,
        'max_connections': 100,
        'features': ['feature1', 'feature2']
    }
)

# Retrieval - automatically deserialized
settings = config.settings  # Python dict, not JSON string
debug_mode = settings['debug']  # True

from django.db import models
from django_extensions.db.fields import AutoSlugField, CreationDateTimeField

class CustomModel(models.Model):
    title = models.CharField(max_length=200)
    
    # AutoSlugField with custom options
    slug = AutoSlugField(
        populate_from='title',
        max_length=100,  # Limit slug length
        help_text='Automatically generated from title',
        overwrite=True,  # Always regenerate on save
        allow_duplicates=False
    )
    
    # CreationDateTimeField with custom options
    created = CreationDateTimeField(
        verbose_name='Date Created',
        help_text='When this record was created'
    )
    
    class Meta:
        ordering = ['-created']

# Location: django_extensions.mongodb.fields
from django_extensions.mongodb.fields import (
    AutoSlugField as MongoAutoSlugField,
    CreationDateTimeField as MongoCreationDateTimeField,
    ModificationDateTimeField as MongoModificationDateTimeField,
    UUIDField as MongoUUIDField
)

# Timestamped model with slug
class BlogPost(models.Model):
    title = models.CharField(max_length=200)
    slug = AutoSlugField(populate_from='title')
    created = CreationDateTimeField()
    modified = ModificationDateTimeField()
    
    class Meta:
        ordering = ['-created']

# API model with random key
class APIEndpoint(models.Model):
    name = models.CharField(max_length=100)
    api_key = RandomCharField(length=32, unique=True)
    config = JSONField(default=dict)
    created = CreationDateTimeField()

# User profile with short UUID
class UserProfile(models.Model):
    id = ShortUUIDField(primary_key=True)
    user = models.OneToOneField('auth.User', on_delete=models.CASCADE)
    preferences = JSONField(default=dict)
    slug = AutoSlugField(populate_from='user__username')