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

nepali/datetime/_datetime.py

@@ -1,441 +1,430 @@
-#
-#
-#	Author : Ajesh Sen Thapa
-#	Website: www.ajesh.com.np
-#
-#
-
-import time
 import datetime as pythonDateTime
-import warnings
-
-from nepali.timezone import NepaliTimeZone, utc_now
-from nepali.utils import to_nepali_timezone
-
-from ._converter import NepaliDateConverter
-
-
-class formater_class_mixin:
-	def get_formater_class(self):
-		return self.__class__.get_formater_class()
-
-	@classmethod
-	def get_formater_class(cls):
-		if not hasattr(cls, '__formater_class__Cache'):
-			from ._formarter import NepaliDateTimeFormater
-			cls.__formater_class__Cache = NepaliDateTimeFormater
-		return cls.__formater_class__Cache
-
-	@classmethod
-	def get_strptime_method(cls):
-		if not hasattr(cls, '_strptime_method_CACHE'):
-			from .parser import strptime
-			cls._strptime_method_CACHE = strptime
-		return cls._strptime_method_CACHE
-
-class nepalidate(formater_class_mixin):
-	def __init__(self, year, month, day) -> None:
-		self.__year = year
-		self.__month = month
-		self.__day = day
-
-		# converting to english date
-		year_en, month_en, day_en = NepaliDateConverter.nepali_to_english(year, month, day)
-		self.__python_date = pythonDateTime.date(year_en, month_en, day_en)
-
-	def __str__(self):
-		return self.strftime_en('%Y-%m-%d')
-
-	def __repr__(self):
-		return "<nepalidate> "+str(self)
-	
-	def to_datetime(self):
-		return pythonDateTime.datetime.combine(self.__python_date, pythonDateTime.time(), tzinfo=NepaliTimeZone())
-
-	def to_date(self):
-		return self.__python_date
-
-	def to_nepalidatetime(self):
-		return nepalidatetime.from_nepali_date(self)
-
-	def to_nepali_datetime(self):
-		warnings.warn(
-			message="nepalidate.to_nepali_datetime is depreciated and no longer be available in version >= 1.0.0, use nepalidate.to_nepalidatetime instead.", 
-			category=DeprecationWarning
-		)
-		return self.to_nepalidatetime()
-
-	def strftime(self, format):
-		NepaliDateTimeFormater = self.get_formater_class()
-		formater = NepaliDateTimeFormater(self)
-		return formater.get_str(format)
-
-	def strftime_en(self, format):
-		NepaliDateTimeFormater = self.get_formater_class()
-		formater = NepaliDateTimeFormater(self, english=True)
-		return formater.get_str(format)
-
-	
-	# operators overloading
-	# TODO: add more operators overloading
-	def __eq__(self, other):
-		""" equal """
-		
-		if type(other) == self.__class__:
-			"""
-			NepaliDate object
-			"""
-			return self.to_date() == other.to_date()
-
-		elif type(other) == pythonDateTime.date:
-			"""
-			pythonDate object
-			"""
-			return self.to_date() == to_nepali_timezone(other)
-			
-		return False
-
-	# static methods
-	@classmethod
-	def strptime(cls, datetime_str, format):
-		nepalidatetime_strptime = cls.get_strptime_method()
-		return nepalidatetime_strptime(datetime_str, format=format).date()
-
-	@staticmethod
-	def now(*args, **kwargs):
-		return nepalidate.today()
-
-	@staticmethod
-	def today():
-		year, month, day = NepaliDateConverter.current_nepali_date()
-		return nepalidate(year, month, day)
-
-	@staticmethod
-	def from_datetime(datetime_object):
-		return nepalidate.from_date(datetime_object.date())
-
-	@staticmethod
-	def from_date(date_object):
-		npDate = nepalidate(*NepaliDateConverter.english_to_nepali(date_object.year, date_object.month, date_object.day))
-		return npDate
-
-	@staticmethod
-	def from_nepalidatetime(datetime_object):
-		return datetime_object.date()
-
-	# property
-
-	def weekday(self):
-		'''
-		Sunday => 0, Saturday => 6
-		'''
-		return (self.__python_date.weekday() + 1) % 7
-		return self.__python_date.weekday()
-
-	# nepali date properties
-	@property
-	def year(self):
-		return self.__year
-
-	@property
-	def month(self):
-		return self.__month
-
-	@property
-	def day(self):
-		return self.__day
-
-	@property
-	def week_day(self):
-		warnings.warn(
-			message="nepalidate.week_day field is depreciated and no longer be available in version >= 1.0.0, use nepalidate.weekday() method instead.", 
-			category=DeprecationWarning
-		)
-		return self.weekday()
+
+from nepali.date_converter import converter as nepali_date_converter
+from nepali.timezone import NepaliTimeZone, to_nepali_timezone, utc_now
+
+from ._nepalimonth import nepalimonth
+
+
+class formatter_class_mixin:
+    """
+    mixin for date time formatter.
+    adds methods `strftime(format)`
+    """
+
+    def get_formatter_class(self):
+        return self.__class__.init_formatter_class()
+
+    @classmethod
+    def init_formatter_class(cls):
+        if not hasattr(cls, "_formatter_class_cache"):
+            from ._formatter import NepaliDateTimeFormatter
+
+            cls._formatter_class_cache = NepaliDateTimeFormatter
+        return cls._formatter_class_cache
+
+    @classmethod
+    def get_strptime_method(cls):
+        if not hasattr(cls, "_strptime_method_cache"):
+            from .parser import strptime
+
+            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:
+        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:
+        nepali_datetime_formatter = self.get_formatter_class()
+        formatter = nepali_datetime_formatter(self, devanagari=True)
+        return formatter.get_str(format)
+
+
+class nepalidate(formatter_class_mixin):
+    def __init__(self, year, month, day) -> None:
+        if isinstance(month, nepalimonth):
+            month = month.value
+
+        self.__year = year
+        self.__month = month
+        self.__day = day
+
+        # converting to english date
+        year_en, month_en, day_en = nepali_date_converter.nepali_to_english(
+            year, month, day
+        )
+        self.__python_date = pythonDateTime.date(year_en, month_en, day_en)
+
+    def __str__(self):
+        return self.strftime_en("%Y-%m-%d")
+
+    def __repr__(self):
+        return f"<nepalidate> {self}"
+
+    def to_datetime(self):
+        return pythonDateTime.datetime.combine(
+            self.__python_date, pythonDateTime.time(), tzinfo=NepaliTimeZone()
+        )
+
+    def to_date(self):
+        return self.__python_date
+
+    def to_nepalidatetime(self):
+        return nepalidatetime.from_nepali_date(self)
+
+    # operators overloading
+
+    def __add__(self, other):
+        """addition"""
+        if type(other) == pythonDateTime.timedelta:
+            # timedelta object
+            return nepalidate.from_date(self.to_date() + other)
+        return NotImplemented
+
+    def __sub__(self, other):
+        """subtraction"""
+        if type(other) == self.__class__:
+            # nepalidate object
+            return self.to_date() - other.to_date()
+
+        elif type(other) == pythonDateTime.date:
+            # python date object
+            return self.to_date() - other
+
+        elif type(other) == pythonDateTime.timedelta:
+            # timedelta object
+            return nepalidate.from_date(self.to_date() - other)
+
+        return NotImplemented
+
+    def __lt__(self, other):
+        """less than"""
+        if type(other) == self.__class__:
+            # nepalidatetime object
+            return self.to_date() < other.to_date()
+
+        elif type(other) == pythonDateTime.date:
+            # python date object
+            return self.to_date() < other
+
+        return NotImplemented
+
+    def __le__(self, other):
+        """less than equal"""
+        if type(other) == self.__class__:
+            # nepalidate object
+            return self.to_date() <= other.to_date()
+
+        elif type(other) == pythonDateTime.date:
+            # python date object
+            return self.to_date() <= other
+
+        return NotImplemented
+
+    def __eq__(self, other):
+        """equal"""
+        if type(other) == self.__class__:
+            # nepalidate object
+            return self.to_date() == other.to_date()
+
+        elif type(other) == pythonDateTime.date:
+            # python date object
+            return self.to_date() == other
+
+        return False
+
+    def __ne__(self, other):
+        """not equal"""
+        if type(other) == self.__class__:
+            # nepalidate object
+            return self.to_date() != other.to_date()
+
+        elif type(other) == pythonDateTime.date:
+            # python date object
+            return self.to_date() != other
+
+        return True
+
+    def __gt__(self, other):
+        """greater than"""
+        if type(other) == self.__class__:
+            # nepalidate object
+            return self.to_date() > other.to_date()
+
+        elif type(other) == pythonDateTime.date:
+            # python date object
+            return self.to_date() > other
+
+        return NotImplemented
+
+    def __ge__(self, other):
+        """greater than equal"""
+        if type(other) == self.__class__:
+            # nepalidate object
+            return self.to_date() >= other.to_date()
+
+        elif type(other) == pythonDateTime.date:
+            # python date object
+            return self.to_date() >= other
+
+        return NotImplemented
+
+    # static methods
+    @classmethod
+    def strptime(cls, datetime_str, format):
+        nepalidatetime_strptime = cls.get_strptime_method()
+        return nepalidatetime_strptime(datetime_str, format=format).date()
+
+    @staticmethod
+    def now():
+        return nepalidate.today()
+
+    @staticmethod
+    def today():
+        return nepalidate.from_date(pythonDateTime.date.today())
+
+    @staticmethod
+    def from_datetime(datetime_object):
+        return nepalidate.from_date(datetime_object.date())
+
+    @staticmethod
+    def from_date(date_object):
+        return nepalidate(
+            *nepali_date_converter.english_to_nepali(
+                date_object.year, date_object.month, date_object.day
+            )
+        )
+
+    @staticmethod
+    def from_nepalidatetime(datetime_object):
+        return datetime_object.date()
+
+    # property
+
+    def weekday(self):
+        """
+        Sunday => 0, Saturday => 6
+        """
+        return (self.__python_date.weekday() + 1) % 7
+
+    # nepali date properties
+    @property
+    def year(self):
+        return self.__year
+
+    @property
+    def month(self):
+        return self.__month
+
+    @property
+    def day(self):
+        return self.__day
+
 
 class nepalitime(pythonDateTime.time):
