django-display-ids 0.1.3__tar.gz → 0.1.4__tar.gz

{django_display_ids-0.1.3 → django_display_ids-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-display-ids
-Version: 0.1.3
+Version: 0.1.4
 Summary: Stripe-like prefixed IDs for Django. Works with existing UUIDs — no schema changes.
 Keywords: django,stripe,uuid,base62,prefixed-id,drf,shortuuid,nanoid,ulid
 License: ISC
@@ -122,6 +122,93 @@ class InvoiceView(DisplayIDLookupMixin, APIView):
         return Response({"id": str(invoice.id)})
 ```
 
+#### Serializer Field
+
+Include `display_id` in your API responses:
+
+```python
+from rest_framework import serializers
+from django_display_ids.contrib.rest_framework import DisplayIDField
+
+class InvoiceSerializer(serializers.Serializer):
+    id = serializers.UUIDField(read_only=True)
+    display_id = DisplayIDField()
+    name = serializers.CharField()
+
+# Output: {"id": "...", "display_id": "inv_2aUyqjCzEIiEcYMKj7TZtw", ...}
+```
+
+The field reads `display_id_prefix` from the model. You can override it:
+
+```python
+display_id = DisplayIDField(prefix="inv")  # Use custom prefix
+```
+
+Prefix must be 1-16 lowercase letters. Invalid prefixes raise `ValueError` at initialization.
+
+**OpenAPI/drf-spectacular**: When drf-spectacular is installed, the field automatically generates proper schema with prefix-specific examples (e.g., `inv_2aUyqjCzEIiEcYMKj7TZtw`). The prefix is resolved from (in order): field's `prefix=` argument, serializer's `Meta.model.display_id_prefix`, or the view's queryset model.
+
+#### OpenAPI Parameter Descriptions
+
+For consistent API documentation, use the provided description helpers:
+
+```python
+from django_display_ids.contrib.rest_framework import id_param_description
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+from drf_spectacular.types import OpenApiTypes
+
+@extend_schema(
+    parameters=[
+        OpenApiParameter(
+            "id",
+            OpenApiTypes.STR,
+            OpenApiParameter.PATH,
+            description=id_param_description("inv"),
+            # -> "Identifier: display_id (inv_xxx) or UUID"
+        )
+    ],
+)
+class InvoiceViewSet(DisplayIDLookupMixin, ModelViewSet):
+    ...
+```
+
+For endpoints that also accept slugs:
+
+```python
+description=id_param_description("app", with_slug=True)
+# -> "Identifier: display_id (app_xxx), UUID, or slug"
+```
+
+Generic constants are also available:
+
+```python
+from django_display_ids.contrib.rest_framework import (
+    ID_PARAM_DESCRIPTION,           # "Identifier: display_id (prefix_xxx) or UUID"
+    ID_PARAM_DESCRIPTION_WITH_SLUG, # "Identifier: display_id (prefix_xxx), UUID, or slug"
+)
+```
+
+#### Deterministic Examples for OpenAPI
+
+Generate consistent example UUIDs and display IDs for OpenAPI schemas:
+
+```python
+from django_display_ids import example_uuid, example_display_id
+
+# Generate deterministic UUID for a prefix
+example_uuid("inv")
+# -> UUID('a172cedc-ae47-474b-615c-54d510a5d84a')
+
+# Generate deterministic display ID
+example_display_id("inv")
+# -> "inv_4ueEO5Nz4X7u9qc3FVHokM"
+
+# Also works with model classes
+example_uuid(Invoice)  # Uses Invoice.display_id_prefix
+```
+
+The same prefix always produces the same example, ensuring consistent documentation across regenerations.
+
 ### Model Mixin
 
 Add a `display_id` property to your models:

{django_display_ids-0.1.3 → django_display_ids-0.1.4}/README.md

@@ -100,6 +100,93 @@ class InvoiceView(DisplayIDLookupMixin, APIView):
         return Response({"id": str(invoice.id)})
 ```
 
+#### Serializer Field
+
+Include `display_id` in your API responses:
+
+```python
+from rest_framework import serializers
+from django_display_ids.contrib.rest_framework import DisplayIDField
+
+class InvoiceSerializer(serializers.Serializer):
+    id = serializers.UUIDField(read_only=True)
+    display_id = DisplayIDField()
+    name = serializers.CharField()
+
+# Output: {"id": "...", "display_id": "inv_2aUyqjCzEIiEcYMKj7TZtw", ...}
+```
+
+The field reads `display_id_prefix` from the model. You can override it:
+
+```python
+display_id = DisplayIDField(prefix="inv")  # Use custom prefix
+```
+
+Prefix must be 1-16 lowercase letters. Invalid prefixes raise `ValueError` at initialization.
+
+**OpenAPI/drf-spectacular**: When drf-spectacular is installed, the field automatically generates proper schema with prefix-specific examples (e.g., `inv_2aUyqjCzEIiEcYMKj7TZtw`). The prefix is resolved from (in order): field's `prefix=` argument, serializer's `Meta.model.display_id_prefix`, or the view's queryset model.
+
+#### OpenAPI Parameter Descriptions
+
+For consistent API documentation, use the provided description helpers:
+
+```python
+from django_display_ids.contrib.rest_framework import id_param_description
+from drf_spectacular.utils import extend_schema, OpenApiParameter
+from drf_spectacular.types import OpenApiTypes
+
+@extend_schema(
+    parameters=[
+        OpenApiParameter(
+            "id",
+            OpenApiTypes.STR,
+            OpenApiParameter.PATH,
+            description=id_param_description("inv"),
+            # -> "Identifier: display_id (inv_xxx) or UUID"
+        )
+    ],
+)
+class InvoiceViewSet(DisplayIDLookupMixin, ModelViewSet):
+    ...
+```
+
+For endpoints that also accept slugs:
+
+```python
+description=id_param_description("app", with_slug=True)
+# -> "Identifier: display_id (app_xxx), UUID, or slug"
+```
+
+Generic constants are also available:
+
+```python
+from django_display_ids.contrib.rest_framework import (
+    ID_PARAM_DESCRIPTION,           # "Identifier: display_id (prefix_xxx) or UUID"
+    ID_PARAM_DESCRIPTION_WITH_SLUG, # "Identifier: display_id (prefix_xxx), UUID, or slug"
+)
+```
+
+#### Deterministic Examples for OpenAPI
+
+Generate consistent example UUIDs and display IDs for OpenAPI schemas:
+
+```python
+from django_display_ids import example_uuid, example_display_id
+
+# Generate deterministic UUID for a prefix
+example_uuid("inv")
+# -> UUID('a172cedc-ae47-474b-615c-54d510a5d84a')
+
+# Generate deterministic display ID
+example_display_id("inv")
+# -> "inv_4ueEO5Nz4X7u9qc3FVHokM"
+
+# Also works with model classes
+example_uuid(Invoice)  # Uses Invoice.display_id_prefix
+```
+
+The same prefix always produces the same example, ensuring consistent documentation across regenerations.
+
 ### Model Mixin
 
 Add a `display_id` property to your models:

{django_display_ids-0.1.3 → django_display_ids-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "django-display-ids"
-version = "0.1.3"
+version = "0.1.4"
 description = "Stripe-like prefixed IDs for Django. Works with existing UUIDs — no schema changes."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -42,6 +42,7 @@ dev = [
     "pytest-django>=4.8",
     "pytest-cov>=6.0",
     "djangorestframework>=3.14",
+    "drf-spectacular>=0.28",
     "shortuuid>=1.0",
     "nox>=2024.0",
     "ruff>=0.8",

{django_display_ids-0.1.3 → django_display_ids-0.1.4}/src/django_display_ids/__init__.py

@@ -30,6 +30,12 @@ from .encoding import (
     encode_display_id,
     encode_uuid,
 )
+from .examples import (
+    example_display_id,
+    example_display_id_for_prefix,
+    example_uuid,
+    example_uuid_for_prefix,
+)
 from .exceptions import (
     AmbiguousIdentifierError,
     InvalidIdentifierError,
@@ -50,6 +56,11 @@ __all__ = [  # noqa: RUF022 - keep categorized order for readability
     "decode_uuid",
     "encode_display_id",
     "decode_display_id",
+    # Examples (for OpenAPI schemas, documentation)
+    "example_uuid",
+    "example_display_id",
+    "example_uuid_for_prefix",  # alias
+    "example_display_id_for_prefix",  # alias
     # Core resolver
     "resolve_object",
     # Errors

django_display_ids-0.1.4/src/django_display_ids/contrib/drf_spectacular/__init__.py

@@ -0,0 +1,93 @@
+"""drf-spectacular extension for DisplayIDField.
+
+This extension auto-registers when drf-spectacular is installed, providing
+proper OpenAPI schema generation for DisplayIDField.
+"""
+
+from __future__ import annotations
+
+try:
+    from drf_spectacular.extensions import OpenApiSerializerFieldExtension
+except ImportError:
+    # drf-spectacular not installed, skip extension registration
+    pass
+else:
+    from django_display_ids.encoding import ENCODED_UUID_LENGTH, encode_uuid
+    from django_display_ids.examples import example_uuid_for_prefix
+
+    class DisplayIDFieldExtension(OpenApiSerializerFieldExtension):
+        """OpenAPI schema extension for DisplayIDField.
+
+        Generates schema with correct prefix example based on the field's
+        configuration or the model's display_id_prefix.
+        """
+
+        target_class = (
+            "django_display_ids.contrib.rest_framework.serializers.DisplayIDField"
+        )
+        match_subclasses = True
+
+        def _get_model_from_view(self, auto_schema):
+            """Try to get model from the view's queryset."""
+            if auto_schema is None:
+                return None
+            view = getattr(auto_schema, "view", None)
+            if view is None:
+                return None
+            # Try get_queryset first
+            if hasattr(view, "get_queryset"):
+                try:
+                    queryset = view.get_queryset()
+                    if hasattr(queryset, "model"):
+                        return queryset.model
+                except Exception:
+                    pass
+            # Try queryset attribute
+            queryset = getattr(view, "queryset", None)
+            if queryset is not None and hasattr(queryset, "model"):
+                return queryset.model
+            return None
+
+        def map_serializer_field(self, auto_schema, direction):
+            """Generate OpenAPI schema for DisplayIDField."""
+            # Get prefix from field override or try to get from model
+            prefix = self.target._prefix_override
+
+            if prefix is None:
+                parent = self.target.parent
+                if parent is not None:
+                    # Try serializer's display_id_prefix attribute first
+                    prefix = getattr(parent, "display_id_prefix", None)
+
+                    # Then try Meta.model.display_id_prefix
+                    if prefix is None:
+                        meta = getattr(parent, "Meta", None)
+                        model = getattr(meta, "model", None) if meta else None
+                        if model is not None:
+                            prefix = getattr(model, "display_id_prefix", None)
+
+            # Try to get prefix from view's queryset model
+            if prefix is None:
+                model = self._get_model_from_view(auto_schema)
+                if model is not None:
+                    prefix = getattr(model, "display_id_prefix", None)
+
+            # Build schema
+            if prefix:
+                example_uuid = example_uuid_for_prefix(prefix)
+                example_encoded = encode_uuid(example_uuid)
+                example = f"{prefix}_{example_encoded}"
+                description = f"Human-readable identifier with '{prefix}_' prefix"
+            else:
+                example_uuid = example_uuid_for_prefix("type")
+                example_encoded = encode_uuid(example_uuid)
+                example = f"type_{example_encoded}"
+                description = "Human-readable identifier with type prefix"
+
+            return {
+                "type": "string",
+                "description": description,
+                "example": example,
+                "pattern": f"^[a-z]{{1,16}}_[0-9A-Za-z]{{{ENCODED_UUID_LENGTH}}}$",
+                "readOnly": True,
+            }

django_display_ids-0.1.4/src/django_display_ids/contrib/rest_framework/__init__.py

@@ -0,0 +1,48 @@
+"""Django REST Framework integration for django-display-ids."""
+
+import contextlib
+
+from .serializers import DisplayIDField
+from .views import DisplayIDLookupMixin
+
+# Register drf-spectacular extension if available
+# The extension auto-registers when the module is imported
+with contextlib.suppress(ImportError):
+    from django_display_ids.contrib import (
+        drf_spectacular as _drf_spectacular,  # noqa: F401
+    )
+
+# OpenAPI parameter descriptions for consistent documentation
+ID_PARAM_DESCRIPTION = "Identifier: display_id (prefix_xxx) or UUID"
+ID_PARAM_DESCRIPTION_WITH_SLUG = "Identifier: display_id (prefix_xxx), UUID, or slug"
+
+
+def id_param_description(prefix: str, *, with_slug: bool = False) -> str:
+    """Generate ID parameter description with the actual prefix.
+
+    Args:
+        prefix: The display_id prefix (e.g., "user", "app").
+        with_slug: Include slug as an identifier option.
+
+    Returns:
+        Description string for OpenAPI parameter.
+
+    Example:
+        >>> id_param_description("user")
+        'Identifier: display_id (user_xxx) or UUID'
+
+        >>> id_param_description("app", with_slug=True)
+        'Identifier: display_id (app_xxx), UUID, or slug'
+    """
+    if with_slug:
+        return f"Identifier: display_id ({prefix}_xxx), UUID, or slug"
+    return f"Identifier: display_id ({prefix}_xxx) or UUID"
+
+
+__all__ = [  # noqa: RUF022 - keep logical order for readability
+    "DisplayIDField",
+    "DisplayIDLookupMixin",
+    "ID_PARAM_DESCRIPTION",
+    "ID_PARAM_DESCRIPTION_WITH_SLUG",
+    "id_param_description",
+]

django_display_ids-0.1.4/src/django_display_ids/contrib/rest_framework/serializers.py

@@ -0,0 +1,116 @@
+"""Django REST Framework serializer fields for display IDs."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from rest_framework import serializers
+
+from django_display_ids.conf import get_setting
+from django_display_ids.encoding import PREFIX_PATTERN, encode_display_id
+
+if TYPE_CHECKING:
+    from django.db import models
+
+__all__ = [
+    "DisplayIDField",
+]
+
+
+class DisplayIDField(serializers.SerializerMethodField):
+    """Serializer field that returns the display_id from a model.
+
+    Automatically generates OpenAPI schema with the correct prefix example
+    when drf-spectacular is installed.
+
+    The field reads `display_id_prefix` from the model to determine the prefix.
+    If the model has no prefix, the field returns None and can be excluded
+    from serialization.
+
+    Example:
+        class UserSerializer(serializers.Serializer):
+            id = serializers.UUIDField(source="uid", read_only=True)
+            display_id = DisplayIDField()
+
+        # Output: {"id": "...", "display_id": "user_2nBm7K8xYq1pLwZj"}
+
+    Example with custom prefix (overrides model's prefix):
+        class UserSerializer(serializers.Serializer):
+            display_id = DisplayIDField(prefix="usr")
+
+    Attributes:
+        prefix: Optional prefix override. If not set, uses model's
+            display_id_prefix attribute.
+    """
+
+    def __init__(self, prefix: str | None = None, **kwargs: Any) -> None:
+        """Initialize the field.
+
+        Args:
+            prefix: Optional prefix override. If not set, uses model's
+                display_id_prefix attribute.
+            **kwargs: Additional arguments passed to SerializerMethodField.
+
+        Raises:
+            ValueError: If prefix is invalid (must be 1-16 lowercase letters).
+        """
+        if prefix is not None and not PREFIX_PATTERN.match(prefix):
+            raise ValueError(f"prefix must be 1-16 lowercase letters, got: {prefix!r}")
+        self._prefix_override = prefix
+        kwargs["read_only"] = True
+        super().__init__(**kwargs)
+
+    def get_prefix(self, obj: models.Model) -> str | None:
+        """Get the prefix for the display ID.
+
+        Args:
+            obj: The model instance.
+
+        Returns:
+            The prefix string or None if not available.
+        """
+        if self._prefix_override is not None:
+            return self._prefix_override
+        return getattr(obj, "display_id_prefix", None)
+
+    def to_representation(self, obj: models.Model) -> str:
+        """Return the display_id from the model.
+
+        Args:
+            obj: The model instance.
+
+        Returns:
+            The display_id string.
+
+        Raises:
+            ValueError: If no prefix is available (neither on field nor model).
+        """
+        prefix = self.get_prefix(obj)
+        if prefix is None:
+            raise ValueError(
+                f"DisplayIDField requires a prefix. Either set prefix= on the "
+                f"field or add display_id_prefix to {obj.__class__.__name__}."
+            )
+
+        # If using prefix override, generate display_id with that prefix
+        if self._prefix_override is not None:
+            # Get uuid_field name from model, then fall back to settings
+            uuid_field_name = getattr(obj, "uuid_field", None)
+            if uuid_field_name is None:
+                uuid_field_name = get_setting("UUID_FIELD")
+            uuid_value = getattr(obj, uuid_field_name, None)
+            if uuid_value is None:
+                raise ValueError(
+                    f"Cannot generate display_id: {obj.__class__.__name__} "
+                    f"has no '{uuid_field_name}' field."
+                )
+            return encode_display_id(prefix, uuid_value)
+
+        # Use the model's display_id property
+        if hasattr(obj, "display_id"):
+            return obj.display_id
+
+        raise ValueError(
+            f"Cannot generate display_id: {obj.__class__.__name__} "
+            f"has no display_id property."
+        )

django_display_ids-0.1.4/src/django_display_ids/examples.py

@@ -0,0 +1,88 @@
+"""Deterministic example generation for display IDs.
+
+These functions generate consistent example UUIDs and display IDs based on
+a prefix or model, useful for OpenAPI schema examples and documentation.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import uuid
+from typing import TYPE_CHECKING
+
+from .encoding import encode_uuid
+
+if TYPE_CHECKING:
+    from django.db.models import Model
+
+__all__ = [
+    "example_display_id",
+    "example_uuid",
+]
+
+
+def _get_prefix(prefix_or_model: str | type[Model]) -> str:
+    """Extract prefix from string or model class."""
+    if isinstance(prefix_or_model, str):
+        return prefix_or_model
+    # It's a model class
+    prefix = getattr(prefix_or_model, "display_id_prefix", None)
+    if prefix is None:
+        raise ValueError(f"Model {prefix_or_model.__name__} has no display_id_prefix")
+    return prefix
+
+
+def example_uuid(prefix_or_model: str | type[Model]) -> uuid.UUID:
+    """Generate a deterministic UUID from a prefix or model.
+
+    Uses SHA-256 hash of the prefix to generate a consistent UUID.
+    This ensures the same prefix always produces the same example UUID.
+
+    Args:
+        prefix_or_model: Either a display ID prefix string (e.g., "app")
+            or a model class with a display_id_prefix attribute.
+
+    Returns:
+        A deterministic UUID based on the prefix.
+
+    Example:
+        >>> example_uuid("app")
+        UUID('a172cedc-ae47-474b-615c-54d510a5d84a')
+
+        >>> example_uuid(App)  # Model with display_id_prefix = "app"
+        UUID('a172cedc-ae47-474b-615c-54d510a5d84a')
+    """
+    prefix = _get_prefix(prefix_or_model)
+    hash_bytes = hashlib.sha256(prefix.encode()).digest()[:16]
+    return uuid.UUID(bytes=hash_bytes)
+
+
+def example_display_id(prefix_or_model: str | type[Model]) -> str:
+    """Generate a deterministic display ID example from a prefix or model.
+
+    Combines the prefix with a base62-encoded UUID derived from
+    the prefix itself.
+
+    Args:
+        prefix_or_model: Either a display ID prefix string (e.g., "app")
+            or a model class with a display_id_prefix attribute.
+
+    Returns:
+        A complete display ID example (e.g., "app_4ueEO5Nz4X7u9qc3FVHokM").
+
+    Example:
+        >>> example_display_id("app")
+        'app_4ueEO5Nz4X7u9qc3FVHokM'
+
+        >>> example_display_id(App)  # Model with display_id_prefix = "app"
+        'app_4ueEO5Nz4X7u9qc3FVHokM'
+    """
+    prefix = _get_prefix(prefix_or_model)
+    ex_uuid = example_uuid(prefix)
+    encoded = encode_uuid(ex_uuid)
+    return f"{prefix}_{encoded}"
+
+
+# Aliases for backwards compatibility
+example_uuid_for_prefix = example_uuid
+example_display_id_for_prefix = example_display_id

django_display_ids-0.1.3/src/django_display_ids/contrib/rest_framework/__init__.py

@@ -1,7 +0,0 @@
-"""Django REST Framework integration for django-display-ids."""
-
-from .views import DisplayIDLookupMixin
-
-__all__ = [
-    "DisplayIDLookupMixin",
-]