nepali 1.0.1__py3-none-any.whl → 1.1.1__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/date_converter.py

@@ -78,7 +78,7 @@ class NepaliDateConverter:
         ((31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30), 365),
         ((31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30), 365),
         ((31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30), 365),
-        ((31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31), 366),
+        ((31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31), 366),  # 2050
         ((31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30), 365),
         ((31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30), 365),
         ((31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30), 365),
@@ -98,7 +98,7 @@ class NepaliDateConverter:
         ((31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30), 365),
         ((31, 31, 32, 32, 31, 30, 30, 29, 30, 29, 30, 30), 365),
         ((31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31), 366),
-        ((31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30), 365),
+        ((31, 31, 31, 32, 31, 31, 29, 30, 30, 29, 30, 30), 365),  # 2070
         ((31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30), 365),
         ((31, 32, 31, 32, 31, 30, 30, 29, 30, 29, 30, 30), 365),
         ((31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 31), 366),
@@ -108,8 +108,8 @@ class NepaliDateConverter:
         ((31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31), 366),
         ((31, 31, 31, 32, 31, 31, 30, 29, 30, 29, 30, 30), 365),
         ((31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30), 365),
-        ((31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30), 365),
-        ((31, 31, 32, 32, 31, 30, 30, 30, 29, 30, 30, 30), 366),
+        ((31, 32, 31, 32, 31, 30, 30, 30, 29, 29, 30, 30), 365),  # 2080
+        ((31, 32, 31, 32, 31, 30, 30, 30, 29, 30, 29, 31), 366),
         ((30, 32, 31, 32, 31, 30, 30, 30, 29, 30, 30, 30), 365),
         ((31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30), 365),
         ((31, 31, 32, 31, 31, 30, 30, 30, 29, 30, 30, 30), 365),

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