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

nepali/datetime/_nepalimonth.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from functools import cached_property
+from typing import Any
+
+from nepali.constants import NEPALI_MONTHS_EN, NEPALI_MONTHS_NE
+
+
+class NepaliMonthMeta(type):
+    _cache: dict[int, nepalimonth] = {}
+
+    def __call__(cls, month: int | str, *args, **kwargs) -> nepalimonth:
+        """
+        Parses the month data and manages the cache.
+
+        :param month: An integer or string representing the month.
+        :type month: Union[int, str]
+        :return: An instance of the nepalimonth class representing the given month.
+        :rtype: nepalimonth
+        :raises ValueError: If the given month is invalid.
+        """
+        value: int | None = None
+        value = None
+
+        if isinstance(month, int):
+            value = int(month)
+        elif isinstance(month, str):
+            try:
+                value = cls._parse_str(month)
+            except ValueError:
+                pass
+
+        # checking if month is valid
+        if value is None or value < 1 or value > 12:
+            raise ValueError(f"Invalid month: {month}")
+
+        # checking cache
+        if value not in cls._cache:
+            cls._cache[value] = super(NepaliMonthMeta, cls).__call__(
+                value, *args, **kwargs
+            )
+
+        return cls._cache[value]
+
+    @staticmethod
+    def _parse_str(month: str) -> int:
+        """
+        Parses str value of the month and returns int.
+
+        :param month: A string representing the month.
+        :type month: str
+        :return: An integer representing the month.
+        :rtype: int
+        :raises ValueError: If the given string does not represent a valid month.
+        """
+        if month.isdigit():
+            return int(month)
+
+        month = month.capitalize()
+        month_names = NEPALI_MONTHS_EN + NEPALI_MONTHS_NE
+        try:
+            index = month_names.index(month)
+        except ValueError:
+            raise ValueError(f"Invalid month name: {month}")
+
+        return (index % 12) + 1
+
+
+class nepalimonth(metaclass=NepaliMonthMeta):
+    """
+    Represents Nepali month: Baishakh, Jestha, ..., Chaitra.
+    Baishakh: 1,
+    Jestha: 2,
+    ...
+    Chaitra: 12
+
+    >>> nepalimonth(1)
+    >>> nepalimonth("Baishakh")
+    >>> nepalimonth("बैशाख")
+
+    :param Union[int, str] month: Month data to be parsed.
+
+    :raises ValueError: The value is invalid.
+    """
+
+    def __init__(self, month) -> None:
+        self.__value = month
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return f"<nepalimonth: {self.__value}>"
+
+    def __int__(self) -> int:
+        return self.value
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, nepalimonth):
+            return self.value == other.value
+        elif isinstance(other, int):
+            return self.value == other
+
+        return False
+
+    @cached_property
+    def value(self) -> int:
+        return self.__value
+
+    @cached_property
+    def name(self) -> str:
+        """Month's english name"""
+        return NEPALI_MONTHS_EN[self.__value - 1]
+
+    @cached_property
+    def name_ne(self) -> str:
+        """Month's nepali name"""
+        return NEPALI_MONTHS_NE[self.__value - 1]

nepali/datetime/_nepaliweek.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from functools import cached_property
+from typing import Any
+
+from nepali.constants import WEEKS_ABBR_EN, WEEKS_ABBR_NE, WEEKS_EN, WEEKS_NE
+
+
+class NepaliWeekMeta(type):
+    _cache: dict[int, nepaliweek] = {}
+
+    def __call__(cls, week: int | str, *args, **kwargs) -> nepaliweek:
+        """
+        Parses the week data and manages the cache.
+
+        :param week: An integer or string representing the week.
+        :type week: Union[int, str]
+        :return: An instance of the nepaliweek class representing the given week.
+        :rtype: nepaliweek
+        :raises ValueError: If the given week is invalid.
+        """
+        value: int | None = None
+
+        if isinstance(week, int):
+            value = int(week)
+        elif isinstance(week, str):
+            try:
+                value = cls._parse_str(week)
+            except ValueError:
+                pass
+
+        # checking if week is valid
+        if value is None or not 0 <= value <= 6:
+            raise ValueError(f"Invalid week: {week}")
+
+        # checking cache
+        if value not in cls._cache:
+            cls._cache[value] = super().__call__(value, *args, **kwargs)
+
+        return cls._cache[value]
+
+    @staticmethod
+    def _parse_str(week: str) -> int:
+        """
+        Parses str value of the week and returns int.
+
+        :param week: A string representing the week.
+        :type week: str
+        :return: An integer representing the week.
+        :rtype: int
+        :raises ValueError: If the given string does not represent a valid week.
+        """
+        if week.isdigit():
+            return int(week)
+
+        week = week.capitalize()
+        week_names = WEEKS_EN + WEEKS_NE + WEEKS_ABBR_EN + WEEKS_ABBR_NE
+        try:
+            index = week_names.index(week)
+        except ValueError:
+            raise ValueError(f"Invalid week name: {week}")
+
+        return index % 7
+
+
+class nepaliweek(metaclass=NepaliWeekMeta):
+    """
+    Represents Nepali week: Sunday, Monday, ..., Saturday.
+    Sunday: 0,
+    Monday: 1,
+    ...
+    Saturday: 6
+
+    >>> nepaliweek(0)
+    >>> nepaliweek("Sunday")
+    >>> nepaliweek("आइतबार")
+    >>> nepaliweek("Sun")
+
+    :param Union[int, str] week: Week data to be parsed.
+    :raises ValueError: The value is invalid.
+    """
+
+    def __init__(self, week) -> None:
+        self.__value = week
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return f"<nepaliweek: {self.__value}>"
+
+    def __int__(self) -> int:
+        return self.value
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, nepaliweek):
+            return self.value == other.value
+        elif isinstance(other, int):
+            return self.value == other
+
+        return False
+
+    @cached_property
+    def value(self) -> int:
+        return self.__value
+
+    @cached_property
+    def name(self) -> str:
+        """Week's english name"""
+        return WEEKS_EN[self.__value]
+
+    @cached_property
+    def abbr(self) -> str:
+        """Week's english abbreviated name"""
+        return WEEKS_ABBR_EN[self.__value]
+
+    @cached_property
+    def name_ne(self) -> str:
+        """Week's nepali name"""
+        return WEEKS_NE[self.__value]
+
+    @cached_property
+    def abbr_ne(self) -> str:
+        """Week's nepali abbreviated name"""
+        return WEEKS_ABBR_NE[self.__value]

