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

django_nepkit/static/django_nepkit/js/nepali-datepicker-init.js

@@ -45,64 +45,73 @@
         if (!inputs || !inputs.length) return;
 
         inputs.forEach(function (el) {
+            var format = el.dataset.format || 'YYYY-MM-DD';
+            // Convert strftime format to datepicker format
+            format = format.replace(/%Y/g, 'YYYY').replace(/%m/g, 'MM').replace(/%d/g, 'DD');
+
+            var options = {
+                dateFormat: format,
+                closeOnDateSelect: true
+            };
+
+            // Determine language based on data attributes
+            var useNepali = el.dataset.ne === 'true';
+            var useEnglish = el.dataset.en === 'true';
+
+            if (useNepali) {
+                // Devanagari digits and Nepali month/day names
+                options.unicodeDate = true;
+            } else if (useEnglish || (!useNepali && !el.dataset.ne)) {
+                // English month/day names and digits
+                options.language = 'english';
+            }
+
             // Nepali Datepicker v5 exposes `element.NepaliDatePicker(options)`
             if (typeof el.NepaliDatePicker === 'function') {
-                el.NepaliDatePicker({
-                    dateFormat: 'YYYY-MM-DD'
-                });
+                el.NepaliDatePicker(options);
+                el.classList.add('nepali-datepicker-initialized');
+            }
+            // Fallback for jQuery plugin (v2.0.2)
+            else if (typeof window.jQuery !== 'undefined' && typeof window.jQuery(el).nepaliDatePicker === 'function') {
+                window.jQuery(el).nepaliDatePicker(options);
                 el.classList.add('nepali-datepicker-initialized');
+            }
 
-                // Ensure theme is applied when the picker is actually shown.
-                // (The plugin often creates/inserts DOM on focus.)
-                var applySoon = function () {
-                    // Run twice: once immediately, once after paint.
-                    applyThemeToDatepickerContainers();
-                    window.setTimeout(applyThemeToDatepickerContainers, 0);
-                };
+            // Ensure theme is applied when the picker is actually shown.
+            // (The plugin often creates/inserts DOM on focus.)
+            var applySoon = function () {
+                // Run twice: once immediately, once after paint.
+                applyThemeToDatepickerContainers();
+                window.setTimeout(applyThemeToDatepickerContainers, 0);
+            };
 
-                el.addEventListener('focus', applySoon);
-                el.addEventListener('click', applySoon);
-            }
+            el.addEventListener('focus', applySoon);
+            el.addEventListener('click', applySoon);
         });
     }
 
-    // Initialize on page load
-    if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', initNepaliDatePickers);
-    } else {
-        initNepaliDatePickers();
-    }
-
-    // Keep in sync if system theme changes (fallback path)
-    if (window.matchMedia) {
-        try {
-            var mql = window.matchMedia('(prefers-color-scheme: dark)');
-            if (mql && typeof mql.addEventListener === 'function') {
-                mql.addEventListener('change', applyThemeToDatepickerContainers);
-            } else if (mql && typeof mql.addListener === 'function') {
-                mql.addListener(applyThemeToDatepickerContainers);
-            }
-        } catch (e) {
-            // ignore
+    // Also listen for DOM changes (admin popups/other dynamic content)
+    function initObserver() {
+        if (typeof MutationObserver !== 'undefined' && document.body) {
+            var observer = new MutationObserver(function () {
+                initNepaliDatePickers();
+                applyThemeToDatepickerContainers();
+            });
+            observer.observe(document.body, {
+                childList: true,
+                subtree: true
+            });
         }
     }
 
-    // Re-initialize when Django admin adds inlines dynamically
-    if (typeof django !== 'undefined' && django.jQuery) {
-        django.jQuery(document).on('formset:added', function () {
-            initNepaliDatePickers();
-        });
-    }
-
-    // Also listen for DOM changes (admin popups/other dynamic content)
-    if (typeof MutationObserver !== 'undefined') {
-        var observer = new MutationObserver(function () {
+    // Initialize on page load
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', function() {
             initNepaliDatePickers();
-            applyThemeToDatepickerContainers();
-        });
-        observer.observe(document.body, {
-            childList: true,
-            subtree: true
+            initObserver();
         });
+    } else {
+        initNepaliDatePickers();
+        initObserver();
     }
 })();

