tessl/pypi-django-import-export
Django application and library for importing and exporting data with included admin integration.
—
Pending
admin-integration.mddocs/
Django Admin Integration
Complete Django admin integration with import/export functionality, including file upload, validation, confirmation workflows, and error handling.
Capabilities
Import Mixin
Adds import functionality to Django ModelAdmin with comprehensive workflow support.
class ImportMixin(BaseImportMixin, ImportExportMixinBase):
import_template_name = 'admin/import_export/import.html'
import_form_class = ImportForm
confirm_form_class = ConfirmImportForm
from_encoding = 'utf-8'
import_error_display = 'first' # 'first' or 'all'
skip_admin_log = None
tmp_storage_class = TempFolderStorage
def import_action(self, request, **kwargs):
"""
Handle import action in Django admin.
Parameters:
- request: Django HttpRequest
- **kwargs: Additional action parameters
Returns:
HttpResponse with import form or confirmation
"""
def process_import(self, request, **kwargs):
"""
Process import request with file upload and validation.
Parameters:
- request: Django HttpRequest
- **kwargs: Import processing options
Returns:
HttpResponse with results or error page
"""
def has_import_permission(self, request):
"""
Check if user has import permission.
Parameters:
- request: Django HttpRequest
Returns:
bool, True if user can import
"""
def get_import_formats(self):
"""
Get list of available import formats.
Returns:
List of format classes available for import
"""
def get_import_context_data(self, **kwargs):
"""
Get context data for import template.
Parameters:
- **kwargs: Additional context data
Returns:
dict, context data for template rendering
"""
def get_import_form_class(self, request):
"""
Get form class for import step.
Parameters:
- request: Django HttpRequest
Returns:
Form class for import file selection
"""
def get_import_form_kwargs(self, request):
"""
Get kwargs for import form instantiation.
Parameters:
- request: Django HttpRequest
Returns:
dict, keyword arguments for form creation
"""
def create_import_form(self):
"""
Create import form instance.
Returns:
ImportForm instance
"""
def create_confirm_form(self):
"""
Create import confirmation form instance.
Returns:
ConfirmImportForm instance
"""
def get_import_resource_kwargs(self, request, *args, **kwargs):
"""
Get kwargs for resource initialization during import.
Parameters:
- request: Django HttpRequest
- *args: Additional arguments
- **kwargs: Additional keyword arguments
Returns:
Dict of resource kwargs
"""
def get_import_data_kwargs(self, request, *args, **kwargs):
"""
Get kwargs for import_data method.
Parameters:
- request: Django HttpRequest
- *args: Additional arguments
- **kwargs: Additional keyword arguments
Returns:
Dict of import_data kwargs
"""
def get_confirm_import_form(self, request):
"""
Get confirmation form for import.
Parameters:
- request: Django HttpRequest
Returns:
ConfirmImportForm instance
"""
def get_import_formats(self):
"""
Get available import formats.
Returns:
List of format classes available for import
"""
def get_resource_classes(self):
"""
Get resource classes for this admin.
Returns:
List of resource classes
"""
def choose_import_resource_class(self, form):
"""
Choose resource class based on form data.
Parameters:
- form: Import form instance
Returns:
Resource class to use for import
"""
def write_to_tmp_storage(self, import_file, input_format):
"""
Write uploaded file to temporary storage.
Parameters:
- import_file: Uploaded file
- input_format: Format class
Returns:
Storage instance with written file
"""Export Mixin
Adds export functionality to Django ModelAdmin with format selection and queryset filtering.
class ExportMixin(BaseExportMixin, ImportExportMixinBase):
export_template_name = 'admin/import_export/export.html'
export_form_class = ExportForm
to_encoding = 'utf-8'
def export_action(self, request):
"""
Handle export action in Django admin.
Parameters:
- request: Django HttpRequest
Returns:
HttpResponse with export form or file download
"""
def get_export_data(self, file_format, request, queryset, **kwargs):
"""
Get export data in specified format.
Parameters:
- file_format: Format class for export
- request: Django HttpRequest
- queryset: QuerySet to export
- **kwargs: Export options
Returns:
Formatted export data
"""
def get_export_queryset(self, request):
"""
Get queryset for export operations.
Parameters:
- request: Django HttpRequest
Returns:
QuerySet to export
"""
def has_export_permission(self, request):
"""
Check if user has export permission.
Parameters:
- request: Django HttpRequest
Returns:
bool, True if user can export
"""
def get_export_resource_kwargs(self, request, *args, **kwargs):
"""
Get kwargs for resource initialization during export.
Parameters:
- request: Django HttpRequest
- *args: Additional arguments
- **kwargs: Additional keyword arguments
Returns:
Dict of resource kwargs
"""
def get_export_formats(self):
"""
Get available export formats.
Returns:
List of format classes available for export
"""
def get_export_filename(self, request, queryset, file_format):
"""
Generate filename for export.
Parameters:
- request: Django HttpRequest
- queryset: QuerySet being exported
- file_format: Format class
Returns:
str, filename for export file
"""
def create_export_form(self):
"""
Create export form instance.
Returns:
ExportForm instance
"""Combined Import/Export Mixin
Combines both import and export functionality in a single mixin.
class ImportExportMixin(ImportMixin, ExportMixin):
"""
Mixin that combines both import and export functionality.
Inherits all methods from ImportMixin and ExportMixin.
"""Export Action Mixin
Adds export functionality as Django admin actions.
class ExportActionMixin(ExportMixin):
def get_actions(self, request):
"""
Get admin actions including export actions.
Parameters:
- request: Django HttpRequest
Returns:
Dict of available actions
"""
def export_admin_action(self, request, queryset):
"""
Export selected items as admin action.
Parameters:
- request: Django HttpRequest
- queryset: Selected items QuerySet
Returns:
HttpResponse with export or redirect
"""Complete Admin Classes
Ready-to-use admin classes that combine ModelAdmin with import/export functionality.
class ImportExportModelAdmin(ImportExportMixin, admin.ModelAdmin):
"""
ModelAdmin with full import/export functionality.
Combines Django's ModelAdmin with ImportExportMixin.
"""
class ExportActionModelAdmin(ExportActionMixin, admin.ModelAdmin):
"""
ModelAdmin with export functionality as admin actions.
Combines Django's ModelAdmin with ExportActionMixin.
"""
class ImportExportActionModelAdmin(ImportMixin, ExportActionModelAdmin):
"""
ModelAdmin with import functionality and export as admin actions.
Combines ImportMixin with ExportActionModelAdmin.
"""Base Mixins
Lower-level mixins that provide core functionality without admin-specific features.
class BaseImportExportMixin:
resource_classes = None
resource_class = None
def get_resource_classes(self):
"""Get resource classes for this mixin."""
def get_resource_class(self):
"""Get primary resource class."""
def get_import_resource_classes(self):
"""Get resource classes available for import."""
def get_export_resource_classes(self):
"""Get resource classes available for export."""
class BaseImportMixin(BaseImportExportMixin):
"""Base import functionality without Django admin dependencies."""
class BaseExportMixin(BaseImportExportMixin):
"""Base export functionality without Django admin dependencies."""View Mixins
Mixins for use with Django class-based views.
class ExportViewMixin(BaseExportMixin):
"""Export functionality for class-based views."""
def get_export_response(self, export_data, file_format, filename):
"""
Create HttpResponse for export download.
Parameters:
- export_data: Exported data
- file_format: Format class
- filename: Export filename
Returns:
HttpResponse with file download
"""
class ExportViewFormMixin(ExportViewMixin, FormView):
"""Export functionality with form handling for class-based views."""
form_class = ExportForm
template_name = 'import_export/export.html'Usage Examples
Basic Admin Integration
from django.contrib import admin
from import_export.admin import ImportExportModelAdmin
from myapp.models import Book
from myapp.resources import BookResource
@admin.register(Book)
class BookAdmin(ImportExportModelAdmin):
resource_class = BookResource
list_display = ['title', 'author', 'published_date']
list_filter = ['published_date', 'author']
search_fields = ['title', 'author']Custom Permissions
class BookAdmin(ImportExportModelAdmin):
resource_class = BookResource
def has_import_permission(self, request):
# Only allow import for staff users
return request.user.is_staff and request.user.has_perm('myapp.add_book')
def has_export_permission(self, request):
# Allow export for all authenticated users
return request.user.is_authenticatedMultiple Resource Classes
from myapp.resources import BookResource, BookAdvancedResource
class BookAdmin(ImportExportModelAdmin):
resource_classes = [BookResource, BookAdvancedResource]
def get_resource_classes(self):
# Choose resource based on user permissions
if self.request.user.is_superuser:
return [BookAdvancedResource, BookResource]
return [BookResource]Custom Template and Forms
from myapp.forms import CustomImportForm, CustomExportForm
class BookAdmin(ImportExportModelAdmin):
resource_class = BookResource
import_template_name = 'admin/myapp/custom_import.html'
export_template_name = 'admin/myapp/custom_export.html'
import_form_class = CustomImportForm
export_form_class = CustomExportFormCustom Resource Kwargs
class BookAdmin(ImportExportModelAdmin):
resource_class = BookResource
def get_import_resource_kwargs(self, request, *args, **kwargs):
kwargs = super().get_import_resource_kwargs(request, *args, **kwargs)
# Pass current user to resource
kwargs['user'] = request.user
return kwargs
def get_export_resource_kwargs(self, request, *args, **kwargs):
kwargs = super().get_export_resource_kwargs(request, *args, **kwargs)
# Pass user preferences to resource
kwargs['user_preferences'] = request.user.preferences
return kwargsExport as Admin Action Only
@admin.register(Book)
class BookAdmin(ExportActionModelAdmin):
resource_class = BookResource
list_display = ['title', 'author', 'published_date']
def export_admin_action(self, request, queryset):
# Custom export action behavior
response = super().export_admin_action(request, queryset)
# Log export action
self.log_export_action(request, queryset)
return response
export_admin_action.short_description = "Export selected books"Import with Custom Processing
class BookAdmin(ImportExportModelAdmin):
resource_class = BookResource
def get_import_data_kwargs(self, request, *args, **kwargs):
kwargs = super().get_import_data_kwargs(request, *args, **kwargs)
# Always use transactions for imports
kwargs['use_transactions'] = True
# Collect failed rows for analysis
kwargs['collect_failed_rows'] = True
return kwargs
def process_import(self, request, **kwargs):
response = super().process_import(request, **kwargs)
# Send notification after import
if hasattr(self, 'import_result') and not self.import_result.has_errors():
send_import_notification(request.user, self.import_result)
return responseCustom Storage for Large Files
from import_export.tmp_storages import CacheStorage
class BookAdmin(ImportExportModelAdmin):
resource_class = BookResource
tmp_storage_class = CacheStorage # Use cache for large files
def write_to_tmp_storage(self, import_file, input_format):
# Custom file processing before storage
if import_file.size > 10 * 1024 * 1024: # 10MB
# Process large files differently
return self.process_large_file(import_file, input_format)
return super().write_to_tmp_storage(import_file, input_format)Integration with Class-Based Views
from django.views.generic import FormView
from import_export.mixins import ExportViewFormMixin
class BookExportView(ExportViewFormMixin):
model = Book
resource_class = BookResource
template_name = 'books/export.html'
def get_export_queryset(self):
# Custom queryset filtering
return Book.objects.filter(published_date__year=2023)
def form_valid(self, form):
file_format = form.cleaned_data['file_format']
queryset = self.get_export_queryset()
resource = self.resource_class()
dataset = resource.export(queryset)
response = self.get_export_response(
dataset, file_format, 'books_2023.csv'
)
return responseInstall with Tessl CLI
npx tessl i tessl/pypi-django-import-export