django-pfx 1.7.6.dev41__tar.gz → 1.7.6.dev43__tar.gz

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-pfx
-Version: 1.7.6.dev41
+Version: 1.7.6.dev43
 Summary: Django PFX is a toolkit designed to streamline the development of RESTful APIs using the Django framework.
 Author: Hervé Martinet
 Author-email: herve.martinet@gmail.com

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/django_pfx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-pfx
-Version: 1.7.6.dev41
+Version: 1.7.6.dev43
 Summary: Django PFX is a toolkit designed to streamline the development of RESTful APIs using the Django framework.
 Author: Hervé Martinet
 Author-email: herve.martinet@gmail.com

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/django_pfx.egg-info/SOURCES.txt

@@ -236,6 +236,8 @@ tests/tests/test_fields_choices.py
 tests/tests/test_fields_date.py
 tests/tests/test_fields_decimal.py
 tests/tests/test_fields_help_text.py
+tests/tests/test_fields_media_local.py
+tests/tests/test_fields_media_s3.py
 tests/tests/test_fields_minutes_duration.py
 tests/tests/test_fields_one2many.py
 tests/tests/test_fields_rich_text.py

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/django_pfx.egg-info/scm_file_list.json

@@ -226,6 +226,8 @@
     "tests/tests/test_fields_date.py",
     "tests/tests/test_fields_decimal.py",
     "tests/tests/test_fields_help_text.py",
+    "tests/tests/test_fields_media_local.py",
+    "tests/tests/test_fields_media_s3.py",
     "tests/tests/test_fields_minutes_duration.py",
     "tests/tests/test_fields_one2many.py",
     "tests/tests/test_fields_rich_text.py",

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/django_pfx.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "1.7.5",
-  "distance": 41,
-  "node": "g32f5225014879db5d0f59213b87db537af6b5a94",
+  "distance": 43,
+  "node": "g06cda0545eb88c42c2152cffc096975b4f14e7e3",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-27"

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/pfx/pfxcore/fields/media_field.py

@@ -6,8 +6,8 @@ from importlib import import_module
 from urllib.parse import unquote_to_bytes
 
 from django.core.exceptions import ValidationError
-from django.db import models
-from django.db.models.signals import post_delete, post_init, post_save
+from django.db import models, transaction
+from django.db.models.signals import post_init, post_save, pre_delete
 from django.dispatch import receiver
 
 from pfx.pfxcore.shortcuts import settings
@@ -104,6 +104,12 @@ class MediaField(models.JSONField):
             setattr(obj, self.name, self.upload(obj, file, name))
             obj.save(update_fields={self.name})
 
+        def delete_file(value):
+            transaction.on_commit(
+                lambda value=value: self.delete(value),
+                robust=True,
+            )
+
         after_save = []
         value = self.value_from_object(obj)
         if isinstance(value, dict):
@@ -112,10 +118,10 @@ class MediaField(models.JSONField):
         else:
             b64 = None
 
-        db_value = obj._media_db_values.get(self.name)
+        db_value = getattr(obj, f'_db_{self.name}')
         if db_value and (b64 or not value):
-            after_save.append(lambda: self.delete(db_value))
             setattr(obj, self.name, None)
+            after_save.append(lambda: delete_file(db_value))
         if b64:
             try:
                 file = decode_data_uri(b64)
@@ -160,21 +166,28 @@ class MediaField(models.JSONField):
         return self.storage.delete(value)
 
 
-# Kept on the instance: the field is shared by every instance of the model.
 @receiver(post_init)
 @receiver(post_save)
-def store_media_db_values(sender, instance, update_fields=None, **kwargs):
+def init_db_value(sender, instance, update_fields=None, **kwargs):
+    """Set the current db value in _db_{field_name} to track changes.
+
+    _db_{field_name} is the standard naming convention in PFX to track
+    current db value (normally done in `__init__()`).
+    """
     for field in sender._meta.fields:
         if isinstance(field, MediaField) and (
                 update_fields is None or field.name in update_fields):
-            if not hasattr(instance, '_media_db_values'):
-                instance._media_db_values = {}
-            instance._media_db_values[field.name] = (
+            setattr(
+                instance, f'_db_{field.name}',
                 field.value_from_object(instance))
 
 
-@receiver(post_delete)
-def post_delete_media(sender, instance, **kwargs):
+@receiver(pre_delete)
+def pre_delete_media(sender, instance, **kwargs):
     for field in sender._meta.fields:
         if isinstance(field, MediaField) and field.auto_delete:
-            field.storage.delete(field.value_from_object(instance))
+            value = field.value_from_object(instance)
+            transaction.on_commit(
+                lambda field=field, value=value: field.storage.delete(value),
+                robust=True,
+            )

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/pfx/pfxcore/test.py

@@ -1,3 +1,4 @@
+import base64
 import copy
 import csv
 import io
@@ -218,7 +219,6 @@ class APIClient(DjangoClient):
 
 
 class TestAssertMixin:
-
     # assert response status code
     def assertRC(self, response, code, msg=None):
         msg = '\n'.join([msg or '', response.formatted()])
@@ -291,6 +291,21 @@ class TestAssertMixin:
         return self.assertNotIn(
             element, self.get_val(src, key, msg=msg), msg=msg)
 
+    def as_data_url(self, content="Test content"):
+        if isinstance(content, str):
+            content = content.encode()
+        b64 = base64.b64encode(content).decode('ascii')
+        return f"data:text/plain;charset=utf-8;base64,{b64}"
+
+    @classmethod
+    def upload_file(
+            cls, obj, field='file', file_name='test.txt',
+            content="A test file content.", **kw):
+        if isinstance(content, str):
+            content = content.encode()
+        return obj.__class__._meta.get_field(field).upload(
+            obj, content, file_name)
+
 
 class TestPermsAssertMixin(TestAssertMixin):
     USER_TESTS = {}

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/tests/tests/__init__.py

@@ -17,6 +17,8 @@ from .test_emails_test_tools import (
 from .test_fields_choices import TestFieldsChoices
 from .test_fields_date import TestFieldsDate
 from .test_fields_decimal import TestFieldsDecimal
+from .test_fields_media_local import TestFieldsMediaLocal
+from .test_fields_media_s3 import TestFieldsMediaS3
 from .test_fields_minutes_duration import TestFieldsMinutesDuration
 from .test_fields_one2many import TestFieldsOne2Many
 from .test_fields_rich_text import TestFieldsRichText

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/tests/tests/basic_api_test.py

@@ -828,11 +828,12 @@ class BasicAPITest(TestAssertMixin, TestCase):
         self.assertTrue(Path(f'/tmp/django-pfx-filestore/{key1}').exists())
 
         # Replace file
-        response = self.client.put(f'/api/books/{book_pk}', dict(
-            local_file=dict(
-                name='test2.txt',
-                base64='data:text/plain;charset=utf-8;'
-                'base64,TmV3IGNvbnRlbnQ=')))
+        with self.captureOnCommitCallbacks(execute=True):
+            response = self.client.put(f'/api/books/{book_pk}', dict(
+                local_file=dict(
+                    name='test2.txt',
+                    base64='data:text/plain;charset=utf-8;'
+                    'base64,TmV3IGNvbnRlbnQ=')))
         self.assertRC(response, 200)
         self.assertNJE(response, 'local_file.key', key1)
         self.assertJE(response, 'local_file.name', 'test2.txt')
@@ -841,8 +842,9 @@ class BasicAPITest(TestAssertMixin, TestCase):
         self.assertTrue(Path(f'/tmp/django-pfx-filestore/{key2}').exists())
 
         # Delete file
-        response = self.client.put(f'/api/books/{book_pk}', dict(
-            local_file=None))
+        with self.captureOnCommitCallbacks(execute=True):
+            response = self.client.put(f'/api/books/{book_pk}', dict(
+                local_file=None))
         self.assertRC(response, 200)
         self.assertJE(response, 'local_file', None)
         self.assertFalse(Path(f'/tmp/django-pfx-filestore/{key2}').exists())
@@ -865,10 +867,11 @@ class BasicAPITest(TestAssertMixin, TestCase):
         book.local_file = dict(
             name='new.txt',
             base64='data:text/plain;charset=utf-8;base64,TmV3IGNvbnRlbnQ=')
-        funcs = Book._meta.get_field('local_file').media_pre_save(book)
-        book.save()
-        for func in funcs:
-            func()
+        with self.captureOnCommitCallbacks(execute=True):
+            funcs = Book._meta.get_field('local_file').media_pre_save(book)
+            book.save()
+            for func in funcs:
+                func()
         return book.local_file['key']
 
     def test_replace_file_after_loading_another_object(self):
@@ -1426,14 +1429,15 @@ class BasicAPITest(TestAssertMixin, TestCase):
             response, f"http://dragonfly.fake/{key}",
             fetch_redirect_response=False)
 
-        with patch.object(
+        with (patch.object(
                 MockBoto3Client, 'delete_object',
-                return_value=None) as mock_delete:
+                return_value=None) as mock_delete,
+                self.captureOnCommitCallbacks(execute=True)):
             response = self.client.delete(
                 f'/api/books/{self.author1_book1.pk}')
-            mock_delete.assert_called_with(
-                Bucket='dragonfly.fake',
-                Key=key)
+        mock_delete.assert_called_with(
+            Bucket='dragonfly.fake',
+            Key=key)
 
     def test_annotate_meta_service(self):
         response = self.client.get('/api/authors-annotate/meta')

django_pfx-1.7.6.dev43/tests/tests/test_fields_media_local.py

@@ -0,0 +1,295 @@
+from pathlib import Path
+from unittest.mock import patch
+
+from django.conf import settings
+from django.db import connection, models, transaction
+from django.test import TestCase, override_settings
+from django.urls import include, path
+
+from pfx.pfxcore import register_views
+from pfx.pfxcore.decorator import rest_view
+from pfx.pfxcore.exceptions import APIError
+from pfx.pfxcore.fields import MediaField
+from pfx.pfxcore.models import JSONReprMixin
+from pfx.pfxcore.storage import LocalStorage
+from pfx.pfxcore.test import APIClient, TestAssertMixin
+from pfx.pfxcore.views import MediaRestViewMixin, RestView
+from tests.views import FakeViewMixin
+
+
+class TestLocalMediaModel(JSONReprMixin, models.Model):
+    file = MediaField(
+        auto_delete=True, blank=True, null=True, storage=LocalStorage())
+
+    class Meta:
+        verbose_name = "TestLocalModel"
+        verbose_name_plural = "TestLocalModels"
+        ordering = ['pk']
+
+
+@rest_view("/test")
+class TestLocalMediaRestView(FakeViewMixin, MediaRestViewMixin, RestView):
+    default_public = True
+    model = TestLocalMediaModel
+
+
+@rest_view("/test-failed")
+class TestLocalMediaFailedRestView(
+        FakeViewMixin, MediaRestViewMixin, RestView):
+    default_public = True
+    model = TestLocalMediaModel
+
+    def is_valid(self, obj, created=False, rel_data=None):
+        with transaction.atomic():
+            res = super().is_valid(obj, created, rel_data)
+            raise APIError("Error")
+        return res
+
+    def delete_object(self, obj):
+        with transaction.atomic():
+            super().delete_object(obj)
+            raise APIError("Error")
+
+
+urlpatterns = [
+    path('api/', include(register_views(TestLocalMediaRestView))),
+    path('api/', include(register_views(TestLocalMediaFailedRestView))),
+    path('api/', include('pfx.pfxcore.urls'))
+]
+
+
+@override_settings(
+    ROOT_URLCONF=__name__,
+    STORAGE_LOCAL_ROOT='/tmp/django-pfx-filestore',
+    STORAGE_LOCAL_X_ACCEL_REDIRECT=False)
+class TestFieldsMediaLocal(TestAssertMixin, TestCase):
+
+    def setUp(self):
+        self.client = APIClient(default_locale='en')
+
+    @classmethod
+    def setUpTestData(cls):
+        with connection.schema_editor() as schema_editor:
+            schema_editor.create_model(TestLocalMediaModel)
+
+    @staticmethod
+    def pathlib_error(method):
+        return patch(
+            f'pathlib.Path.{method}', side_effect=OSError('Disk error'))
+
+    @property
+    def filestore(self):
+        return Path(settings.STORAGE_LOCAL_ROOT)
+
+    def count_files(self):
+        return sum(
+            1 for path in self.filestore.rglob("*")
+            if path.is_file())
+
+    def test_get(self):
+        obj = TestLocalMediaModel.objects.create()
+        obj.file = self.upload_file(
+            obj, 'file', 'test.txt', "Test content")
+        obj.full_clean()
+        obj.save()
+
+        response = self.client.get(f'/api/test/{obj.pk}')
+        self.assertRC(response, 200)
+        self.assertJE(response, 'pk', obj.pk)
+        self.assertJE(response, 'file.content-length', '12')
+        self.assertJE(response, 'file.content-type', 'text/plain')
+        self.assertJEExists(response, 'file.key')
+        self.assertJE(response, 'file.name', 'test.txt')
+        self.assertJE(
+            response, 'file.url', f"/test/{obj.pk}/file")
+        key = self.get_val(response, 'file.key')
+        path = Path(f'/tmp/django-pfx-filestore/{key}')
+        self.assertTrue(path.exists())
+        with open(path, 'r') as f:
+            self.assertEqual(f.read(), "Test content")
+
+    def test_create(self):
+        response = self.client.post('/api/test', dict(
+            file=dict(
+                name='test.txt',
+                base64=self.as_data_url("Test content"))))
+        self.assertRC(response, 200)
+        obj_pk = self.get_val(response, 'pk')
+        self.assertJE(response, 'file.content-length', '12')
+        self.assertJE(response, 'file.content-type', 'text/plain')
+        self.assertJEExists(response, 'file.key')
+        self.assertJE(response, 'file.name', 'test.txt')
+        self.assertJE(
+            response, 'file.url', f"/test/{obj_pk}/file")
+        key = self.get_val(response, 'file.key')
+        path = self.filestore / key
+        self.assertTrue(path.exists())
+        with open(path, 'r') as f:
+            self.assertEqual(f.read(), "Test content")
+
+    def test_create_failed_after_save(self):
+        nb_files = self.count_files()
+
+        response = self.client.post('/api/test-failed', dict(
+            file=dict(
+                name='test.txt',
+                base64=self.as_data_url("Test content"))))
+        self.assertRC(response, 400)
+        self.assertEqual(TestLocalMediaModel.objects.count(), 0)
+
+        # If an error occurs after _save(), an orphan file exists.
+        self.assertEqual(self.count_files(), nb_files + 1)
+
+    def test_create_failed_disk(self):
+        nb_files = self.count_files()
+
+        with (
+                self.assertLogs(level='ERROR'),
+                self.pathlib_error('mkdir') as mock_mkdir):
+            response = self.client.post('/api/test', dict(
+                file=dict(
+                    name='test.txt',
+                    base64=self.as_data_url("Test content"))))
+        self.assertRC(response, 500)
+        # If the file can't be created, the objet is not saved.
+        self.assertEqual(TestLocalMediaModel.objects.count(), 0)
+
+        self.assertEqual(self.count_files(), nb_files)
+        mock_mkdir.assert_called_once()
+
+    def test_update(self):
+        obj = TestLocalMediaModel.objects.create()
+        obj.file = self.upload_file(
+            obj, 'file', 'test.txt', "Test content")
+        obj.full_clean()
+        obj.save()
+        path1 = self.filestore / obj.file['key']
+        self.assertTrue(path1.exists())
+
+        with self.captureOnCommitCallbacks(execute=True):
+            response = self.client.put(f'/api/test/{obj.pk}', dict(
+                file=dict(
+                    name='test2.txt',
+                    base64=self.as_data_url("Test updated"))))
+        self.assertRC(response, 200)
+        self.assertJE(response, 'pk', obj.pk)
+        self.assertJE(response, 'file.content-length', '12')
+        self.assertJE(response, 'file.content-type', 'text/plain')
+        self.assertJEExists(response, 'file.key')
+        self.assertJE(response, 'file.name', 'test2.txt')
+        self.assertJE(
+            response, 'file.url', f"/test/{obj.pk}/file")
+        key = self.get_val(response, 'file.key')
+        path2 = self.filestore / key
+        self.assertFalse(path1.exists())
+        self.assertTrue(path2.exists())
+        with open(path2, 'r') as f:
+            self.assertEqual(f.read(), "Test updated")
+
+    def test_update_failed_after_save(self):
+        obj = TestLocalMediaModel.objects.create()
+        obj.file = self.upload_file(
+            obj, 'file', 'test.txt', "Test content")
+        obj.full_clean()
+        obj.save()
+        key1 = obj.file['key']
+        self.assertTrue((self.filestore / key1).exists())
+        nb_files = self.count_files()
+
+        with self.captureOnCommitCallbacks(execute=True):
+            response = self.client.put(f'/api/test-failed/{obj.pk}', dict(
+                file=dict(
+                    name='test2.txt',
+                    base64=self.as_data_url("Test updated"))))
+        self.assertRC(response, 400)
+        obj.refresh_from_db()
+        self.assertEqual(obj.file['name'], 'test.txt')
+        self.assertEqual(obj.file['key'], key1)
+
+        self.assertTrue((self.filestore / key1).exists())
+        # If an error occurs after _save(), an orphan file exists.
+        self.assertEqual(self.count_files(), nb_files + 1)
+
+    def test_update_failed_disk(self):
+        obj = TestLocalMediaModel.objects.create()
+        obj.file = self.upload_file(
+            obj, 'file', 'test.txt', "Test content")
+        obj.full_clean()
+        obj.save()
+        key1 = obj.file['key']
+        self.assertTrue((self.filestore / key1).exists())
+        nb_files = self.count_files()
+
+        with (
+                self.assertLogs(level='ERROR'),
+                self.pathlib_error('mkdir') as mock_mkdir,
+                self.captureOnCommitCallbacks(execute=True)):
+            response = self.client.put(f'/api/test/{obj.pk}', dict(
+                file=dict(
+                    name='test2.txt',
+                    base64=self.as_data_url("Test updated"))))
+        self.assertRC(response, 500)
+
+        # If the file can't be created, the objet is not saved.
+        obj.refresh_from_db()
+        self.assertEqual(obj.file['name'], 'test.txt')
+        self.assertEqual(obj.file['key'], key1)
+
+        self.assertTrue((self.filestore / key1).exists())
+
+        self.assertEqual(self.count_files(), nb_files)
+        mock_mkdir.assert_called_once()
+
+    def test_delete(self):
+        obj = TestLocalMediaModel.objects.create()
+        obj.file = self.upload_file(
+            obj, 'file', 'test.txt', "Test content")
+        obj.full_clean()
+        obj.save()
+        path = self.filestore / obj.file['key']
+        self.assertTrue(path.exists())
+
+        with self.captureOnCommitCallbacks(execute=True):
+            response = self.client.delete(f'/api/test/{obj.pk}')
+        self.assertRC(response, 200)
+        with self.assertRaises(TestLocalMediaModel.DoesNotExist):
+            obj.refresh_from_db()
+        self.assertFalse(path.exists())
+
+    def test_delete_failed_after_save(self):
+        obj = TestLocalMediaModel.objects.create()
+        obj.file = self.upload_file(
+            obj, 'file', 'test.txt', "Test content")
+        obj.full_clean()
+        obj.save()
+        path = self.filestore / obj.file['key']
+        self.assertTrue(path.exists())
+
+        with self.captureOnCommitCallbacks(execute=True):
+            response = self.client.delete(f'/api/test-failed/{obj.pk}')
+        self.assertRC(response, 400)
+        obj.refresh_from_db()
+        self.assertTrue(path.exists())
+
+    def test_delete_failed_disk(self):
+        obj = TestLocalMediaModel.objects.create()
+        obj.file = self.upload_file(
+            obj, 'file', 'test.txt', "Test content")
+        obj.full_clean()
+        obj.save()
+        path = self.filestore / obj.file['key']
+        self.assertTrue(path.exists())
+
+        with (
+                self.assertLogs(level='ERROR'),
+                self.pathlib_error('unlink') as mock_unlink,
+                self.captureOnCommitCallbacks(execute=True)):
+            response = self.client.delete(f'/api/test/{obj.pk}')
+
+        self.assertRC(response, 200)
+        with self.assertRaises(TestLocalMediaModel.DoesNotExist):
+            obj.refresh_from_db()
+
+        # File exists (orphan)
+        self.assertTrue(path.exists())
+        mock_unlink.assert_called_once()

django_pfx-1.7.6.dev43/tests/tests/test_fields_media_s3.py

@@ -0,0 +1,76 @@
+from unittest.mock import MagicMock, patch
+
+from django.db import connection, models, transaction
+from django.test import TestCase, override_settings
+from django.urls import include, path
+
+from pfx.pfxcore import register_views
+from pfx.pfxcore.decorator import rest_view
+from pfx.pfxcore.exceptions import APIError
+from pfx.pfxcore.fields import MediaField
+from pfx.pfxcore.models import JSONReprMixin
+from pfx.pfxcore.storage import S3Storage
+from pfx.pfxcore.test import APIClient, MockBoto3Client, TestAssertMixin
+from pfx.pfxcore.views import MediaRestViewMixin, RestView
+from tests.views import FakeViewMixin
+
+
+class TestS3MediaModel(JSONReprMixin, models.Model):
+    file = MediaField(
+        auto_delete=True, blank=True, null=True, storage=S3Storage())
+
+    class Meta:
+        verbose_name = "TestS3Model"
+        verbose_name_plural = "TestS3Models"
+        ordering = ['pk']
+
+
+@rest_view("/test")
+class TestS3MediaRestView(FakeViewMixin, RestView):
+    default_public = True
+    model = TestS3MediaModel
+
+
+@rest_view("/test-failed")
+class TestS3MediaFailedRestView(
+        FakeViewMixin, MediaRestViewMixin, RestView):
+    default_public = True
+    model = TestS3MediaModel
+
+    def is_valid(self, obj, created=False, rel_data=None):
+        with transaction.atomic():
+            res = super().is_valid(obj, created, rel_data)
+            raise APIError("Error")
+        return res
+
+    def delete_object(self, obj):
+        with transaction.atomic():
+            super().delete_object(obj)
+            raise APIError("Error")
+
+
+urlpatterns = [
+    path('api/', include(register_views(TestS3MediaRestView))),
+    path('api/', include(register_views(TestS3MediaFailedRestView))),
+    path('api/', include('pfx.pfxcore.urls'))
+]
+
+
+@override_settings(
+    ROOT_URLCONF=__name__,
+    STORAGE_S3_AWS_REGION="fake-region",
+    STORAGE_S3_AWS_ACCESS_KEY="FAKE",
+    STORAGE_S3_AWS_SECRET_KEY="FAKE-SECRET",
+    STORAGE_S3_AWS_S3_BUCKET="dragonfly.fake",
+    STORAGE_S3_AWS_GET_URL_EXPIRE=300,
+    STORAGE_S3_AWS_PUT_URL_EXPIRE=300)
+@patch("boto3.client", MagicMock(return_value=MockBoto3Client()))
+class TestFieldsMediaS3(TestAssertMixin, TestCase):
+
+    def setUp(self):
+        self.client = APIClient(default_locale='en')
+
+    @classmethod
+    def setUpTestData(cls):
+        with connection.schema_editor() as schema_editor:
+            schema_editor.create_model(TestS3MediaModel)

{django_pfx-1.7.6.dev41 → django_pfx-1.7.6.dev43}/tests/tests/test_table_file_helpers.py

@@ -8,8 +8,6 @@ from pathlib import Path
 from django.http import HttpResponse, StreamingHttpResponse
 from django.test import SimpleTestCase, override_settings
 
-from openpyxl import Workbook
-
 from pfx.pfxcore.test import CSVFileHelper, XLSXFileHelper
 
 CSV = "Name,Age\nAlice,30\nBob,\n"
@@ -17,6 +15,7 @@ CSV = "Name,Age\nAlice,30\nBob,\n"
 
 def xlsx(*sheets):
     """An Excel file of `sheets`, (title, rows) pairs."""
+    from openpyxl import Workbook
     workbook = Workbook()
     workbook.remove(workbook.active)
     for title, rows in sheets: