tessl/pypi-django-filer

A file management application for Django that makes handling of files and images a breeze.

—

Pending

Overview

Eval results

Files

Configuration

Name: tessl/pypi-django-filer
Author: tessl

Django Filer provides comprehensive configuration options for storage backends, permissions, validation, upload handling, and admin interface customization. All settings are configured in your Django settings.py file.

Capabilities

Core Settings

Basic configuration options that control filer's core behavior and features.

# Image Model Configuration
FILER_IMAGE_MODEL = 'filer.Image'
# str: Swappable image model path (default: 'filer.Image')
# Allows using custom image models inheriting from BaseImage

# Permission System
FILER_ENABLE_PERMISSIONS = True  
# bool: Enable folder-level permissions (default: False)
# When enabled, provides granular read/edit/add_children permissions

# Default Public/Private State
FILER_IS_PUBLIC_DEFAULT = True
# bool: Default public state for new files (default: True)
# Used by is_public_default() function

# Admin Interface
FILER_PAGINATE_BY = 100
# int: Number of items per page in admin (default: 100)

FILER_ADMIN_ICON_SIZES = [
    ('16', '16x16'),
    ('32', '32x32'), 
    ('48', '48x48'),
    ('64', '64x64'),
]
# list: Available icon sizes in admin interface

FILER_TABLE_ICON_SIZE = 40
# int: Icon size for admin table view (default: 40)

FILER_THUMBNAIL_ICON_SIZE = 120
# int: Icon size for admin thumbnail view (default: 120)

FILER_FOLDER_ADMIN_DEFAULT_LIST_TYPE = 'tb'
# str: Default admin list view type ('tb' for table, 'th' for thumbnail)

# File Model Registry
FILER_FILE_MODELS = (
    'filer.models.File',
    'filer.models.Image',
)
# tuple: Ordered list of file model classes to check when adding files

# Debug and Logging
FILER_DEBUG = False
# bool: Enable debug mode for filer (default: False)

FILER_ENABLE_LOGGING = False
# bool: Enable error logging (default: False)

Storage Configuration

Configure storage backends for public and private files, including custom storage classes and media serving.

# Storage Backend Configuration
FILER_STORAGES = {
    'public': {
        'main': {
            'ENGINE': 'django.core.files.storage.FileSystemStorage',
            'OPTIONS': {
                'location': '/path/to/public/media',
                'base_url': '/media/filer_public/',
            },
        },
        'thumbnails': {
            'ENGINE': 'django.core.files.storage.FileSystemStorage', 
            'OPTIONS': {
                'location': '/path/to/public/thumbnails',
                'base_url': '/media/filer_public_thumbnails/',
            },
        },
    },
    'private': {
        'main': {
            'ENGINE': 'django.core.files.storage.FileSystemStorage',
            'OPTIONS': {
                'location': '/path/to/private/media',
                'base_url': '/smedia/filer_private/',
            },
        },
        'thumbnails': {
            'ENGINE': 'django.core.files.storage.FileSystemStorage',
            'OPTIONS': {
                'location': '/path/to/private/thumbnails', 
                'base_url': '/smedia/filer_private_thumbnails/',
            },
        },
    },
}
# dict: Complete storage configuration for public/private files and thumbnails

# Legacy Storage Settings (still supported)
FILER_PUBLICMEDIA_STORAGE = 'django.core.files.storage.FileSystemStorage'
FILER_PUBLICMEDIA_ROOT = '/path/to/public/media'
FILER_PUBLICMEDIA_URL = '/media/filer_public/'

FILER_PRIVATEMEDIA_STORAGE = 'django.core.files.storage.FileSystemStorage'
FILER_PRIVATEMEDIA_ROOT = '/path/to/private/media'
FILER_PRIVATEMEDIA_URL = '/smedia/filer_private/'

# Server Configuration for Private Files
FILER_SERVERS = {
    'private': {
        'main': {
            'ENGINE': 'filer.server.backends.default.DefaultServer',
            'OPTIONS': {},
        },
        'thumbnails': {
            'ENGINE': 'filer.server.backends.default.DefaultServer',
            'OPTIONS': {},
        },
    },
}
# dict: Server backends for serving private files

# Available server backends:
# - 'filer.server.backends.default.DefaultServer' - Django default
# - 'filer.server.backends.nginx.NginxXAccelRedirectServer' - Nginx X-Accel
# - 'filer.server.backends.xsendfile.ApacheXSendfileServer' - Apache X-Sendfile

Server Backend Classes

Available server backend implementations for efficient private file serving.