+    def __repr__(self):
+        return f"<nepalitime> {self}"
+
+    # static methods
+
+    @staticmethod
+    def now():
+        dt_now = pythonDateTime.datetime.now()
+        return nepalitime(dt_now.hour, dt_now.minute, dt_now.second, dt_now.microsecond)
+
+
+class nepalidatetime(formatter_class_mixin):
+    """
+    nepalidatetime
+    """
+
+    def __init__(self, year, month, day, hour=0, minute=0, second=0, microsecond=0):
+        self.__np_date = nepalidate(year, month, day)
+        self.__np_time = nepalitime(hour, minute, second, microsecond)
+
+    def __str__(self):
+        return f"{self.__np_date} {self.__np_time}"
+
+    def __repr__(self):
+        return f"<nepalidatetime> {self}"
+
+    # operator overloading
+
+    def __add__(self, other):
+        """addition"""
+        if type(other) == pythonDateTime.timedelta:
+            # timedelta object
+            return nepalidatetime.from_datetime(self.to_datetime() + other)
+
+        return NotImplemented
+
+    def __sub__(self, other):
+        """subtraction"""
+        if type(other) == self.__class__:
+            # nepalidatetime object
+            return self.to_datetime() - other.to_datetime()
+
+        elif type(other) == pythonDateTime.datetime:
+            # python datetime object
+            return self.to_datetime() - to_nepali_timezone(other)
 
-	def __repr__(self):
-		return "<nepalitime> "+str(self)
+        elif type(other) == pythonDateTime.timedelta:
+            # timedelta object
+            return nepalidatetime.from_datetime(self.to_datetime() - other)
 
-	# static methods
-	
-	@staticmethod
-	def now(*args, **kwargs):
-		dt_now = pythonDateTime.datetime.now()
-		return nepalitime(dt_now.hour, dt_now.minute, dt_now.second, dt_now.microsecond)
+        return NotImplemented
 
+    def __lt__(self, other):
+        """less than"""
+        if type(other) == self.__class__:
+            # nepalidatetime object
+            return self.to_datetime() < other.to_datetime()
 
-class nepalidatetime(formater_class_mixin):
-	"""
-	nepalidatetime
-	"""
+        elif type(other) == pythonDateTime.datetime:
+            # python datetime object
+            return self.to_datetime() < to_nepali_timezone(other)
 
-	def __init__(self, year, month, day, hour=0, minute=0, second=0, microsecond=0):
-		self.__npDate = nepalidate(year, month, day)
-		self.__npTime = nepalitime(hour, minute, second, microsecond) 
+        return NotImplemented
 
-	def __str__(self):
-		return str(self.__npDate)+' '+str(self.__npTime)
+    def __le__(self, other):
+        """less than equal"""
+        if type(other) == self.__class__:
+            # nepalidatetime object
+            return self.to_datetime() <= other.to_datetime()
 
