import dataclasses
import functools
import pkgutil
from typing import Protocol

import blinker
from django_tasks import task


def publish(name: str, /, *, payload: dict[str, object]) -> None:
    """
    Publish an asynchronous event with the given `payload` for all receivers
    subscribed to `name`.
    """
    signal = _get_namespace().signal(name)
    for receiver in signal.receivers_for(blinker.ANY):
        receiver_identifier = _get_receiver_identifier(receiver)
        _execute_event.enqueue(
            receiver_identifier=receiver_identifier, name=name, payload=payload
        )


def subscribe(name: str, /, *, receiver: Receiver) -> None:
    """
    Subscribe a `receiver` callable for the given event `name`.
    """
    signal = _get_namespace().signal(name)
    signal.connect(receiver)


@dataclasses.dataclass(frozen=True, kw_only=True)
class Event:
    """
    The event object a receiver is called with.
    """

    name: str
    payload: dict[str, object]


class Receiver(Protocol):
    """
    Protocol for event receiver callables.
    """

    __qualname__: str

    def __call__(self, event: Event, /) -> None: ...


# Private


@functools.cache
def _get_namespace() -> blinker.Namespace:
    """
    Return the namespace used for all events.
    """
    return blinker.Namespace()


@task(queue_name="events")
def _execute_event(
    *, receiver_identifier: str, name: str, payload: dict[str, object]
) -> None:
    """
    Call the identified receiver with the event.
    """
    receiver_callable = _get_receiver_callable(receiver_identifier)
    receiver_callable(Event(name=name, payload=payload))


def _get_receiver_identifier(receiver: Receiver, /) -> str:
    """
    Return the identifier `<package>:<object>` for the given receiver.
    """
    return f"{receiver.__module__}:{receiver.__qualname__}"


def _get_receiver_callable(receiver_identifier: str, /) -> Receiver:
    """
    Return the receiver for the given identifier.
    """
    receiver_callable: Receiver = pkgutil.resolve_name(receiver_identifier)
    return receiver_callable

  INSTALLED_APPS = [
      ...,
+     "django_tasks",
+     "django_tasks.backends.database",
  }

+ TASKS = {
+     "default": {
+         "BACKEND": "django_tasks.backends.database.DatabaseBackend",
+         "QUEUES": ["events"],
+     }
+ }

from django import apps

import events


class Config(apps.AppConfig):
    ...

    def ready(self) -> None:
        events.subscribe("user.created", receiver=user_created)


def user_created(event: events.Event, /) -> None:
    ...

import events


def create_user(...) -> None:
    user = ...
    events.publish("user.created", payload={"user_id": user.id})

from django.db import models


class UUIDv7(models.Func):
    function = "uuidv7"
    output_field = models.UUIDField()


class UUIDExtractTimestamp(models.Func):
    function = "uuid_extract_timestamp"
    output_field = models.DateTimeField()


class Record(models.Model):
    uuid = models.UUIDField(db_default=UUIDv7(), primary_key=True)
    creation_time = models.GeneratedField(
        expression=UUIDExtractTimestamp("uuid"),
        output_field=models.DateTimeField(),
        db_persist=True,
    )

alias rp import rich; rich.print(%*)
alias rpo import rich; from django import forms; rich.print(forms.model_to_dict(%*))

print("Aliases: Use `rp obj` and `rpo instance` to print objects and model instances.\n")

from django import forms

import rich

rp = rich.print


def rpo(*args):
    for instance in args:
        rich.print(forms.model_to_dict(instance))


print("Helpers: Use `rp(*args)` and `rpo(*args)` to print objects and model instances.\n")

-----> $ python src/manage.py collectstatic --noinput
       Post-processing 'polls/style.css' failed!
       whitenoise.storage.MissingFileError: The file 'polls/style.css.map' could not be found with <whitenoise.storage.CompressedManifestStaticFilesStorage object at 0x7f5c4b1970e0>.
       The CSS file 'polls/style.css' references a file which could not be found:
         polls/style.css.map
       Please check the URL references in this CSS file, particularly any
       relative paths which might be pointing to the wrong location.