# Base Server Backend
class ServerBase:
    """
    Abstract base class for server backends.
    
    Provides interface for serving private files through
    various web server mechanisms.
    """
    
    def serve(self, request, file_obj, **kwargs):
        """
        Serve a private file through the backend.
        
        Args:
            request: Django HTTP request
            file_obj: File object to serve
            **kwargs: Additional backend-specific options
            
        Returns:
            HttpResponse: Response for serving the file
        """

# Default Django Server
class DefaultServer(ServerBase):
    """
    Default server backend using Django's static file serving.
    
    Suitable for development but not recommended for production
    as it serves files through Django process.
    """

# Nginx X-Accel-Redirect Server  
class NginxXAccelRedirectServer(ServerBase):
    """
    Nginx X-Accel-Redirect server backend for efficient file serving.
    
    Uses Nginx's internal redirect mechanism to serve files
    without passing through Django process.
    
    Configuration Options:
    - location: File system path prefix
    - nginx_location: Nginx internal location prefix
    """

# Apache X-Sendfile Server
class ApacheXSendfileServer(ServerBase):
    """
    Apache X-Sendfile server backend for efficient file serving.
    
    Uses Apache's X-Sendfile module to serve files efficiently
    without loading them into memory.
    
    Configuration Options:
    - sendfile_root: Root directory for sendfile
    """

Upload and File Handling

Settings that control file uploads, processing, and validation.

# Upload Limits
FILER_UPLOADER_CONNECTIONS = 3
# int: Maximum simultaneous upload connections (default: 3, 1 for SQLite)

FILER_UPLOADER_MAX_FILES = 100
# int: Maximum number of files per upload session (default: 100)

FILER_UPLOADER_MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
# int: Maximum individual file size in bytes (default: 10MB)

FILER_MAX_IMAGE_PIXELS = None
# int or None: Maximum image pixel count for security (default: None)

FILER_MAX_SVG_THUMBNAIL_SIZE = 1024 * 1024  # 1MB
# int: Maximum SVG file size for thumbnail generation (default: 1MB)

# Filename Generation
FILER_FILENAME_GENERATORS = [
    'filer.utils.generate_filename.randomized',
]
# list: Functions for generating upload filenames

# Canonical URL Settings
FILER_CANONICAL_URL = 'canonical/'
# str: URL pattern for canonical file URLs (default: 'canonical/')

File Validation

Configure MIME type validation, file type restrictions, and custom validators.

# MIME Type Validation
FILER_MIME_TYPE_WHITELIST = None
# list or None: Allowed MIME types (None = allow all)
# Example: ['image/jpeg', 'image/png', 'application/pdf']

# File Validators
FILE_VALIDATORS = [
    'filer.validation.validate_upload',
]
# list: List of file validation functions

# Image MIME Types
IMAGE_MIME_TYPES = [
    'image/jpeg',
    'image/jpg', 
    'image/png',
    'image/gif',
    'image/bmp',
    'image/tiff',
    'image/webp',
    'image/svg+xml',
]
# list: Recognized image MIME types

# Validation Functions
def validate_upload(file_obj):
    """
    Custom file validation function.
    
    Args:
        file_obj: File object to validate
        
    Raises:
        ValidationError: If file is invalid
    """

# SVG Validation (security)
FILER_VALIDATE_SVG = True
# bool: Enable SVG security validation (default: True)

Admin Interface Customization

Customize the Django admin interface appearance and behavior.

# Icon Library
ICON_CSS_LIB = (
    'filer/css/admin_filer.css',
)
# tuple: CSS files for admin icons

# Admin Templates
FILER_ADMIN_TEMPLATES = {
    'file_picker': 'admin/filer/widgets/admin_file.html',
    'folder_picker': 'admin/filer/widgets/admin_folder.html',
}
# dict: Custom admin widget templates

# JavaScript and CSS
FILER_STATIC_MEDIA_PREFIX = '/static/filer/'
# str: Prefix for filer static media URLs

Integration Settings

Settings for integrating with other Django packages and systems.

# Django CMS Integration
INSTALLED_APPS = [
    # ...
    'filer',
    'easy_thumbnails',
    'filer.contrib.django_cms',  # Optional CMS integration
]

# Easy Thumbnails Configuration
THUMBNAIL_ALIASES = {
    '': {
        'admin_clipboard_icon': {'size': (32, 32), 'crop': True},
        'admin_directory_listing_icon': {'size': (48, 48), 'crop': True},
        'admin_tiny_icon': {'size': (16, 16), 'crop': True},
    },
}

# Thumbnail Processors
THUMBNAIL_PROCESSORS = [
    'easy_thumbnails.processors.colorspace',
    'easy_thumbnails.processors.autocrop',
    'filer.thumbnail_processors.scale_and_crop_with_subject_location',
    'easy_thumbnails.processors.filters',
]
# list: Thumbnail processing pipeline

# ClamAV Antivirus Integration (optional)
FILER_CLAMAV_ENABLED = False
# bool: Enable ClamAV virus scanning (requires filer.contrib.clamav)

FILER_CLAMAV_SOCKET_PATH = '/var/run/clamav/clamd.ctl'
# str: Path to ClamAV socket

Usage Examples

Basic Configuration

# settings.py
import os

# Basic filer setup
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes', 
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    
    # Required for filer
    'filer',
    'easy_thumbnails',
]

# Media files configuration
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

# Enable permissions
FILER_ENABLE_PERMISSIONS = True

# Default to public files
FILER_IS_PUBLIC_DEFAULT = True

# Upload limits
FILER_UPLOADER_MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB

Production Storage Configuration

# settings.py for production
import os

# Separate public and private media
FILER_STORAGES = {
    'public': {
        'main': {
            'ENGINE': 'django.core.files.storage.FileSystemStorage',
            'OPTIONS': {
                'location': os.path.join(BASE_DIR, 'media', 'filer_public'),
                'base_url': '/media/filer_public/',
            },
        },
        'thumbnails': {
            'ENGINE': 'django.core.files.storage.FileSystemStorage',
            'OPTIONS': {
                'location': os.path.join(BASE_DIR, 'media', 'filer_public_thumbnails'),
                'base_url': '/media/filer_public_thumbnails/',
            }, 
        },
    },
    'private': {
        'main': {
            'ENGINE': 'django.core.files.storage.FileSystemStorage',
            'OPTIONS': {
                'location': os.path.join(BASE_DIR, 'protected'),
                'base_url': '/protected/filer_private/',
            },
        },
        'thumbnails': {
            'ENGINE': 'django.core.files.storage.FileSystemStorage',
            'OPTIONS': {
                'location': os.path.join(BASE_DIR, 'protected', 'thumbnails'),
                'base_url': '/protected/filer_private_thumbnails/',
            },
        },
    },
}

# Use nginx for serving private files
FILER_SERVERS = {
    'private': {
        'main': {
            'ENGINE': 'filer.server.backends.nginx.NginxXAccelRedirectServer',
            'OPTIONS': {
                'location': '/protected/',
                'nginx_location': '/internal-protected/',
            },
        },
        'thumbnails': {
            'ENGINE': 'filer.server.backends.nginx.NginxXAccelRedirectServer', 
            'OPTIONS': {
                'location': '/protected/thumbnails/',
                'nginx_location': '/internal-protected/thumbnails/',
            },
        },
    },
}

Custom Image Model Configuration

# models.py
from filer.models.abstract import BaseImage

class CustomImage(BaseImage):
    credit = models.CharField(max_length=255, blank=True)
    keywords = models.TextField(blank=True)
    
    class Meta:
        app_label = 'myapp'

# settings.py  
FILER_IMAGE_MODEL = 'myapp.CustomImage'

# Update file models list
FILER_FILE_MODELS = (
    'filer.models.File',
    'myapp.models.CustomImage',  # Use custom image model
)

Validation Configuration

# settings.py
from filer.validation import validate_upload

# Custom file validation
def custom_validate_upload(file_obj):
    from django.core.exceptions import ValidationError
    
    # Size validation
    if file_obj.size > 100 * 1024 * 1024:  # 100MB
        raise ValidationError('File too large')
    
    # Name validation  
    if 'virus' in file_obj.name.lower():
        raise ValidationError('Suspicious filename')

# File validation pipeline
FILE_VALIDATORS = [
    validate_upload,
    'myapp.validators.custom_validate_upload',
]

# MIME type restrictions
FILER_MIME_TYPE_WHITELIST = [
    'image/jpeg',
    'image/png', 
    'image/gif',
    'application/pdf',
    'text/plain',
]

# Enable SVG validation for security
FILER_VALIDATE_SVG = True

Development vs Production Settings

# settings/base.py
FILER_ENABLE_PERMISSIONS = True
FILER_IS_PUBLIC_DEFAULT = True

# settings/development.py
from .base import *

FILER_DEBUG = True
FILER_ENABLE_LOGGING = True

# Simple file storage for development
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'

# settings/production.py
from .base import *

FILER_DEBUG = False
FILER_ENABLE_LOGGING = True

# Production storage with separate public/private
FILER_STORAGES = {
    # ... production storage config
}

# Security settings
FILER_UPLOADER_MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
FILER_MIME_TYPE_WHITELIST = [
    'image/jpeg', 'image/png', 'application/pdf'
]

Install with Tessl CLI