nepali 0.5.5__py3-none-any.whl → 1.2.0__py3-none-any.whl

nepali/phone_number.py

@@ -0,0 +1,183 @@
+import re
+from enum import Enum
+
+_mobile_number_re = re.compile(r"^(?:\+977|977)?(?:-)?(?:98|97|96)\d{8}$")
+_landline_number_re = re.compile(
+    r"^(?:\+977|977)?(?:-)?(?:0)?(?:[01][1-9]|2[13-9]|[3-9]\d)\d{6,7}$"
+)
+
+
+class Operator(Enum):
+    NEPAL_TELECOM = "Nepal Telecom"
+    NCELL = "Ncell"
+    SMART_CELL = "Smart Cell"
+    UTL = "UTL"
+    HELLO_MOBILE = "Hello Mobile"
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return f"<Operator: {self.value}>"
+
+
+def is_mobile_number(number: str) -> bool:
+    """
+    Returns True is the input number is mobile number.
+
+    >>> is_mobile = is_mobile_number(number)
+    >>> if is_mobile:
+    >>>     ...
+    """
+    try:
+        return bool(_mobile_number_re.match(number))
+    except Exception:
+        return False
+
+
+def is_landline_number(number: str) -> bool:
+    """
+    Returns True is the input number is mobile number.
+
+    >>> is_mobile = is_mobile_number(number)
+    >>> if is_mobile:
+    >>>     ...
+    """
+    try:
+        return bool(_landline_number_re.match(number))
+    except Exception:
+        return False
+
+
+def is_valid(number: str) -> bool:
+    return is_mobile_number(number) or is_landline_number(number)
+
+
+def get_exact_number(number: str) -> str:
+    # replacing start 977
+    if number.startswith("977"):
+        number = number.replace("977", "")
+    # replacing +977 and all -
+    return number.replace("+977", "").replace("-", "")
+
+
+def parse(number: str):
+    """
+    Parse and returns the details of the phone number: `dict`.
+    The return data may vary between mobile and landline numbers.
+    If the number is invalid it returns `None`.
+
+    If you want to make sure you get a valid response, please use
+    `is_valid`, `is_mobile_number`, and `is_landline_number`.
+
+    :return:
+    {
+        "type": "Mobile" | "Landline",
+        "number": "XXXXXXX",
+        ...
+    }
+    """
+    if not number and type(number) != str:
+        return None
+
+    number = number.replace("-", "")
+
+    # checking if mobile number
+    if is_mobile_number(number):
+        return _parse_mobile_number(number)
+
+    if is_landline_number(number):
+        return _parse_landline_number(number)
+
+    return None
+
+
+def _get_operator(number: str) -> Operator | None:
+    """
+    Returns operator from the number.
+    NOTE: The number should be 10digit mobile number.
+    """
+    starting_number = number[:3]
+
+    # NTC
+    if starting_number in ["984", "985", "986", "974", "975"]:
+        return Operator.NEPAL_TELECOM
+
+    # NCELL
+    if starting_number in ["980", "981", "982"]:
+        return Operator.NCELL
+
+    # Smart Cell
+    if starting_number in ["961", "962", "988"]:
+        return Operator.SMART_CELL
+
+    # UTL
+    if starting_number == "972":
+        return Operator.UTL
+
+    # Hello Mobile
+    if starting_number == "963":
+        return Operator.HELLO_MOBILE
+
+    return None
+
+
+def _parse_mobile_number(number: str):
+    """
+    Parse and returns mobile number details.
+    :return:
+    {
+        "type": "Mobile",
+        "number": "98XXXXXXXX",
+        "operator": <Operator>
+    }
+    """
+    number = get_exact_number(number)
+    operator = _get_operator(number)
+
+    if not operator:
+        return None
+
+    detail = {
+        "type": "Mobile",
+        "number": number,
+        "operator": operator,
+    }
+    return detail
+
+
+def _get_area_code(number) -> str:
+    """
+    Returns area code of the number.
+    NOTE: The number should be landline number without +977/977.
+    """
+    code = number[:3]
+
+    # Kathmandu, Lalitpur, and Bhaktapur => 01
+    if number.startswith("01") and code not in ["010", "011", "019"]:
+        return "01"
+
+    return code
+
+
+def _parse_landline_number(number) -> dict:
+    """
+    Parse and returns mobile number details.
+    :return:
+    {
+        "type": "Landline",
+        "number": "98XXXXXXXX",
+        "operator": <Operator>
+    }
+    """
+    number = get_exact_number(number)
+
+    # adding zero
+    if number[0] != "0":
+        number = f"0{number}"
+
+    return {
+        "type": "Landline",
+        "number": number,
+        "area_code": _get_area_code(number),
+    }

