django-nepkit 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

django_nepkit/models.py

@@ -1,9 +1,13 @@
 from datetime import date as python_date
+from datetime import datetime as python_datetime
 
 from django.db import models
+from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
 from nepali.datetime import nepalidate, nepalidatetime
+from nepali.locations import districts, municipalities, provinces
 
+from django_nepkit.forms import NepaliDateFormField
 from django_nepkit.utils import (
     BS_DATE_FORMAT,
     BS_DATETIME_FORMAT,
@@ -11,6 +15,43 @@ from django_nepkit.utils import (
     try_parse_nepali_datetime,
 )
 from django_nepkit.validators import validate_nepali_phone_number
+from django_nepkit.widgets import (
+    DistrictSelectWidget,
+    MunicipalitySelectWidget,
+    NepaliDatePickerWidget,
+    ProvinceSelectWidget,
+)
+from django_nepkit.conf import nepkit_settings
+
+
+class NepaliFieldMixin:
+    """Adds Nepali 'ne' and 'en' support to any field."""
+
+    def __init__(self, *args, **kwargs):
+        default_lang = nepkit_settings.DEFAULT_LANGUAGE
+        self.ne = kwargs.pop("ne", default_lang == "ne")
+
+        explicit_en = "en" in kwargs
+        en_value = kwargs.pop("en", not self.ne)
+
+        if self.ne and not explicit_en:
+            self.en = False
+        else:
+            self.en = en_value
+
+        self.htmx = kwargs.pop("htmx", False)
+
+        super().__init__(*args, **kwargs)
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        if self.ne:
+            kwargs["ne"] = True
+        if not self.en:
+            kwargs["en"] = False
+        if self.htmx:
+            kwargs["htmx"] = True
+        return name, path, args, kwargs
 
 
 class NepaliPhoneNumberField(models.CharField):
@@ -22,77 +63,89 @@ class NepaliPhoneNumberField(models.CharField):
         self.validators.append(validate_nepali_phone_number)
 
 
-class NepaliDateField(models.CharField):
-    """
-    A Django Model Field that stores Nepali (Bikram Sambat) Date.
-    Internally it stores the date as BS string (YYYY-MM-DD) in the database.
-    """
-
-    description = _("Nepali Date (Bikram Sambat)")
+class BaseNepaliBSField(NepaliFieldMixin, models.CharField):
+    """Base class for Nepali date and datetime fields."""
 
     def __init__(self, *args, **kwargs):
         self.auto_now = kwargs.pop("auto_now", False)
         self.auto_now_add = kwargs.pop("auto_now_add", False)
 
-        # Match Django's DateField behavior
         if self.auto_now or self.auto_now_add:
             kwargs.setdefault("editable", False)
             kwargs.setdefault("blank", True)
 
-        kwargs.setdefault("max_length", 10)
+        kwargs.setdefault("max_length", getattr(self, "default_max_length", 20))
         super().__init__(*args, **kwargs)
 
     def pre_save(self, model_instance, add):
         if self.auto_now or (self.auto_now_add and add):
-            # Using nepalidate.today() to get current BS date.
-            # This is BS-native as much as possible.
-            value = nepalidate.today().strftime(BS_DATE_FORMAT)
+            now = timezone.now()
+            if timezone.is_aware(now):
+                now = timezone.localtime(now)
+
+            nepali_cls = getattr(self, "nepali_cls", nepalidate)
+            format_str = getattr(self, "format_str", BS_DATE_FORMAT)
+
+            value = (
+                nepali_cls.from_date(now).strftime(format_str)
+                if nepali_cls == nepalidate
+                else nepali_cls.from_datetime(now).strftime(format_str)
+            )
             setattr(model_instance, self.attname, value)
             return value
         return super().pre_save(model_instance, add)
 
     def from_db_value(self, value, expression, connection):
-        parsed = try_parse_nepali_date(value)
+        parsed = self.parse_func(value)
         return parsed if parsed is not None else value
 
     def to_python(self, value):
-        if value is None or isinstance(value, nepalidate):
+        if value is None or isinstance(value, self.nepali_cls):
             return value
-        if isinstance(value, python_date):
-            # If we MUST handle AD date object, we convert it to BS.
-            # But we should prefer strings or nepalidate.
+        if isinstance(value, (python_date, python_datetime)):
             try:
-                return nepalidate.from_date(value)
+                if isinstance(value, python_datetime) and timezone.is_aware(value):
+                    value = timezone.localtime(value)
+                return (
+                    self.nepali_cls.from_date(value)
+                    if self.nepali_cls == nepalidate
+                    else self.nepali_cls.from_datetime(value)
+                )
             except (ValueError, TypeError):
                 return str(value)
         if isinstance(value, str):
-            parsed = try_parse_nepali_date(value)
+            parsed = self.parse_func(value)
             return parsed if parsed is not None else value
         return super().to_python(value)
 
+    def _get_string_value(self, value):
+        if isinstance(value, (nepalidate, nepalidatetime)):
+            return value.strftime(self.format_str)
+        return value
+
     def validate(self, value, model_instance):
-        if isinstance(value, nepalidate):
-            value = value.strftime(BS_DATE_FORMAT)
-        super().validate(value, model_instance)
+        super().validate(self._get_string_value(value), model_instance)
 
     def run_validators(self, value):
-        if isinstance(value, nepalidate):
-            value = value.strftime(BS_DATE_FORMAT)
-        super().run_validators(value)
+        super().run_validators(self._get_string_value(value))
 
     def get_prep_value(self, value):
         if value is None:
             return value
-        if isinstance(value, nepalidate):
-            return value.strftime(BS_DATE_FORMAT)
-        if isinstance(value, python_date):
+        if isinstance(value, self.nepali_cls):
+            return value.strftime(self.format_str)
+        if isinstance(value, (python_date, python_datetime)):
             try:
-                return nepalidate.from_date(value).strftime(BS_DATE_FORMAT)
+                if isinstance(value, python_datetime) and timezone.is_aware(value):
+                    value = timezone.localtime(value)
+                nepali_obj = (
+                    self.nepali_cls.from_date(value)
+                    if self.nepali_cls == nepalidate
+                    else self.nepali_cls.from_datetime(value)
+                )
+                return nepali_obj.strftime(self.format_str)
             except (ValueError, TypeError):
                 return str(value)
-        if isinstance(value, str):
-            return value
-        # Fallback: convert to string
         return str(value)
 
     def deconstruct(self):
@@ -104,166 +157,94 @@ class NepaliDateField(models.CharField):
         return name, path, args, kwargs
 
     def formfield(self, **kwargs):
-        from .forms import NepaliDateFormField
-        from .widgets import NepaliDatePickerWidget
-
         defaults = {
-            "form_class": NepaliDateFormField,
-            "widget": NepaliDatePickerWidget,
+            "widget": NepaliDatePickerWidget(ne=self.ne, en=self.en),
         }
         defaults.update(kwargs)
         return super().formfield(**defaults)
 
 
-class NepaliTimeField(models.TimeField):
-    """
-    A Django Model Field for Time with Nepali localization support.
-    Supports auto_now and auto_now_add like standard Django TimeField.
-    """
-
-    description = _("Nepali Time")
+class NepaliDateField(BaseNepaliBSField):
+    description = _("Nepali Date (Bikram Sambat)")
+    default_max_length = 10
+    nepali_cls = nepalidate
+    format_str = BS_DATE_FORMAT
+    parse_func = staticmethod(try_parse_nepali_date)
 
+    def formfield(self, **kwargs):
+        kwargs.setdefault("form_class", NepaliDateFormField)
+        return super().formfield(**kwargs)
 
-class NepaliDateTimeField(models.CharField):
-    """
-    A Django Model Field that stores Nepali (Bikram Sambat) DateTime.
-    Internally it stores the datetime as BS string (YYYY-MM-DD HH:MM:SS) in the database.
-    """
 
-    description = _("Nepali DateTime (Bikram Sambat)")
+class NepaliTimeField(NepaliFieldMixin, models.TimeField):
+    description = _("Nepali Time")
 
-    def __init__(self, *args, **kwargs):
-        self.auto_now = kwargs.pop("auto_now", False)
-        self.auto_now_add = kwargs.pop("auto_now_add", False)
 
-        # Match Django's DateTimeField behavior
-        if self.auto_now or self.auto_now_add:
-            kwargs.setdefault("editable", False)
-            kwargs.setdefault("blank", True)
+class NepaliDateTimeField(BaseNepaliBSField):
+    description = _("Nepali DateTime (Bikram Sambat)")
+    default_max_length = 19
+    nepali_cls = nepalidatetime
+    format_str = BS_DATETIME_FORMAT
+    parse_func = staticmethod(try_parse_nepali_datetime)
 
-        kwargs.setdefault("max_length", 19)  # YYYY-MM-DD HH:MM:SS
-        super().__init__(*args, **kwargs)
 
-    def pre_save(self, model_instance, add):
-        if self.auto_now or (self.auto_now_add and add):
-            # Using nepalidatetime.now() to get current BS datetime
-            value = nepalidatetime.now().strftime(BS_DATETIME_FORMAT)
-            setattr(model_instance, self.attname, value)
-            return value
-        return super().pre_save(model_instance, add)
-
-    def from_db_value(self, value, expression, connection):
-        parsed = try_parse_nepali_datetime(value)
-        return parsed if parsed is not None else value
+class BaseLocationField(NepaliFieldMixin, models.CharField):
+    """Base class for Province, District, and Municipality fields."""
 
-    def to_python(self, value):
-        if value is None or isinstance(value, nepalidatetime):
-            return value
-        if isinstance(value, str):
-            parsed = try_parse_nepali_datetime(value)
-            return parsed if parsed is not None else value
-        return super().to_python(value)
+    def __init__(self, *args, **kwargs):
+        kwargs.setdefault("max_length", 100)
 
-    def validate(self, value, model_instance):
-        if isinstance(value, nepalidatetime):
-            value = value.strftime(BS_DATETIME_FORMAT)
-        super().validate(value, model_instance)
+        default_lang = nepkit_settings.DEFAULT_LANGUAGE
+        ne = kwargs.get("ne", default_lang == "ne")
 
-    def run_validators(self, value):
-        if isinstance(value, nepalidatetime):
-            value = value.strftime(BS_DATETIME_FORMAT)
-        super().run_validators(value)
+        # Load choices from the library (provinces, districts, etc.)
+        kwargs.setdefault("choices", self.get_choices_from_source(ne))
+        super().__init__(*args, **kwargs)
 
-    def get_prep_value(self, value):
-        if value is None:
-            return value
-        if isinstance(value, nepalidatetime):
-            return value.strftime(BS_DATETIME_FORMAT)
-        if isinstance(value, str):
-            return value
-        # Fallback: convert to string
-        return str(value)
+    def get_choices_from_source(self, ne):
+        source = getattr(self, "source", [])
+        return [(self._get_name(item, ne), self._get_name(item, ne)) for item in source]
 
-    def deconstruct(self):
-        name, path, args, kwargs = super().deconstruct()
-        if self.auto_now:
-            kwargs["auto_now"] = True
-        if self.auto_now_add:
-            kwargs["auto_now_add"] = True
-        return name, path, args, kwargs
+    def _get_name(self, item, ne):
+        name = getattr(item, "name_nepali", item.name) if ne else item.name
+        # Handle name variations and Koshi Province mapping
+        if name == "Province 1":
+            return "Koshi Province"
+        if name == "प्रदेश नं. १":
+            return "कोशी प्रदेश"
+        return name
 
     def formfield(self, **kwargs):
-        from .widgets import NepaliDatePickerWidget
-
-        defaults = {
-            "widget": NepaliDatePickerWidget,
-        }
-        defaults.update(kwargs)
-        return super().formfield(**defaults)
-
+        widget_cls = getattr(self, "widget_class", None)
+        if widget_cls:
+            defaults = {"widget": widget_cls(ne=self.ne, en=self.en, htmx=self.htmx)}
+            defaults.update(kwargs)
+            return super(models.CharField, self).formfield(**defaults)
+        return super().formfield(**kwargs)
 
-class ProvinceField(models.CharField):
-    """
-    A Django Model Field for Nepali Provinces.
-    """
 
+class ProvinceField(BaseLocationField):
     description = _("Nepali Province")
+    source = provinces
+    widget_class = ProvinceSelectWidget
 
-    def __init__(self, *args, **kwargs):
-        from nepali.locations import provinces
-
-        kwargs.setdefault("max_length", 100)
-        kwargs.setdefault("choices", [(p.name, p.name) for p in provinces])
-        super().__init__(*args, **kwargs)
-
-    def formfield(self, **kwargs):
-        from .widgets import ProvinceSelectWidget
-
-        defaults = {"widget": ProvinceSelectWidget}
-        defaults.update(kwargs)
-        return super().formfield(**defaults)
-
-
-class DistrictField(models.CharField):
-    """
-    A Django Model Field for Nepali Districts.
-    """
 
+class DistrictField(BaseLocationField):
     description = _("Nepali District")
+    source = districts
+    widget_class = DistrictSelectWidget
 
-    def __init__(self, *args, **kwargs):
-        from nepali.locations import districts
-
-        kwargs.setdefault("max_length", 100)
-        kwargs.setdefault("choices", [(d.name, d.name) for d in districts])
-        super().__init__(*args, **kwargs)
-
-    def formfield(self, **kwargs):
-        from .widgets import DistrictSelectWidget
-
-        defaults = {"widget": DistrictSelectWidget}
-        defaults.update(kwargs)
-        return super().formfield(**defaults)
 
+class MunicipalityField(BaseLocationField):
+    description = _("Nepali Municipality")
+    source = municipalities
+    widget_class = MunicipalitySelectWidget
 
-class MunicipalityField(models.CharField):
-    """
-    A Django Model Field for Nepali Municipalities.
-    Includes Metropolitan, Sub-Metropolitan, Municipality, and Rural Municipality.
-    """
 
-    description = _("Nepali Municipality")
+class NepaliCurrencyField(models.DecimalField):
+    description = _("Nepali Currency")
 
     def __init__(self, *args, **kwargs):
-        from nepali.locations import municipalities
-
-        kwargs.setdefault("max_length", 100)
-        kwargs.setdefault("choices", [(m.name, m.name) for m in municipalities])
+        kwargs.setdefault("max_digits", 19)
+        kwargs.setdefault("decimal_places", 2)
         super().__init__(*args, **kwargs)
-
-    def formfield(self, **kwargs):
-        from .widgets import MunicipalitySelectWidget
-
-        defaults = {"widget": MunicipalitySelectWidget}
-        defaults.update(kwargs)
-        return super().formfield(**defaults)

django_nepkit/serializers.py

@@ -12,19 +12,21 @@ except ModuleNotFoundError as e:
         "to use `django_nepkit.serializers`."
     ) from e
 