nepali/datetime/parser/__init__.py

@@ -1,6 +1,6 @@
-from ._parser import strptime, parse
+from ._parser import parse, strptime
 
 __all__ = [
-	'strptime',
-	'parse',
-]
+    "strptime",
+    "parse",
+]

nepali/datetime/parser/_parser.py

@@ -1,65 +1,74 @@
-from nepali.exceptions import InvalidDateTimeFormatException, FormatNotMatchException
+from nepali.exceptions import FormatNotMatchException, InvalidDateTimeFormatException
 
-from.validators import validate
+from .validators import validate
 
-__all__ = ["strptime", "parse",]
+__all__ = [
+    "strptime",
+    "parse",
+]
 
 _standard_datetime_format_CACHE = None
 
+
 def strptime(datetime_str, format):
-	'''
-	Parses nepalidatetime str with the corresponding format.
-	returns nepalidatetime object.
-	'''
-	nepalidatetime_object = validate(datetime_str, format)
-	if nepalidatetime_object == None:
-		raise FormatNotMatchException('Datetime string did not match with the given format.') 
-	return nepalidatetime_object
+    """
+    Parses nepalidatetime str with the corresponding format.
+    returns nepalidatetime object.
+    """
+    nepalidatetime_object = validate(datetime_str, format)
+    if nepalidatetime_object is None:
+        raise FormatNotMatchException(
+            "Datetime string did not match with the given format."
+        )
+    return nepalidatetime_object
+
 
 def _get_standard_formats():
-	global _standard_datetime_format_CACHE
-	if _standard_datetime_format_CACHE != None:
-		return _standard_datetime_format_CACHE
+    global _standard_datetime_format_CACHE
+    if _standard_datetime_format_CACHE is not None:
+        return _standard_datetime_format_CACHE
 
-	STANDARD_DATE_FORMAT = [
-		'%Y-%m-%d',
-		'%d-%m-%Y',
-		'%Y %m %d',
-		'%Y %B %d',
-		'%d %B %Y',
-		'%d %B, %Y',
-		'%B %d, %Y',
-		'%Y/%m/%d',
-		'%d/%m/%Y',
-	]
+    STANDARD_DATE_FORMAT = [
+        "%Y-%m-%d",
+        "%d-%m-%Y",
+        "%Y %m %d",
+        "%Y %B %d",
+        "%d %B %Y",
+        "%d %B, %Y",
+        "%B %d, %Y",
+        "%Y/%m/%d",
+        "%d/%m/%Y",
+    ]
 
-	STANDARD_TIME_FORMAT = [
-		'%H:%M',
-		'%I:%M %p',
-		'%I %p',
-		'%I%p',
-		'%H:%M:%S',
-		'%H:%M:%S:%f',
-	]
+    STANDARD_TIME_FORMAT = [
+        "%H:%M",
+        "%I:%M %p",
+        "%I %p",
+        "%I%p",
+        "%H:%M:%S",
+        "%H:%M:%S:%f",
+    ]
 
-	_standard_datetime_format_CACHE = STANDARD_DATE_FORMAT.copy()
-	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)]
-	return _standard_datetime_format_CACHE
+    _standard_datetime_format_CACHE = STANDARD_DATE_FORMAT.copy()
+    for time_format in STANDARD_TIME_FORMAT:
+        for date_format in STANDARD_DATE_FORMAT:
+            _standard_datetime_format_CACHE += [
+                f"{date_format} {time_format}",
+                f"{date_format}, {time_format}",
+            ]
+    return _standard_datetime_format_CACHE
 
 
 def parse(datetime_str):
-	"""
-	parses nepali datetime
-	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 != None:
-			return nepalidatetime_object
+    """
+    parses nepali datetime
+    eg. parse('2078-10-12') => <NepaliDateTime: 2078-10-12>
+    """
+    standard_formats = _get_standard_formats()
+    for format in standard_formats:
+        try:
+            return strptime(datetime_str, format=format)
+        except FormatNotMatchException:
+            pass
 
-	raise InvalidDateTimeFormatException('Invalid format to parse nepali datetime.') 
+    raise InvalidDateTimeFormatException("Invalid format to parse nepali datetime.")