nepali/templatetags/nepalidatetime.py

@@ -1,31 +1,201 @@
+"""
+This module contains django templatetags for nepali date and time.
+"""
+import datetime
+import warnings
+from typing import Optional, Union
+
 from django import template
 from django.utils import timezone
 
-from nepali.datetime import nepalidatetime, nepalihumanize as humanize
-from nepali.utils import to_local, to_utc, to_nepali_datetime
+from nepali.datetime import nepalidate as _nepalidate
+from nepali.datetime import nepalidatetime as _nepalidatetime
+from nepali.datetime import nepalihumanize as humanize
+from nepali.exceptions import InvalidNepaliDateTimeObjectException
+from nepali.utils import to_nepalidatetime
 
+_DEFAULT_DATE_FORMAT = "%B %d, %Y, %A"
+DEPRECIATION_WARNING_MESSAGE = (
+    "The templatetag 'nepalidatetime' has been depreciated "
+    "and will be removed in the future release. "
+    "Please use `django-nepali` package."
+)
+_datetime = Union[datetime.date, datetime.datetime, _nepalidate, _nepalidatetime]
 register = template.Library()
 
-@register.filter(name='nepalidate')
-def nepalidate(datetime_obj, format="%B %d, %Y, %A"):
-	nepali_datetime_obj = to_nepali_datetime(datetime_obj)
-	if nepali_datetime_obj == None: return None
-	return nepali_datetime_obj.strftime(format)
-
-@register.filter(name='nepalidate_en')
-def nepalidate_en(datetime_obj, format="%B %d, %Y, %A"):
-	nepali_datetime_obj = to_nepali_datetime(datetime_obj)
-	if nepali_datetime_obj == None: return None
-	return nepali_datetime_obj.strftime_en(format)
-
-@register.filter(name='nepalihumanize')
-def nepalihumanize(datetime_obj, threshold=None, format=None):
-	""" templatetag to humanize nepalidatetime """
-	nepali_datetime_obj = to_nepali_datetime(datetime_obj)
-	if nepali_datetime_obj == None: return None
-	return humanize(nepali_datetime_obj, threshold=threshold, format=format)
-	
+
+@register.filter(name="nepalidate")
+def nepalidate(
+    datetime_obj: _datetime, format: str = _DEFAULT_DATE_FORMAT
+) -> Union[str, None]:
+    """
+    Renders the datetime object into nepali datetime format in 'en-US' locale (English).
+
+    Usage:
+    ```
+    {{ datetime_obj|nepalidate }}
+    {{ datetime_obj|nepalidate:"%Y-%m-%d" }}
+    ```
+
+    :param datetime_obj: Datetime object
+    :param format: Output format, defaults to "%B %d, %Y, %A"
+    :returns: Nepali datetime format in 'en-US' locale
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    return nepalidate_en(datetime_obj, format=format)
+
+
+@register.filter(name="nepalidate_en")
+def nepalidate_en(
+    datetime_obj: _datetime, format: str = _DEFAULT_DATE_FORMAT
+) -> Union[str, None]:
+    """
+    Renders the datetime object into nepali datetime format in 'en-US' locale (English).
+
+    Usage:
+    ```
+    {{ datetime_obj|nepalidate_en }}
+    {{ datetime_obj|nepalidate_en:"%Y-%m-%d" }}
+    ```
+
+    :param datetime_obj: Datetime object
+    :param format: Output format, defaults to "%B %d, %Y, %A"
+    :returns: Nepali datetime format in 'en-US' locale
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    try:
+        nepali_datetime_obj = to_nepalidatetime(datetime_obj)
+        return nepali_datetime_obj.strftime_en(format)
+    except InvalidNepaliDateTimeObjectException:
+        return None
+
+
+@register.filter(name="nepalidate_ne")
+def nepalidate_ne(
+    datetime_obj: _datetime, format: str = _DEFAULT_DATE_FORMAT
+) -> Union[str, None]:
+    """
+    Renders the datetime object into nepali datetime format in 'ne' locale (Nepali).
+
+    Usage:
+    ```
+    {{ datetime_obj|nepalidate_ne }}
+    {{ datetime_obj|nepalidate_ne:"%Y-%m-%d" }}
+    ```
+
+    :param datetime_obj: Datetime object
+    :param format: Output format, defaults to "%B %d, %Y, %A"
+    :returns: Nepali datetime format in 'ne' locale
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    try:
+        nepali_datetime_obj = to_nepalidatetime(datetime_obj)
+        return nepali_datetime_obj.strftime_ne(format)
+    except InvalidNepaliDateTimeObjectException:
+        return None
+
+
+@register.filter(name="nepalihumanize")
+def nepalihumanize(
+    datetime_obj: _datetime,
+    threshold: Optional[int] = None,
+    format: Optional[str] = None,
+) -> Union[str, None]:
+    """
+    Renders the datetime object to a human readable form for 'ne' locale (Nepali).
+
+    Usage:
+    ```
+    {{ datetime_obj|nepalihumanize }}
+    ```
+
+    :param datetime_obj: Datetime object
+    :param threshold: Threshold in seconds that determines when to render
+        the datetime object in the standard datetime format, optional
+    :param format: Output format if threshold exceeded, optional
+    :returns: Datetime object in human readable form
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    try:
+        nepali_datetime_obj = to_nepalidatetime(datetime_obj)
+        return humanize(nepali_datetime_obj, threshold=threshold, format=format)
+    except InvalidNepaliDateTimeObjectException:
+        return None
+
+
+@register.simple_tag
+def nepalinow(format: str = _DEFAULT_DATE_FORMAT) -> str:
+    """
+    Renders the current nepali datetime in 'en-US' locale (English).
+
+    Usage:
+    ```
+    {% nepalinow %}
+    {% nepalinow '%Y-%m-%d' %}
+    ```
+
+    :param datetime_obj: Datetime object
+    :param format: Output format, defaults to "%B %d, %Y, %A"
+    :returns: Current nepali datetime
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    return nepalinow_en(format)
+
+
 @register.simple_tag
-def nepalinow(format="%B %d, %Y, %A"):
-	""" templatetag to display current datetime in nepali format """
-	return to_nepali_datetime(timezone.now()).strftime(format)
+def nepalinow_en(format: str = _DEFAULT_DATE_FORMAT) -> str:
+    """
+    Renders the current nepali datetime in 'en-US' locale (English).
+
+    Usage:
+    ```
+    {% nepalinow_en %}
+    {% nepalinow_en '%Y-%m-%d' %}
+    ```
+
+    :param datetime_obj: Datetime object
+    :param format: Output format, defaults to "%B %d, %Y, %A"
+    :returns: Current nepali datetime
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    return to_nepalidatetime(timezone.now()).strftime(format)
+
+
+@register.simple_tag
+def nepalinow_ne(format: str = _DEFAULT_DATE_FORMAT) -> str:
+    """
+    Renders the current nepali datetime in 'ne' locale (Nepali).
+
+    Usage:
+    ```
+    {% nepalinow_ne %}
+    {% nepalinow_ne '%Y-%m-%d' %}
+    ```
+
+    :param datetime_obj: Datetime object
+    :param format: Output format, defaults to "%B %d, %Y, %A"
+    :returns: Current nepali datetime
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    return to_nepalidatetime(timezone.now()).strftime_ne(format)

nepali/templatetags/nepalinumber.py

@@ -1,13 +1,103 @@
+"""
+This module contains django templatetags for nepali number.
+"""
+import warnings
+from typing import Any
+
 from django import template
 
-from nepali.number import NepaliNumber
+from nepali.number import (
+    add_comma,
+    add_comma_english,
+    convert_and_add_comma,
+    english_to_nepali,
+)
 
 register = template.Library()
 
-@register.filter(name='nepalinumber')
-def nepalinumber(value):
-	return NepaliNumber.convert(value)
+DEPRECIATION_WARNING_MESSAGE = (
+    "The templatetag 'nepalinumber' has been depreciated "
+    "and will be removed in the future release. "
+    "Please use `django-nepali` package."
+)
+
+
+@register.filter(name="nepalinumber")
+def nepalinumber(value: Any) -> str:
+    """
+    Converts the number into nepali number and renders it.
+
+    Usage:
+    ```
+    {{ number|nepalinumber }}
+    ```
+
+    :param value: Number to be converted
+    :returns: Nepali output of given number
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    return english_to_nepali(value)
+
+
+@register.filter(name="nepalinumber_with_comma")
+def nepalinumber_with_comma(value: Any) -> str:
+    """
+    Converts the number into nepali number and renders it.
+
+    Usage:
+    ```
+    {{ number|nepalinumber_with_comma }}
+    ```
+    Basically same as `{{ number|nepalinumber|nepali_comma }}`
+
+    :param value: Number to be converted and commas added
+    :returns: Nepali output of given number with commas
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    return convert_and_add_comma(value)
+
+
+@register.filter(name="nepali_comma")
+def nepali_comma(value: Any) -> str:
+    """
+    Renders the given value with commas added in Nepali style without converting the number.
+
+    Usage:
+    ```
+    {{ number|nepali_comma }}
+    ```
+
+    :param value: Number to be added with commas
+    :returns: Output of given number with commas
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    return add_comma(value)
+
+
+@register.filter(name="english_comma")
+def english_comma(value: Any) -> str:
+    """
+    Renders the given value with commas added in English style without converting the number.
+
+    Usage:
+    ```
+    {{ number|english_comma }}
+    ```
 
-@register.filter(name='nepalinumber_with_comma')
-def nepalinumber_with_comma(value):
-	return NepaliNumber.convert_and_add_comma(value)
+    :param value: Number to be added with commas
+    :returns: Output of given number with commas
+    """
+    warnings.warn(
+        message=DEPRECIATION_WARNING_MESSAGE,
+        category=DeprecationWarning,
+    )
+    return add_comma_english(value)

nepali/tests/test_date_converter.py

@@ -0,0 +1,148 @@
+"""
+To run only this unit test use the command below.
+
+    python -m unittest nepali/tests/test_date_converter.py -v
+"""
+import unittest
+
+from nepali.date_converter import converter
+
+
+class TestNepaliDateConverter(unittest.TestCase):
+    """tests for date_converter.converter module"""
+    # test date range
+    def test_english_date_range(self):
+        self.assertEqual(converter.en_min_year(), 1944)
+        self.assertEqual(converter.en_max_year(), 2042)
+
+    def test_nepali_date_range(self):
+        self.assertEqual(converter.np_min_year(), 2000)
+        self.assertEqual(converter.np_max_year(), 2099)
+
+    # english_to_nepali
+    def test_converter_english_to_nepali_raise_exception_on_max_year_range(self):
+        with self.assertRaises(Exception):
+            converter.english_to_nepali(2060, 1, 4)
+
+    def test_converter_english_to_nepali_raise_exception_on_min_year_range(self):
+        with self.assertRaises(Exception):
+            converter.english_to_nepali(1920, 1, 4)
+
+    def test_converter_english_to_nepali_raise_exception_on_min_month_range(self):
+        with self.assertRaises(Exception):
+            converter.english_to_nepali(2023, 0, 4)
+
+    def test_converter_english_to_nepali_raise_exception_on_max_month_range(self):
+        with self.assertRaises(Exception):
+            converter.english_to_nepali(2023, 13, 4)
+
+    def test_converter_english_to_nepali_raise_exception_on_min_day_range(self):
+        with self.assertRaises(Exception):
+            converter.english_to_nepali(2023, 1, 0)
+
+    def test_converter_english_to_nepali_raise_exception_on_max_day_range(self):
+        with self.assertRaises(Exception):
+            converter.english_to_nepali(2023, 1, 40)
+
+    def test_converter_english_to_nepali_returns_valid_past_nepali_date(self):
+        y, m, d = converter.english_to_nepali(1994, 8, 13)
+        self.assertEqual(y, 2051)
+        self.assertEqual(m, 4)
+        self.assertEqual(d, 29)
+
+    def test_converter_english_to_nepali_returns_valid_past_nepali_date2(self):
+        y, m, d = converter.english_to_nepali(1944, 5, 28)
+        self.assertEqual(y, 2001)
+        self.assertEqual(m, 2)
+        self.assertEqual(d, 15)
+
+    def test_converter_english_to_nepali_returns_valid_recent_nepali_date(self):
+        y, m, d = converter.english_to_nepali(2023, 1, 28)
+        self.assertEqual(y, 2079)
+        self.assertEqual(m, 10)
+        self.assertEqual(d, 14)
+
+    def test_converter_english_to_nepali_returns_valid_future_nepali_date(self):
+        y, m, d = converter.english_to_nepali(2030, 11, 26)
+        self.assertEqual(y, 2087)
+        self.assertEqual(m, 8)
+        self.assertEqual(d, 10)
+
+    def test_converter_english_to_nepali_for_min_edge_date(self):
+        y, m, d = converter.english_to_nepali(1944, 1, 1)
+        self.assertEqual(y, 2000)
+        self.assertEqual(m, 9)
+        self.assertEqual(d, 17)
+
+    def test_converter_english_to_nepali_for_max_edge_date(self):
+        y, m, d = converter.english_to_nepali(2042, 12, 31)
+        self.assertEqual(y, 2099)
+        self.assertEqual(m, 9)
+        self.assertEqual(d, 16)
+
+    # nepali_to_english
+    def test_converter_nepali_to_englishReturnErrorOnMaxYearRange(self):
+        with self.assertRaises(Exception):
+            converter.nepali_to_english(3000, 1, 4)
+
+    def test_converter_nepali_to_english_raise_exception_on_min_year_range(self):
+        with self.assertRaises(Exception):
+            converter.nepali_to_english(1920, 1, 4)
+
+    def test_converter_nepali_to_english_raise_exception_on_min_month_range(self):
+        with self.assertRaises(Exception):
+            converter.nepali_to_english(2079, 0, 4)
+
+    def test_converter_nepali_to_english_raise_exception_on_max_month_range(self):
+        with self.assertRaises(Exception):
+            converter.nepali_to_english(2079, 13, 4)
+
+    def test_converter_nepali_to_english_raise_exception_on_min_day_range(self):
+        with self.assertRaises(Exception):
+            converter.nepali_to_english(2079, 1, 0)
+
+    def test_converter_nepali_to_english_raise_exception_on_max_day_range(self):
+        with self.assertRaises(Exception):
+            converter.nepali_to_english(2079, 1, 40)
+
+    def test_converter_nepali_to_english_returns_valid_past_english_date(self):
+        y, m, d = converter.nepali_to_english(2051, 4, 29)
+        self.assertEqual(y, 1994)
+        self.assertEqual(m, 8)
+        self.assertEqual(d, 13)
+
+    def test_converter_nepali_to_english_returns_valid_past_english_date2(self):
+        y, m, d = converter.nepali_to_english(2001, 2, 15)
+        self.assertEqual(y, 1944)
+        self.assertEqual(m, 5)
+        self.assertEqual(d, 28)
+
+    def test_converter_nepali_to_english_returns_valid_recent_english_date(self):
+        y, m, d = converter.nepali_to_english(2079, 10, 14)
+        self.assertEqual(y, 2023)
+        self.assertEqual(m, 1)
+        self.assertEqual(d, 28)
+
+    def test_converter_nepali_to_english_returns_valid_future_english_date(self):
+        y, m, d = converter.nepali_to_english(2087, 8, 10)
+        self.assertEqual(y, 2030)
+        self.assertEqual(m, 11)
+        self.assertEqual(d, 26)
+
+    def test_converter_nepali_to_english_returns_valid_english_leap_year_date(self):
+        y, m, d = converter.nepali_to_english(2080, 12, 15)
+        self.assertEqual(y, 2024)
+        self.assertEqual(m, 3)
+        self.assertEqual(d, 28)
+
+    def test_converter_nepali_to_english_for_min_edge_date(self):
+        y, m, d = converter.nepali_to_english(2000, 1, 1)
+        self.assertEqual(y, 1943)
+        self.assertEqual(m, 4)
+        self.assertEqual(d, 14)
+
+    def test_converter_nepali_to_english_for_max_edge_date(self):
+        y, m, d = converter.nepali_to_english(2099, 12, 30)
+        self.assertEqual(y, 2043)
+        self.assertEqual(m, 4)
+        self.assertEqual(d, 13)