From 5be8db8e42fb7417fbec0eadb2e13c0e78863c84 Mon Sep 17 00:00:00 2001 From: Abhinav Maurya Date: Sun, 8 Nov 2026 00:44:31 +0530 Subject: [PATCH 1/3] support native excel types for method and readonly fields --- drf_excel/fields.py | 25 +++++++++++-- drf_excel/renderers.py | 24 ++++++++++-- tests/test_fields.py | 81 +++++++++++++++++++++++++++++++++++++++++ tests/test_renderers.py | 64 ++++++++++++++++++++++++++++++++ 4 files changed, 187 insertions(+), 7 deletions(-) diff --git a/drf_excel/fields.py b/drf_excel/fields.py index 0ba8439..7d9d5a8 100644 --- a/drf_excel/fields.py +++ b/drf_excel/fields.py @@ -126,7 +126,11 @@ def init_value(self, value): def prep_cell(self, cell: Cell): super().prep_cell(cell) - if isinstance(self.drf_field, IntegerField): + if isinstance(self.drf_field, IntegerField) or ( + not isinstance(self.drf_field, FloatField | DecimalField) + and isinstance(self.value, int) + and not isinstance(self.value, bool) + ): cell.number_format = get_setting("INTEGER_FORMAT") or FORMAT_NUMBER else: cell.number_format = get_setting("DECIMAL_FORMAT") or FORMAT_NUMBER_00 @@ -179,6 +183,10 @@ def init_value(self, value): return self._parse_date(value, "TIME_FORMAT", parse_time).replace( tzinfo=None ) + elif isinstance(value, datetime.datetime) and value.tzinfo is not None: + return value.replace(tzinfo=None) + elif isinstance(value, datetime.time) and value.tzinfo is not None: + return value.replace(tzinfo=None) except Exception: pass @@ -187,11 +195,20 @@ def init_value(self, value): def prep_cell(self, cell: Cell): super().prep_cell(cell) - if isinstance(self.drf_field, DateTimeField): + if isinstance(self.drf_field, DateTimeField) or ( + not isinstance(self.drf_field, DateField | TimeField) + and isinstance(self.value, datetime.datetime) + ): cell.number_format = get_setting("DATETIME_FORMAT") or FORMAT_DATE_DATETIME - elif isinstance(self.drf_field, DateField): + elif isinstance(self.drf_field, DateField) or ( + not isinstance(self.drf_field, DateTimeField | TimeField) + and isinstance(self.value, datetime.date) + ): cell.number_format = get_setting("DATE_FORMAT") or FORMAT_DATE_YYYYMMDD2 - elif isinstance(self.drf_field, TimeField): + elif isinstance(self.drf_field, TimeField) or ( + not isinstance(self.drf_field, DateTimeField | DateField) + and isinstance(self.value, datetime.time) + ): cell.number_format = get_setting("TIME_FORMAT") or FORMAT_DATE_TIME4 diff --git a/drf_excel/renderers.py b/drf_excel/renderers.py index 537f3a1..f6b2eb3 100644 --- a/drf_excel/renderers.py +++ b/drf_excel/renderers.py @@ -1,5 +1,7 @@ +import datetime import json from collections.abc import Iterable, MutableMapping +from decimal import Decimal from tempfile import TemporaryFile from django.utils.functional import Promise @@ -18,6 +20,8 @@ FloatField, IntegerField, ListField, + ReadOnlyField, + SerializerMethodField, TimeField, ) from rest_framework.renderers import BaseRenderer @@ -404,11 +408,25 @@ def _drf_to_xlsx_field(self, key, value) -> XLSXField: "cell_style": cell_style, } - if isinstance(field, BooleanField): + is_generic_field = ( + field is None + or isinstance(field, SerializerMethodField | ReadOnlyField) + or type(field) is Field + ) + + if isinstance(field, BooleanField) or ( + is_generic_field and isinstance(value, bool) + ): return XLSXBooleanField(boolean_display=self.boolean_display, **kwargs) - elif isinstance(field, IntegerField | FloatField | DecimalField): + elif isinstance(field, IntegerField | FloatField | DecimalField) or ( + is_generic_field + and isinstance(value, int | float | Decimal) + and not isinstance(value, bool) + ): return XLSXNumberField(**kwargs) - elif isinstance(field, DateTimeField | DateField | TimeField): + elif isinstance(field, DateTimeField | DateField | TimeField) or ( + is_generic_field and isinstance(value, datetime.date | datetime.time) + ): return XLSXDateField(**kwargs) elif ( isinstance(field, ListField) diff --git a/tests/test_fields.py b/tests/test_fields.py index bc582b0..4e7aacf 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -14,6 +14,8 @@ FloatField, IntegerField, ListField, + ReadOnlyField, + SerializerMethodField, TimeField, ) @@ -216,6 +218,38 @@ def test_cell_float(self, style: XLSXStyle, worksheet: Worksheet): assert cell.value == 35.5 assert cell.number_format == "0.00" + def test_cell_integer_with_generic_field( + self, style: XLSXStyle, worksheet: Worksheet + ): + f = XLSXNumberField( + key="count", + value=42, + field=ReadOnlyField(), + style=style, + mapping="", + cell_style=style, + ) + cell = f.cell(worksheet, 1, 1) + assert isinstance(cell, Cell) + assert cell.value == 42 + assert cell.number_format == "0" + + def test_cell_float_with_generic_field( + self, style: XLSXStyle, worksheet: Worksheet + ): + f = XLSXNumberField( + key="ratio", + value=3.14, + field=SerializerMethodField(), + style=style, + mapping="", + cell_style=style, + ) + cell = f.cell(worksheet, 1, 1) + assert isinstance(cell, Cell) + assert cell.value == 3.14 + assert cell.number_format == "0.00" + class TestXLSXDateField: @pytest.mark.parametrize( @@ -397,6 +431,53 @@ def test_cell_time_custom_format( assert cell.value == dt.time(9, 10, 11) assert cell.number_format == "hh - mm - ss" + def test_cell_date_with_generic_field(self, style: XLSXStyle, worksheet: Worksheet): + today = dt.date(2026, 11, 8) + f = XLSXDateField( + key="day", + value=today, + field=ReadOnlyField(), + style=style, + mapping="", + cell_style=style, + ) + cell = f.cell(worksheet, 1, 1) + assert isinstance(cell, Cell) + assert cell.value == today + assert cell.number_format == "yyyy-mm-dd" + + def test_cell_datetime_with_generic_field( + self, style: XLSXStyle, worksheet: Worksheet + ): + now = dt.datetime(2026, 11, 8, 12, 30, tzinfo=dt.timezone.utc) + f = XLSXDateField( + key="timestamp", + value=now, + field=SerializerMethodField(), + style=style, + mapping="", + cell_style=style, + ) + cell = f.cell(worksheet, 1, 1) + assert isinstance(cell, Cell) + assert cell.value == dt.datetime(2026, 11, 8, 12, 30) + assert cell.number_format == "yyyy-mm-dd h:mm:ss" + + def test_cell_time_with_generic_field(self, style: XLSXStyle, worksheet: Worksheet): + current_time = dt.time(14, 15) + f = XLSXDateField( + key="time", + value=current_time, + field=None, + style=style, + mapping="", + cell_style=style, + ) + cell = f.cell(worksheet, 1, 1) + assert isinstance(cell, Cell) + assert cell.value == current_time + assert cell.number_format == "h:mm:ss" + class TestXLSXListField: def test_cell_default_separator(self, style: XLSXStyle, worksheet: Worksheet): diff --git a/tests/test_renderers.py b/tests/test_renderers.py index b39e014..3be66c6 100644 --- a/tests/test_renderers.py +++ b/tests/test_renderers.py @@ -1,3 +1,6 @@ +import datetime as dt +from decimal import Decimal + from django.utils.translation import gettext_lazy as _ from PIL import Image from rest_framework import serializers @@ -195,3 +198,64 @@ def get_serializer(*args, **kwargs): assert len(rows) == 2 assert rows[0][0].value == "title" assert rows[1][0].value == "test" + + def test_render_method_and_readonly_fields(self, workbook_reader): + """ + Verify that SerializerMethodField and ReadOnlyField values are mapped + to their native Excel cell types (numbers, booleans, dates) rather than + falling back to text strings. + """ + + class TypedMethodSerializer(serializers.Serializer): + count = serializers.SerializerMethodField() + price = serializers.ReadOnlyField() + is_active = serializers.SerializerMethodField() + created_at = serializers.SerializerMethodField() + title = serializers.CharField() + + def get_count(self, obj): + return 42 + + def get_is_active(self, obj): + return True + + def get_created_at(self, obj): + return dt.date(2026, 11, 8) + + class TypedView(MyBaseView): + header = {"use_header": False} + + @staticmethod + def get_serializer(*args, **kwargs): + return TypedMethodSerializer() + + serializer = TypedMethodSerializer( + {"price": Decimal("19.99"), "title": "Widget"} + ) + result = self.renderer.render( + [serializer.data], + renderer_context={"view": TypedView}, + ) + wb = workbook_reader(result, read_only=False) + sheet = wb.worksheets[0] + + headers = [sheet.cell(1, col).value for col in range(1, 6)] + cells = {headers[col - 1]: sheet.cell(2, col) for col in range(1, 6)} + + assert cells["count"].data_type == "n" + assert cells["count"].value == 42 + assert cells["count"].number_format == "0" + + assert cells["price"].data_type == "n" + assert cells["price"].value == 19.99 + assert cells["price"].number_format == "0.00" + + assert cells["is_active"].data_type == "b" + assert cells["is_active"].value is True + + assert cells["created_at"].data_type == "d" + assert cells["created_at"].value == dt.datetime(2026, 11, 8, 0, 0) + assert cells["created_at"].number_format == "yyyy-mm-dd" + + assert cells["title"].data_type == "s" + assert cells["title"].value == "Widget" From a72293144369946b3a840a5766c0a8b0adbe88bf Mon Sep 17 00:00:00 2001 From: Abhinav Maurya Date: Wed, 11 Nov 2026 02:37:58 +0530 Subject: [PATCH 2/3] refactor(fields): simplify format branches and combine tzinfo check Combine datetime and time tzinfo stripping into a single union check, and simplify number and date prep_cell format branches. --- drf_excel/fields.py | 38 ++++++++++++++++++-------------------- 1 file changed, 18 insertions(+), 20 deletions(-) diff --git a/drf_excel/fields.py b/drf_excel/fields.py index 7d9d5a8..baf8279 100644 --- a/drf_excel/fields.py +++ b/drf_excel/fields.py @@ -126,11 +126,11 @@ def init_value(self, value): def prep_cell(self, cell: Cell): super().prep_cell(cell) - if isinstance(self.drf_field, IntegerField) or ( - not isinstance(self.drf_field, FloatField | DecimalField) - and isinstance(self.value, int) - and not isinstance(self.value, bool) - ): + if isinstance(self.drf_field, IntegerField): + cell.number_format = get_setting("INTEGER_FORMAT") or FORMAT_NUMBER + elif isinstance(self.drf_field, FloatField | DecimalField): + cell.number_format = get_setting("DECIMAL_FORMAT") or FORMAT_NUMBER_00 + elif isinstance(self.value, int) and not isinstance(self.value, bool): cell.number_format = get_setting("INTEGER_FORMAT") or FORMAT_NUMBER else: cell.number_format = get_setting("DECIMAL_FORMAT") or FORMAT_NUMBER_00 @@ -183,9 +183,10 @@ def init_value(self, value): return self._parse_date(value, "TIME_FORMAT", parse_time).replace( tzinfo=None ) - elif isinstance(value, datetime.datetime) and value.tzinfo is not None: - return value.replace(tzinfo=None) - elif isinstance(value, datetime.time) and value.tzinfo is not None: + elif ( + isinstance(value, datetime.datetime | datetime.time) + and value.tzinfo is not None + ): return value.replace(tzinfo=None) except Exception: pass @@ -195,20 +196,17 @@ def init_value(self, value): def prep_cell(self, cell: Cell): super().prep_cell(cell) - if isinstance(self.drf_field, DateTimeField) or ( - not isinstance(self.drf_field, DateField | TimeField) - and isinstance(self.value, datetime.datetime) - ): + if isinstance(self.drf_field, DateTimeField): cell.number_format = get_setting("DATETIME_FORMAT") or FORMAT_DATE_DATETIME - elif isinstance(self.drf_field, DateField) or ( - not isinstance(self.drf_field, DateTimeField | TimeField) - and isinstance(self.value, datetime.date) - ): + elif isinstance(self.drf_field, DateField): cell.number_format = get_setting("DATE_FORMAT") or FORMAT_DATE_YYYYMMDD2 - elif isinstance(self.drf_field, TimeField) or ( - not isinstance(self.drf_field, DateTimeField | DateField) - and isinstance(self.value, datetime.time) - ): + elif isinstance(self.drf_field, TimeField): + cell.number_format = get_setting("TIME_FORMAT") or FORMAT_DATE_TIME4 + elif isinstance(self.value, datetime.datetime): + cell.number_format = get_setting("DATETIME_FORMAT") or FORMAT_DATE_DATETIME + elif isinstance(self.value, datetime.date): + cell.number_format = get_setting("DATE_FORMAT") or FORMAT_DATE_YYYYMMDD2 + elif isinstance(self.value, datetime.time): cell.number_format = get_setting("TIME_FORMAT") or FORMAT_DATE_TIME4 From cff676e4fb95fb4e7987a635f34e67380e718288 Mon Sep 17 00:00:00 2001 From: Bruno Alla Date: Wed, 11 Nov 2026 08:46:43 +0000 Subject: [PATCH 3/3] Fix Ruff --- tests/test_fields.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_fields.py b/tests/test_fields.py index 4e7aacf..5340e99 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -449,7 +449,7 @@ def test_cell_date_with_generic_field(self, style: XLSXStyle, worksheet: Workshe def test_cell_datetime_with_generic_field( self, style: XLSXStyle, worksheet: Worksheet ): - now = dt.datetime(2026, 11, 8, 12, 30, tzinfo=dt.timezone.utc) + now = dt.datetime(2026, 11, 8, 12, 30, tzinfo=dt.UTC) f = XLSXDateField( key="timestamp", value=now,