nepali 1.0.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

nepali/{datetime/constants.py → constants.py}

@@ -1,4 +1,12 @@
-MONTHS_EN = (
+"""
+This files contains constants for the py-Nepali project.
+"""
+
+# Nepali timezone
+NEPAL_TIMEZONE = "Asia/Kathmandu"
+
+# Nepali months in english
+NEPALI_MONTHS_EN = (
     "Baishakh",
     "Jestha",
     "Ashad",
@@ -13,7 +21,8 @@ MONTHS_EN = (
     "Chaitra",
 )
 
-MONTHS_NE = (
+# Nepali months in Nepali (devanagari)
+NEPALI_MONTHS_NE = (
     "बैशाख",
     "जेठ",
     "असार",
@@ -28,6 +37,7 @@ MONTHS_NE = (
     "चैत",
 )
 
+# Week names in english
 WEEKS_EN = (
     "Sunday",
     "Monday",
@@ -38,8 +48,10 @@ WEEKS_EN = (
     "Saturday",
 )
 
+# Week abbreviation name in english
 WEEKS_ABBR_EN = ("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat")
 
+# Weeks names in Nepali (devanagari)
 WEEKS_NE = (
     "आइतबार",
     "सोमबार",
@@ -50,4 +62,5 @@ WEEKS_NE = (
     "शनिबार",
 )
 
+# Week abbreviation name in Nepali (devanagari)
 WEEKS_ABBR_NE = ("आइत", "सोम", "मंगल", "बुध", "बिही", "शुक्र", "शनि")

nepali/datetime/__init__.py

@@ -1,4 +1,4 @@
-from ._datetime import nepalidate, nepalitime, nepalidatetime
+from ._datetime import nepalidate, nepalidatetime, nepalitime
 from ._formatter import NepaliDateTimeFormatter
 from ._humanize import HumanizeDateTime, nepalihumanize
 from ._nepalimonth import nepalimonth

nepali/datetime/_datetime.py

@@ -1,7 +1,7 @@
 import datetime as pythonDateTime
 
 from nepali.date_converter import converter as nepali_date_converter
-from nepali.timezone import NepaliTimeZone, utc_now, to_nepali_timezone
+from nepali.timezone import NepaliTimeZone, to_nepali_timezone, utc_now
 
 from ._nepalimonth import nepalimonth
 
@@ -17,31 +17,31 @@ class formatter_class_mixin:
 
     @classmethod
     def init_formatter_class(cls):
-        if not hasattr(cls, "__formatter_class__Cache"):
+        if not hasattr(cls, "_formatter_class_cache"):
             from ._formatter import NepaliDateTimeFormatter
 
-            cls.__formatter_class__Cache = NepaliDateTimeFormatter
-        return cls.__formatter_class__Cache
+            cls._formatter_class_cache = NepaliDateTimeFormatter
+        return cls._formatter_class_cache
 
     @classmethod
     def get_strptime_method(cls):
-        if not hasattr(cls, "_strptime_method_CACHE"):
+        if not hasattr(cls, "_strptime_method_cache"):
             from .parser import strptime
 
-            cls._strptime_method_CACHE = strptime
-        return cls._strptime_method_CACHE
+            cls._strptime_method_cache = strptime
+        return cls._strptime_method_cache
 
     def strftime(self, format: str) -> str:
         return self.strftime_en(format)
 
     def strftime_en(self, format: str) -> str:
-        NepaliDateTimeFormatter = self.get_formatter_class()
-        formatter = NepaliDateTimeFormatter(self, devanagari=False)
+        nepali_datetime_formatter = self.get_formatter_class()
+        formatter = nepali_datetime_formatter(self, devanagari=False)
         return formatter.get_str(format)
 
     def strftime_ne(self, format: str) -> str:
-        NepaliDateTimeFormatter = self.get_formatter_class()
-        formatter = NepaliDateTimeFormatter(self, devanagari=True)
+        nepali_datetime_formatter = self.get_formatter_class()
+        formatter = nepali_datetime_formatter(self, devanagari=True)
         return formatter.get_str(format)
 
 
@@ -194,12 +194,11 @@ class nepalidate(formatter_class_mixin):
 
     @staticmethod
     def from_date(date_object):
-        npDate = nepalidate(
+        return nepalidate(
             *nepali_date_converter.english_to_nepali(
                 date_object.year, date_object.month, date_object.day
             )
         )
-        return npDate
 
     @staticmethod
     def from_nepalidatetime(datetime_object):

nepali/datetime/_formatter.py

@@ -1,4 +1,5 @@
 import datetime as pythonDateTime
+
 from nepali import number
 from nepali.exceptions import (
     InvalidDateFormatException,
@@ -40,7 +41,7 @@ class NepaliDateTimeFormatter:
     }
 
     def __init__(self, datetime_object, devanagari=False):
-        # TODO: Change variable npDateTime into snakecase: `np_date_time`
+        # TODO: Change variable npDateTime into snake case: `np_date_time`
         if type(datetime_object) == nepalidatetime:
             self.npDateTime = datetime_object
         elif type(datetime_object) == nepalidate:
@@ -100,7 +101,7 @@ class NepaliDateTimeFormatter:
 
     def get_format_map(self, ch: str) -> str:
         if ch not in self.format_map:
-            raise InvalidDateFormatException("Invalid Date format %{}".format(ch))
+            raise InvalidDateFormatException(f"Invalid Date format %{ch}")
         return self.format_map[ch]
 
     @property

nepali/datetime/_humanize.py

@@ -1,10 +1,7 @@
-import datetime as pythonDateTime
-
 from nepali import number
-from nepali.timezone import now, to_nepali_timezone
-from nepali.exceptions import InvalidNepaliDateTimeObjectException
+from nepali.timezone import now
 
-from ._datetime import nepalidate, nepalidatetime
+from .utils import to_nepalidatetime
 
 
 class HumanizeDateTime:
@@ -29,20 +26,7 @@ class HumanizeDateTime:
         threshold (kwargs): threshold to be humanize
         format (kwargs): format to display behind threshold
         """
-        if type(datetime_obj) == nepalidatetime:
-            self.datetime_obj = datetime_obj.to_datetime()
-        elif type(datetime_obj) == nepalidate:
-            self.datetime_obj = nepalidatetime.from_nepali_date(
-                datetime_obj
-            ).to_datetime()
-        elif type(datetime_obj) == pythonDateTime.date:
-            self.datetime_obj = nepalidatetime.from_date(datetime_obj).to_datetime()
-        elif type(datetime_obj) == pythonDateTime.datetime:
-            self.datetime_obj = to_nepali_timezone(datetime_obj)
-        else:
-            raise InvalidNepaliDateTimeObjectException(
-                "Argument must be instance of NepaliDate or NepaliDateTime or datetime.datetime or datetime.date"
-            )
+        self.datetime_obj = to_nepalidatetime(datetime_obj)
 
         self.threshold = kwargs.get("threshold")
         self.format = kwargs.get("format")
@@ -53,8 +37,11 @@ class HumanizeDateTime:
     def __calc_seconds(self):
         """calculates total seconds from now"""
         current_date_time = now()
-        date = self.datetime_obj
-        self.seconds = int((current_date_time - date).total_seconds())
+
+        # TODO (@aj3sh): support datetime - nepalidatetime
+        self.seconds = int(
+            (current_date_time - self.datetime_obj.to_datetime()).total_seconds()
+        )
 
         self.interval_tense = self.__past_text
         if self.seconds < 0:
@@ -67,13 +54,12 @@ class HumanizeDateTime:
         """returns humanize string"""
         seconds = self.__calc_seconds()  # calculating seconds
 
-        if self.threshold is not None:
-            if seconds >= self.threshold:
-                return self.get_datetime().strip()
+        if self.threshold is not None and seconds >= self.threshold:
+            return self._get_datetime_str().strip()
 
-        return self.get_humanize().strip()
+        return self._get_humanize_str().strip()
 
-    def get_humanize(self):
+    def _get_humanize_str(self):
         """
         returns humanize datetime
         """
@@ -118,14 +104,13 @@ class HumanizeDateTime:
             str(interval_value) + " " + str(interval_text) + " " + self.interval_tense
         )
 
-    def get_datetime(self):
+    def _get_datetime_str(self):
         """
         returns date in nepali characters
         """
         if not self.format:
             self.format = "%B %d, %Y"
-        ndt = nepalidatetime.from_datetime(self.datetime_obj)
-        return ndt.strftime_ne(self.format)
+        return self.datetime_obj.strftime_ne(self.format)
 
     def __str__(self):
         return self.to_str()

nepali/datetime/_nepalimonth.py

@@ -1,7 +1,7 @@
 from functools import cached_property
 from typing import Any, Dict, Optional, Union
 
-from .constants import MONTHS_EN, MONTHS_NE
+from nepali.constants import NEPALI_MONTHS_EN, NEPALI_MONTHS_NE
 
 
 class NepaliMonthMeta(type):
@@ -40,7 +40,8 @@ class NepaliMonthMeta(type):
 
         return cls._cache[value]
 
-    def _parse_str(cls, month: str) -> int:
+    @staticmethod
+    def _parse_str(month: str) -> int:
         """
         Parses str value of the month and returns int.
 
@@ -54,7 +55,7 @@ class NepaliMonthMeta(type):
             return int(month)
 
         month = month.capitalize()
-        month_names = MONTHS_EN + MONTHS_NE
+        month_names = NEPALI_MONTHS_EN + NEPALI_MONTHS_NE
         try:
             index = month_names.index(month)
         except ValueError:
@@ -66,7 +67,7 @@ class NepaliMonthMeta(type):
 class nepalimonth(metaclass=NepaliMonthMeta):
     """
     Represents Nepali month: Baishakh, Jestha, ..., Chaitra.
-    Baishak: 1,
+    Baishakh: 1,
     Jestha: 2,
     ...
     Chaitra: 12
@@ -107,9 +108,9 @@ class nepalimonth(metaclass=NepaliMonthMeta):
     @cached_property
     def name(self) -> str:
         """Month's english name"""
-        return MONTHS_EN[self.__value - 1]
+        return NEPALI_MONTHS_EN[self.__value - 1]
 
     @cached_property
     def name_ne(self) -> str:
         """Month's nepali name"""
-        return MONTHS_NE[self.__value - 1]
+        return NEPALI_MONTHS_NE[self.__value - 1]

nepali/datetime/_nepaliweek.py

@@ -1,7 +1,7 @@
 from functools import cached_property
 from typing import Any, Dict, Optional, Union
 
-from .constants import WEEKS_EN, WEEKS_NE, WEEKS_ABBR_EN, WEEKS_ABBR_NE
+from nepali.constants import WEEKS_ABBR_EN, WEEKS_ABBR_NE, WEEKS_EN, WEEKS_NE
 
 
 class NepaliWeekMeta(type):
@@ -28,7 +28,7 @@ class NepaliWeekMeta(type):
                 pass
 
         # checking if week is valid
-        if value is None or not (0 <= value <= 6):
+        if value is None or not 0 <= value <= 6:
             raise ValueError(f"Invalid week: {week}")
 
         # checking cache
@@ -37,7 +37,8 @@ class NepaliWeekMeta(type):
 
         return cls._cache[value]
 
-    def _parse_str(cls, week: str) -> int:
+    @staticmethod
+    def _parse_str(week: str) -> int:
         """
         Parses str value of the week and returns int.
 

nepali/datetime/parser/__init__.py

@@ -1,4 +1,4 @@
-from ._parser import strptime, parse
+from ._parser import parse, strptime
 
 __all__ = [
     "strptime",

nepali/datetime/parser/_parser.py

@@ -1,4 +1,4 @@
-from nepali.exceptions import InvalidDateTimeFormatException, FormatNotMatchException
+from nepali.exceptions import FormatNotMatchException, InvalidDateTimeFormatException
 
 from .validators import validate
 
@@ -53,10 +53,8 @@ def _get_standard_formats():
     for time_format in STANDARD_TIME_FORMAT:
         for date_format in STANDARD_DATE_FORMAT:
             _standard_datetime_format_CACHE += [
-                "{} {}".format(date_format, time_format)
-            ]
-            _standard_datetime_format_CACHE += [
-                "{}, {}".format(date_format, time_format)
+                f"{date_format} {time_format}",
+                f"{date_format}, {time_format}",
             ]
     return _standard_datetime_format_CACHE
 
@@ -67,10 +65,10 @@ def parse(datetime_str):
     eg. parse('2078-10-12') => <NepaliDateTime: 2078-10-12>
     """
     standard_formats = _get_standard_formats()
-    nepalidatetime_object = None
     for format in standard_formats:
-        nepalidatetime_object = validate(datetime_str, format=format)
-        if nepalidatetime_object is not None:
-            return nepalidatetime_object
+        try:
+            return strptime(datetime_str, format=format)
+        except FormatNotMatchException:
+            pass
 
     raise InvalidDateTimeFormatException("Invalid format to parse nepali datetime.")

nepali/datetime/parser/validators.py

@@ -2,11 +2,11 @@
 validates parsing
 """
 import re
+from typing import Optional, Tuple
 
 from nepali.char import nepali_to_english_text
+from nepali.constants import NEPALI_MONTHS_EN, WEEKS_ABBR_EN, WEEKS_EN
 from nepali.datetime import nepalidatetime, nepalimonth, nepaliweek
-from nepali.datetime.constants import MONTHS_EN, WEEKS_EN, WEEKS_ABBR_EN
-
 
 __nepali_time_re__CACHE = None
 
@@ -41,8 +41,8 @@ class NepaliTimeRE(dict):
                 "z": r"(?P<z>[+-]\d\d:?[0-5]\d(:?[0-5]\d(\.\d{1,6})?)?|(?-i:Z))",
                 "A": self.__seqToRE(WEEKS_EN, "A"),
                 "a": self.__seqToRE(WEEKS_ABBR_EN, "a"),
-                "B": self.__seqToRE(MONTHS_EN, "B"),
-                "b": self.__seqToRE(MONTHS_EN, "b"),
+                "B": self.__seqToRE(NEPALI_MONTHS_EN, "B"),
+                "b": self.__seqToRE(NEPALI_MONTHS_EN, "b"),
                 "p": self.__seqToRE(
                     (
                         "AM",
@@ -68,39 +68,42 @@ class NepaliTimeRE(dict):
         else:
             return ""
         regex = "|".join(re.escape(stuff) for stuff in to_convert)
-        regex = "(?P<%s>%s" % (directive, regex)
-        return "%s)" % regex
+        regex = f"(?P<{directive}>{regex}"
+        return f"{regex})"
 
-    def pattern(self, format):
+    def pattern(self, date_format):
         """
-        Handle conversion from format directives to regexes.
+        Handle conversion from format directives to regex.
         """
         processed_format = ""
         regex_chars = re.compile(r"([\\.^$*+?\(\){}\[\]|])")
-        format = regex_chars.sub(r"\\\1", format)
+        date_format = regex_chars.sub(r"\\\1", date_format)
         whitespace_replacement = re.compile(r"\s+")
-        format = whitespace_replacement.sub(r"\\s+", format)
-        while "%" in format:
-            directive_index = format.index("%") + 1
+        date_format = whitespace_replacement.sub(r"\\s+", date_format)
+        while "%" in date_format:
+            directive_index = date_format.index("%") + 1
             index_increment = 1
 
-            if format[directive_index] == "-":
+            if date_format[directive_index] == "-":
                 index_increment = 2
 
-            if format[directive_index : directive_index + index_increment] not in self:
+            if (
+                date_format[directive_index : directive_index + index_increment]
+                not in self
+            ):
                 return None
 
             processed_format = "%s%s%s" % (
                 processed_format,
-                format[: directive_index - 1],
-                self[format[directive_index : directive_index + index_increment]],
+                date_format[: directive_index - 1],
+                self[date_format[directive_index : directive_index + index_increment]],
             )
-            format = format[directive_index + index_increment :]
-        return "^%s%s$" % (processed_format, format)
+            date_format = date_format[directive_index + index_increment :]
+        return f"^{processed_format}{date_format}$"
 
-    def compile(self, format):
+    def compile(self, date_format):
         """Return a compiled re object for the format string."""
-        return re.compile(self.pattern(format), re.IGNORECASE)
+        return re.compile(self.pattern(date_format), re.IGNORECASE)
 
 
 def get_nepali_time_re_object():
@@ -131,13 +134,144 @@ def extract(datetime_str, format):
     # converting datetime_str to english if any exists
     datetime_str = nepali_to_english_text(datetime_str)
 
-    re_compiled_format = get_nepali_time_re_object().compile(format=format)
+    re_compiled_format = get_nepali_time_re_object().compile(format)
     match = re_compiled_format.match(datetime_str)
     if match is None:
         return {}
     return match.groupdict()
 
 
+def __convert_12_hour_to_24_hour(hour: int, am_pm: str) -> int:
+    """Converts hours from 12-hour format to 24-hour format.
+
+    :param hour: The hour value to convert.
+    :param am_pm: Either "am" or "pm"; signifies whether the hour is in am or pm.
+
+    :returns: The value of `hour` converted to 24-hour format.
+    """
+    am_pm = am_pm.lower()
+    if am_pm == "am" and hour == 12:
+        return 0
+    elif am_pm == "pm" and hour != 12:
+        return hour + 12
+    return hour
+
+
+def __calculate_year(data: dict) -> Optional[int]:
+    """Calculates the year value from given data.
+
+    :param data: The dictionary of the format:
+                    {
+                        "Y": 2078,
+                        "b": "Mangsir",
+                        "d": 12,
+                        ...
+                    }
+
+    :returns: The year value of given date data.
+    """
+    if "y" in data:
+        return int(data["y"]) + 2000
+    elif "Y" in data:
+        return int(data["Y"])
+    return None
+
+
+def __calculate_month(data: dict) -> nepalimonth:
+    """Calculates the month value from given data.
+
+    :param data: The dictionary of the format:
+                    {
+                        "Y": 2078,
+                        "b": "Mangsir",
+                        "d": 12,
+                        ...
+                    }
+
+    :returns: The month value of given date data.
+    """
+    if "m" in data:
+        return nepalimonth(int(data["m"]))
+    elif "b" in data:
+        return nepalimonth(data["b"])
+    elif "B" in data:
+        return nepalimonth(data["B"])
+    return nepalimonth(1)
+
+
+def __calculate_day(data: dict) -> int:
+    """Calculates the day value from given data.
+
+    :param data: The dictionary of the format:
+                    {
+                        "Y": 2078,
+                        "b": "Mangsir",
+                        "d": 12,
+                        ...
+                    }
+
+    :returns: The day value of given date data.
+    """
+    if "d" in data:
+        return int(data["d"])
+    return 1
+
+
+def __calculate_hour_minute_seconds(data: dict) -> Tuple[int, int, int, int]:
+    """Calculates hour, minutes, seconds and microseconds from given data.
+
+    :param data: The dictionary of the format:
+                    {
+                        "Y": 2078,
+                        "b": "Mangsir",
+                        "d": 12,
+                        "H": 12,
+                        "M": 12,
+                        "S": 12,
+                        "f": 12,
+                        ...
+                    }
+
+    :returns: A tuple of hour, minute, seconds and microseconds.
+    """
+    hour = minute = second = fraction = 0
+    if "H" in data:
+        hour = int(data["H"])
+    elif "I" in data:
+        am_pm = data.get("p", "").lower() or "am"
+        hour = __convert_12_hour_to_24_hour(hour=int(data["I"]), am_pm=am_pm)
+
+    if "M" in data:
+        minute = int(data["M"])
+
+    if "S" in data:
+        second = int(data["S"])
+
+    if "f" in data:
+        s = data["f"]
+        # Pad to always return microseconds.
+        s += "0" * (6 - len(s))
+        fraction = int(s)
+
+    return hour, minute, second, fraction
+
+
+def __calculate_weekday(data: dict) -> Optional[nepaliweek]:
+    """Calculates the weekday of the date given in data.
+
+    :param data: The data that describes the date.
+
+    :returns: The weekday value; 0 for Sunday, 1 for Monday, etc.
+    """
+    if "a" in data:
+        return nepaliweek(data["a"])
+    elif "A" in data:
+        return nepaliweek(data["A"])
+    elif "w" in data:
+        return nepaliweek((int(data["w"]) - 1) % 7)
+    return None
+
+
 def transform(data: dict):
     """
     transforms different format data to uniform data
@@ -160,62 +294,12 @@ def transform(data: dict):
     }
     """
 
-    year = None
-    month = day = 1
-    hour = minute = second = fraction = 0
-    weekday = None
-
-    for date_key in data.keys():
-        if date_key == "y":
-            year = int(data["y"])
-            year += 2000
-        elif date_key == "Y":
-            year = int(data["Y"])
-        elif date_key == "m":
-            month = int(data["m"])
-        elif date_key == "B":
-            month = nepalimonth(data["B"])
-        elif date_key == "b":
-            month = nepalimonth(data["b"])
-        elif date_key == "d":
-            day = int(data["d"])
-        elif date_key == "H":
-            hour = int(data["H"])
-        elif date_key == "I":
-            hour = int(data["I"])
-            ampm = data.get("p", "").lower()
-            # If there was no AM/PM indicator, we'll treat this like AM
-            if ampm in ("", "am"):
-                # We're in AM so the hour is correct unless we're
-                # looking at 12 midnight.
-                # 12 midnight == 12 AM == hour 0
-                if hour == 12:
-                    hour = 0
-            elif ampm == "pm":
-                # We're in PM so we need to add 12 to the hour unless
-                # we're looking at 12 noon.
-                # 12 noon == 12 PM == hour 12
-                if hour != 12:
-                    hour += 12
-        elif date_key == "M":
-            minute = int(data["M"])
-        elif date_key == "S":
-            second = int(data["S"])
-        elif date_key == "f":
-            s = data["f"]
-            # Pad to always return microseconds.
-            s += "0" * (6 - len(s))
-            fraction = int(s)
-        elif date_key == "A":
-            weekday = nepaliweek(data["A"])
-        elif date_key == "a":
-            weekday = nepaliweek(data["a"])
-        elif date_key == "w":
-            weekday = int(data["w"])
-            if weekday == 0:
-                weekday = 6
-            else:
-                weekday -= 1
+    year = __calculate_year(data)
+    month = __calculate_month(data)
+    day = __calculate_day(data)
+    hour, minute, second, fraction = __calculate_hour_minute_seconds(data)
+    weekday = __calculate_weekday(data)
+
     return {
         "year": year,
         "month": month,
@@ -239,7 +323,7 @@ def validate(datetime_str, format):
     """
 
     # 1. validate if format is correct.
-    if get_nepali_time_re_object().pattern(format=format) is None:
+    if get_nepali_time_re_object().pattern(format) is None:
         # regex pattern generation failed
         return None
 

nepali/datetime/utils.py

@@ -1,5 +1,6 @@
 import datetime
 from typing import Any
+
 from nepali.exceptions import InvalidNepaliDateTimeObjectException
 
 from ._datetime import nepalidate, nepalidatetime

nepali/locations/__init__.py

@@ -1,3 +1,3 @@
-from ._locations import provinces, districts, municipalities
+from ._locations import districts, municipalities, provinces
 
 __all__ = ["provinces", "districts", "municipalities"]

nepali/locations/_locations.py

@@ -1,6 +1,6 @@
 from typing import List, Tuple
 
-from .models import Province, District, Municipality, MunicipalityType
+from .models import District, Municipality, MunicipalityType, Province
 
 
 def _loadData() -> Tuple[List[Province], List[District], List[Municipality]]: