Add instance to context and extend python format language (#2)

Author: codingjoe

README.rst

@@ -26,28 +26,22 @@ Basic example:
     from django.db import models
     from dynamic_names import FilePattern
 
-    upload_to_pattern = FilePattern('{app_name:.25}/{model_name:.30}/{uuid_base32}{ext}')
+    upload_to_pattern = FilePattern(
+        filename_pattern='{app_name:.25}/{model_name:.30}/{uuid:base32}{ext}'
+    )
 
     class FileModel(models.Model):
         my_file = models.FileField(upload_to=upload_to_pattern)
 
 
 Auto slug example:
 
-.. code-block:: python
-
-    from django.db import models
-    from dynamic_names import FilePattern
 
-    class SlugPattern(FilePattern):
-        filename_pattern = '{app_name:.25}/{model_name:.30}/{slug}{ext}'
-
-    class FileModel(models.Model):
-        title = models.CharField(max_length=100)
-        my_file = models.FileField(upload_to=SlugPattern(populate_slug_from='title'))
+Features
+--------
 
-Supported Attributes
---------------------
+Field names
+~~~~~~~~~~~
 
 ``ext``
     File extension including the dot.
@@ -61,19 +55,58 @@ Supported Attributes
 ``app_label``
     App label of the Django model.
 
-``uuid_base16``
-    Base16 (hex) representation of a UUID.
+``instance``
+    Instance of the model before it has been saved. You may not have a primary
+    key at this point.
+
+``uuid``
+    UUID version 4 that supports multiple type specifiers. The UUID will be
+    the same should you use it twice in the same string, but different on each
+    invocation of the ``upload_to`` callable.
+
+    The type specifiers allow you to format the UUID in different ways, e.g.
+    ``{uuid:x}`` will give you a with a hexadecimal UUID.
+
+    The supported type specifiers are:
+
+    ``s``
+        String representation of a UUID including dashes.
+
+    ``i``
+        Integer representation of a UUID. Like to ``UUID.int``.
+
+    ``x``
+        Hexadecimal (Base16) representation of a UUID. Like to ``UUID.hex``.
 
-``uuid_base32``
-    Base32 representation of a UUID.
+    ``X``
+        Upper case hexadecimal representation of a UUID. Like to
+        ``UUID.hex``.
 
-``uuid_base64``
-    Base64 representation of a UUID. Not supported by all file systems.
+    ``base32``
+        Base32 representation of a UUID without padding.
 
-``slug``
-    Auto created slug based on another field on the model instance.
+    ``base64``
+        Base64 representation of a UUID without padding.
 
-``slug_from``
-    Name of the field the slug should be populated from.
+        .. warning:: Not all file systems support Base64 file names.
+
+Type specifiers
+~~~~~~~~~~~~~~~
+
+You can also use a special slug type specifier, that slugifies strings.
+
+Example:
+
+.. code-block:: python
+
+    from django.db import models
+    from dynamic_names import FilePattern
+
+    upload_to_pattern = FilePattern(
+        filename_pattern='{app_name:.25}/{model_name:.30}/{instance.title:slug}{ext}'
+    )
+
+    class FileModel(models.Model):
+        title = models.CharField(max_length=100)
+        my_file = models.FileField(upload_to=upload_to_pattern)
 
-    .. note:: The field name itself is not part of the pattern.

dynamic_filenames.py

@@ -1,15 +1,44 @@
 import base64
 import os
 import uuid
+from string import Formatter
 
 try:  # use unicode-slugify library if installed
     from slugify import slugify
-
-    SLUGIFY_KWARGS = dict(only_ascii=True)
 except ImportError:
     from django.utils.text import slugify
 
-    SLUGIFY_KWARGS = dict(allow_unicode=False)
+
+class SlugFormatter(Formatter):
+
+    def format_field(self, value, format_spec):
+        if format_spec == 'slug':
+            return slugify(value)
+        return super().format_field(value=value, format_spec=format_spec)
+
+
+class ExtendedUUID(uuid.UUID):
+
+    def __format__(self, format_spec):
+        if format_spec == '':
+            return str(self)
+        if format_spec == 's':
+            return str(self)
+        if format_spec == 'i':
+            return str(self.int)
+        if format_spec == 'x':
+            return self.hex.lower()
+        if format_spec == 'X':
+            return self.hex.upper()
+        if format_spec == 'base32':
+            return base64.b32encode(
+                self.bytes
+            ).decode('utf-8').rstrip('=\n')
+        if format_spec == 'base64':
+            return base64.urlsafe_b64encode(
+                self.bytes
+            ).decode('utf-8').rstrip('=\n')
+        return super().__format__(format_spec)
 
 
 class FilePattern:
@@ -23,7 +52,7 @@ class FilePattern:
         from django.db import models
         from dynamic_names import FilePattern
 
-        upload_to_pattern = FilePattern('{app_name:.25}/{model_name:.30}/{uuid_base32}{ext}')
+        upload_to_pattern = FilePattern('{app_name:.25}/{model_name:.30}/{uuid:base32}{ext}')
 
         class FileModel(models.Model):
             my_file = models.FileField(upload_to=upload_to_pattern)
@@ -34,11 +63,13 @@ class FileModel(models.Model):
         name: Filename excluding the folders.
         model_name: Name of the Django model.
         app_label: App label of the Django model.
-        uuid_base16: Base16 (hex) representation of a UUID.
-        uuid_base32: Base32 representation of a UUID.
-        uuid_base64: Base64 representation of a UUID. Not supported by all file systems.
-        slug: Auto created slug based on another field on the model instance.
-        slug_from: Name of the field the slug should be populated from.
+        uuid:
+            UUID version 4 that supports multiple type specifiers. The UUID will be
+            the same should you use it twice in the same string, but different on each
+            invocation of the ``upload_to`` callable.
+        instance:
+            Instance of the model before it has been saved.
+            You may not have a primary key at this point.
 
 
     Auto slug example:
@@ -48,45 +79,38 @@ class FileModel(models.Model):
         from django.db import models
         from dynamic_names import FilePattern
 
-        class SlugPattern(FilePattern):
-            filename_pattern = '{app_name:.25}/{model_name:.30}/{slug}{ext}'
+        class TitleSlugPattern(FilePattern):
+            filename_pattern = '{app_name:.25}/{model_name:.30}/{instance.title:slug}{ext}'
 
         class FileModel(models.Model):
             title = models.CharField(max_length=100)
-            my_file = models.FileField(upload_to=SlugPattern(slug_from='title'))
+            my_file = models.FileField(upload_to=TitleSlugPattern())
 
     """
 
-    slug_from = None
+    formatter = SlugFormatter()
 
     filename_pattern = '{name}{ext}'
 
     def __call__(self, instance, filename):
         """Return filename based for given instance and filename."""
         # UUID needs to be set on call, not per instance to avoid state leakage.
-        guid = self.get_uuid()
         path, ext = os.path.splitext(filename)
         path, name = os.path.split(path)
         defaults = {
             'ext': ext,
             'name': name,
             'model_name': instance._meta.model_name,
             'app_label': instance._meta.app_label,
-            'uuid_base10': self.uuid_2_base10(guid),
-            'uuid_base16': self.uuid_2_base16(guid),
-            'uuid_base32': self.uuid_2_base32(guid),
-            'uuid_base64': self.uuid_2_base64(guid),
+            'uuid': self.get_uuid(),
+            'instance': instance,
         }
         defaults.update(self.override_values)
-        if self.slug_from is not None:
-            field_value = getattr(instance, self.slug_from)
-            defaults['slug'] = slugify(field_value, **SLUGIFY_KWARGS)
-        return self.filename_pattern.format(**defaults)
+        return self.formatter.format(self.filename_pattern, **defaults)
 
     def __init__(self, **kwargs):
         self.kwargs = kwargs
         override_values = kwargs.copy()
-        self.slug_from = override_values.pop('slug_from', self.slug_from)
         self.filename_pattern = override_values.pop('filename_pattern', self.filename_pattern)
         self.override_values = override_values
 
@@ -98,34 +122,4 @@ def deconstruct(self):
     @staticmethod
     def get_uuid():
         """Return UUID version 4."""
-        return uuid.uuid4()
-
-    @staticmethod
-    def uuid_2_base10(uuid):
-        """Return 39 digits long integer UUID as Base10."""
-        return uuid.int
-
-    @staticmethod
-    def uuid_2_base16(uuid):
-        """Return 32 char long UUID as Base16 (hex)."""
-        return uuid.hex
-
-    @staticmethod
-    def uuid_2_base32(uuid):
-        """Return 27 char long UUIDv4 as Base32."""
-        return base64.b32encode(
-            uuid.bytes
-        ).decode('utf-8').rstrip('=\n')
-
-    @staticmethod
-    def uuid_2_base64(uuid):
-        """
-        Return 23 char long UUIDv4 as Base64.
-
-        .. warning:: Not all file systems support Base64 file names.
-            e.g. The Apple File System (APFS) is case insensitive by default.
-
-        """
-        return base64.urlsafe_b64encode(
-            uuid.bytes
-        ).decode('utf-8').rstrip('=\n')
+        return ExtendedUUID(bytes=os.urandom(16), version=4)