import tempfile

import pytest
from pytest_django.fixtures import SettingsWrapper
from whitenoise import storage


def test_collect_static_files_manifest(settings: SettingsWrapper) -> None:
    """
    Test that all referenced static files exist in the manifest.
    """
    with tempfile.TemporaryDirectory() as directory:
        settings.STATIC_ROOT = directory
        try:
            call_command("collectstatic", no_input=True)
        except storage.MissingFileError:
            pytest.fail("Missing file in the static files manifest")

from django.conf import STATICFILES_STORAGE_ALIAS

from environs import env

MIDDLEWARE = [
    ...,
    "whitenoise.middleware.WhiteNoiseMiddleware",
    ...,
]

STORAGES = {
    STATICFILES_STORAGE_ALIAS: {
        "BACKEND": "whitenoise.storage.CompressedManifestStaticFilesStorage",
    },
}

if env.bool("CI", False):
    MIDDLEWARE.remove("whitenoise.middleware.WhiteNoiseMiddleware")
    STORAGES[STATICFILES_STORAGE_ALIAS] = {
        "BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage",
    }

.venv/lib/python3.13/site-packages/django/contrib/staticfiles/storage.py:516: in stored_name
    raise ValueError(
E   ValueError: Missing staticfiles manifest entry for 'polls/style.css'

  STORAGES = {
      STATICFILES_STORAGE_ALIAS: {
-         "BACKEND": "whitenoise.storage.CompressedManifestStaticFilesStorage",
+         "BACKEND": env.str("WHITENOISE_BACKEND", default="whitenoise.storage.CompressedManifestStaticFilesStorage"),
      },
  }

- if env.bool("CI", False):
-     MIDDLEWARE.remove("whitenoise.middleware.WhiteNoiseMiddleware")
-     STORAGES[STATICFILES_STORAGE_ALIAS] = {
-         "BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage",
-     }

WHITENOISE_BACKEND="whitenoise.storage.StaticFilesStorage"

  import tempfile

+ from django.conf import STATICFILES_STORAGE_ALIAS
+
  import pytest
  from pytest_django.fixtures import SettingsWrapper
  from whitenoise import storage


  def test_collect_static_files_manifest(settings: SettingsWrapper) -> None:
      """
      Test that all referenced static files exist in the manifest.
      """
+     settings.STORAGES = {
+         STATICFILES_STORAGE_ALIAS: {
+             "BACKEND": "whitenoise.storage.CompressedManifestStaticFilesStorage",
+         },
+     }
      with tempfile.TemporaryDirectory() as directory:
          settings.STATIC_ROOT = directory
          try:
              call_command("collectstatic", no_input=True)
          except storage.MissingFileError:
              pytest.fail("Missing file in the static files manifest")

UserWarning: No directory at: /.../static_root/

  STORAGES = {
      STATICFILES_STORAGE_ALIAS: {
          "BACKEND": env.str("WHITENOISE_BACKEND", default="whitenoise.storage.CompressedManifestStaticFilesStorage"),
      },
  }

+ # For both performance and security reasons, `WHITENOISE_AUTOREFRESH` should not be used in production.
+ WHITENOISE_AUTOREFRESH = env.bool("WHITENOISE_AUTOREFRESH", False)

WHITENOISE_AUTOREFRESH=true

from django.contrib.postgres.fields import ArrayField
from django.db import models

class Post(models.Model):
    tags = ArrayField(models.CharField(max_length=200))

from django.db.models import F, Func

posts = Post.objects.annotate(
    tags_shuffle=Func(F("tags"), function="ARRAY_SHUFFLE"),
)

from django.db import models

class Post(models.Model):
    published_year = models.IntegerField()
    published_month = models.IntegerField()
    published_day = models.IntegerField()

from django.db.models import DateField, F, Func

posts = Post.objects.annotate(
    published_date=Func(
        F("published_year"),
        F("published_month"),
        F("published_day"),
        output_field=DateField(),
        function="MAKE_DATE",
    )
)

class Priority(enum.IntEnum):
    LOW = 1
    MEDIUM = 2
    HIGH = 3

# The default priority for all tasks.
CELERY_TASK_DEFAULT_PRIORITY = 2
# The default max priority for all queues.
CELERY_TASK_QUEUE_MAX_PRIORITY = 3

CELERY_QUEUE_DEFAULT = "celery"
CELERY_QUEUE_PRIORITY = "priority"
CELERY_TASK_QUEUES = [
    Queue(
        name=CELERY_QUEUE_DEFAULT,
        exchange=Exchange(CELERY_QUEUE_DEFAULT),
        routing_key=CELERY_QUEUE_DEFAULT,
    ),
    Queue(
        name=CELERY_QUEUE_PRIORITY,
        exchange=Exchange(CELERY_QUEUE_PRIORITY),
        routing_key=CELERY_QUEUE_PRIORITY,
        queue_arguments={"x-max-priority": 3}
    ),
]

amqp.exceptions.PreconditionFailed: Queue.declare: (406) PRECONDITION_FAILED - inequivalent arg 'x-max-priority' for queue 'celery' in vhost '/': received the value '3' of type 'signedint' but current is none

# Caution! Delete all queues from RabbitMQ.
rabbitmqadmin --format=tsv --quiet list queues name | while read name; do rabbitmqadmin --quiet delete queue name=${name}; done

@app.task(priority=Priority.LOW)
def generate_report():
    ...


@app.task(priority=Priority.HIGH)
def send_email():
    ...

filename = "ACME™ Anvil.jpg"
metadata: dict[str, str] = {
    "filename": filename,
}
client.upload_fileobj(
    Fileobj=...,
    Bucket=...,
    Key=...,
    ExtraArgs={"Metadata": metadata}
)

metadata: dict[str, str] = {
    "filename": filename.encode("ascii", "backslashreplace").decode(),
}

>>> filename.encode("ascii", "backslashreplace").decode()
'ACME\\u2122 Anvil.jpg'

>>> "ACME\\u2122 Anvil.jpg".encode("ascii").decode("unicode-escape")
'ACME™ Anvil.jpg'

>>> "😵‍💫".encode("ascii", "backslashreplace").decode()
'\\U0001f635\\u200d\\U0001f4ab'

>>> "\\U0001f635\\u200d\\U0001f4ab".encode("ascii").decode("unicode-escape")
'😵\u200d💫'

>>> print("\\U0001f635\\u200d\\U0001f4ab".encode("ascii").decode("unicode-escape"))
😵‍💫

from django.db import models

class User(models.Model):
    name = models.CharField(blank=True)

users = User.objects.filter(name__istartswith="John")

SELECT "data_user"."id", "data_user"."name"
FROM "data_user"
WHERE UPPER("data_user"."name"::text) LIKE UPPER('John%')

from django.db import models
from django.db.models.functions import Upper

class User(models.Model):
    name = models.CharField(blank=True)

    class Meta:
        indexes = [
            models.Index(Upper("name"), name="name_idx"),
        ]

from django.db import models
from django.db.models.functions import Upper

class User(models.Model):
    name = models.CharField(blank=True)

    class Meta:
        indexes = [
            models.Index(
                Upper("name"),
                name="name_idx",
                condition=~models.Q(name=Upper(models.Value(""))),
            ),
        ]

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, data, sessions
Running migrations:
  Applying data.0001_initial...Traceback (most recent call last):
  File "project/src/manage.py", line 22, in <module>
    main()
  ...
  File "project/.venv/lib/python3.12/site-packages/django/db/models/sql/query.py", line 1772, in names_to_path
    raise FieldError(
django.core.exceptions.FieldError: Cannot resolve keyword '' into field. Choices are: id, question_text