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

django_nepkit/__init__.py

@@ -6,14 +6,26 @@ from .models import (
     ProvinceField,
     DistrictField,
     MunicipalityField,
+    NepaliCurrencyField,
 )
 from .admin import (
     NepaliDateFilter,
+    NepaliMonthFilter,
     format_nepali_date,
     format_nepali_datetime,
     NepaliModelAdmin,
     NepaliAdminMixin,
 )
+from .serializers import (
+    NepaliCurrencySerializerField,
+    NepaliLocalizedSerializerMixin,
+)
+from .filters import (
+    NepaliDateYearFilter,
+    NepaliDateMonthFilter,
+    NepaliDateRangeFilter,
+    NepaliCurrencyRangeFilter,
+)
 
 __all__ = [
     "NepaliDateField",
@@ -24,8 +36,16 @@ __all__ = [
     "DistrictField",
     "MunicipalityField",
     "NepaliDateFilter",
+    "NepaliMonthFilter",
     "format_nepali_date",
     "format_nepali_datetime",
     "NepaliModelAdmin",
     "NepaliAdminMixin",
+    "NepaliCurrencyField",
+    "NepaliCurrencySerializerField",
+    "NepaliLocalizedSerializerMixin",
+    "NepaliDateYearFilter",
+    "NepaliDateMonthFilter",
+    "NepaliDateRangeFilter",
+    "NepaliCurrencyRangeFilter",
 ]

django_nepkit/admin.py

@@ -2,77 +2,71 @@ from django.contrib import admin
 from django.utils.translation import gettext_lazy as _
 from nepali.datetime import nepalidate, nepalidatetime
 
-from django_nepkit.models import NepaliDateField
+from django_nepkit.conf import nepkit_settings
+from django_nepkit.models import (
+    NepaliDateField,
+    NepaliDateTimeField,
+    NepaliCurrencyField,
+)
 from django_nepkit.utils import (
     try_parse_nepali_date,
     try_parse_nepali_datetime,
+    format_nepali_currency,
 )
+from django_nepkit.utils import BS_DATE_FORMAT
 
 
-def format_nepali_date(date_value, format_string="%B %d, %Y"):
-    """
-    Format a nepalidate object with Nepali month names.
-
-    Args:
-        date_value: A nepalidate object or string in YYYY-MM-DD format
-        format_string: strftime format string (default: '%B %d, %Y')
-                      %B = Full month name (Baishak, Jestha, etc.)
-                      %b = Short month name
-                      %d = Day of month
-                      %Y = Year
-
-    Returns:
-        Formatted date string with Nepali month names, or empty string if invalid
-    """
-    if date_value is None:
+def _format_nepali_common(value, try_parse_func, format_string, ne, cls_type):
+    """Helper to format dates/times with optional Devanagari support."""
+    if value is None:
         return ""
 
     try:
-        parsed = try_parse_nepali_date(date_value)
+        parsed = try_parse_func(value)
         if parsed is not None:
+            if ne and hasattr(parsed, "strftime_ne"):
+                return parsed.strftime_ne(format_string)
             return parsed.strftime(format_string)
-        if isinstance(date_value, nepalidate):
-            return date_value.strftime(
-                format_string
-            )  # defensive; should be covered above
+        if isinstance(value, cls_type):
+            if ne and hasattr(value, "strftime_ne"):
+                return value.strftime_ne(format_string)
+            return value.strftime(format_string)
     except (ValueError, TypeError, AttributeError):
         pass
 
-    return str(date_value) if date_value else ""
+    return str(value) if value else ""
 
 
-def format_nepali_datetime(datetime_value, format_string="%B %d, %Y %I:%M %p"):
+def format_nepali_date(date_value, format_string="%B %d, %Y", ne=False):
     """
-    Format a nepalidatetime object with Nepali month names.
-
-    Default output uses **12-hour time with AM/PM**.
+    Format a nepalidate object with Nepali month names.
     """
-    if datetime_value is None:
-        return ""
-
-    try:
-        parsed = try_parse_nepali_datetime(datetime_value)
-        if parsed is not None:
-            return parsed.strftime(format_string)
-        if isinstance(datetime_value, nepalidatetime):
-            return datetime_value.strftime(
-                format_string
-            )  # defensive; should be covered above
-    except (ValueError, TypeError, AttributeError):
-        pass
+    return _format_nepali_common(
+        date_value, try_parse_nepali_date, format_string, ne, nepalidate
+    )
 
-    return str(datetime_value) if datetime_value else ""
 
-
-class NepaliDateFilter(admin.FieldListFilter):
+def format_nepali_datetime(datetime_value, format_string=None, ne=False):
     """
-    A list filter for NepaliDateField to filter by BS Year.
+    Format a nepalidatetime object with Nepali month names.
     """
+    if format_string is None:
+        if nepkit_settings.TIME_FORMAT == 24:
+            format_string = "%B %d, %Y %H:%M"
+        else:
+            format_string = "%B %d, %Y %I:%M %p"
+
+    return _format_nepali_common(
+        datetime_value, try_parse_nepali_datetime, format_string, ne, nepalidatetime
+    )
+
+
+class BaseNepaliDateFilter(admin.FieldListFilter):
+    """Base class for date filters (Year/Month)."""
 
     def __init__(self, field, request, params, model, model_admin, field_path):
-        self.parameter_name = f"{field_path}_bs_year"
+        self.parameter_name = f"{field_path}_{self.suffix}"
         super().__init__(field, request, params, model, model_admin, field_path)
-        self.title = _("Nepali Date (Year)")
 
     def expected_parameters(self):
         return [self.parameter_name]
@@ -83,40 +77,85 @@ class NepaliDateFilter(admin.FieldListFilter):
             "query_string": changelist.get_query_string(remove=[self.parameter_name]),
             "display": _("All"),
         }