django_nepkit/utils.py

@@ -3,75 +3,299 @@ from __future__ import annotations
 from typing import Any, Optional
 
 from nepali.datetime import nepalidate, nepalidatetime
+from nepali.locations import districts, municipalities, provinces
 
+from django_nepkit.conf import nepkit_settings
 
-BS_DATE_FORMAT = "%Y-%m-%d"
-BS_DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+BS_DATE_FORMAT = nepkit_settings.BS_DATE_FORMAT
+BS_DATETIME_FORMAT = nepkit_settings.BS_DATETIME_FORMAT
 
 
-def try_parse_nepali_date(value: Any) -> Optional[nepalidate]:
-    """
-    Best-effort conversion to `nepalidate`.
-
-    - Returns `None` for empty values.
-    - Returns `nepalidate` for valid inputs.
-    - Returns `None` if the value cannot be parsed.
-
-    Callers decide whether to raise, fallback, etc.
-    """
+def _try_parse_nepali(value: Any, cls: Any, fallback_fmt: str) -> Any:
+    """Helper to turn a string into a Nepali date object."""
     if value in (None, ""):
         return None
-    if isinstance(value, nepalidate):
+    if isinstance(value, cls):
         return value
     if isinstance(value, str):
-        try:
-            return nepalidate.strptime(value.strip(), BS_DATE_FORMAT)
-        except Exception:
-            return None
+        formats = nepkit_settings.DATE_INPUT_FORMATS
+        if fallback_fmt not in formats:
+            formats = list(formats) + [fallback_fmt]
+
+        for fmt in formats:
+            try:
+                return cls.strptime(value.strip(), fmt)
+            except Exception:
+                continue
     return None
 
 
+def try_parse_nepali_date(value: Any) -> Optional[nepalidate]:
+    """Convert any value to a Nepali Date."""
+    return _try_parse_nepali(value, nepalidate, BS_DATE_FORMAT)
+
+
 def try_parse_nepali_datetime(value: Any) -> Optional[nepalidatetime]:
+    """Convert any value to a Nepali Date and Time."""
+    return _try_parse_nepali(value, nepalidatetime, BS_DATETIME_FORMAT)
+
+
+def _get_location_children(parent_list, parent_name, child_attr, ne=False):
+    """Find children (like districts) of a parent (like a province)."""
+    selected_parent = None
+    for p in parent_list:
+        p_name = p.name
+        p_name_ne = getattr(p, "name_nepali", None)
+
+        if p_name == parent_name or p_name_ne == parent_name:
+            selected_parent = p
+            break
+
+    if not selected_parent:
+        return []
+
+    children = getattr(selected_parent, child_attr, [])
+
+    if ne:
+        return [
+            {
+                "id": getattr(child, "name_nepali", child.name),
+                "text": getattr(child, "name_nepali", child.name),
+            }
+            for child in children
+        ]
+    else:
+        return [{"id": child.name, "text": child.name} for child in children]
+
+
+def get_districts_by_province(province_name, ne=False, en=True):
+    """Get all districts for a province."""
+    # Logic note: if ne=True is passed, we shouldn't care about en=True (handled by caller typically)
+    return _get_location_children(provinces, province_name, "districts", ne=ne)
+
+
+def get_municipalities_by_district(district_name, ne=False, en=True):
+    """Get all municipalities for a district."""
+    return _get_location_children(districts, district_name, "municipalities", ne=ne)
+
+
+def format_nepali_currency(
+    number: Any, currency_symbol: str = "Rs.", ne: bool = False
+) -> str:
     """
-    Best-effort conversion to `nepalidatetime`.
+    Formats a number with Nepali-style commas and optional currency symbol.
+    Eg. 1234567 -> Rs. 12,34,567
+    """
+    from nepali.number import add_comma, english_to_nepali
+
+    if number is None:
+        return ""
+
+    try:
+        # Convert to string and split by decimal point
+        num_str = f"{float(number):.2f}"
+        if "." in num_str:
+            integer_part, decimal_part = num_str.split(".")
+        else:
+            integer_part, decimal_part = num_str, ""
+
+        # Format integer part with commas
+        formatted_integer = add_comma(int(integer_part))
+
+        # Join back
+        res = formatted_integer
+        if decimal_part:
+            res = f"{res}.{decimal_part}"
+
+        if ne:
+            res = english_to_nepali(res)
+
+        if currency_symbol:
+            return f"{currency_symbol} {res}"
+        return res
+    except Exception:
+        return str(number)
 
