Work on admin integration:

* added ExportForm to admin integration for choosing export file format

* refactor admin integration to allow better handling of specific formats
  supported features and better handling of reading text files

* include all avialable formats in Admin integration

Author: bmihelac

docs/changelog.rst

@@ -2,6 +2,15 @@
 Change Log
 ===========
 
+0.1.1dev
+========
+
+* added ExportForm to admin integration for choosing export file format
+
+* refactor admin integration to allow better handling of specific formats
+  supported features and better handling of reading text files
+
+* include all avialable formats in Admin integration
 
 0.1.0
 =====

import_export/admin.py

@@ -1,24 +1,34 @@
 import tempfile
 from datetime import datetime
 
-import tablib
-
 from django.contrib import admin
 from django.utils.translation import ugettext_lazy as _
 from django.conf.urls.defaults import patterns, url
 from django.template.response import TemplateResponse
 from django.contrib import messages
 from django.http import HttpResponseRedirect, HttpResponse
-from django.utils.importlib import import_module
 from django.core.urlresolvers import reverse
 
 from .forms import (
         ImportForm,
         ConfirmImportForm,
+        ExportForm,
         )
 from .resources import (
         modelresource_factory,
         )
+from .formats import base_formats
+
+
+DEFAULT_FORMATS = (
+            base_formats.CSV,
+            base_formats.XLS,
+            base_formats.TSV,
+            base_formats.ODS,
+            base_formats.JSON,
+            base_formats.YAML,
+            base_formats.HTML,
+            )
 
 
 class ImportMixin(object):
@@ -29,10 +39,7 @@ class ImportMixin(object):
     change_list_template = 'admin/import_export/change_list_import.html'
     import_template_name = 'admin/import_export/import.html'
     resource_class = None
-    format_choices = (
-            ('', '---'),
-            ('tablib.formats._csv', 'CSV'),
-            )
+    formats = DEFAULT_FORMATS
     from_encoding = "utf-8"
 
     def get_urls(self):
@@ -54,50 +61,29 @@ def get_resource_class(self):
         else:
             return self.resource_class
 
-    def get_format(self, format_class):
-        if format_class:
-            return import_module(format_class)
-        return None
-
-    def get_mode_for_format(self, format):
-        """
-        Returns mode for opening files.
+    def get_import_formats(self):
         """
-        return 'rU'
-
-    def load_dataset(self, stream, input_format=None, from_encoding=None):
-        """
-        Loads data from ``stream`` given valid tablib ``input_format``
-        and returns tablib dataset
-
-        If ``from_encoding`` is specified, data will be converted to `utf-8`
-        characterset.
+        Returns available import formats.
         """
-        if from_encoding:
-            text = unicode(stream.read(), from_encoding).encode('utf-8')
-        else:
-            text = stream.read()
-        if not input_format:
-            data = tablib.import_set(text)
-        else:
-            data = tablib.Dataset()
-            input_format.import_set(data, text)
-        return data
+        return [f for f in self.formats if f().can_import()]
 
     def process_import(self, request, *args, **kwargs):
         opts = self.model._meta
         resource = self.get_resource_class()()
 
         confirm_form = ConfirmImportForm(request.POST)
         if confirm_form.is_valid():
-            input_format = self.get_format(
-                    confirm_form.cleaned_data['input_format'])
-            import_mode = self.get_mode_for_format(input_format)
+            import_formats = self.get_import_formats()
+            input_format = import_formats[
+                    int(confirm_form.cleaned_data['input_format'])
+                    ]()
             import_file = open(confirm_form.cleaned_data['import_file_name'],
-                    import_mode)
+                    input_format.get_read_mode())
+            data = import_file.read()
+            if not input_format.is_binary() and self.from_encoding:
+                data = unicode(data, self.from_encoding).encode('utf-8')
+            dataset = input_format.create_dataset(data)
 
-            dataset = self.load_dataset(import_file, input_format,
-                    self.from_encoding)
             resource.import_data(dataset, dry_run=False,
                     raise_errors=True)
 
@@ -115,34 +101,34 @@ def import_action(self, request, *args, **kwargs):
 
         context = {}
 
-        form = ImportForm(self.format_choices,
+        import_formats = self.get_import_formats()
+        form = ImportForm(import_formats,
                 request.POST or None,
                 request.FILES or None)
 
-        if request.POST:
-            if form.is_valid():
-                input_format = self.get_format(
-                        form.cleaned_data['input_format'])
-                import_mode = self.get_mode_for_format(input_format)
-                import_file = form.cleaned_data['import_file']
-                import_file.open(import_mode)
-
-                dataset = self.load_dataset(import_file, input_format,
-                        self.from_encoding)
-                result = resource.import_data(dataset, dry_run=True,
-                        raise_errors=False)
-
-                context['result'] = result
-
-                if not result.has_errors():
-                    tmp_file = tempfile.NamedTemporaryFile(delete=False)
-                    for chunk in import_file.chunks():
-                        tmp_file.write(chunk)
-                    tmp_file.close()
-                    context['confirm_form'] = ConfirmImportForm(initial={
-                        'import_file_name': tmp_file.name,
-                        'input_format': form.cleaned_data['input_format'],
-                        })
+        if request.POST and form.is_valid():
+            input_format = import_formats[
+                    int(form.cleaned_data['input_format'])
+                    ]()
+            import_file = form.cleaned_data['import_file']
+            import_file.open(input_format.get_read_mode())
+            data = import_file.read()
+            if not input_format.is_binary() and self.from_encoding:
+                data = unicode(data, self.from_encoding).encode('utf-8')
+            dataset = input_format.create_dataset(data)
+            result = resource.import_data(dataset, dry_run=True,
+                    raise_errors=False)
+
+            context['result'] = result
+
+            if not result.has_errors():
+                tmp_file = tempfile.NamedTemporaryFile(delete=False)
+                tmp_file.write(data)
+                tmp_file.close()
+                context['confirm_form'] = ConfirmImportForm(initial={
+                    'import_file_name': tmp_file.name,
+                    'input_format': form.cleaned_data['input_format'],
+                    })
 
         context['form'] = form
         context['opts'] = self.model._meta
@@ -158,7 +144,8 @@ class ExportMixin(object):
     """
     resource_class = None
     change_list_template = 'admin/import_export/change_list_export.html'
-    export_format = 'csv'
+    export_template_name = 'admin/import_export/export.html'
+    formats = DEFAULT_FORMATS
     to_encoding = "utf-8"
 
     def get_urls(self):
@@ -177,10 +164,17 @@ def get_resource_class(self):
         else:
             return self.resource_class
 
-    def get_export_filename(self):
+    def get_export_formats(self):
+        """
+        Returns available import formats.
+        """
+        return [f for f in self.formats if f().can_export()]
+
+    def get_export_filename(self, file_format):
         date_str = datetime.now().strftime('%Y-%m-%d')
         filename = "%s-%s.%s" % (self.model.__name__,
-                date_str, self.export_format)
+                date_str,
+                file_format.get_extension())
         return filename
 
     def get_export_queryset(self, request):
@@ -203,16 +197,30 @@ def get_export_queryset(self, request):
         return cl.query_set
 
     def export_action(self, request, *args, **kwargs):
-        resource_class = self.get_resource_class()
-        queryset = self.get_export_queryset(request)
-        data = resource_class().export(queryset)
-        filename = self.get_export_filename()
-        response = HttpResponse(
-                getattr(data, self.export_format),
-                mimetype='application/octet-stream',
-                )
-        response['Content-Disposition'] = 'attachment; filename=%s' % filename
-        return response
+        formats = self.get_export_formats()
+        form = ExportForm(formats, request.POST or None)
+        if form.is_valid():
+            file_format = formats[
+                    int(form.cleaned_data['file_format'])
+                    ]()
+
+            resource_class = self.get_resource_class()
+            queryset = self.get_export_queryset(request)
+            data = resource_class().export(queryset)
+            response = HttpResponse(
+                    file_format.export_data(data),
+                    mimetype='application/octet-stream',
+                    )
+            response['Content-Disposition'] = 'attachment; filename=%s' % (
+                   self.get_export_filename(file_format),
+                   )
+            return response
+
+        context = {}
+        context['form'] = form
+        context['opts'] = self.model._meta
+        return TemplateResponse(request, [self.export_template_name],
+                context, current_app=self.admin_site.name)
 
 
 class ImportExportMixin(ImportMixin, ExportMixin):

import_export/formats/__init__.py

@@ -0,0 +1,144 @@
+import warnings
+import tablib
+
+try:
+    from tablib.compat import xlrd
+    XLS_IMPORT = True
+except ImportError:
+    xls_warning = "Installed `tablib` library does not include"
+    "import support for 'xls' format."
+    warnings.warn(xls_warning, ImportWarning)
+    XLS_IMPORT = False
+
+from django.utils.importlib import import_module
+
+
+class Format(object):
+
+    def get_title(self):
+        return type(self)
+
+    def create_dataset(self, in_stream):
+        """
+        Create dataset from given string.
+        """
+        raise NotImplementedError()
+
+    def export_data(self, dataset):
+        """
+        Returns format representation for given dataset.
+        """
+        raise NotImplementedError()
+
+    def is_binary(self):
+        """
+        Returns if this format is binary.
+        """
+        return True
+
+    def get_read_mode(self):
+        """
+        Returns mode for opening files.
+        """
+        return 'r'
+
+    def get_extension(self):
+        """
+        Returns extension for this format files.
+        """
+        return ""
+
+    def can_import(self):
+        return False
+
+    def can_export(self):
+        return False
+
+
+class TablibFormat(Format):
+    TABLIB_MODULE = None
+
+    def get_format(self):
+        """
+        Import and returns tablib module.
+        """
+        return import_module(self.TABLIB_MODULE)
+
+    def get_title(self):
+        return self.get_format().title
+
+    def create_dataset(self, in_stream):
+        data = tablib.Dataset()
+        self.get_format().import_set(data, in_stream)
+        return data
+
+    def export_data(self, dataset):
+        return self.get_format().export_set(dataset)
+
+    def get_extension(self):
+        return self.get_format().extensions[0]
+
+    def can_import(self):
+        return hasattr(self.get_format(), 'import_set')
+
+    def can_export(self):
+        return hasattr(self.get_format(), 'export_set')
+
+
+class TextFormat(TablibFormat):
+
+    def get_read_mode(self):
+        return 'rU'
+
+    def is_binary(self):
+        return False
+
+
+class CSV(TextFormat):
+    TABLIB_MODULE = 'tablib.formats._csv'
+
+
+class JSON(TextFormat):
+    TABLIB_MODULE = 'tablib.formats._json'
+
+
+class YAML(TextFormat):
+    TABLIB_MODULE = 'tablib.formats._yaml'
+
+
+class TSV(TextFormat):
+    TABLIB_MODULE = 'tablib.formats._tsv'
+
+
+class ODS(TextFormat):
+    TABLIB_MODULE = 'tablib.formats._ods'
+
+
+class XLSX(TextFormat):
+    TABLIB_MODULE = 'tablib.formats._xlsx'
+
+
+class HTML(TextFormat):
+    TABLIB_MODULE = 'tablib.formats._html'
+
+
+class XLS(TextFormat):
+    TABLIB_MODULE = 'tablib.formats._xls'
+
+    def can_import(self):
+        return XLS_IMPORT
+
+    def create_dataset(self, in_stream):
+        """
+        Create dataset from first sheet.
+        """
+        assert XLS_IMPORT
+        xls_book = xlrd.open_workbook(file_contents=in_stream)
+        dataset = tablib.Dataset()
+        sheet = xls_book.sheets()[0]
+        for i in xrange(sheet.nrows):
+            if i == 0:
+                dataset.headers = sheet.row_values(0)
+            else:
+                dataset.append(sheet.row_values(i))
+        return dataset

import_export/formats/base_formats.py

@@ -11,11 +11,34 @@ class ImportForm(forms.Form):
             choices=(),
             )
 
-    def __init__(self, format_choices, *args, **kwargs):
+    def __init__(self, import_formats, *args, **kwargs):
         super(ImportForm, self).__init__(*args, **kwargs)
-        self.fields['input_format'].choices = format_choices
+        choices = []
+        for i, f in enumerate(import_formats):
+            choices.append((str(i), f().get_title(),))
+        if len(import_formats) > 1:
+            choices.insert(0, ('', '---'))
+
+        self.fields['input_format'].choices = choices
 
 
 class ConfirmImportForm(forms.Form):
     import_file_name = forms.CharField(widget=forms.HiddenInput())
     input_format = forms.CharField(widget=forms.HiddenInput())
+
+
+class ExportForm(forms.Form):
+    file_format = forms.ChoiceField(
+            label=_('Format'),
+            choices=(),
+            )
+
+    def __init__(self, formats, *args, **kwargs):
+        super(ExportForm, self).__init__(*args, **kwargs)
+        choices = []
+        for i, f in enumerate(formats):
+            choices.append((str(i), f().get_title(),))
+        if len(formats) > 1:
+            choices.insert(0, ('', '---'))
+
+        self.fields['file_format'].choices = choices

import_export/forms.py

@@ -0,0 +1,37 @@
+{% extends "admin/import_export/base.html" %}
+{% load url from future %}
+{% load i18n %}
+{% load admin_urls %}
+{% load import_export_tags %}
+
+{% block breadcrumbs_last %}
+{% trans "Export" %}
+{% endblock %}
+
+{% block content %}
+<h1>{% trans "Export" %}</h1>
+
+<form action="{% url opts|admin_urlname:"export" %}" method="POST">
+  {% csrf_token %}
+
+    <fieldset class="module aligned">
+      {% for field in form %}
+        <div class="form-row">
+          {{ field.errors }}
+
+          {{ field.label_tag }}
+
+          {{ field }}
+
+          {% if field.field.help_text %}
+          <p class="help">{{ field.field.help_text|safe }}</p>
+          {% endif %}
+        </div>
+      {% endfor %}
+    </fieldset>
+
+    <div class="submit-row">
+      <input type="submit" class="default" value="{% trans "Submit" %}">
+    </div>
+</form>
+{% endblock %}

import_export/templates/admin/import_export/export.html

@@ -24,7 +24,7 @@ def test_import_export_template(self):
         self.assertContains(response, _('Export'))
 
     def test_import(self):
-        input_format = 'tablib.formats._csv'
+        input_format = '0'
         filename = os.path.join(
                 os.path.dirname(__file__),
                 os.path.pardir,
@@ -50,4 +50,10 @@ def test_import(self):
     def test_export(self):
         response = self.client.get('/admin/core/book/export/')
         self.assertEqual(response.status_code, 200)
+
+        data = {
+                'file_format': '0',
+                }
+        response = self.client.post('/admin/core/book/export/', data)
+        self.assertEqual(response.status_code, 200)
         self.assertTrue(response.has_header("Content-Disposition"))