django-import-export 3.0.2__tar.gz → 3.2.0__tar.gz

{django-import-export-3.0.2 → django-import-export-3.2.0}/AUTHORS

@@ -131,5 +131,12 @@ The following is a list of much appreciated contributors:
 * HaPyTeX (Willem Van Onsem)
 * nikhaldi (Nik Haldimann)
 * TheRealVizard (Eduardo Leyva)
+* 1gni5 (Jules Ducange)
 * mpasternak (Michał Pasternak)
-* nikatlas (Nikos Atlas)
+* nikatlas (Nikos Atlas)
+* cocorocho (Erkan Çoban)
+* bdnettleton (Brian Nettleton)
+* Ptosiek (Antonin)
+* samupl (Jakub Szafrański)
+* smunoz-ml (Santiago Muñoz)
+* carlosal0ns0 (Carlos Alonso)

{django-import-export-3.0.2/django_import_export.egg-info → django-import-export-3.2.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: django-import-export
-Version: 3.0.2
+Version: 3.2.0
 Summary: Django application and library for importing and exporting data with included admin integration.
 Home-page: https://github.com/django-import-export/django-import-export
-Author: Informatika Mihelac
-Author-email: bmihelac@mihelac.org
+Author: Bojan Mihelač
+Author-email: djangoimportexport@gmail.com
 License: BSD License
 Project-URL: Documentation, https://django-import-export.readthedocs.io/en/stable/
 Project-URL: Changelog, https://django-import-export.readthedocs.io/en/stable/changelog.html
@@ -53,53 +53,13 @@ django-import-export
 .. image:: https://img.shields.io/pypi/djversions/django-import-export
     :alt: PyPI - Django Version
 
-django-import-export is a Django application and library for importing
-and exporting data with included admin integration.
-
-Features:
-
-* support multiple formats (Excel, CSV, JSON, ...
-  and everything else that `tablib`_ supports)
-
-* admin integration for importing
-
-* preview import changes
-
-* admin integration for exporting
-
-* export data respecting admin filters
-
-.. image:: https://raw.githubusercontent.com/django-import-export/django-import-export/main/docs/_static/images/django-import-export-change.png
+.. image:: https://static.pepy.tech/personalized-badge/django-import-export?period=month&units=international_system&left_color=black&right_color=blue&left_text=Downloads/month
+    :target: https://pepy.tech/project/django-import-export
 
+django-import-export is a Django application and library for importing
+and exporting data from a variety of formats.  Includes Django Admin site integration.
 
 * Documentation: https://django-import-export.readthedocs.io/en/stable/
 * GitHub: https://github.com/django-import-export/django-import-export/
 * Free software: BSD license
 * PyPI: https://pypi.org/project/django-import-export/
-
-Example app
------------
-
-To run the demo app::
-
-    cd tests
-    ./manage.py makemigrations
-    ./manage.py migrate
-    ./manage.py createsuperuser
-    ./manage.py loaddata category book
-    ./manage.py runserver
-
-Contribute
-----------
-
-If you'd like to contribute, simply fork `the repository`_, commit your
-changes to the **develop** branch (or branch off of it), and send a pull
-request. Make sure you add yourself to AUTHORS_.
-
-As most projects, we try to follow PEP8_ as closely as possible. Please bear
-in mind that most pull requests will be rejected without proper unit testing.
-
-.. _`PEP8`: https://www.python.org/dev/peps/pep-0008/
-.. _`tablib`: https://github.com/jazzband/tablib
-.. _`the repository`: https://github.com/django-import-export/django-import-export/
-.. _AUTHORS: https://github.com/django-import-export/django-import-export/blob/master/AUTHORS

{django-import-export-3.0.2 → django-import-export-3.2.0}/README.rst

@@ -23,53 +23,13 @@ django-import-export
 .. image:: https://img.shields.io/pypi/djversions/django-import-export
     :alt: PyPI - Django Version
 
-django-import-export is a Django application and library for importing
-and exporting data with included admin integration.
-
-Features:
-
-* support multiple formats (Excel, CSV, JSON, ...
-  and everything else that `tablib`_ supports)
-
-* admin integration for importing
-
-* preview import changes
-
-* admin integration for exporting
-
-* export data respecting admin filters
-
-.. image:: https://raw.githubusercontent.com/django-import-export/django-import-export/main/docs/_static/images/django-import-export-change.png
+.. image:: https://static.pepy.tech/personalized-badge/django-import-export?period=month&units=international_system&left_color=black&right_color=blue&left_text=Downloads/month
+    :target: https://pepy.tech/project/django-import-export
 
+django-import-export is a Django application and library for importing
+and exporting data from a variety of formats.  Includes Django Admin site integration.
 
 * Documentation: https://django-import-export.readthedocs.io/en/stable/
 * GitHub: https://github.com/django-import-export/django-import-export/
 * Free software: BSD license
 * PyPI: https://pypi.org/project/django-import-export/
-
-Example app
------------
-
-To run the demo app::
-
-    cd tests
-    ./manage.py makemigrations
-    ./manage.py migrate
-    ./manage.py createsuperuser
-    ./manage.py loaddata category book
-    ./manage.py runserver
-
-Contribute
-----------
-
-If you'd like to contribute, simply fork `the repository`_, commit your
-changes to the **develop** branch (or branch off of it), and send a pull
-request. Make sure you add yourself to AUTHORS_.
-
-As most projects, we try to follow PEP8_ as closely as possible. Please bear
-in mind that most pull requests will be rejected without proper unit testing.
-
-.. _`PEP8`: https://www.python.org/dev/peps/pep-0008/
-.. _`tablib`: https://github.com/jazzband/tablib
-.. _`the repository`: https://github.com/django-import-export/django-import-export/
-.. _AUTHORS: https://github.com/django-import-export/django-import-export/blob/master/AUTHORS

{django-import-export-3.0.2 → django-import-export-3.2.0/django_import_export.egg-info}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: django-import-export
-Version: 3.0.2
+Version: 3.2.0
 Summary: Django application and library for importing and exporting data with included admin integration.
 Home-page: https://github.com/django-import-export/django-import-export
-Author: Informatika Mihelac
-Author-email: bmihelac@mihelac.org
+Author: Bojan Mihelač
+Author-email: djangoimportexport@gmail.com
 License: BSD License
 Project-URL: Documentation, https://django-import-export.readthedocs.io/en/stable/
 Project-URL: Changelog, https://django-import-export.readthedocs.io/en/stable/changelog.html
@@ -53,53 +53,13 @@ django-import-export
 .. image:: https://img.shields.io/pypi/djversions/django-import-export
     :alt: PyPI - Django Version
 
-django-import-export is a Django application and library for importing
-and exporting data with included admin integration.
-
-Features:
-
-* support multiple formats (Excel, CSV, JSON, ...
-  and everything else that `tablib`_ supports)
-
-* admin integration for importing
-
-* preview import changes
-
-* admin integration for exporting
-
-* export data respecting admin filters
-
-.. image:: https://raw.githubusercontent.com/django-import-export/django-import-export/main/docs/_static/images/django-import-export-change.png
+.. image:: https://static.pepy.tech/personalized-badge/django-import-export?period=month&units=international_system&left_color=black&right_color=blue&left_text=Downloads/month
+    :target: https://pepy.tech/project/django-import-export
 
+django-import-export is a Django application and library for importing
+and exporting data from a variety of formats.  Includes Django Admin site integration.
 
 * Documentation: https://django-import-export.readthedocs.io/en/stable/
 * GitHub: https://github.com/django-import-export/django-import-export/
 * Free software: BSD license
 * PyPI: https://pypi.org/project/django-import-export/
-
-Example app
------------
-
-To run the demo app::
-
-    cd tests
-    ./manage.py makemigrations
-    ./manage.py migrate
-    ./manage.py createsuperuser
-    ./manage.py loaddata category book
-    ./manage.py runserver
-
-Contribute
-----------
-
-If you'd like to contribute, simply fork `the repository`_, commit your
-changes to the **develop** branch (or branch off of it), and send a pull
-request. Make sure you add yourself to AUTHORS_.
-
-As most projects, we try to follow PEP8_ as closely as possible. Please bear
-in mind that most pull requests will be rejected without proper unit testing.
-
-.. _`PEP8`: https://www.python.org/dev/peps/pep-0008/
-.. _`tablib`: https://github.com/jazzband/tablib
-.. _`the repository`: https://github.com/django-import-export/django-import-export/
-.. _AUTHORS: https://github.com/django-import-export/django-import-export/blob/master/AUTHORS

django-import-export-3.2.0/django_import_export.egg-info/requires.txt

@@ -0,0 +1,3 @@
+diff-match-patch
+Django>=3.2
+tablib[html,ods,xls,xlsx,yaml]>=3.4.0

django-import-export-3.2.0/import_export/__init__.py

@@ -0,0 +1 @@
+__version__ = '3.2.0'

{django-import-export-3.0.2 → django-import-export-3.2.0}/import_export/admin.py

@@ -172,17 +172,17 @@ class ImportMixin(BaseImportMixin, ImportExportMixinBase):
 
             return self.process_result(result, request)
 
-    def process_dataset(self, dataset, confirm_form, request, *args, **kwargs):
+    def process_dataset(self, dataset, confirm_form, request, *args, rollback_on_validation_errors=False, **kwargs):
 
-        res_kwargs = self.get_import_resource_kwargs(request, form=confirm_form, *args, **kwargs)
+        res_kwargs = self.get_import_resource_kwargs(request, *args, form=confirm_form, **kwargs)
         resource = self.choose_import_resource_class(confirm_form)(**res_kwargs)
+        imp_kwargs = self.get_import_data_kwargs(request, *args, form=confirm_form, **kwargs)
 
-        imp_kwargs = self.get_import_data_kwargs(request, form=confirm_form, *args, **kwargs)
         return resource.import_data(dataset,
                                     dry_run=False,
-                                    raise_errors=True,
-                                    file_name=confirm_form.cleaned_data['original_file_name'],
+                                    file_name=confirm_form.cleaned_data.get('original_file_name'),
                                     user=request.user,
+                                    rollback_on_validation_errors=True,
                                     **imp_kwargs)
 
     def process_result(self, result, request):
@@ -264,7 +264,7 @@ class ImportMixin(BaseImportMixin, ImportExportMixinBase):
         .. deprecated:: 3.0
             Use :meth:`~import_export.admin.ImportMixin.get_import_form_kwargs` or
             :meth:`~import_export.admin.ImportMixin.get_confirm_form_kwargs`
-            instead, depending on which form you wish to customise.
+            instead, depending on which form you wish to customize.
         """
         warnings.warn(
             "ImportMixin.get_form_kwargs() is deprecated and will be removed "
@@ -299,7 +299,7 @@ class ImportMixin(BaseImportMixin, ImportExportMixinBase):
                 category=DeprecationWarning
             )
             return form_class(formats, **kwargs)
-        return form_class(formats, self.get_import_resource_classes(), **kwargs)
+        return form_class(formats, resources=self.get_import_resource_classes(), **kwargs)
 
     def get_import_form_class(self, request):
         """
@@ -451,6 +451,12 @@ class ImportMixin(BaseImportMixin, ImportExportMixinBase):
         tmp_storage.save(data)
         return tmp_storage
 
+    def add_data_read_fail_error_to_form(self, form, e):
+        form.add_error('import_file',
+                       _(f"'{type(e).__name__}' encountered while trying to read file. "
+                         "Ensure you have chosen the correct format for the file. "
+                         f"{str(e)}"))
+
     def import_action(self, request, *args, **kwargs):
         """
         Perform a dry_run of the import to make sure the import will not
@@ -474,9 +480,9 @@ class ImportMixin(BaseImportMixin, ImportExportMixinBase):
             if issubclass(form_class, ImportExportFormBase):
                 import_form = form_class(
                     import_formats,
-                    self.get_import_resource_classes(),
                     request.POST or None,
                     request.FILES or None,
+                    resources=self.get_import_resource_classes(),
                     **form_kwargs
                 )
             else:
@@ -498,54 +504,74 @@ class ImportMixin(BaseImportMixin, ImportExportMixinBase):
             if not input_format.is_binary():
                 input_format.encoding = self.from_encoding
             import_file = import_form.cleaned_data['import_file']
-            # first always write the uploaded file to disk as it may be a
-            # memory file or else based on settings upload handlers
-            tmp_storage = self.write_to_tmp_storage(import_file, input_format)
-            # allows get_confirm_form_initial() to include both the
-            # original and saved file names from form.cleaned_data
-            import_file.tmp_storage_name = tmp_storage.name
-
-            try:
-                # then read the file, using the proper format-specific mode
-                # warning, big files may exceed memory
-                data = tmp_storage.read()
-                dataset = input_format.create_dataset(data)
-            except Exception as e:
-                import_form.add_error('import_file',
-                               _(f"'{type(e).__name__}' encountered while trying to read file. "
-                                 "Ensure you have chosen the correct format for the file. "
-                                 f"{str(e)}"))
-
-            if not import_form.errors:
-                # prepare kwargs for import data, if needed
-                res_kwargs = self.get_import_resource_kwargs(request, form=import_form, *args, **kwargs)
-                resource = self.choose_import_resource_class(import_form)(**res_kwargs)
-                resources = [resource]
-
-                # prepare additional kwargs for import_data, if needed
-                imp_kwargs = self.get_import_data_kwargs(request, form=import_form, *args, **kwargs)
-                result = resource.import_data(dataset, dry_run=True,
-                                              raise_errors=False,
-                                              file_name=import_file.name,
-                                              user=request.user,
-                                              **imp_kwargs)
-
-                context['result'] = result
-
-                if not result.has_errors() and not result.has_validation_errors():
-                    if getattr(self.get_form_kwargs, "is_original", False):
-                        # Use new API
-                        context["confirm_form"] = self.create_confirm_form(
-                            request, import_form=import_form
-                        )
+
+            if getattr(settings, "IMPORT_EXPORT_SKIP_ADMIN_CONFIRM", False):
+                # This setting means we are going to skip the import confirmation step.
+                # Go ahead and process the file for import in a transaction
+                # If there are any errors, we roll back the transaction.
+                # rollback_on_validation_errors is set to True so that we rollback on
+                # validation errors. If this is not done validation errors would be
+                # silently skipped.
+                data = bytes()
+                for chunk in import_file.chunks():
+                    data += chunk
+                try:
+                    dataset = input_format.create_dataset(data)
+                except Exception as e:
+                    self.add_data_read_fail_error_to_form(import_form, e)
+                if not import_form.errors:
+                    result = self.process_dataset(dataset, import_form, request, *args, raise_errors=False,
+                                                  rollback_on_validation_errors=True, **kwargs)
+                    if not result.has_errors() and not result.has_validation_errors():
+                        return self.process_result(result, request)
                     else:
-                        confirm_form_class = self.get_confirm_form_class(request)
-                        initial = self.get_confirm_form_initial(request, import_form)
-                        context["confirm_form"] = confirm_form_class(
-                            initial=self.get_form_kwargs(form=import_form, **initial)
-                        )
+                        context['result'] = result
+            else:
+                # first always write the uploaded file to disk as it may be a
+                # memory file or else based on settings upload handlers
+                tmp_storage = self.write_to_tmp_storage(import_file, input_format)
+                # allows get_confirm_form_initial() to include both the
+                # original and saved file names from form.cleaned_data
+                import_file.tmp_storage_name = tmp_storage.name
+
+                try:
+                    # then read the file, using the proper format-specific mode
+                    # warning, big files may exceed memory
+                    data = tmp_storage.read()
+                    dataset = input_format.create_dataset(data)
+                except Exception as e:
+                    self.add_data_read_fail_error_to_form(import_form, e)
+
+                if not import_form.errors:
+                    # prepare kwargs for import data, if needed
+                    res_kwargs = self.get_import_resource_kwargs(request, *args, form=import_form, **kwargs)
+                    resource = self.choose_import_resource_class(import_form)(**res_kwargs)
+                    resources = [resource]
+
+                    # prepare additional kwargs for import_data, if needed
+                    imp_kwargs = self.get_import_data_kwargs(request, *args, form=import_form, **kwargs)
+                    result = resource.import_data(dataset, dry_run=True,
+                                                  raise_errors=False,
+                                                  file_name=import_file.name,
+                                                  user=request.user,
+                                                  **imp_kwargs)
+
+                    context['result'] = result
+
+                    if not result.has_errors() and not result.has_validation_errors():
+                        if getattr(self.get_form_kwargs, "is_original", False):
+                            # Use new API
+                            context["confirm_form"] = self.create_confirm_form(
+                                request, import_form=import_form
+                            )
+                        else:
+                            confirm_form_class = self.get_confirm_form_class(request)
+                            initial = self.get_confirm_form_initial(request, import_form)
+                            context["confirm_form"] = confirm_form_class(
+                                initial=self.get_form_kwargs(form=import_form, **initial)
+                            )
         else:
-            res_kwargs = self.get_import_resource_kwargs(request, form=import_form, *args, **kwargs)
+            res_kwargs = self.get_import_resource_kwargs(request, *args, form=import_form, **kwargs)
             resource_classes = self.get_import_resource_classes()
             resources = [resource_class(**res_kwargs) for resource_class in resource_classes]
 
@@ -653,7 +679,10 @@ class ExportMixin(BaseExportMixin, ImportExportMixinBase):
             raise PermissionDenied
 
         data = self.get_data_for_export(request, queryset, *args, **kwargs)
-        export_data = file_format.export_data(data)
+        export_data = file_format.export_data(data,
+                                              escape_output=self.should_escape_output,
+                                              escape_html=self.should_escape_html,
+                                              escape_formulae=self.should_escape_formulae)
         encoding = kwargs.get("encoding")
         if not file_format.is_binary() and encoding:
             export_data = export_data.encode(encoding)
@@ -697,7 +726,7 @@ class ExportMixin(BaseExportMixin, ImportExportMixinBase):
         else:
             form_type = self.get_export_form()
         formats = self.get_export_formats()
-        form = form_type(formats, self.get_export_resource_classes(), request.POST or None)
+        form = form_type(formats,  request.POST or None, resources=self.get_export_resource_classes())
         if form.is_valid():
             file_format = formats[
                 int(form.cleaned_data['file_format'])

{django-import-export-3.0.2 → django-import-export-3.2.0}/import_export/exceptions.py

@@ -1,8 +1,3 @@
-import warnings
-
-warnings.warn("the exceptions module is deprecated and will be removed in a future release", DeprecationWarning)
-
-
 class ImportExportError(Exception):
     """A generic exception for all others to extend."""
     pass

{django-import-export-3.0.2 → django-import-export-3.2.0}/import_export/fields.py

@@ -3,6 +3,7 @@ from django.db.models.fields import NOT_PROVIDED
 from django.db.models.manager import Manager
 
 from . import widgets
+from .exceptions import FieldError
 
 
 class Field:
@@ -17,7 +18,7 @@ class Field:
         this field in the export.
 
     :param widget: Defines a widget that will be used to represent this
-        field's data in the export.
+        field's data in the export, or transform the value during import.
 
     :param readonly: A Boolean which defines if this field will be ignored
         during import.
@@ -27,11 +28,17 @@ class Field:
         not return an adequate value.
 
     :param saves_null_values: Controls whether null values are saved on the object
+    :param dehydrate_method: Lets you choose your own method for dehydration rather
+        than using `dehydrate_{field_name}` syntax.
+    :param m2m_add: changes save of this field to add the values, if they do not exist,
+        to a ManyToMany field instead of setting all values.  Only useful if field is
+        a ManyToMany field.
     """
     empty_values = [None, '']
 
     def __init__(self, attribute=None, column_name=None, widget=None,
-                 default=NOT_PROVIDED, readonly=False, saves_null_values=True):
+                 default=NOT_PROVIDED, readonly=False, saves_null_values=True,
+                 dehydrate_method=None, m2m_add=False):
         self.attribute = attribute
         self.default = default
         self.column_name = column_name