-    - Returns `None` for empty values.
-    - Returns `nepalidatetime` for valid inputs.
-    - Returns `None` if the value cannot be parsed.
 
-    Callers decide whether to raise, fallback, etc.
+def number_to_nepali_words(number: Any) -> str:
     """
-    if value in (None, ""):
-        return None
-    if isinstance(value, nepalidatetime):
-        return value
-    if isinstance(value, str):
-        try:
-            return nepalidatetime.strptime(value.strip(), BS_DATETIME_FORMAT)
-        except Exception:
-            return None
-    return None
+    Converts a number to Nepali words.
+    Eg. 123 -> एक सय तेईस
+    """
+    from django_nepkit.constants import NEPALI_ONES, NEPALI_UNITS
+
+    if number is None:
+        return ""
+
+    try:
+        num = int(float(number))
+    except (ValueError, TypeError):
+        return str(number)
+
+    if num == 0:
+        return "शून्य"
 
+    def _convert(n):
+        if n == 0:
+            return ""
+        if n < 100:
+            return NEPALI_ONES[n]
 
-def get_districts_by_province(province_name):
+        for i in range(len(NEPALI_UNITS) - 1, 0, -1):
+            div, unit_name = NEPALI_UNITS[i]
+            if n >= div:
+                prefix_val = n // div
+                remainder = n % div
+
+                # For 'सय' (100), we use NEPALI_ONES[prefix_val]
+                # For others, we might need recursive calls if prefix_val >= 100
+                prefix_words = _convert(prefix_val)
+                res = f"{prefix_words} {unit_name}"
+                if remainder > 0:
+                    res += f" {_convert(remainder)}"
+                return res.strip()
+        return ""
+
+    return _convert(num)
+
+
+def english_to_nepali_unicode(text: Any) -> str:
     """
-    Returns a list of districts in the given province.
+    Converts English text/numbers to Nepali Unicode.
+    Currently focuses on numbers.
     """
-    from nepali.locations import provinces
+    from nepali.number import english_to_nepali
 
-    selected_province = next((p for p in provinces if p.name == province_name), None)
-    if not selected_province:
-        return []
-    return [{"id": d.name, "text": d.name} for d in selected_province.districts]
+    if text is None:
+        return ""
 
+    return english_to_nepali(text)
 
-def get_municipalities_by_district(district_name):
+
+def _normalize_nepali_text(text):
     """
-    Returns a list of municipalities in the given district.
+    Normalize Nepali text for easier matching.
+    Replaces Chandrabindu with Anusvara.
     """
-    from nepali.locations import districts
+    if not text:
+        return text
+    return text.replace("ँ", "ं").replace("ाँ", "ां")
 
-    selected_district = next((d for d in districts if d.name == district_name), None)
-    if not selected_district:
-        return []
-    return [{"id": m.name, "text": m.name} for m in selected_district.municipalities]
+
+def _matches_location_name(name_eng, name_nep, token, normalized_token):
+    """
+    Check if a token matches a location name (English or Nepali).
+
+    Args:
+        name_eng: English name of location
+        name_nep: Nepali name of location
+        token: Original token to match
+        normalized_token: Normalized version of token
+
+    Returns:
+        True if token matches the location name
+    """
+    token_lower = token.lower()
+    name_nep_norm = _normalize_nepali_text(name_nep)
+
+    # Exact matches
+    if (
+        token == name_nep
+        or normalized_token == name_nep_norm
+        or token_lower == name_eng.lower()
+    ):
+        return True
+
+    # Partial matches for English (e.g., "Pokhara" in "Pokhara Metropolitan City")
+    # Only if token is at least 4 characters to avoid too many false positives
+    if len(token) >= 4:
+        if token_lower in name_eng.lower():
+            return True
+
+    # Partial matches for Nepali
+    if len(normalized_token) >= 2:
+        if normalized_token in name_nep_norm:
+            return True
+
+    return False
+
+
+def _find_location_in_tokens(location_list, tokens, normalized_tokens):
+    """
+    Find a location from a list by matching against tokens.
+
+    Args:
+        location_list: List of location objects to search
+        tokens: List of original tokens
+        normalized_tokens: List of normalized tokens
+
+    Returns:
+        Matching location object or None
+    """
+    for i, token in enumerate(tokens):
+        nt = normalized_tokens[i]
+        for location in location_list:
+            if _matches_location_name(location.name, location.name_nepali, token, nt):
+                return location
+    return None
+
+
+def _is_nepali_text(tokens):
+    """Check if any token contains Devanagari characters."""
+    import re
+
+    return any(re.search(r"[\u0900-\u097F]", t) for t in tokens)
+
+
+def normalize_address(address_string: str) -> dict[str, Optional[str]]:
+    """
+    Attempts to normalize a Nepali address string into Province, District, and Municipality.
+    Returns a dictionary with 'province', 'district', and 'municipality'.
+    """
+    if not address_string:
+        return {"province": None, "district": None, "municipality": None}
+
+    result: dict[str, Optional[str]] = {
+        "province": None,
+        "district": None,
+        "municipality": None,
+    }
+
+    # Prepare tokens
+    content = address_string.replace(",", " ").replace("-", " ")
+    tokens = [t.strip() for t in content.split() if t.strip()]
+    normalized_tokens = [_normalize_nepali_text(t) for t in tokens]
+
+    # Find locations - most specific to least specific
+    found_municipality = _find_location_in_tokens(
+        municipalities, tokens, normalized_tokens
+    )
+    found_district = _find_location_in_tokens(districts, tokens, normalized_tokens)
+    found_province = _find_location_in_tokens(provinces, tokens, normalized_tokens)
+
+    # Fill in the gaps using hierarchy
+    if found_municipality:
+        result["municipality"] = found_municipality.name
+        if not found_district:
+            found_district = found_municipality.district
+        if not found_province:
+            found_province = found_municipality.province
+
+    if found_district:
+        result["district"] = found_district.name
+        if not found_province:
+            found_province = found_district.province
+
+    if found_province:
+        result["province"] = found_province.name
+
+    # Use Nepali names if input contains Nepali text
+    if _is_nepali_text(tokens):
+        if found_municipality:
+            result["municipality"] = found_municipality.name_nepali
+        if found_district:
+            result["district"] = found_district.name_nepali
+        if found_province:
+            result["province"] = found_province.name_nepali
+
+    return result

django_nepkit/validators.py

@@ -3,7 +3,7 @@ from django.utils.translation import gettext_lazy as _
 from nepali import phone_number
 
 
