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

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)

django_nepkit/lang_utils.py

@@ -0,0 +1,52 @@
+"""
+Language parameter utilities for django-nepkit.
+Helper functions to resolve Nepali/English language parameters consistently.
+"""
+
+from django_nepkit.conf import nepkit_settings
+
+
+def resolve_language_params(ne=None, en=None, **kwargs):
+    """
+    Resolve language parameters with fallback to default settings.
+    """
+    default_lang = nepkit_settings.DEFAULT_LANGUAGE
+
+    # Extract from kwargs if provided
+    if ne is None and "ne" in kwargs:
+        ne = kwargs.get("ne")
+    if en is None and "en" in kwargs:
+        en = kwargs.get("en")
+
+    # Set defaults
+    if ne is None:
+        ne = default_lang == "ne"
+
+    # Handle en parameter logic
+    explicit_en = en is not None
+    if en is None:
+        en = not ne
+
+    # If ne is True and en wasn't explicitly set, en should be False
+    if ne and not explicit_en:
+        en = False
+
+    return ne, en
+
+
+def pop_language_params(kwargs):
+    """
+    Pop ne/en parameters from kwargs dict and return resolved values.
+    """
+    default_lang = nepkit_settings.DEFAULT_LANGUAGE
+    ne = kwargs.pop("ne", default_lang == "ne")
+
+    explicit_en = "en" in kwargs
+    en_value = kwargs.pop("en", not ne)
+
+    if ne and not explicit_en:
+        en = False
+    else:
+        en = en_value
+
+    return ne, en

django_nepkit/models.py

@@ -1,8 +1,11 @@
 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.utils import (
     BS_DATE_FORMAT,
@@ -11,6 +14,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 +62,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 +156,91 @@ 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):
+        # Import here to avoid circular dependency
+        from django_nepkit.forms import NepaliDateFormField
 
-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.
-    """
+        kwargs.setdefault("form_class", NepaliDateFormField)
+        return super().formfield(**kwargs)
 
-    description = _("Nepali DateTime (Bikram Sambat)")
 
-    def __init__(self, *args, **kwargs):
-        self.auto_now = kwargs.pop("auto_now", False)
-        self.auto_now_add = kwargs.pop("auto_now_add", False)
+class NepaliTimeField(NepaliFieldMixin, models.TimeField):
+    description = _("Nepali Time")
 
-        # Match Django's DateTimeField behavior
-        if self.auto_now or self.auto_now_add:
-            kwargs.setdefault("editable", False)
-            kwargs.setdefault("blank", True)
 
-        kwargs.setdefault("max_length", 19)  # YYYY-MM-DD HH:MM:SS
-        super().__init__(*args, **kwargs)
+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)
 
-    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):
+        return getattr(item, "name_nepali", item.name) if ne else item.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)