@@ -40,6 +47,8 @@ class Field:
         self.widget = widget
         self.readonly = readonly
         self.saves_null_values = saves_null_values
+        self.dehydrate_method = dehydrate_method
+        self.m2m_add = m2m_add
 
     def __repr__(self):
         """
@@ -112,7 +121,10 @@ class Field:
                 if not is_m2m:
                     setattr(obj, attrs[-1], cleaned)
                 else:
-                    getattr(obj, attrs[-1]).set(cleaned)
+                    if self.m2m_add:
+                        getattr(obj, attrs[-1]).add(*cleaned)
+                    else:
+                        getattr(obj, attrs[-1]).set(cleaned)
 
     def export(self, obj):
         """
@@ -123,3 +135,15 @@ class Field:
         if value is None:
             return ""
         return self.widget.render(value, obj)
+
+    def get_dehydrate_method(self, field_name=None):
+        """
+        Returns method name to be used for dehydration of the field.
+        Defaults to `dehydrate_{field_name}`
+        """
+        DEFAULT_DEHYDRATE_METHOD_PREFIX = "dehydrate_"
+
+        if not self.dehydrate_method and not field_name:
+            raise FieldError("Both dehydrate_method and field_name are not supplied.")
+
+        return self.dehydrate_method or DEFAULT_DEHYDRATE_METHOD_PREFIX + field_name