-from django_nepkit.utils import try_parse_nepali_date, try_parse_nepali_datetime
-
-# --------------------------------------------------
-# Base Serializer Field
-# --------------------------------------------------
+from django_nepkit.conf import nepkit_settings
+from django_nepkit.utils import (
+    BS_DATE_FORMAT,
+    BS_DATETIME_FORMAT,
+    format_nepali_currency,
+    try_parse_nepali_date,
+    try_parse_nepali_datetime,
+)
 
 
 class BaseNepaliBSField(serializers.Field):
     """
-    Base DRF field for Nepali (BS) Date / DateTime.
-
-    - **Input**: BS string, or an already-parsed `nepalidate`/`nepalidatetime`
-    - **Output**: formatted BS string (configurable)
+    Handles Nepali (BS) dates.
+    - Input: A date string (like '2080-01-01') or a date object.
+    - Output: A formatted string for your API.
     """
 
     format: str = ""
@@ -35,14 +37,36 @@ class BaseNepaliBSField(serializers.Field):
         "invalid_type": "Invalid type. Expected a string.",
     }
 
-    def __init__(self, *, format: Optional[str] = None, **kwargs: Any) -> None:
+    def __init__(
+        self,
+        *,
+        format: Optional[str] = None,
+        ne: Optional[bool] = None,
+        en: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> None:
         """
         Args:
             format: Optional `strftime` format used for representation.
                     If not provided, uses the class default.
+            ne: If True, output in Devanagari script. If None, uses DEFAULT_LANGUAGE.
+            en: If True, output in English. If None, derived from ne.
         """
         if format is not None:
             self.format = format
+
+        default_lang = nepkit_settings.DEFAULT_LANGUAGE
+
+        if ne is None:
+            self.ne = default_lang == "ne"
+        else:
+            self.ne = ne
+
+        if en is None:
+            self.en = not self.ne
+        else:
+            self.en = en
+
         super().__init__(**kwargs)
 
     def _parse(self, value: str):
@@ -52,20 +76,25 @@ class BaseNepaliBSField(serializers.Field):
             return try_parse_nepali_datetime(value)
         return None
 
+    def _format_value(self, value: Any) -> str:
+        """Format value using strftime or strftime_ne (Devanagari) based on self.ne."""
+        if self.ne and hasattr(value, "strftime_ne"):
+            return value.strftime_ne(self.format)  # type: ignore[attr-defined]
+        return value.strftime(self.format)  # type: ignore[attr-defined]
+
     def to_representation(self, value: Any) -> Optional[str]:
         if value is None:
             return None
 
         if isinstance(value, self.nepali_type):
-            return value.strftime(self.format)  # type: ignore[attr-defined]
+            return self._format_value(value)
 
-        # If DB returns string, try to normalize it.
+        # Convert string dates to Nepali date objects
         if isinstance(value, str):
             parsed = self._parse(value)
             if parsed is not None:
-                return parsed.strftime(self.format)  # type: ignore[attr-defined]
+                return self._format_value(parsed)
 
-        # Fallback: best-effort stringify (keeps behavior non-breaking)
         return str(value)
 
     def to_internal_value(self, data: Any):
@@ -85,29 +114,99 @@ class BaseNepaliBSField(serializers.Field):
         self.fail("invalid", format=self.format)
 
 
-# --------------------------------------------------
-# Nepali Date (BS)
-# --------------------------------------------------
+class NepaliDateSerializerField(BaseNepaliBSField):
+    """API field for Nepali Dates."""
 
+    format = BS_DATE_FORMAT
+    nepali_type = nepalidate
 
-class NepaliDateSerializerField(BaseNepaliBSField):
+
+class NepaliDateTimeSerializerField(BaseNepaliBSField):
+    """API field for Nepali Date and Time."""
+
+    format = BS_DATETIME_FORMAT
+    nepali_type = nepalidatetime
+
+
+class NepaliCurrencySerializerField(serializers.Field):
     """
-    DRF field for Nepali BS Date (YYYY-MM-DD)
+    API field for Nepali Currency.
+    Formats decimal values with Nepali-style commas.
     """
 
-    format = "%Y-%m-%d"
-    nepali_type = nepalidate
+    def __init__(self, currency_symbol="Rs.", ne=None, **kwargs):
+        self.currency_symbol = currency_symbol
+        self.ne = ne
+        super().__init__(**kwargs)
+
+    def to_representation(self, value):
+        if value is None:
+            return None
 
+        ne = self.ne
+        if ne is None:
+            ne = self.context.get("ne", nepkit_settings.DEFAULT_LANGUAGE == "ne")
 
-# --------------------------------------------------
-# Nepali DateTime (BS)
-# --------------------------------------------------
+        return format_nepali_currency(
+            value, currency_symbol=self.currency_symbol, ne=ne
+        )
 
+    def to_internal_value(self, data):
+        # We don't support converting back from formatted string to decimal here
+        # Users should send raw decimal/float values for input.
+        return data
 
-class NepaliDateTimeSerializerField(BaseNepaliBSField):
+
+class NepaliLocalizedSerializerMixin:
     """
-    DRF field for Nepali BS DateTime (YYYY-MM-DD HH:MM:SS)
+    A mixin for ModelSerializer that automatically adds localized counterparts
+    for eligible fields if `ne=True` is passed in the context.
+    Eligible fields: NepaliDateField, NepaliDateTimeField, NepaliCurrencyField.
+
+    Usage:
+        class MySerializer(NepaliLocalizedSerializerMixin, serializers.ModelSerializer):
+            ...
     """
 
-    format = "%Y-%m-%d %H:%M:%S"
-    nepali_type = nepalidatetime
+    def to_representation(self, instance):
+        ret = super().to_representation(instance)  # type: ignore[misc]
+        ne = self.context.get("ne", False)
+        if not ne:
+            return ret
+
+        from django_nepkit.models import (
+            NepaliCurrencyField,
+            NepaliDateField,
+            NepaliDateTimeField,
+        )
+
+        model = getattr(self.Meta, "model", None)  # type: ignore[attr-defined]
+        if not model:
+            return ret
+
+        for field_name, value in list(ret.items()):
+            try:
+                model_field = model._meta.get_field(field_name)
+                localized_name = f"{field_name}_ne"
+
+                if localized_name in ret:
+                    continue
+
+                if isinstance(model_field, NepaliDateField):
+                    raw_val = getattr(instance, field_name)
+                    if hasattr(raw_val, "strftime_ne"):
+                        ret[localized_name] = raw_val.strftime_ne(BS_DATE_FORMAT)
+
+                elif isinstance(model_field, NepaliDateTimeField):
+                    raw_val = getattr(instance, field_name)
+                    if hasattr(raw_val, "strftime_ne"):
+                        ret[localized_name] = raw_val.strftime_ne(BS_DATETIME_FORMAT)
+
+                elif isinstance(model_field, NepaliCurrencyField):
+                    ret[localized_name] = format_nepali_currency(
+                        value, currency_symbol="", ne=True
+                    )
+            except Exception:
+                continue
+
+        return ret