-        current_year = nepalidate.today().year
-        for year in range(current_year - 10, current_year + 2):
+        for value, display in self.get_filter_options():
             yield {
-                "selected": self.used_parameters.get(self.parameter_name) == str(year),
+                "selected": self.used_parameters.get(self.parameter_name) == str(value),
                 "query_string": changelist.get_query_string(
-                    {self.parameter_name: str(year)}
+                    {self.parameter_name: str(value)}
                 ),
-                "display": str(year),
+                "display": display,
             }
 
     def queryset(self, request, queryset):
         value = self.used_parameters.get(self.parameter_name)
         if value:
-            year = int(value)
-            # Convert BS year range to AD date range
-            start_date_bs = nepalidate(year, 1, 1)
-            # Find last day of the year. Some BS years end on the 30th,
-            # so we try 31 first and then fall back to 30 if that date
-            # is not valid.
-            try:
-                end_date_bs = nepalidate(year, 12, 31)
-            except ValueError:
-                end_date_bs = nepalidate(year, 12, 30)
+            return self.apply_filter(queryset, value)
+        return queryset
 
-            start_date_ad = start_date_bs.to_date()
-            end_date_ad = end_date_bs.to_date()
+    def get_filter_options(self):
+        raise NotImplementedError
 
+    def apply_filter(self, queryset, value):
+        raise NotImplementedError
+
+
+class NepaliDateFilter(BaseNepaliDateFilter):
+    """Filter by Nepali Year (e.g., 2080)."""
+
+    suffix = "bs_year"
+    title = _("Nepali Date (Year)")
+
+    def get_filter_options(self):
+        current_year = nepalidate.today().year
+        return [(y, str(y)) for y in range(current_year - 10, current_year + 2)]
+
+    def apply_filter(self, queryset, value):
+        if BS_DATE_FORMAT.startswith("%Y"):
+            separator = BS_DATE_FORMAT[2] if len(BS_DATE_FORMAT) > 2 else "-"
             return queryset.filter(
-                **{f"{self.field_path}__range": (start_date_ad, end_date_ad)}
+                **{f"{self.field_path}__startswith": f"{value}{separator}"}
             )