-	def __repr__(self):
-		return "<nepalidatetime> "+str(self)
+        elif type(other) == pythonDateTime.datetime:
+            # python datetime object
+            return self.to_datetime() <= to_nepali_timezone(other)
 
+        return NotImplemented
 
-	# operator overloadings
+    def __eq__(self, other):
+        """equal"""
+        if type(other) == self.__class__:
+            # nepalidatetime object
+            return self.to_datetime() == other.to_datetime()
 
-	def __add__(self, other):
-		""" addition """
+        elif type(other) == pythonDateTime.datetime:
+            # python datetime object
+            return self.to_datetime() == to_nepali_timezone(other)
 
-		if type(other) == pythonDateTime.timedelta:
-			"""
-			timedelta object
-			"""
-			return nepalidatetime.from_datetime(self.to_datetime() + other)
+        return False
 
+    def __ne__(self, other):
+        """not equal"""
+        if type(other) == self.__class__:
+            # nepalidatetime object
+            return self.to_datetime() != other.to_datetime()
 
-		return None
+        elif type(other) == pythonDateTime.datetime:
+            # python datetime object
+            return self.to_datetime() != to_nepali_timezone(other)
 
-	def __sub__(self, other):
-		""" substraction """
+        return True
 
-		if type(other) == self.__class__:
-			"""
-			nepalidatetime object
-			"""
-			return self.to_datetime() - other.to_datetime()
+    def __gt__(self, other):
+        """greater than"""
+        if type(other) == self.__class__:
+            # nepalidatetime object
+            return self.to_datetime() > other.to_datetime()
 
-		elif type(other) == pythonDateTime.datetime:
-			return self.to_datetime() - to_nepali_timezone(other)
+        elif type(other) == pythonDateTime.datetime:
+            # python datetime object
+            return self.to_datetime() > to_nepali_timezone(other)
 
-		elif type(other) == pythonDateTime.timedelta:
-			"""
-			timedelta object
-			"""
-			return nepalidatetime.from_datetime(self.to_datetime() - other)
+        return NotImplemented
 
+    def __ge__(self, other):
+        """greater than equal"""
+        if type(other) == self.__class__:
+            # nepalidatetime object
+            return self.to_datetime() >= other.to_datetime()
 
-		return None
+        elif type(other) == pythonDateTime.datetime:
+            # python datetime object
+            return self.to_datetime() >= to_nepali_timezone(other)
 
-	def __lt__(self, other):
-		""" less than """
+        return NotImplemented
 
