npdatetime 0.1.1__py3-none-any.whl

npdatetime/__init__.pyi

@@ -0,0 +1,293 @@
+"""Most of the code derived from Python3.5 's datetime.pyi"""
+import sys
+import datetime as _actual_datetime
+
+from time import struct_time
+from typing import Optional, Tuple, overload, ClassVar, Type, TypeVar
+
+
+# __version__: str
+__author__: str
+
+_S = TypeVar("_S")
+_A = TypeVar("_A")
+
+_Text = str
+
+MINYEAR: int
+MAXYEAR: int
+
+NEPAL_TIME_UTC_OFFSET: int
+
+
+class tzinfo:
+   def tzname(self, dt: Optional[datetime]) -> Optional[str]: ...
+   def utcoffset(self, dt: Optional[datetime]) -> Optional[_actual_datetime.timedelta]: ...
+   def dst(self, dt: Optional[datetime]) -> Optional[_actual_datetime.timedelta]: ...
+   def fromutc(self, dt: datetime) -> datetime: ...
+
+
+class timezone(tzinfo):
+   utc: ClassVar[timezone]
+   min: ClassVar[timezone]
+   max: ClassVar[timezone]
+
+   def __init__(self, offset: _actual_datetime.timedelta, name: str = ...) -> None: ...
+   def __hash__(self) -> int: ...
+
+
+_tzinfo = tzinfo
+
+
+class date:
+   min: ClassVar[date]
+   max: ClassVar[date]
+   resolution: ClassVar[_actual_datetime.timedelta]
+
+   def __new__(cls: Type[_S], year: int, month: int, day: int) -> _S: ...
+
+   @classmethod
+   def fromtimestamp(cls: Type[_S], __timestamp: float) -> _S: ...
+   @classmethod
+   def today(cls: Type[_S]) -> _S: ...
+   @classmethod
+   def fromordinal(cls: Type[_S], n: int) -> _S: ...
+   @classmethod
+   def from_datetime_date(cls, from_date: _A) -> _S: ...
+   def to_datetime_date(self) -> _A: ...
+   if sys.version_info >= (3, 7):
+      @classmethod
+      def fromisoformat(cls: Type[_S], date_string: str) -> _S: ...
+   if sys.version_info >= (3, 8):
+      @classmethod
+      def fromisocalendar(cls: Type[_S], year: int, week: int, day: int) -> _S: ...
+
+   @property
+   def year(self) -> int: ...
+   @property
+   def month(self) -> int: ...
+   @property
+   def day(self) -> int: ...
+
+   def ctime(self) -> str: ...
+   def strftime(self, fmt: _Text) -> str: ...
+   def __format__(self, fmt: str) -> str: ...
+   def isoformat(self) -> str: ...
+   def timetuple(self) -> struct_time: ...
+   def toordinal(self) -> int: ...
+   def replace(self, year: int = ..., month: int = ..., day: int = ...) -> date: ...
+   def __le__(self, other: date) -> bool: ...
+   def __lt__(self, other: date) -> bool: ...
+   def __ge__(self, other: date) -> bool: ...
+   def __gt__(self, other: date) -> bool: ...
+   if sys.version_info >= (3, 8):
+      def __add__(self: _S, other: _actual_datetime.timedelta) -> _S: ...
+      def __radd__(self: _S, other: _actual_datetime.timedelta) -> _S: ...
+   else:
+      def __add__(self, other: _actual_datetime.timedelta) -> date: ...
+      def __radd__(self, other: _actual_datetime.timedelta) -> date: ...
+   @overload
+   def __sub__(self, other: _actual_datetime.timedelta) -> date: ...
+   @overload
+   def __sub__(self, other: date) -> _actual_datetime.timedelta: ...
+   def __hash__(self) -> int: ...
+   def weekday(self) -> int: ...
+   def isoweekday(self) -> int: ...
+   def isocalendar(self) -> Tuple[int, int, int]: ...
+
+class time:
+   min: ClassVar[time]
+   max: ClassVar[time]
+   resolution: ClassVar[_actual_datetime.timedelta]
+
+   if sys.version_info >= (3, 6):
+      def __init__(self, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ...,
+                  tzinfo: Optional[_tzinfo] = ..., *, fold: int = ...) -> None: ...
+   else:
+      def __init__(self, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ...,
+                  tzinfo: Optional[_tzinfo] = ...) -> None: ...
+
+   @property
+   def hour(self) -> int: ...
+   @property
+   def minute(self) -> int: ...
+   @property
+   def second(self) -> int: ...
+   @property
+   def microsecond(self) -> int: ...
+   @property
+   def tzinfo(self) -> Optional[_tzinfo]: ...
+   if sys.version_info >= (3, 6):
+      @property
+      def fold(self) -> int: ...
+
+   def __le__(self, other: time) -> bool: ...
+   def __lt__(self, other: time) -> bool: ...
+   def __ge__(self, other: time) -> bool: ...
+   def __gt__(self, other: time) -> bool: ...
+   def __hash__(self) -> int: ...
+   if sys.version_info >= (3, 6):
+      def isoformat(self, timespec: str = ...) -> str: ...
+   else:
+      def isoformat(self) -> str: ...
+   if sys.version_info >= (3, 7):
+      @classmethod
+      def fromisoformat(cls: Type[_S], time_string: str) -> _S: ...
+   def strftime(self, fmt: _Text) -> str: ...
+   def __format__(self, fmt: str) -> str: ...
+   def utcoffset(self) -> Optional[_actual_datetime.timedelta]: ...
+   def tzname(self) -> Optional[str]: ...
+   def dst(self) -> Optional[int]: ...
+   if sys.version_info >= (3, 6):
+      def replace(self, hour: int = ..., minute: int = ..., second: int = ...,
+                  microsecond: int = ..., tzinfo: Optional[_tzinfo] = ...,
+                  *, fold: int = ...) -> time: ...
+   else:
+      def replace(self, hour: int = ..., minute: int = ..., second: int = ...,
+                  microsecond: int = ..., tzinfo: Optional[_tzinfo] = ...) -> time: ...
+
+
+_date = date
+_time = time
+
+
+class datetime(date):
+   min: ClassVar[datetime]
+   max: ClassVar[datetime]
+   resolution: ClassVar[_actual_datetime.timedelta]
+
+   if sys.version_info >= (3, 6):
+      def __new__(
+         cls: Type[_S],
+         year: int,
+         month: int,
+         day: int,
+         hour: int = ...,
+         minute: int = ...,
+         second: int = ...,
+         microsecond: int = ...,
+         tzinfo: Optional[_tzinfo] = ...,
+         *,
+         fold: int = ...,
+      ) -> _S: ...
+   else:
+      def __new__(
+         cls: Type[_S],
+         year: int,
+         month: int,
+         day: int,
+         hour: int = ...,
+         minute: int = ...,
+         second: int = ...,
+         microsecond: int = ...,
+         tzinfo: Optional[_tzinfo] = ...,
+      ) -> _S: ...
+
+   @property
+   def year(self) -> int: ...
+   @property
+   def month(self) -> int: ...
+   @property
+   def day(self) -> int: ...
+   @property
+   def hour(self) -> int: ...
+   @property
+   def minute(self) -> int: ...
+   @property
+   def second(self) -> int: ...
+   @property
+   def microsecond(self) -> int: ...
+   @property
+   def tzinfo(self) -> Optional[_tzinfo]: ...
+   if sys.version_info >= (3, 6):
+      @property
+      def fold(self) -> int: ...
+
+   @classmethod
+   def fromtimestamp(cls: Type[_S], t: float, tz: Optional[_tzinfo] = ...) -> _S: ...
+   @classmethod
+   def utcfromtimestamp(cls: Type[_S], t: float) -> _S: ...
+   @classmethod
+   def today(cls: Type[_S]) -> _S: ...
+   @classmethod
+   def fromordinal(cls: Type[_S], n: int) -> _S: ...
+   if sys.version_info >= (3, 8):
+      @classmethod
+      def now(cls: Type[_S], tz: Optional[_tzinfo] = ...) -> _S: ...
+   else:
+      @overload
+      @classmethod
+      def now(cls: Type[_S], tz: None = ...) -> _S: ...
+      @overload
+      @classmethod
+      def now(cls, tz: _tzinfo) -> datetime: ...
+   @classmethod
+   def utcnow(cls: Type[_S]) -> _S: ...
+   if sys.version_info >= (3, 6):
+      @classmethod
+      def combine(cls, date: _date, time: _time, tzinfo: Optional[_tzinfo] = ...) -> datetime: ...
+   else:
+      @classmethod
+      def combine(cls, date: _date, time: _time) -> datetime: ...
+   if sys.version_info >= (3, 7):
+      @classmethod
+      def fromisoformat(cls: Type[_S], date_string: str) -> _S: ...
+   def strftime(self, fmt: _Text) -> str: ...
+   def __format__(self, fmt: str) -> str: ...
+   def toordinal(self) -> int: ...
+   def timetuple(self) -> struct_time: ...
+   def timestamp(self) -> float: ...
+   def utctimetuple(self) -> struct_time: ...
+   def date(self) -> _date: ...
+   def time(self) -> _time: ...
+   def timetz(self) -> _time: ...
+   if sys.version_info >= (3, 6):
+      def replace(self, year: int = ..., month: int = ..., day: int = ..., hour: int = ...,
+                  minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo:
+                  Optional[_tzinfo] = ..., *, fold: int = ...) -> datetime: ...
+   else:
+      def replace(self, year: int = ..., month: int = ..., day: int = ..., hour: int = ...,
+                  minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo:
+                  Optional[_tzinfo] = ...) -> datetime: ...
+   if sys.version_info >= (3, 8):
+      def astimezone(self: _S, tz: Optional[_tzinfo] = ...) -> _S: ...
+   elif sys.version_info >= (3, 3):
+      def astimezone(self, tz: Optional[_tzinfo] = ...) -> datetime: ...
+   else:
+      def astimezone(self, tz: _tzinfo) -> datetime: ...
+   def ctime(self) -> str: ...
+   if sys.version_info >= (3, 6):
+      def isoformat(self, sep: str = ..., timespec: str = ...) -> str: ...
+   else:
+      def isoformat(self, sep: str = ...) -> str: ...
+   @classmethod
+   def strptime(cls, date_string: _Text, format: _Text) -> datetime: ...
+   def utcoffset(self) -> Optional[_actual_datetime.timedelta]: ...
+   def tzname(self) -> Optional[str]: ...
+   def dst(self) -> Optional[_actual_datetime.timedelta]: ...
+   def __le__(self, other: datetime) -> bool: ...  # type: ignore
+   def __lt__(self, other: datetime) -> bool: ...  # type: ignore
+   def __ge__(self, other: datetime) -> bool: ...  # type: ignore
+   def __gt__(self, other: datetime) -> bool: ...  # type: ignore
+   if sys.version_info >= (3, 8):
+      def __add__(self: _S, other: _actual_datetime.timedelta) -> _S: ...
+      def __radd__(self: _S, other: _actual_datetime.timedelta) -> _S: ...
+   else:
+      def __add__(self, other: _actual_datetime.timedelta) -> datetime: ...
+      def __radd__(self, other: _actual_datetime.timedelta) -> datetime: ...
+   @overload  # type: ignore
+   def __sub__(self, other: datetime) -> _actual_datetime.timedelta: ...
+   @overload
+   def __sub__(self, other: _actual_datetime.timedelta) -> datetime: ...
+   def __hash__(self) -> int: ...
+   def weekday(self) -> int: ...
+   def isoweekday(self) -> int: ...
+   def isocalendar(self) -> Tuple[int, int, int]: ...
+
+
+class UTC0545(_actual_datetime.tzinfo):
+   def utcoffset(self, dt: datetime) -> _actual_datetime.timedelta: ...
+   def dst(self, dt: datetime) -> _actual_datetime.timedelta: ...
+   def tzname(self, dt: datetime) -> str: ...
+   def fromutc(self, dt: datetime) -> datetime: ...
+   