-        return queryset
+
+        return queryset.filter(**{f"{self.field_path}__icontains": f"{value}"})
+
+
+class NepaliMonthFilter(BaseNepaliDateFilter):
+    """Filter by Nepali Month (e.g., Baisakh)."""
+
+    suffix = "bs_month"
+    title = _("Nepali Date (Month)")
+
+    def get_filter_options(self):
+        ne = nepkit_settings.DEFAULT_LANGUAGE == "ne"
+        names = [
+            ("बैशाख", "Baisakh"),
+            ("जेठ", "Jestha"),
+            ("असार", "Ashad"),
+            ("साउन", "Shrawan"),
+            ("भदौ", "Bhadra"),
+            ("असोज", "Ashwin"),
+            ("कात्तिक", "Kartik"),
+            ("मंसिर", "Mangsir"),
+            ("पुष", "Poush"),
+            ("माघ", "Magh"),
+            ("फागुन", "Falgun"),
+            ("चैत", "Chaitra"),
+        ]
+        return [(f"{i:02d}", n[0] if ne else n[1]) for i, n in enumerate(names, 1)]
+
+    def apply_filter(self, queryset, value):
+        from django_nepkit.utils import BS_DATE_FORMAT
+
+        if BS_DATE_FORMAT == "%Y-%m-%d":
+            return queryset.filter(**{f"{self.field_path}__contains": f"-{value}-"})
+
+        separator = BS_DATE_FORMAT[2] if len(BS_DATE_FORMAT) > 2 else "-"
+        return queryset.filter(
+            **{f"{self.field_path}__contains": f"{separator}{value}{separator}"}
+        )
 
 
-# Register NepaliDateFilter as the default list filter for NepaliDateField
+# Standard filter for any NepaliDateField in Admin
 admin.FieldListFilter.register(
     lambda f: isinstance(f, NepaliDateField),
     NepaliDateFilter,
@@ -125,65 +164,176 @@ admin.FieldListFilter.register(
 
 
 class NepaliAdminMixin:
-    """
-    Mixin for Django admin classes that provides Nepali date utilities.
-    Makes format_nepali_date and NepaliDateFilter available without explicit imports.
-    """
+    """Provides date formatting tools for Admin classes."""
+
+    def _get_field_ne_setting(self, field_name):
+        """
+        Get the 'ne' setting from a model field.
+
+        Args:
+            field_name: Name of the field in the model
+
+        Returns:
+            True if field has ne=True, False otherwise
+        """
+        if not hasattr(self, "model"):
+            return False
 
-    def format_nepali_date(self, date_value, format_string="%B %d, %Y"):
+        try:
+            field = self.model._meta.get_field(field_name)
+            if hasattr(field, "ne"):
+                return field.ne
+        except (AttributeError, LookupError):
+            pass
+
+        return False
+
+    def format_nepali_date(
+        self, date_value, format_string="%B %d, %Y", ne=None, field_name=None
+    ):
         """
         Format a nepalidate object with Nepali month names.
         Available as a method on admin classes using this mixin.
+
+        Args:
+            date_value: A nepalidate object or string
+            format_string: strftime format string
+            ne: If True, format using Devanagari script. If None, auto-detect from field or global settings (default: None)
+            field_name: Name of the field to auto-detect 'ne' setting from (optional)
         """
-        return format_nepali_date(date_value, format_string)
+        if ne is None and field_name:
+            ne = self._get_field_ne_setting(field_name)
+        elif ne is None:
+            ne = nepkit_settings.DEFAULT_LANGUAGE == "ne"
+
+        return format_nepali_date(date_value, format_string, ne=ne)
 
     def format_nepali_datetime(
-        self, datetime_value, format_string="%B %d, %Y %I:%M %p"
+        self,
+        datetime_value,
+        format_string=None,
+        ne=None,
+        field_name=None,
     ):
-        return format_nepali_datetime(datetime_value, format_string)
+        """
+        Format a nepalidatetime object with Nepali month names.
+
+        Args:
+            datetime_value: A nepalidatetime object or string
+            format_string: strftime format string
+            ne: If True, format using Devanagari script. If None, auto-detect from field or global settings (default: None)
+            field_name: Name of the field to auto-detect 'ne' setting from (optional)
+        """
+        if ne is None and field_name:
+            ne = self._get_field_ne_setting(field_name)
+        elif ne is None:
+            ne = nepkit_settings.DEFAULT_LANGUAGE == "ne"
+
+        return format_nepali_datetime(datetime_value, format_string, ne=ne)
+
+    def format_nepali_currency(self, value, currency_symbol="Rs.", ne=False, **kwargs):
+        """
+        Format a number with Nepali-style commas.
+        Available as a method on admin classes using this mixin.
+        """
+        return format_nepali_currency(value, currency_symbol=currency_symbol, ne=ne)
 
 
 class NepaliModelAdmin(NepaliAdminMixin, admin.ModelAdmin):
     """
-    Base ModelAdmin class with Nepali date utilities built-in.
-    Use this instead of admin.ModelAdmin to have format_nepali_date available.
+    Standard Admin class that automatically formats Nepali dates in lists.
 
     Example:
         from django_nepkit import NepaliModelAdmin, NepaliDateFilter
 
         @admin.register(MyModel)
         class MyModelAdmin(NepaliModelAdmin):
-            list_filter = (('date_field', NepaliDateFilter),)
-
-            def display_date(self, obj):
-                return self.format_nepali_date(obj.date_field)
+            list_display = ("name", "birth_date", "created_at")  # auto-formatted
+            list_filter = (("birth_date", NepaliDateFilter),)
     """
 
-    # Make NepaliDateFilter available as a class attribute
+    # Make filters available as class attributes
     NepaliDateFilter = NepaliDateFilter
+    NepaliMonthFilter = NepaliMonthFilter
+
+    def _make_nepali_display(self, field_name, formatter_method):
+        """Helper to create display columns for Nepali dates."""
+        admin_instance = self
+        try:
+            field = self.model._meta.get_field(field_name)
+            short_description = getattr(
+                field, "verbose_name", field_name.replace("_", " ").title()
+            )
+        except Exception:
+            short_description = field_name.replace("_", " ").title()
+
+        def display(obj):
+            val = getattr(obj, field_name, None)
+            if val is None:
+                return admin_instance.get_empty_value_display()
+            # Call the passed formatter method (bound to self)
+            return formatter_method(val, field_name=field_name)
+
+        display.short_description = short_description
+        display.admin_order_field = field_name
+        return display
+
+    def _make_nepali_date_display(self, field_name):
+        return self._make_nepali_display(field_name, self.format_nepali_date)
+
+    def _make_nepali_datetime_display(self, field_name):
+        return self._make_nepali_display(field_name, self.format_nepali_datetime)
+
+    def _make_nepali_currency_display(self, field_name):
+        return self._make_nepali_display(field_name, self.format_nepali_currency)
+
+    def get_list_display(self, request):
+        list_display = super().get_list_display(request)
+        result = []
+        for item in list_display:
+            if not isinstance(item, str):
+                result.append(item)
+                continue
+            try:
+                field = self.model._meta.get_field(item)
+                if isinstance(field, NepaliDateField):
+                    result.append(self._make_nepali_date_display(item))
+                    continue
+                if isinstance(field, NepaliDateTimeField):
+                    result.append(self._make_nepali_datetime_display(item))
+                    continue
+                if isinstance(field, NepaliCurrencyField):
+                    result.append(self._make_nepali_currency_display(item))
+                    continue
+            except Exception:
+                pass
+            result.append(item)
+        return result
 
-    # Ensure admin forms render Nepali fields with the proper widget,
-    # even if a project doesn't provide custom ModelForms.
     def formfield_for_dbfield(self, db_field, request, **kwargs):
-        """
-        Force Nepali widgets in Django admin without requiring user forms.
-        """
+        """Automatically use NepaliDatePicker in the admin form."""
         try:
             from django_nepkit.models import NepaliDateField, NepaliDateTimeField
             from django_nepkit.widgets import NepaliDatePickerWidget
         except Exception:
             return super().formfield_for_dbfield(db_field, request, **kwargs)
 
-        if isinstance(db_field, (NepaliDateField, NepaliDateTimeField)):
-            kwargs.setdefault("widget", NepaliDatePickerWidget)
+        if (
+            isinstance(db_field, (NepaliDateField, NepaliDateTimeField))
+            and nepkit_settings.ADMIN_DATEPICKER
+        ):
+            # Pass ne/en parameters from field to widget if they exist
+            widget_kwargs = {}
+            if hasattr(db_field, "ne"):
+                widget_kwargs["ne"] = db_field.ne
+            if hasattr(db_field, "en"):
+                widget_kwargs["en"] = db_field.en
+            kwargs.setdefault("widget", NepaliDatePickerWidget(**widget_kwargs))
 
         return super().formfield_for_dbfield(db_field, request, **kwargs)
 
     class Media:
-        """
-        Django admin ships jQuery as `django.jQuery` (not `window.jQuery`).
-        The Nepali date picker library expects a global `jQuery`, so we bridge it.
-        """
+        """Loads the Nepali Datepicker and bridging scripts."""
 
         css = {
             "all": (
@@ -201,9 +351,9 @@ class NepaliModelAdmin(NepaliAdminMixin, admin.ModelAdmin):
         )
 
 
-# Exporting for easy usage
 __all__ = [
     "NepaliDateFilter",
+    "NepaliMonthFilter",
     "format_nepali_date",
     "format_nepali_datetime",
     "NepaliAdminMixin",

django_nepkit/conf.py

@@ -0,0 +1,34 @@
+from django.conf import settings
+
+DEFAULTS = {
+    "DEFAULT_LANGUAGE": "en",
+    "DATE_INPUT_FORMATS": ["%Y-%m-%d", "%d/%m/%Y", "%d-%m-%Y"],
+    "ADMIN_DATEPICKER": True,
+    "TIME_FORMAT": 12,
+    "BS_DATE_FORMAT": "%Y-%m-%d",
+    "BS_DATETIME_FORMAT": "%Y-%m-%d %H:%M:%S",
+}
+
+
+class NepkitSettings:
+    """Handles the global NEPKIT settings from your settings.py."""
+
+    def __init__(self, user_settings=None, defaults=None):
+        self._user_settings = user_settings or {}
+        self.defaults = defaults or DEFAULTS
+
+    def __getattr__(self, attr):
+        if attr not in self.defaults:
+            raise AttributeError(f"Invalid NEPKIT setting: '{attr}'")
+
+        try:
+            # Check if the user has a custom setting
+            val = self._user_settings[attr]
+        except KeyError:
+            # Use default value if not set
+            val = self.defaults[attr]
+
+        return val
+
+
+nepkit_settings = NepkitSettings(getattr(settings, "NEPKIT", {}), DEFAULTS)

django_nepkit/filters.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.db.models import QuerySet
+
+try:
+    from django_filters import rest_framework as filters
+except ImportError as e:
+    raise ModuleNotFoundError(
+        "django-nepkit filter support is optional. Install with `django-nepkit[drf]` "
+        "to use `django_nepkit.filters`."
+    ) from e
+
+
+class NepaliDateYearFilter(filters.NumberFilter):
+    """
+    A filter for `NepaliDateField` that allows filtering by Bikram Sambat Year.
+    Expects an integer year (e.g., 2080).
+    """
+
+    def filter(self, qs: QuerySet, value: Any) -> QuerySet:
+        if value:
+            from django_nepkit.utils import BS_DATE_FORMAT
+
+            # Find the date separator (e.g., '-' in '2080-01-01')
+            if BS_DATE_FORMAT.startswith("%Y"):
+                separator = BS_DATE_FORMAT[2] if len(BS_DATE_FORMAT) > 2 else "-"
+                return qs.filter(
+                    **{f"{self.field_name}__startswith": f"{value}{separator}"}
+                )
+
+            # Fallback if the format is unusual
+            return qs.filter(**{f"{self.field_name}__icontains": str(value)})
+        return qs
+
+
+class NepaliDateMonthFilter(filters.NumberFilter):
+    """
+    A filter for `NepaliDateField` that allows filtering by Bikram Sambat Month.
+    Expects an integer month (1-12).
+    """
+
+    def filter(self, qs: QuerySet, value: Any) -> QuerySet:
+        if value:
+            from django_nepkit.utils import BS_DATE_FORMAT
+
+            month_str = f"{int(value):02d}"
+
+            # Standard format: look for '-01-' for Baisakh
+            if BS_DATE_FORMAT == "%Y-%m-%d":
+                return qs.filter(**{f"{self.field_name}__contains": f"-{month_str}-"})
+
+            # Adaptive check for other separators
+            separator = BS_DATE_FORMAT[2] if len(BS_DATE_FORMAT) > 2 else "-"
+            return qs.filter(
+                **{f"{self.field_name}__contains": f"{separator}{month_str}{separator}"}
+            )
+        return qs
+
+
+class NepaliDateRangeFilter(filters.CharFilter):
+    """
+    A filter for `NepaliDateField` that allows filtering by a range of BS dates.
+    Supports:
+    - "start,end" -> range
+    - "start," -> greater than or equal
+    - ",end" -> less than or equal
+    - "date" -> exact match
+    """
+
+    def filter(self, qs: QuerySet, value: Any) -> QuerySet:
+        if value:
+            parts = [p.strip() for p in str(value).split(",")]
+            if len(parts) == 1:
+                return qs.filter(**{self.field_name: parts[0]})
+            if len(parts) == 2:
+                if parts[0] and parts[1]:
+                    return qs.filter(
+                        **{f"{self.field_name}__range": (parts[0], parts[1])}
+                    )
+                if parts[0]:
+                    return qs.filter(**{f"{self.field_name}__gte": parts[0]})
+                if parts[1]:
+                    return qs.filter(**{f"{self.field_name}__lte": parts[1]})
+        return qs
+
+
+class NepaliCurrencyRangeFilter(filters.CharFilter):
+    """
+    A filter for `NepaliCurrencyField` that allows range filtering.
+    Supports:
+    - "min,max" -> range
+    - "min," -> greater than or equal
+    - ",max" -> less than or equal
+    - "value" -> exact match
+    """
+
+    def filter(self, qs: QuerySet, value: Any) -> QuerySet:
+        if value:
+            parts = [p.strip() for p in str(value).split(",")]
+            if len(parts) == 1:
+                return qs.filter(**{self.field_name: parts[0]})
+            if len(parts) == 2:
+                if parts[0] and parts[1]:
+                    return qs.filter(
+                        **{f"{self.field_name}__range": (parts[0], parts[1])}
+                    )
+                if parts[0]:
+                    return qs.filter(**{f"{self.field_name}__gte": parts[0]})
+                if parts[1]:
+                    return qs.filter(**{f"{self.field_name}__lte": parts[1]})
+        return qs

django_nepkit/forms.py

@@ -6,19 +6,18 @@ from nepali.datetime import nepalidate
 
 from django_nepkit.utils import try_parse_nepali_date
 from django_nepkit.validators import validate_nepali_phone_number
+from django_nepkit.widgets import NepaliDatePickerWidget
 
 
 class NepaliDateFormField(forms.DateField):
-    """
-    A Django Form Field for Nepali Date (Bikram Sambat).
-    """
-
-    from .widgets import NepaliDatePickerWidget
+    """A form field for entering Nepali dates."""
 
     widget = NepaliDatePickerWidget
 
     def __init__(self, *args, **kwargs):
         kwargs.pop("max_length", None)
+        # Clean up arguments not needed for base Field
+        kwargs.pop("empty_value", None)
         super().__init__(*args, **kwargs)
 
     def to_python(self, value):
@@ -34,16 +33,17 @@ class NepaliDateFormField(forms.DateField):
                 return parsed
             raise ValueError("Invalid BS date format")
         except Exception:
+            from django_nepkit.utils import BS_DATE_FORMAT
+
             raise forms.ValidationError(
-                _("Enter a valid Nepali date in YYYY-MM-DD format."),
+                _("Enter a valid Nepali date in %(format)s format.")
+                % {"format": BS_DATE_FORMAT},
                 code="invalid",
             )
 
 
 class NepaliPhoneNumberFormField(forms.CharField):
-    """
-    A Django Form Field for Nepali Phone Numbers.
-    """
+    """A form field for entering Nepali phone numbers."""
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)