apply ruff format

Author: paigewilliams

admin_async_upload/fields.py

@@ -11,7 +11,7 @@ class FormResumableFileField(fields.FileField):
     def to_python(self, data):
         if self.required:
             if not data or data == "None":
-                raise ValidationError(self.error_messages['empty'])
+                raise ValidationError(self.error_messages["empty"])
         return data
 
 
@@ -20,17 +20,18 @@ class FormResumableMultipleFileField(fields.Field):
     Form field that handles multiple file uploads via resumable.js.
     Stores file paths as a JSON array and returns a list of file paths.
     """
+
     widget = ResumableAdminWidget
 
     def to_python(self, data):
         """Convert JSON string to Python list of file paths."""
-        if not data or data in ['None', 'False', None]:
+        if not data or data in ["None", "False", None]:
             return []
-        
+
         # If already a list, return it
         if isinstance(data, list):
             return data
-        
+
         # Try to parse as JSON
         try:
             parsed = json.loads(data)
@@ -49,19 +50,19 @@ def clean(self, value):
         """
         # Convert to Python type (list of file paths)
         value = self.to_python(value)
-        
+
         # Run validation
         self.validate(value)
-        
+
         # Run any custom validators
         self.run_validators(value)
-        
+
         return value
 
     def prepare_value(self, value):
         """Convert Python list to JSON string for rendering."""
         if value is None:
-            return ''
+            return ""
         if isinstance(value, str):
             return value
         if isinstance(value, list):
@@ -71,5 +72,4 @@ def prepare_value(self, value):
     def validate(self, value):
         """Validate that all file paths in the list are valid."""
         if self.required and not value:
-            raise ValidationError(self.error_messages['required'])
-
+            raise ValidationError(self.error_messages["required"])

admin_async_upload/files.py

@@ -25,7 +25,7 @@ def __init__(self, field, user, params):
         self.user = user
         self.params = params
         self.chunk_suffix = "_part_"
-        self.chunk_folder = getattr(settings, 'ADMIN_RESUMABLE_CHUNK_FOLDER', '')
+        self.chunk_folder = getattr(settings, "ADMIN_RESUMABLE_CHUNK_FOLDER", "")
 
     @cached_property
     def resumable_storage(self):
@@ -46,7 +46,9 @@ def storage_filename(self):
             instance = self.field.model.objects.filter(pk=instance_id).first()
         else:
             instance = None
-        return self.resumable_storage.full_filename(self.filename, self.upload_to, instance=instance)
+        return self.resumable_storage.full_filename(
+            self.filename, self.upload_to, instance=instance
+        )
 
     @property
     def upload_to(self):
@@ -57,8 +59,11 @@ def chunk_exists(self):
         """
         Checks if the requested chunk exists.
         """
-        return self.chunk_storage.exists(self.current_chunk_name) and \
-               self.chunk_storage.size(self.current_chunk_name) == int(self.params.get('resumableCurrentChunkSize'))
+        return self.chunk_storage.exists(
+            self.current_chunk_name
+        ) and self.chunk_storage.size(self.current_chunk_name) == int(
+            self.params.get("resumableCurrentChunkSize")
+        )
 
     @property
     def chunk_names(self):
@@ -72,10 +77,9 @@ def chunk_names(self):
             # chunks folder doesn't exist yet
             return chunks
         for file in files:
-            if fnmatch.fnmatch(file, '%s%s*' % (self.filename,
-                                                self.chunk_suffix)):
+            if fnmatch.fnmatch(file, "%s%s*" % (self.filename, self.chunk_suffix)):
                 if self.chunk_folder:
-                    chunks.append(self.chunk_folder + '/' + file)
+                    chunks.append(self.chunk_folder + "/" + file)
                 else:
                     chunks.append(file)
         return chunks
@@ -86,7 +90,7 @@ def current_chunk_name(self):
         chunk_name = "%s%s%s" % (
             self.filename,
             self.chunk_suffix,
-            self.params.get('resumableChunkNumber').zfill(4)
+            self.params.get("resumableChunkNumber").zfill(4),
         )
         if self.chunk_folder:
             return "%s/%s" % (self.chunk_folder, chunk_name)
@@ -97,11 +101,10 @@ def chunks(self):
         Iterates over all stored chunks.
         """
         # TODO: add user identifier to chunk name
-        files = sorted(self.chunk_storage.listdir('')[1])
+        files = sorted(self.chunk_storage.listdir("")[1])
         for file in files:
-            if fnmatch.fnmatch(file, '%s%s*' % (self.filename,
-                                                self.chunk_suffix)):
-                yield self.chunk_storage.open(file, 'rb').read()
+            if fnmatch.fnmatch(file, "%s%s*" % (self.filename, self.chunk_suffix)):
+                yield self.chunk_storage.open(file, "rb").read()
 
     def delete_chunks(self):
         [self.chunk_storage.delete(chunk) for chunk in self.chunk_names]
@@ -112,7 +115,7 @@ def file(self):
         Merges file and returns its file pointer.
         """
         if not self.is_complete:
-            raise Exception('Chunk(s) still missing')
+            raise Exception("Chunk(s) still missing")
         outfile = tempfile.NamedTemporaryFile("w+b")
         for chunk in self.chunk_names:
             outfile.write(self.chunk_storage.open(chunk).read())
@@ -124,18 +127,18 @@ def filename(self):
         Gets the filename.
         """
         # TODO: add user identifier to chunk name
-        filename = self.params.get('resumableFilename')
-        if '/' in filename:
-            raise Exception('Invalid filename')
-        value = "%s_%s" % (self.params.get('resumableTotalSize'), filename)
+        filename = self.params.get("resumableFilename")
+        if "/" in filename:
+            raise Exception("Invalid filename")
+        value = "%s_%s" % (self.params.get("resumableTotalSize"), filename)
         return value
 
     @property
     def is_complete(self):
         """
         Checks if all chunks are already stored.
         """
-        return int(self.params.get('resumableTotalSize')) == self.size
+        return int(self.params.get("resumableTotalSize")) == self.size
 
     def process_chunk(self, file):
         """
@@ -160,6 +163,8 @@ def collect(self):
         Saves the complete file to persistent storage and deletes chunks.
         Returns the actual filename in persistent storage.
         """
-        actual_filename = self.persistent_storage.save(self.storage_filename, File(self.file))
+        actual_filename = self.persistent_storage.save(
+            self.storage_filename, File(self.file)
+        )
         self.delete_chunks()
         return actual_filename

admin_async_upload/models.py

@@ -4,22 +4,25 @@
 
 
 class AsyncFileField(models.FileField):
-
     def __init__(self, *args, **kwargs):
-        self.max_files = kwargs.pop('max_files', None)
+        self.max_files = kwargs.pop("max_files", None)
         super(AsyncFileField, self).__init__(*args, **kwargs)
-    
+
     def deconstruct(self):
         name, path, args, kwargs = super(AsyncFileField, self).deconstruct()
         if self.max_files is not None:
-            kwargs['max_files'] = self.max_files
+            kwargs["max_files"] = self.max_files
         return name, path, args, kwargs
 
     def formfield(self, **kwargs):
-        defaults = {'form_class': FormResumableFileField}
+        defaults = {"form_class": FormResumableFileField}
         if self.model and self.name:
-            defaults['widget'] = ResumableAdminWidget(attrs={
-                'model': self.model,
-                'field_name': self.name, 'max_files': getattr(self, 'max_files', None)})
+            defaults["widget"] = ResumableAdminWidget(
+                attrs={
+                    "model": self.model,
+                    "field_name": self.name,
+                    "max_files": getattr(self, "max_files", None),
+                }
+            )
         kwargs.update(defaults)
         return super(AsyncFileField, self).formfield(**kwargs)

admin_async_upload/storage.py

@@ -1,6 +1,7 @@
 import datetime
 
 import posixpath
+
 try:
     from django.core.files.storage import storages, InvalidStorageError
 except ImportError:
@@ -13,11 +14,14 @@
 
 
 class ResumableStorage(object):
-
     def __init__(self):
         # For backward compatibility, still check old settings
-        self.persistent_storage_name = getattr(settings, 'ADMIN_RESUMABLE_STORAGE', None)
-        self.chunk_storage_name = getattr(settings, 'ADMIN_RESUMABLE_CHUNK_STORAGE', None)
+        self.persistent_storage_name = getattr(
+            settings, "ADMIN_RESUMABLE_STORAGE", None
+        )
+        self.chunk_storage_name = getattr(
+            settings, "ADMIN_RESUMABLE_CHUNK_STORAGE", None
+        )
 
     def get_chunk_storage(self, *args, **kwargs):
         """
@@ -35,24 +39,29 @@ def get_chunk_storage(self, *args, **kwargs):
                 except (KeyError, InvalidStorageError):
                     # Not a STORAGES key, treat as class path
                     from django.core.files.storage import get_storage_class
+
                     storage_class = get_storage_class(self.chunk_storage_name)
                     return storage_class(*args, **kwargs)
             else:
                 # Older Django - use get_storage_class
                 from django.core.files.storage import get_storage_class
+
                 storage_class = get_storage_class(self.chunk_storage_name)
                 return storage_class(*args, **kwargs)
         else:
             # Default to local FileSystemStorage for performance
             # (chunks should not be written to remote storage like S3)
             if storages:
                 from django.core.files.storage import FileSystemStorage
+
                 return FileSystemStorage(*args, **kwargs)
             else:
                 from django.core.files.storage import get_storage_class
-                storage_class = get_storage_class('django.core.files.storage.FileSystemStorage')
+
+                storage_class = get_storage_class(
+                    "django.core.files.storage.FileSystemStorage"
+                )
                 return storage_class(*args, **kwargs)
-        
 
     def get_persistent_storage(self, *args, **kwargs):
         """
@@ -66,17 +75,21 @@ def get_persistent_storage(self, *args, **kwargs):
             if self.persistent_storage_name:
                 # If a specific storage backend is configured, use it
                 from django.core.files.storage import get_storage_class
+
                 storage_class = get_storage_class(self.persistent_storage_name)
                 return storage_class(*args, **kwargs)
             else:
                 # Use default storage from STORAGES setting
-                return storages['default']
+                return storages["default"]
         else:
             # Fallback for older Django versions
             from django.core.files.storage import get_storage_class
 
-            persistent_storage_class_name = self.persistent_storage_name or \
-                getattr(settings, 'DEFAULT_FILE_STORAGE', 'django.core.files.storage.FileSystemStorage')
+            persistent_storage_class_name = self.persistent_storage_name or getattr(
+                settings,
+                "DEFAULT_FILE_STORAGE",
+                "django.core.files.storage.FileSystemStorage",
+            )
             storage_class = get_storage_class(persistent_storage_class_name)
 
             return storage_class(*args, **kwargs)

admin_async_upload/urls.py

@@ -3,5 +3,5 @@
 from . import views
 
 urlpatterns = [
-    path('upload/', views.admin_resumable, name='admin_resumable'),
+    path("upload/", views.admin_resumable, name="admin_resumable"),
 ]

admin_async_upload/validators.py

@@ -12,11 +12,18 @@ class StorageFileValidator(object):
     Any validation must happen either on the client-side or requires upload to be completed
     and file saved in application storage.
     """
+
     messages = {
-        'file': _(u"File {name} does not exist."),
-        'extension': _(u"Extension {extension} not allowed. Allowed extensions are: {allowed_extensions}"),
-        'min_size': _(u"File {name} too small ({size} bytes). The minimum file size is {min_size} bytes."),
-        'max_size': _(u"File {name} too large ({size} bytes). The maximum file size is {max_size} bytes."),
+        "file": _("File {name} does not exist."),
+        "extension": _(
+            "Extension {extension} not allowed. Allowed extensions are: {allowed_extensions}"
+        ),
+        "min_size": _(
+            "File {name} too small ({size} bytes). The minimum file size is {min_size} bytes."
+        ),
+        "max_size": _(
+            "File {name} too large ({size} bytes). The maximum file size is {max_size} bytes."
+        ),
     }
 
     def __init__(self, min_size=0, max_size=None, allowed_extensions=None):
@@ -30,34 +37,42 @@ def get_storage(self):
     def validate_extension(self, value):
         ext = splitext(value)[1].lower()
         if self.allowed_extensions and ext not in self.allowed_extensions:
-            message = self.messages['extension'].format(**{
-                'extension': ext,
-                'allowed_extensions': ', '.join(self.allowed_extensions)
-            })
+            message = self.messages["extension"].format(
+                **{
+                    "extension": ext,
+                    "allowed_extensions": ", ".join(self.allowed_extensions),
+                }
+            )
             raise ValidationError(message)
 
     def validate_exists(self, value, storage):
         if not storage.exists(value):
-            message = self.messages['file'].format(**{
-                'name': value,
-            })
+            message = self.messages["file"].format(
+                **{
+                    "name": value,
+                }
+            )
             raise ValidationError(message)
 
     def validate_size(self, value, storage):
         size = storage.size(value)
         if size > self.max_size:
-            message = self.messages['max_size'].format(**{
-                'name': value,
-                'size': size,
-                'max_size': self.max_size,
-            })
+            message = self.messages["max_size"].format(
+                **{
+                    "name": value,
+                    "size": size,
+                    "max_size": self.max_size,
+                }
+            )
             raise ValidationError(message)
         elif size < self.min_size:
-            message = self.messages['min_size'].format(**{
-                'name': value,
-                'size': size,
-                'min_size': self.min_size,
-            })
+            message = self.messages["min_size"].format(
+                **{
+                    "name": value,
+                    "size": size,
+                    "min_size": self.min_size,
+                }
+            )
             raise ValidationError(message)
 
     def __call__(self, value):