-		if type(other) == self.__class__:
-			"""
-			nepalidatetime object
-			"""
-			return self.to_datetime() < other.to_datetime()
+    # object transformation
 
-		elif type(other) == pythonDateTime.datetime:
-			"""
-			pythonDateTime object
-			"""
-			return self.to_datetime() < to_nepali_timezone(other)
+    def to_datetime(self):
+        return pythonDateTime.datetime.combine(
+            self.__np_date.to_date(), self.__np_time, tzinfo=NepaliTimeZone()
+        )
 
+    def to_date(self):
+        return self.to_datetime().date()
 
-		return None
+    def date(self):
+        return self.__np_date
+
+    def time(self):
+        return self.__np_time
 
-	def __le__(self, other):
-		""" less than equal """
+    # static methods
 
-		if type(other) == self.__class__:
-			"""
-			nepalidatetime object
-			"""
-			return self.to_datetime() <= other.to_datetime()
+    @classmethod
+    def strptime(cls, datetime_str, format):
+        nepalidatetime_strptime = cls.get_strptime_method()
+        return nepalidatetime_strptime(datetime_str, format=format)
 
-		elif type(other) == pythonDateTime.datetime:
-			"""
-			pythonDateTime object
-			"""
-			return self.to_datetime() <= to_nepali_timezone(other)
+    @staticmethod
+    def from_datetime(dt):
+        dt = to_nepali_timezone(dt)
+        nd = nepalidate.from_date(dt.date())
+        return nepalidatetime(
+            nd.year, nd.month, nd.day, dt.hour, dt.minute, dt.second, dt.microsecond
+        )
 
+    @staticmethod
+    def from_date(date_object):
+        nepali_date_object = nepalidate.from_date(date_object)
+        return nepalidatetime.from_nepali_date(nepali_date_object)
 
-		return None
+    @staticmethod
+    def from_nepali_date(nepali_date_object):
+        return nepalidatetime(
+            nepali_date_object.year, nepali_date_object.month, nepali_date_object.day
+        )
+
+    @staticmethod
+    def now():
+        return nepalidatetime.from_datetime(utc_now())
 
-	def __eq__(self, other):
-		""" equal """
-		
-		if type(other) == self.__class__:
-			"""
-			nepalidatetime object
-			"""
-			return self.to_datetime() == other.to_datetime()
+    # property
 
-		elif type(other) == pythonDateTime.datetime:
-			"""
-			pythonDateTime object
-			"""
-			return self.to_datetime() == to_nepali_timezone(other)
-
-		return False
+    @property
+    def year(self):
+        return self.__np_date.year
 
+    @property
+    def month(self):
+        return self.__np_date.month
 
-	def __ne__(self, other):
-		""" not equal """
+    @property
+    def day(self):
+        return self.__np_date.day
 
-		if type(other) == self.__class__:
-			"""
-			nepalidatetime object
-			"""
-			return self.to_datetime() != other.to_datetime()
+    def weekday(self):
+        """
+        Sunday => 0, Saturday => 6
+        """
+        return self.__np_date.weekday()
+
+    @property
+    def hour(self):
+        return self.__np_time.hour
 