npdatetime/_custom_strptime.py

@@ -0,0 +1,305 @@
+"""Code derived form of  Python3.5 's _strptime.py core library to support npdatetime."""
+import time
+import locale
+import calendar
+import _strptime as _actual_strptime
+
+from datetime import (timedelta as datetime_timedelta, timezone as datetime_timezone)
+
+from npdatetime import date as datetime_date
+
+try:
+   from _thread import allocate_lock as _thread_allocate_lock
+except ImportError:
+   from _dummy_thread import allocate_lock as _thread_allocate_lock
+
+__all__ = []
+
+_MONTHNAMES = (None, "bai", "jes", "asa", "shr", "bha", "asw", "kar", "man", "pou", "mag", "fal", "cha")
+_FULLMONTHNAMES = (None, "bashan", "jestha", "asar", "shrawan", "bhadau", "aswin", "kartik", "mangsir", "poush", "magh", "falgun", "chaitra")
+
+
+def _getlang():
+   # Figure out what the current language is set to.
+   return locale.getlocale(locale.LC_TIME)
+
+
+class _TimeRE(_actual_strptime.TimeRE):
+
+   def __init__(self, locale_time=None):
+      """Create keys/values.
+
+      Order of execution is important for dependency reasons.
+
+      """
+      if locale_time:
+         self.locale_time = locale_time
+      else:
+         self.locale_time = _actual_strptime.LocaleTime()
+      base = super(_actual_strptime.TimeRE, self)
+      base.__init__({
+         # The " \d" part of the regex is to make %c from ANSI C work
+         'd': r"(?P<d>3[0-2]|[1-2]\d|0[1-9]|[1-9]| [1-9])",
+         'f': r"(?P<f>[0-9]{1,6})",
+         'H': r"(?P<H>2[0-3]|[0-1]\d|\d)",
+         'I': r"(?P<I>1[0-2]|0[1-9]|[1-9])",
+         'j': r"(?P<j>36[0-6]|3[0-5]\d|[1-2]\d\d|0[1-9]\d|00[1-9]|[1-9]\d|0[1-9]|[1-9])",
+         'm': r"(?P<m>1[0-2]|0[1-9]|[1-9])",
+         'M': r"(?P<M>[0-5]\d|\d)",
+         'S': r"(?P<S>6[0-1]|[0-5]\d|\d)",
+         'U': r"(?P<U>5[0-3]|[0-4]\d|\d)",
+         'w': r"(?P<w>[0-6])",
+         # W is set below by using 'U'
+         'y': r"(?P<y>\d\d)",
+         # XXX: Does 'Y' need to worry about having less or more than
+         #     4 digits?
+         'Y': r"(?P<Y>\d\d\d\d)",
+         'z': r"(?P<z>[+-]\d\d[0-5]\d)",
+         'A': self.__seqToRE(self.locale_time.f_weekday, 'A'),
+         'a': self.__seqToRE(self.locale_time.a_weekday, 'a'),
+         'B': self.__seqToRE(_FULLMONTHNAMES[1:], 'B'),
+         'b': self.__seqToRE(_MONTHNAMES[1:], 'b'),
+         'p': self.__seqToRE(self.locale_time.am_pm, 'p'),
+         'Z': self.__seqToRE((tz for tz_names in self.locale_time.timezone
+                              for tz in tz_names),
+                              'Z'),
+         '%': '%'})
+      base.__setitem__('W', base.__getitem__('U').replace('U', 'W'))
+      base.__setitem__('c', self.pattern(self.locale_time.LC_date_time))
+      base.__setitem__('x', self.pattern(self.locale_time.LC_date))
+      base.__setitem__('X', self.pattern(self.locale_time.LC_time))
+
+
+_cache_lock = _thread_allocate_lock()
+# DO NOT modify _TimeRE_cache or _regex_cache without acquiring the cache lock
+# first!
+_TimeRE_cache = _TimeRE()
+_CACHE_MAX_SIZE = 5  # Max number of regexes stored in _regex_cache
+_regex_cache = {}
+
+
+def _calc_julian_from_U_or_W(year, week_of_year, day_of_week, week_starts_Mon):
+   """Calculate the Julian day based on the year, week of the year, and day of
+   the week, with week_start_day representing whether the week of the year
+   assumes the week starts on Sunday or Monday (6 or 0)."""
+   first_weekday = datetime_date(year, 1, 1).weekday()
+   # If we are dealing with the %U directive (week starts on Sunday), it's
+   # easier to just shift the view to Sunday being the first day of the
+   # week.
+   if not week_starts_Mon:
+      first_weekday = (first_weekday + 1) % 7
+      day_of_week = (day_of_week + 1) % 7
+   # Need to watch out for a week 0 (when the first day of the year is not
+   # the same as that specified by %U or %W).
+   week_0_length = (7 - first_weekday) % 7
+   if week_of_year == 0:
+      return 1 + day_of_week - first_weekday
+   else:
+      days_to_week = week_0_length + (7 * (week_of_year - 1))
+      return 1 + days_to_week + day_of_week
+
+
+def _strptime(data_string, format="%a %b %d %H:%M:%S %Y"):
+   """Return a 2-tuple consisting of a time struct and an int containing
+   the number of microseconds based on the input string and the
+   format string."""
+
+   for index, arg in enumerate([data_string, format]):
+      if not isinstance(arg, str):
+         msg = "strptime() argument {} must be str, not {}"
+         raise TypeError(msg.format(index, type(arg)))
+
+   global _TimeRE_cache, _regex_cache
+   with _cache_lock:
+      locale_time = _TimeRE_cache.locale_time
+      if (_getlang() != locale_time.lang or
+               time.tzname != locale_time.tzname or
+               time.daylight != locale_time.daylight):
+         _TimeRE_cache = _TimeRE()
+         _regex_cache.clear()
+         locale_time = _TimeRE_cache.locale_time
+      if len(_regex_cache) > _CACHE_MAX_SIZE:
+         _regex_cache.clear()
+      format_regex = _regex_cache.get(format)
+      if not format_regex:
+         try:
+               format_regex = _TimeRE_cache.compile(format)
+         # KeyError raised when a bad format is found; can be specified as
+         # \\, in which case it was a stray % but with a space after it
+         except KeyError as err:
+               bad_directive = err.args[0]
+               if bad_directive == "\\":
+                  bad_directive = "%"
+               del err
+               raise ValueError("'%s' is a bad directive in format '%s'" %
+                              (bad_directive, format)) from None
+         # IndexError only occurs when the format string is "%"
+         except IndexError:
+               raise ValueError("stray %% in format '%s'" % format) from None
+         _regex_cache[format] = format_regex
+   found = format_regex.match(data_string)
+   if not found:
+      raise ValueError("time data %r does not match format %r" %
+                        (data_string, format))
+   if len(data_string) != found.end():
+      raise ValueError("unconverted data remains: %s" %
+                        data_string[found.end():])
+
+   year = None
+   month = day = 1
+   hour = minute = second = fraction = 0
+   tz = -1
+   tzoffset = None
+   # Default to -1 to signify that values not known; not critical to have,
+   # though
+   week_of_year = -1
+   week_of_year_start = -1
+   # weekday and julian defaulted to None so as to signal need to calculate
+   # values
+   weekday = julian = None
+   found_dict = found.groupdict()
+   for group_key in found_dict.keys():
+      # Directives not explicitly handled below:
+      #   c, x, X
+      #      handled by making out of other directives
+      #   U, W
+      #      worthless without day of the week
+      if group_key == 'y':
+         year = int(found_dict['y'])
+         # Open Group specification for strptime() states that a %y
+         # value in the range of [00, 68] is in the century 2000, while
+         # [69,99] is in the century 1900
+         if year <= 89:
+               year += 2000
+         else:
+               year += 1900
+      elif group_key == 'Y':
+         year = int(found_dict['Y'])
+      elif group_key == 'm':
+         month = int(found_dict['m'])
+      elif group_key == 'B':
+         month = _FULLMONTHNAMES.index(found_dict['B'].lower())
+      elif group_key == 'b':
+         month = _MONTHNAMES.index(found_dict['b'].lower())
+      elif group_key == 'd':
+         day = int(found_dict['d'])
+      elif group_key == 'H':
+         hour = int(found_dict['H'])
+      elif group_key == 'I':
+         hour = int(found_dict['I'])
+         ampm = found_dict.get('p', '').lower()
+         # If there was no AM/PM indicator, we'll treat this like AM
+         if ampm in ('', locale_time.am_pm[0]):
+               # 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 == locale_time.am_pm[1]:
+               # 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 group_key == 'M':
+         minute = int(found_dict['M'])
+      elif group_key == 'S':
+         second = int(found_dict['S'])
+      elif group_key == 'f':
+         s = found_dict['f']
+         # Pad to always return microseconds.
+         s += "0" * (6 - len(s))
+         fraction = int(s)
+      elif group_key == 'A':
+         weekday = locale_time.f_weekday.index(found_dict['A'].lower())
+      elif group_key == 'a':
+         weekday = locale_time.a_weekday.index(found_dict['a'].lower())
+      elif group_key == 'w':
+         weekday = int(found_dict['w'])
+         if weekday == 0:
+               weekday = 6
+         else:
+               weekday -= 1
+      elif group_key == 'j':
+         julian = int(found_dict['j'])
+      elif group_key in ('U', 'W'):
+         week_of_year = int(found_dict[group_key])
+         if group_key == 'U':
+               # U starts week on Sunday.
+               week_of_year_start = 6
+         else:
+               # W starts week on Monday.
+               week_of_year_start = 0
+      elif group_key == 'z':
+         z = found_dict['z']
+         tzoffset = int(z[1:3]) * 60 + int(z[3:5])
+         if z.startswith("-"):
+               tzoffset = -tzoffset
+      elif group_key == 'Z':
+         # Since -1 is default value only need to worry about setting tz if
+         # it can be something other than -1.
+         found_zone = found_dict['Z'].lower()
+         for value, tz_values in enumerate(locale_time.timezone):
+               if found_zone in tz_values:
+                  # Deal with bad locale setup where timezone names are the
+                  # same and yet time.daylight is true; too ambiguous to
+                  # be able to tell what timezone has daylight savings
+                  if (time.tzname[0] == time.tzname[1] and
+                           time.daylight and found_zone not in ("utc", "gmt")):
+                     break
+                  else:
+                     tz = value
+                     break
+
+   if year is None:
+      year = 1975
+   if julian is None and week_of_year != -1 and weekday is not None:
+      week_starts_Mon = True if week_of_year_start == 0 else False
+      julian = _calc_julian_from_U_or_W(year, week_of_year, weekday,
+                                       week_starts_Mon)
+      if julian <= 0:
+         year -= 1
+         yday = 366 if calendar.isleap(year) else 365
+         julian += yday
+   # Cannot pre-calculate datetime_date() since can change in Julian
+   # calculation and thus could have different value for the day of the week
+   # calculation.
+   if julian is None:
+      # Need to add 1 to result since first day of the year is 1, not 0.
+      julian = datetime_date(year, month, day).toordinal() - \
+               datetime_date(year, 1, 1).toordinal() + 1
+   else:  # Assume that if they bothered to include Julian day it will
+      # be accurate.
+      datetime_result = datetime_date.fromordinal((julian - 1) + datetime_date(year, 1, 1).toordinal())
+      year = datetime_result.year
+      month = datetime_result.month
+      day = datetime_result.day
+   if weekday is None:
+      weekday = datetime_date(year, month, day).weekday()
+   # Add timezone info
+   tzname = found_dict.get("Z")
+   if tzoffset is not None:
+      gmtoff = tzoffset * 60
+   else:
+      gmtoff = None
+
+   return (year, month, day,
+         hour, minute, second,
+         weekday, julian, tz, tzname, gmtoff), fraction
+
+
+def _strptime_datetime(cls, data_string, format="%a %b %d %H:%M:%S %Y"):
+   """Return a class cls instance based on the input string and the
+   format string."""
+   tt, fraction = _strptime(data_string, format)
+   tzname, gmtoff = tt[-2:]
+   args = tt[:6] + (fraction,)
+   if gmtoff is not None:
+      tzdelta = datetime_timedelta(seconds=gmtoff)
+      if tzname:
+         tz = datetime_timezone(tzdelta, tzname)
+      else:
+         tz = datetime_timezone(tzdelta)
+      args += (tz,)
+
+   return cls(*args)

npdatetime/config.py

@@ -0,0 +1,14 @@
+import os
+
+# Define the base directory
+BASE_DIR = os.path.dirname(__file__)
+
+# Path to the calendar data file
+CALENDAR_PATH = os.path.join(BASE_DIR, 'data', 'calendar_bs.csv')
+
+# Reference date for conversions
+REFERENCE_DATE_AD = {'year': 1918, 'month': 4, 'day': 13}
+
+# Valid range for Nepali dates
+MINDATE = {'year': 1975, 'month': 1, 'day': 1}
+MAXDATE = {'year': 2100, 'month': 12, 'day': 30}