diff --git a/drf_excel/fields.py b/drf_excel/fields.py index 0ba8439..baf8279 100644 --- a/drf_excel/fields.py +++ b/drf_excel/fields.py @@ -128,6 +128,10 @@ def prep_cell(self, cell: Cell): 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 @@ -179,6 +183,11 @@ def init_value(self, value): return self._parse_date(value, "TIME_FORMAT", parse_time).replace( tzinfo=None ) + elif ( + isinstance(value, datetime.datetime | datetime.time) + and value.tzinfo is not None + ): + return value.replace(tzinfo=None) except Exception: pass @@ -193,6 +202,12 @@ def prep_cell(self, cell: Cell): cell.number_format = get_setting("DATE_FORMAT") or FORMAT_DATE_YYYYMMDD2 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 class XLSXListField(XLSXField): 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..5340e99 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.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"