{django-import-export-3.0.2 → django-import-export-3.2.0}/import_export/formats/base_formats.py

@@ -1,3 +1,6 @@
+import html
+import warnings
+
 import tablib
 from tablib.formats import registry
 
@@ -12,7 +15,7 @@ class Format:
         """
         raise NotImplementedError()
 
-    def export_data(self, dataset, **kwargs):
+    def export_data(self, dataset, escape_output=False, **kwargs):
         """
         Returns format representation for given dataset.
         """
@@ -80,9 +83,15 @@ class TablibFormat(Format):
         return self.get_format().title
 
     def create_dataset(self, in_stream, **kwargs):
-        return tablib.import_set(in_stream, format=self.get_title())
+        return tablib.import_set(in_stream, format=self.get_title(), **kwargs)
 
     def export_data(self, dataset, **kwargs):
+        # remove the deprecated `escape_output` param if present
+        kwargs.pop("escape_output", None)
+        if kwargs.pop("escape_html", None):
+            self._escape_html(dataset)
+        if kwargs.pop("escape_formulae", None):
+            self._escape_formulae(dataset)
         return dataset.export(self.get_title(), **kwargs)
 
     def get_extension(self):
@@ -97,6 +106,21 @@ class TablibFormat(Format):
     def can_export(self):
         return hasattr(self.get_format(), 'export_set')
 
+    def _escape_html(self, dataset):
+        for _ in dataset:
+            row = dataset.lpop()
+            row = [html.escape(str(cell)) for cell in row]
+            dataset.append(row)
+
+    def _escape_formulae(self, dataset):
+        def _do_escape(s):
+            return s.replace("=", "", 1) if s.startswith("=") else s
+
+        for _ in dataset:
+            row = dataset.lpop()
+            row = [_do_escape(str(cell)) for cell in row]
+            dataset.append(row)
+
 
 class TextFormat(TablibFormat):
 
@@ -145,6 +169,16 @@ class HTML(TextFormat):
     TABLIB_MODULE = 'tablib.formats._html'
     CONTENT_TYPE = 'text/html'
 
+    def export_data(self, dataset, escape_output=False, **kwargs):
+        if escape_output:
+            warnings.warn(
+                "escape_output flag now deprecated - "
+                "this will be removed in a future release",
+                DeprecationWarning,
+            )
+            super()._escape_html(dataset)
+        return super().export_data(dataset, **kwargs)
+
 
 class XLS(TablibFormat):
     TABLIB_MODULE = 'tablib.formats._xls'
@@ -192,7 +226,6 @@ class XLSX(TablibFormat):
             dataset.append(row_values)
         return dataset
 
-
 #: These are the default formats for import and export. Whether they can be
 #: used or not is depending on their implementation in the tablib library.
 DEFAULT_FORMATS = [fmt for fmt in (

{django-import-export-3.0.2 → django-import-export-3.2.0}/import_export/forms.py

@@ -1,4 +1,5 @@
 import os.path
+import warnings
 
 from django import forms
 from django.conf import settings
@@ -13,8 +14,19 @@ class ImportExportFormBase(forms.Form):
         required=False,
     )
 
-    def __init__(self, resources=None, *args, **kwargs):
+    def __init__(self,  *args, resources=None, **kwargs):
         super().__init__(*args, **kwargs)
+        if len(args) == 1 and resources is None:
+            # issue 1565: definition of __init__() was incorrect
+            # this logic included to aid backwards compatibility,
+            # for cases where users are calling with the original form.
+            # this check can be removed in a future release
+            warnings.warn(
+                "'resources' must be supplied as a named parameter",
+                category=DeprecationWarning
+            )
+            resources = args
+
         if resources and len(resources) > 1:
             resource_choices = []
             for i, resource in enumerate(resources):
@@ -34,7 +46,8 @@ class ImportForm(ImportExportFormBase):
     )
 
     def __init__(self, import_formats, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+        resources = kwargs.pop("resources", None)
+        super().__init__(*args, resources=resources, **kwargs)
         choices = [
             (str(i), f().get_title())
             for i, f in enumerate(import_formats)
@@ -77,7 +90,8 @@ class ExportForm(ImportExportFormBase):
         )
 
     def __init__(self, formats, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+        resources = kwargs.pop("resources", None)
+        super().__init__(*args, resources=resources, **kwargs)
         choices = []
         for i, f in enumerate(formats):
             choices.append((str(i), f().get_title(),))