-		elif type(other) == pythonDateTime.datetime:
-			"""
-			pythonDateTime object
-			"""
-			return self.to_datetime() != to_nepali_timezone(other)
-		
-		return True
-	
-	def __gt__(self, other):
-		""" greater than """
-
-		if type(other) == self.__class__:
-			"""
-			nepalidatetime object
-			"""
-			return self.to_datetime() > other.to_datetime()
-
-		elif type(other) == pythonDateTime.datetime:
-			"""
-			pythonDateTime object
-			"""
-			return self.to_datetime() > to_nepali_timezone(other)
-
-			
-		return None
-	
-	def __ge__(self, other):
-		""" greater than equal """
-
-		if type(other) == self.__class__:
-			"""
-			nepalidatetime object
-			"""
-			return self.to_datetime() >= other.to_datetime()
-
-		elif type(other) == pythonDateTime.datetime:
-			"""
-			pythonDateTime object
-			"""
-			return self.to_datetime() >= to_nepali_timezone(other)
-
-			
-		return None 
-
-	# object transformation
-	def to_datetime(self):
-		return pythonDateTime.datetime.combine(self.__npDate.to_date(), self.__npTime, tzinfo=NepaliTimeZone())
-
-	def to_date(self):
-		return self.to_datetime().date()
-
-	def date(self):
-		return self.__npDate
-
-	def time(self):
-		return self.__npTime
-
-	# string format
-	def strftime(self, format):
-		NepaliDateTimeFormater = self.get_formater_class()
-		formater = NepaliDateTimeFormater(self)
-		return formater.get_str(format)
-
-	def strftime_en(self, format):
-		NepaliDateTimeFormater = self.get_formater_class()
-		formater = NepaliDateTimeFormater(self, english=True)
-		return formater.get_str(format)
-
-	# static methods
-
-	@classmethod
-	def strptime(cls, datetime_str, format):
-		nepalidatetime_strptime = cls.get_strptime_method()
-		return nepalidatetime_strptime(datetime_str, format=format)
-
-	@staticmethod
-	def from_datetime(dt):
-		dt = to_nepali_timezone(dt)
-		nd = nepalidate.from_date(dt.date())
-		return nepalidatetime(nd.year, nd.month, nd.day, dt.hour, dt.minute, dt.second, dt.microsecond)
-
-	@staticmethod
-	def from_date(date_object):
-		nepali_date_object = nepalidate.from_date(date_object)
-		return nepalidatetime.from_nepali_date(nepali_date_object)
-
-	@staticmethod
-	def from_nepali_date(nepali_date_object):
-		return nepalidatetime(nepali_date_object.year, nepali_date_object.month, nepali_date_object.day)
-
-	@staticmethod
-	def now():
-		return nepalidatetime.from_datetime(utc_now())
-
-	# property
-
-	@property
-	def year(self):
-		return self.__npDate.year
-
-	@property
-	def month(self):
-		return self.__npDate.month
-
-	@property
-	def day(self):
-		return self.__npDate.day
-
-	def weekday(self):
-		'''
-		Sunday => 0, Saturday => 6
-		'''
-		return self.__npDate.weekday()
-
-	@property
-	def week_day(self):
-		warnings.warn(
-			message="nepalidate.week_day field is depreciated and no longer be available in version >= 1.0.0, use nepalidatetime.weekday() method instead.", 
-			category=DeprecationWarning
-		)
-		return self.__npDate.weekday()
-
-	@property
-	def hour(self):
-		return self.__npTime.hour
-
-	@property
-	def minute(self):
-		return self.__npTime.minute
-
-	@property
-	def second(self):
-		return self.__npTime.second
-
-
-class NepaliDate(nepalidate):
-	def __init__(self, *args, **kwargs):
-		warnings.warn(
-			message="NepaliDate is depreciated and no longer be available in version >= 1.0.0, use nepalidate instead.", 
-			category=DeprecationWarning
-		)
-		super().__init__(*args, **kwargs)
-
-class NepaliTime(nepalidate):
-	def __init__(self, *args, **kwargs):
-		warnings.warn(
-			message="NepaliTime is depreciated and no longer be available in version >= 1.0.0, use nepalitime instead.", 
-			category=DeprecationWarning
-		)
-		super().__init__(*args, **kwargs)
-
-class NepaliDateTime(nepalidate):
-	def __init__(self, *args, **kwargs):
-		warnings.warn(
-			message="NepaliDateTime is depreciated and no longer be available in version >= 1.0.0, use nepalidatetime instead.", 
-			category=DeprecationWarning
-		)
-		super().__init__(*args, **kwargs)
+    @property
+    def minute(self):
+        return self.__np_time.minute
 
+    @property
+    def second(self):
+        return self.__np_time.second