-# validates the given value is a valid nepali phone number
+# Check if a phone number is valid in Nepal
 def validate_nepali_phone_number(value):
     if not phone_number.is_valid(value):
         raise ValidationError(

django_nepkit/views.py

@@ -1,22 +1,139 @@
-from django.http import JsonResponse
+from django.http import JsonResponse, HttpResponse
 
 from django_nepkit.utils import (
     get_districts_by_province,
     get_municipalities_by_district,
 )
 
+from django_nepkit.conf import nepkit_settings
 
-def district_list_view(request):
-    province = request.GET.get("province")
-    if not province:
+
+def _render_options(data, placeholder):
+    """Internal helper to render list of options as HTML."""
+    options = [f'<option value="">{placeholder}</option>']
+    for item in data:
+        options.append(f'<option value="{item["id"]}">{item["text"]}</option>')
+    return HttpResponse("\n".join(options), content_type="text/html")
+
+
+def _get_primary_param(request, param_name, exclude_params=None):
+    """
+    Extract a parameter from request.GET with fallback logic.
+
+    Args:
+        request: Django request object
+        param_name: Primary parameter name to look for
+        exclude_params: List of parameter names to exclude from fallback
+
+    Returns:
+        Parameter value or None
+    """
+    from django_nepkit.constants import INTERNAL_PARAMS
+
+    if exclude_params is None:
+        exclude_params = INTERNAL_PARAMS
+
+    # Try primary parameter first
+    value = request.GET.get(param_name)
+
+    # Fallback: take the first non-internal parameter
+    if not value:
+        for key, val in request.GET.items():
+            if key not in exclude_params and val:
+                value = val
+                break
+
+    return value
+
+
+def _parse_language_params(request):
+    """
+    Parse language parameters from request.
+
+    Args:
+        request: Django request object
+
+    Returns:
+        Tuple of (ne, en) boolean values
+    """
+    default_lang = nepkit_settings.DEFAULT_LANGUAGE
+    ne_param = request.GET.get("ne")
+    ne = ne_param.lower() == "true" if ne_param else default_lang == "ne"
+
+    en_param = request.GET.get("en")
+    en = en_param.lower() == "true" if en_param else not ne
+
+    return ne, en
+
+
+def _should_return_html(request):
+    """
+    Check if response should be HTML format.
+
+    Args:
+        request: Django request object
+
+    Returns:
+        Boolean indicating if HTML format is requested
+    """
+    return (
+        request.GET.get("html", "false").lower() == "true"
+        or request.headers.get("HX-Request") == "true"
+    )
+
+
+def _location_list_view(request, param_name, data_func, placeholders):
+    """
+    Generic view handler for location hierarchy endpoints.
+
+    Args:
+        request: Django request object
+        param_name: Name of the primary parameter to extract
+        data_func: Function to call to get location data
+        placeholders: Tuple of (nepali_placeholder, english_placeholder)
+
+    Returns:
+        JsonResponse or HttpResponse with location data
+    """
+    param_value = _get_primary_param(request, param_name)
+
+    if not param_value:
         return JsonResponse([], safe=False)
-    data = get_districts_by_province(province)
+
+    ne, en = _parse_language_params(request)
+    as_html = _should_return_html(request)
+
+    data = data_func(param_value, ne=ne, en=en)
+
+    if as_html:
+        placeholder = placeholders[0] if ne else placeholders[1]
+        return _render_options(data, placeholder)
+
     return JsonResponse(data, safe=False)
 
 
+def district_list_view(request):
+    """Return list of districts for a given province."""
+    from django_nepkit.constants import PLACEHOLDERS
+
+    return _location_list_view(
+        request,
+        param_name="province",
+        data_func=get_districts_by_province,
+        placeholders=(PLACEHOLDERS["district"]["ne"], PLACEHOLDERS["district"]["en"]),
+    )
+
+
 def municipality_list_view(request):
-    district = request.GET.get("district")
-    if not district:
-        return JsonResponse([], safe=False)
-    data = get_municipalities_by_district(district)
-    return JsonResponse(data, safe=False)
+    """Return list of municipalities for a given district."""
+    from django_nepkit.constants import PLACEHOLDERS
+
+    return _location_list_view(
+        request,
+        param_name="district",
+        data_func=get_municipalities_by_district,
+        placeholders=(
+            PLACEHOLDERS["municipality"]["ne"],
+            PLACEHOLDERS["municipality"]["en"],
+        ),
+    )