persiantools 5.2.1__tar.gz → 5.3.0__tar.gz

{persiantools-5.2.1 → persiantools-5.3.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016-2025 Majid Hajiloo
+Copyright (c) 2016 Majid Hajiloo
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{persiantools-5.2.1/persiantools.egg-info → persiantools-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: persiantools
-Version: 5.2.1
+Version: 5.3.0
 Summary: Jalali date and datetime with other tools
 Home-page: https://github.com/majiidd/persiantools
 Author: Majid Hajiloo
@@ -8,7 +8,6 @@ Author-email: majid.hajiloo@gmail.com
 License: MIT
 Keywords: jalali shamsi persian digits characters converter jalalidate jalalidatetime date datetime jdate jdatetime farsi
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: Persian
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python

{persiantools-5.2.1 → persiantools-5.3.0}/persiantools/__init__.py

@@ -7,7 +7,7 @@
 
 __title__ = "persiantools"
 __url__ = "https://github.com/majiidd/persiantools"
-__version__ = "5.2.1"
+__version__ = "5.3.0"
 __build__ = __version__
 __author__ = "Majid Hajiloo"
 __author_email__ = "majid.hajiloo@gmail.com"

{persiantools-5.2.1 → persiantools-5.3.0}/persiantools/jdatetime.py

@@ -633,12 +633,13 @@ class JalaliDate:
             raise ValueError(f"Invalid date separator: {dtstr[4]}")
 
         month = int(dtstr[5:7])
-
         if dtstr[7] != "-":
             raise ValueError("Invalid date separator")
 
         day = int(dtstr[8:10])
 
+        cls._check_date_fields(year, month, day, "en")
+
         return [year, month, day]
 
     def __hash__(self):
@@ -941,8 +942,122 @@ class JalaliDate:
         raise NotImplementedError
 
     @classmethod
-    def strptime(cls, data_string, fmt):
-        raise NotImplementedError
+    def strptime(cls, data_string, fmt, locale="en"):
+        if locale not in ["en", "fa"]:
+            raise ValueError("locale must be 'en' or 'fa'")
+
+        if locale == "fa":
+            data_string = digits.fa_to_en(data_string)
+
+        month_names_list = MONTH_NAMES_EN[1:] if locale == "en" else MONTH_NAMES_FA[1:]
+        month_names_abbr_list = MONTH_NAMES_ABBR_EN[1:] if locale == "en" else MONTH_NAMES_ABBR_FA[1:]
+        weekday_names_list = WEEKDAY_NAMES_EN if locale == "en" else WEEKDAY_NAMES_FA
+        weekday_names_abbr_list = WEEKDAY_NAMES_ABBR_EN if locale == "en" else WEEKDAY_NAMES_ABBR_FA
+
+        directives_regex_pattern = {
+            "%Y": r"(?P<Y>\d{4})",
+            "%y": r"(?P<y>\d{2})",
+            "%m": r"(?P<m>1[0-2]|0?[1-9])",
+            "%d": r"(?P<d>\d{1,2})",
+            "%b": cls._seqToRE(month_names_abbr_list, "b"),
+            "%B": cls._seqToRE(month_names_list, "B"),
+            "%a": cls._seqToRE(weekday_names_abbr_list, "a"),
+            "%A": cls._seqToRE(weekday_names_list, "A"),
+        }
+
+        fmt = utils.replace(
+            fmt,
+            {
+                "%x": "%Y/%m/%d",
+                "%c": "%a %b %d %Y",
+            },
+        )
+
+        data_string_regex = utils.replace(fmt, directives_regex_pattern)
+        full_pattern = f"^{data_string_regex}$"
+
+        match = re.match(full_pattern, data_string, re.IGNORECASE)
+        if not match:
+            match_strict = re.match(f"^{data_string_regex}$", data_string, re.IGNORECASE)
+            if not match_strict:
+                raise ValueError(f"Date string '{data_string}' does not match format '{fmt}'")
+            directives = match_strict.groupdict()
+        else:
+            directives = match.groupdict()
+
+        parsed_components = {}
+        for k, v in directives.items():
+            if v is not None:
+                if k not in ["a", "A", "b", "B"] and v.isdigit():
+                    parsed_components[k] = int(v)
+                else:
+                    parsed_components[k] = v
+
+        year = parsed_components.get("Y")
+        yy = parsed_components.get("y")
+
+        if year is None and yy is not None:
+            if not (0 <= yy <= 99):
+                raise ValueError(f"Year without century (yy) '{yy}' out of range 00-99.")
+            # Heuristic: if yy > 70, assume 13yy, else 14yy.
+            year = (
+                (1300 + yy) if yy > (2070 - 2000) else (1400 + yy)
+            )  # Adjusted heuristic to be roughly 70 for 1300 century.
+            # Current Jalali year is around 140x. So values like 01, 02.. up to e.g. 70 => 14xx.
+            # values like 71, 72 .. 99 => 13xx.
+        elif year is None:
+            raise ValueError("Year information is missing from the date string or format.")
+
+        month = parsed_components.get("m")
+        if month is None:
+            month_name_abbr = parsed_components.get("b")
+            month_name_full = parsed_components.get("B")
+
+            found_month = False
+            if month_name_abbr is not None:
+                normalized_month_abbr = month_name_abbr.capitalize() if locale == "en" else month_name_abbr
+                try:
+                    month = month_names_abbr_list.index(normalized_month_abbr) + 1
+                    found_month = True
+                except ValueError:
+                    try:
+                        month = month_names_list.index(normalized_month_abbr) + 1
+                        found_month = True
+                    except ValueError:
+                        pass
+
+            if not found_month and month_name_full is not None:
+                normalized_month_full = month_name_full.capitalize() if locale == "en" else month_name_full
+                try:
+                    month = month_names_list.index(normalized_month_full) + 1
+                    found_month = True
+                except ValueError:
+                    pass
+
+            if not found_month:
+                raise ValueError(
+                    f"Month name not recognized from '{month_name_abbr or month_name_full}' for locale '{locale}'."
+                )
+
+        day = parsed_components.get("d")
+        if day is None:
+            raise ValueError("Day information is missing from the date string or format.")
+
+        cls._check_date_fields(year, month, day, locale)
+
+        return cls(year, month, day, locale=locale)
+
+    @staticmethod
+    def _seqToRE(to_convert, directive):
+        to_convert = sorted(to_convert, key=len, reverse=True)
+        for value in to_convert:
+            if value != "":
+                break
+        else:
+            return ""
+        regex = "|".join(re_escape(stuff) for stuff in to_convert)
+        regex = f"(?P<{directive}>{regex}"
+        return "%s)" % regex
 
 
 _tzinfo_class = tzinfo
@@ -1604,21 +1719,26 @@ class JalaliDateTime(JalaliDate):
         look for the table under "strftime() and strptime() Format Codes" section.
         """
         directives_regex_pattern = {
-            "%Y": r"(?P<Y>\d\d\d\d)",
+            "%Y": r"(?P<Y>\d{4})",
             "%m": r"(?P<m>1[0-2]|0[1-9]|[1-9])",
             "%d": r"(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])",
-            "%a": cls.__seqToRE(cls, weekday_names_abbr, "a"),
-            "%A": cls.__seqToRE(cls, weekday_names, "A"),
-            "%b": cls.__seqToRE(cls, month_names_abbr, "b"),
-            "%B": cls.__seqToRE(cls, month_names, "B"),
+            "%a": cls._seqToRE(weekday_names_abbr, "a"),
+            "%A": cls._seqToRE(weekday_names, "A"),
+            "%b": cls._seqToRE(month_names_abbr, "b"),
+            "%B": cls._seqToRE(month_names, "B"),
             "%H": r"(?P<H>2[0-3]|[0-1]\d|\d)",
             "%I": r"(?P<I>1[0-2]|0[1-9]|[1-9])",
-            "%p": cls.__seqToRE(cls, periods, "p"),
+            "%p": cls._seqToRE(periods, "p"),
             "%M": r"(?P<M>[0-5]\d|\d)",
             "%S": r"(?P<S>6[0-1]|[0-5]\d|\d)",
             "%f": r"(?P<f>\d{1,6})",
-            "%z": r"(?P<z>[-+](?P<zH>[0-1]?[0-9]|2[0-3])(?P<zM>[0-5]?[0-9])(?P<zS>[0-5]?[0-9])?(\.(?P<zf>(\d{,6})))?)",
-            "%Z": cls.__seqToRE(cls, pytz.all_timezones, "Z"),
+            "%z": (
+                r"(?P<z>[-+](?P<zH>2[0-3]|[0-1]\d)"
+                r"(?:[:]?)(?P<zM>[0-5]\d)"
+                r"(?:[:]?(?P<zS>[0-5]\d))?"
+                r"(?:\.(?P<zf>\d{1,6}))?)"
+            ),
+            "%Z": cls._seqToRE(pytz.all_timezones, "Z"),
         }
 
         fmt = utils.replace(
@@ -1631,8 +1751,9 @@ class JalaliDateTime(JalaliDate):
         )
 
         data_string_regex = utils.replace(fmt, directives_regex_pattern)
+        full_pattern = f"^{data_string_regex}$"
 
-        if re.match(data_string_regex, data_string, re.IGNORECASE):
+        if re.match(full_pattern, data_string, re.IGNORECASE):
             directives = re.search(data_string_regex, data_string, re.IGNORECASE).groupdict()
 
             if "Y" in directives.keys() and len(directives.get("Y")) < 4:
@@ -1684,17 +1805,6 @@ class JalaliDateTime(JalaliDate):
         else:
             raise ValueError("data string and format are not matched")
 
-    def __seqToRE(self, to_convert, directive):
-        to_convert = sorted(to_convert, key=len, reverse=True)
-        for value in to_convert:
-            if value != "":
-                break
-        else:
-            return ""
-        regex = "|".join(re_escape(stuff) for stuff in to_convert)
-        regex = f"(?P<{directive}>{regex}"
-        return "%s)" % regex
-
     def __repr__(self):
         """Convert to formal string, for repr()."""
         d_datetime = [

{persiantools-5.2.1 → persiantools-5.3.0/persiantools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: persiantools
-Version: 5.2.1
+Version: 5.3.0
 Summary: Jalali date and datetime with other tools
 Home-page: https://github.com/majiidd/persiantools
 Author: Majid Hajiloo
@@ -8,7 +8,6 @@ Author-email: majid.hajiloo@gmail.com
 License: MIT
 Keywords: jalali shamsi persian digits characters converter jalalidate jalalidatetime date datetime jdate jdatetime farsi
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: Persian
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python

{persiantools-5.2.1 → persiantools-5.3.0}/setup.py

@@ -18,7 +18,6 @@ setup(
     long_description_content_type="text/markdown",
     classifiers=[
         "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
         "Natural Language :: Persian",
         "Operating System :: OS Independent",
         "Programming Language :: Python",

{persiantools-5.2.1 → persiantools-5.3.0}/tests/test_digits.py

@@ -90,3 +90,14 @@ class TestDigits(TestCase):
 
         with pytest.raises(TypeError):
             digits.to_word("123")
+
+    def test_fractional_part_too_long(self):
+        old_mantissa = digits.MANTISSA
+        try:
+            digits.MANTISSA = ("دهم",)
+            with self.assertRaises(ValueError, msg="Fractional part is too long"):
+                # 0.15 -> left = "0", right = "15", right.rstrip("0") == "15"
+                # mantissa_index = len("15") - 1 == 1, which is >= len(MANTISSA) == 1.
+                digits.to_word(0.15)
+        finally:
+            digits.MANTISSA = old_mantissa

{persiantools-5.2.1 → persiantools-5.3.0}/tests/test_jalalidate.py

@@ -13,6 +13,7 @@ class TestJalaliDate(TestCase):
     def test_shamsi_to_gregorian(self):
         cases = [
             (JalaliDate(1100, 1, 1), date(1721, 3, 21)),
+            (JalaliDate(1210, 12, 30), date(1832, 3, 20)),
             (JalaliDate(1367, 2, 14), date(1988, 5, 4)),
             (JalaliDate(1395, 3, 21), date(2016, 6, 10)),
             (JalaliDate(1395, 12, 9), date(2017, 2, 27)),
@@ -67,6 +68,7 @@ class TestJalaliDate(TestCase):
             (JalaliDate(1402, 1, 1), date(2023, 3, 21)),
             (JalaliDate(1403, 1, 1), date(2024, 3, 20)),
             (JalaliDate(1404, 1, 1), date(2025, 3, 21)),
+            (JalaliDate(1498, 12, 30), date(2120, 3, 20)),
             (JalaliDate(1505, 1, 1), date(2126, 3, 21)),
             (JalaliDate.today(), date.today()),
         ]
@@ -124,6 +126,9 @@ class TestJalaliDate(TestCase):
 
     def test_checkdate(self):
         cases = [
+            (1206, 12, 30, False),
+            (1210, 12, 30, True),
+            (1214, 12, 30, True),
             (1367, 2, 14, True),
             (1395, 12, 30, True),
             (1394, 12, 30, False),
@@ -136,14 +141,21 @@ class TestJalaliDate(TestCase):
             (1396, 7, 27, True),
             (1397, 11, 29, True),
             (1399, 11, 31, False),
+            (1400, 1, 32, False),
             (1400, 4, 25, True),
             (1400, 12, 30, False),
             (1403, 4, 3, True),
             (1403, 12, 30, True),
+            (1473, 12, 30, False),
+            (1474, 12, 30, True),
+            (1498, 12, 30, True),
         ]
         for year, month, day, valid in cases:
             self.assertEqual(JalaliDate.check_date(year, month, day), valid)
 
+        with pytest.raises(ValueError):
+            JalaliDate._check_date_fields(1404, 3, 16, "ar")
+
     def test_completeday(self):
         jdate = JalaliDate(1398, 3, 17)
         self.assertEqual(jdate.year, 1398)
@@ -211,6 +223,18 @@ class TestJalaliDate(TestCase):
         with pytest.raises(ValueError, match="locale must be 'en' or 'fa'"):
             jdate.replace(locale="de")
 
+        with pytest.raises(ValueError):
+            JalaliDate.days_before_month(0)
+
+        with pytest.raises(ValueError):
+            JalaliDate.days_before_month(13)
+
+        with pytest.raises(ValueError):
+            JalaliDate.days_in_month(13, 1404)
+
+        with pytest.raises(ValueError):
+            JalaliDate.days_in_month(0, 1400)
+
     def test_leap(self):
         cases = [
             # First 33-year cycle
@@ -409,6 +433,24 @@ class TestJalaliDate(TestCase):
         with pytest.raises(ValueError):
             JalaliDate.fromisoformat("2021W123")
 
+        with pytest.raises(ValueError):
+            JalaliDate.fromisoformat("1395-03")
+
+        with pytest.raises(ValueError):
+            JalaliDate.fromisoformat("13950301")
+
+        with pytest.raises(ValueError):
+            JalaliDate.fromisoformat("1395-13-01")
+
+        with pytest.raises(ValueError):
+            JalaliDate.fromisoformat("1400-01-32")
+
+        with pytest.raises(ValueError):
+            JalaliDate.fromisoformat("1395-03-01 extra")
+
+        with pytest.raises(ValueError):
+            JalaliDate.fromisoformat(" 1395-03-01")
+
         j_date = JalaliDate(1400, 1, 1)
         self.assertEqual(j_date.strftime("%A, %d %B %Y"), "Yekshanbeh, 01 Farvardin 1400")
         self.assertEqual(j_date.strftime("%A, %d %B %Y", locale="fa"), "یکشنبه, ۰۱ فروردین ۱۴۰۰")
@@ -561,8 +603,145 @@ class TestJalaliDate(TestCase):
         self.assertEqual(repr(JalaliDate(1403, 4, 7)), "JalaliDate(1403, 4, 7, Panjshanbeh)")
 
     def test_strptime(self):
-        with self.assertRaises(NotImplementedError):
-            JalaliDate.strptime("1400-01-01", "%Y-%m-%d")
+        # 1. Basic parsing
+        self.assertEqual(JalaliDate.strptime("1367-02-14", "%Y-%m-%d"), JalaliDate(1367, 2, 14))
+        self.assertEqual(JalaliDate.strptime("1367/02/14", "%Y/%m/%d"), JalaliDate(1367, 2, 14))
+        self.assertEqual(JalaliDate.strptime("13670214", "%Y%m%d"), JalaliDate(1367, 2, 14))
+        self.assertEqual(JalaliDate.strptime("16/03/1404", "%d/%m/%Y"), JalaliDate(1404, 3, 16))
+        self.assertEqual(JalaliDate.strptime("16/03/1404", "%d/%m/%Y", locale="en"), JalaliDate(1404, 3, 16))
+
+        # 2. Year variations
+        self.assertEqual(JalaliDate.strptime("99-01-01", "%y-%m-%d"), JalaliDate(1399, 1, 1))  # 99 > 70 => 1399
+        self.assertEqual(JalaliDate.strptime("00-01-01", "%y-%m-%d"), JalaliDate(1400, 1, 1))
+        self.assertEqual(JalaliDate.strptime("01-01-01", "%y-%m-%d"), JalaliDate(1401, 1, 1))  # 01 <= 70 => 1401
+        self.assertEqual(JalaliDate.strptime("04-01-01", "%y-%m-%d"), JalaliDate(1404, 1, 1))
+        self.assertEqual(JalaliDate.strptime("70-10-10", "%y-%m-%d"), JalaliDate(1470, 10, 10))  # 70 => 1470
+
+        # 3. Month variations
+        self.assertEqual(JalaliDate.strptime("1400-01-15", "%Y-%m-%d"), JalaliDate(1400, 1, 15))
+        self.assertEqual(JalaliDate.strptime("1400-Far-15", "%Y-%b-%d"), JalaliDate(1400, 1, 15))
+        self.assertEqual(JalaliDate.strptime("1400-FAR-15", "%Y-%b-%d"), JalaliDate(1400, 1, 15))
+        self.assertEqual(JalaliDate.strptime("1400-far-15", "%Y-%b-%d"), JalaliDate(1400, 1, 15))
+        self.assertEqual(JalaliDate.strptime("1367-Ord-14", "%Y-%b-%d"), JalaliDate(1367, 2, 14))
+        self.assertEqual(JalaliDate.strptime("1400-Farvardin-15", "%Y-%B-%d"), JalaliDate(1400, 1, 15))
+        self.assertEqual(JalaliDate.strptime("1400-FARVARDIN-15", "%Y-%B-%d"), JalaliDate(1400, 1, 15))
+        self.assertEqual(JalaliDate.strptime("1400-farvardin-15", "%Y-%B-%d"), JalaliDate(1400, 1, 15))
+        self.assertEqual(JalaliDate.strptime("1400-Ordibehesht-10", "%Y-%B-%d"), JalaliDate(1400, 2, 10))
+        self.assertEqual(JalaliDate.strptime("1398-Esf-05", "%Y-%b-%d"), JalaliDate(1398, 12, 5))
+        self.assertEqual(JalaliDate.strptime("1403-Esfand-30", "%Y-%B-%d"), JalaliDate(1403, 12, 30))
+
+        # 4. Day variations
+        self.assertEqual(JalaliDate.strptime("1404-03-05", "%Y-%m-%d"), JalaliDate(1404, 3, 5))
+        self.assertEqual(JalaliDate.strptime("1404-03-31", "%Y-%m-%d"), JalaliDate(1404, 3, 31))
+
+        # 5. Locale testing ('en' and 'fa')
+        self.assertEqual(
+            JalaliDate.strptime("1401-Ord-05", "%Y-%b-%d", locale="en"), JalaliDate(1401, 2, 5, locale="en")
+        )
+
+        # Persian locale
+        self.assertEqual(
+            JalaliDate.strptime("۱۴۰۰-۰۱-۱۵", "%Y-%m-%d", locale="fa"), JalaliDate(1400, 1, 15, locale="fa")
+        )
+        self.assertEqual(
+            JalaliDate.strptime("۱۴۰۰-فروردین-۱۵", "%Y-%B-%d", locale="fa"), JalaliDate(1400, 1, 15, locale="fa")
+        )
+        self.assertEqual(
+            JalaliDate.strptime("۱۴۰۰-فرو-۱۵", "%Y-%b-%d", locale="fa"), JalaliDate(1400, 1, 15, locale="fa")
+        )
+        self.assertEqual(
+            JalaliDate.strptime("۱۴۰۰-اردیبهشت-۱۰", "%Y-%B-%d", locale="fa"), JalaliDate(1400, 2, 10, locale="fa")
+        )
+        self.assertEqual(
+            JalaliDate.strptime("۱۳۹۸-اسفند-۰۵", "%Y-%B-%d", locale="fa"), JalaliDate(1398, 12, 5, locale="fa")
+        )
+        self.assertEqual(
+            JalaliDate.strptime("۱۳۹۸-اسف-۰۵", "%Y-%b-%d", locale="fa"), JalaliDate(1398, 12, 5, locale="fa")
+        )
+        # Mixed Farsi digits and names
+        self.assertEqual(
+            JalaliDate.strptime("1398-اسفند-۰۵", "%Y-%B-%d", locale="fa"), JalaliDate(1398, 12, 5, locale="fa")
+        )
+
+        # 6. Format strings with literals and different separators
+        self.assertEqual(JalaliDate.strptime("Date: 1404/12 Day: 29", "Date: %Y/%m Day: %d"), JalaliDate(1404, 12, 29))
+        self.assertEqual(
+            JalaliDate.strptime("Year 1367 Month 02 Day 14", "Year %Y Month %m Day %d"), JalaliDate(1367, 2, 14)
+        )
+        # self.assertEqual(JalaliDate.strptime("1400|01|01", "%Y|%m|%d"), JalaliDate(1400, 1, 1))
+        self.assertEqual(JalaliDate.strptime("Jalali:1403-10-20", "Jalali:%Y-%m-%d"), JalaliDate(1403, 10, 20))
+
+        # 7. Weekday directives (%a and %A) - parsed but ignored for date construction
+        self.assertEqual(
+            JalaliDate.strptime("Jomeh, 1404-03-16", "%A, %Y-%m-%d"), JalaliDate(1404, 3, 16)
+        )  # 1404-03-16 is a Jomeh
+        self.assertEqual(JalaliDate.strptime("Sha, 1400-01-06", "%a, %Y-%m-%d"), JalaliDate(1400, 1, 6))
+        self.assertEqual(JalaliDate.strptime("Yekshanbeh 1400-Farvardin-01", "%A %Y-%B-%d"), JalaliDate(1400, 1, 1))
+        # Test with fa locale weekdays
+        self.assertEqual(
+            JalaliDate.strptime("شنبه, ۱۴۰۰-۰۱-۰۶", "%A, %Y-%m-%d", locale="fa"), JalaliDate(1400, 1, 6, locale="fa")
+        )
+        self.assertEqual(
+            JalaliDate.strptime("ش, ۱۴۰۰-۰۱-۰۶", "%a, %Y-%m-%d", locale="fa"), JalaliDate(1400, 1, 6, locale="fa")
+        )
+
+        # 8. Invalid inputs
+        with self.assertRaises(ValueError, msg="Month out of range"):
+            JalaliDate.strptime("1400-13-01", "%Y-%m-%d")
+        with self.assertRaises(ValueError, msg="Day out of range for month"):
+            JalaliDate.strptime("1400-01-32", "%Y-%m-%d")
+        with self.assertRaises(ValueError, msg="Day out of range for month (Mehr has 30 days)"):
+            JalaliDate.strptime("1400-07-31", "%Y-%m-%d")
+        with self.assertRaises(ValueError, msg="Invalid month name"):
+            JalaliDate.strptime("1399/Feb/20", "%Y/%b/%d")
+        with self.assertRaises(ValueError, msg="String does not match format"):
+            JalaliDate.strptime("1400/01/01 Extra", "%Y/%m/%d")
+        with self.assertRaises(ValueError, msg="String does not match format - incorrect separator"):
+            JalaliDate.strptime("1400.01.01", "%Y-%m-%d")
+        with self.assertRaises(ValueError, msg="Year with %Y must be 4 digits"):
+            JalaliDate.strptime("123-01-01", "%Y-%m-%d")
+        with self.assertRaises(ValueError, msg="Year with %y must be 2 digits"):  # The regex for %y is \d{2}
+            JalaliDate.strptime("1-01-01", "%y-%m-%d")
+        with self.assertRaises(ValueError, msg="Date string does not match format (empty date string)"):
+            JalaliDate.strptime("", "%Y-%m-%d")
+        with self.assertRaises(ValueError, msg="Date string does not match format (empty format string)"):
+            JalaliDate.strptime("1400-01-01", "")
+        with self.assertRaises(ValueError, msg="Month information missing"):
+            JalaliDate.strptime("1400--01", "%Y-%m-%d")
+        with self.assertRaises(ValueError, msg="Day information missing"):
+            JalaliDate.strptime("1400-01-", "%Y-%m-%d")
+        with self.assertRaises(ValueError, msg="Year information missing"):
+            JalaliDate.strptime("-01-01", "%Y-%m-%d")
+        with self.assertRaises(ValueError):
+            JalaliDate.strptime("1402-12-30", "%Y-%m-%d")
+        with self.assertRaises(ValueError):
+            JalaliDate.strptime("98-12-30", "%y-%m-%d")
+        with self.assertRaises(ValueError):
+            JalaliDate.strptime("1404-01-01", "%Y-%m-%d", "ar")
+
+        # 9. Edge cases
+        # Leap year: 1399 was a leap year (Esfand has 30 days)
+        self.assertEqual(JalaliDate.strptime("1399-12-30", "%Y-%m-%d"), JalaliDate(1399, 12, 30))
+        # Non-leap year: 1400 was not a leap year (Esfand has 29 days)
+        self.assertEqual(JalaliDate.strptime("1400-12-29", "%Y-%m-%d"), JalaliDate(1400, 12, 29))
+        with self.assertRaises(ValueError, msg="Esfand 30 on non-leap year 1400"):
+            JalaliDate.strptime("1400-12-30", "%Y-%m-%d")
+
+        # Leap year: 1403 is a leap year
+        self.assertEqual(JalaliDate.strptime("1403-12-30", "%Y-%m-%d"), JalaliDate(1403, 12, 30))
+        self.assertEqual(JalaliDate.strptime("03-12-30", "%y-%m-%d"), JalaliDate(1403, 12, 30))
+
+        self.assertEqual(JalaliDate.strptime(f"{MINYEAR:04d}-01-01", "%Y-%m-%d"), JalaliDate(MINYEAR, 1, 1))
+        self.assertEqual(JalaliDate.strptime(f"{MAXYEAR:04d}-12-29", "%Y-%m-%d"), JalaliDate(MAXYEAR, 12, 29))
+
+        # Test %x and %c replacements
+        # %x: %Y/%m/%d
+        self.assertEqual(JalaliDate.strptime("1399/05/10", "%x"), JalaliDate(1399, 5, 10))
+        # %c: %a %b %d %Y
+        self.assertEqual(JalaliDate.strptime("Sha Far 01 1380", "%c"), JalaliDate(1380, 1, 1))  # 1380-01-01 is Shanbeh
+        self.assertEqual(JalaliDate.strptime("ش فرو ۰۱ ۱۳۸۰", "%c", locale="fa"), JalaliDate(1380, 1, 1, locale="fa"))
+
+        self.assertEqual(JalaliDate.strptime("1400-Tir-15", "%Y-%b-%d"), JalaliDate(1400, 4, 15))
 
     def test_locale_setter_invalid_value(self):
         jdate = JalaliDate.today()

{persiantools-5.2.1 → persiantools-5.3.0}/tests/test_jalalidatetime.py

@@ -92,6 +92,23 @@ class TestJalaliDateTime(TestCase):
             time.struct_time((1988, 5, 4, 14, 0, 0, 2, 125, 0)),
         )
 
+    def test_check_utc_offset(self):
+        JalaliDateTime.check_utc_offset("utcoffset", None)
+        JalaliDateTime.check_utc_offset("dst", None)
+
+        offset = timedelta(minutes=30)
+        JalaliDateTime.check_utc_offset("utcoffset", offset)
+        JalaliDateTime.check_utc_offset("dst", offset)
+
+        with pytest.raises(AssertionError):
+            JalaliDateTime.check_utc_offset("invalid", timedelta(minutes=30))
+
+        with pytest.raises(TypeError):
+            JalaliDateTime.check_utc_offset("utcoffset", 30)
+
+        with pytest.raises(ValueError):
+            JalaliDateTime.check_utc_offset("dst", timedelta(seconds=61))
+
     def test_others(self):
         self.assertTrue(JalaliDateTime.fromtimestamp(time.time() - 10) <= JalaliDateTime.now())
         self.assertEqual(JalaliDateTime(1367, 2, 14, 4, 30, 0, 0, pytz.utc).timestamp(), 578723400)
@@ -114,6 +131,9 @@ class TestJalaliDateTime(TestCase):
         self.assertIsNone(JalaliDateTime.today().tzname())
         self.assertIsNone(JalaliDateTime.today().dst())
 
+        dt = JalaliDateTime(1367, 2, 14, 4, 30, 0, 0, pytz.utc)
+        self.assertEqual(dt.dst(), timedelta(0))
+
         self.assertEqual(
             JalaliDateTime(1367, 2, 14, 4, 30, 0, 0).ctime(),
             "Chaharshanbeh 14 Ordibehesht 1367 04:30:00",
@@ -329,6 +349,11 @@ class TestJalaliDateTime(TestCase):
         jdt = JalaliDateTime(1374, 4, 8, 16, 28, 3, 227, pytz.utc)
         self.assertEqual(jdt, JalaliDateTime.strptime(jdt.strftime("%c %f %z %Z"), "%c %f %z %Z"))
 
+        jdt_utc_combined = JalaliDateTime(1374, 4, 8, 16, 28, 3, 227, timezone.utc)
+        self.assertEqual(
+            jdt_utc_combined, JalaliDateTime.strptime(jdt_utc_combined.strftime("%c %f %z %Z"), "%c %f %z %Z")
+        )
+
     def test_strptime_basic(self):
         date_string = "1400-01-01 12:30:45"
         fmt = "%Y-%m-%d %H:%M:%S"
@@ -352,6 +377,98 @@ class TestJalaliDateTime(TestCase):
         self.assertEqual(jdt.second, 45)
         self.assertEqual(jdt.utcoffset(), timedelta(hours=3, minutes=30))
 
+    def test_strptime_z_directive_valid_formats(self):
+        base_dt_str = "1400-01-01 10:00:00"
+        fmt_base = "%Y-%m-%d %H:%M:%S"
+
+        valid_z_formats = [
+            ("+0330", 3, 30),
+            ("-0500", -5, 0),
+            ("+0430", 4, 30),
+            ("-0715", -7, -15),
+            ("+0000", 0, 0),
+            ("-0000", 0, 0),
+            ("+1400", 14, 0),
+            ("-1400", -14, 0),
+            ("+0059", 0, 59),
+        ]
+
+        for tz_str, hours, minutes in valid_z_formats:
+            date_string = f"{base_dt_str} {tz_str}"
+            fmt = f"{fmt_base} %z"
+            with self.subTest(date_string=date_string, fmt=fmt):
+                jdt = JalaliDateTime.strptime(date_string, fmt)
+                self.assertIsNotNone(jdt.tzinfo, f"tzinfo should not be None for {date_string}")
+                self.assertIsInstance(jdt.tzinfo, timezone, f"tzinfo should be datetime.timezone for {date_string}")
+                expected_offset = timedelta(hours=hours, minutes=minutes)
+                self.assertEqual(jdt.utcoffset(), expected_offset, f"Offset mismatch for {date_string}")
+                self.assertEqual(jdt.year, 1400)
+                self.assertEqual(jdt.hour, 10)
+
+    def test_strptime_z_directive_invalid_formats(self):
+        base_dt_str = "1400-01-01 10:00:00"
+        fmt_base = "%Y-%m-%d %H:%M:%S"
+
+        invalid_z_formats = [
+            "0330",  # Missing sign: In Python, the %z directive requires a leading '+' or '-' for the timezone offset.
+            "+330",  # Incorrect number of digits (hour)
+            "+033",  # Incorrect number of digits (minute)
+            "+03:3",  # Incorrect number of digits (minute with colon)
+            "+03-30",  # Invalid separator
+            "03:30",  # Missing sign with colon
+            "+03:300",  # Too many minute digits
+            "+030:30",  # Too many hour digits
+            "+0A30",  # Non-numeric hour
+            "+03B0",  # Non-numeric minute
+            "+2500",  # Hour out of range (max is +2359 or +1400 for this specific regex in Python for %z)
+            "+2400",  # Hour part out of range (>=24)
+            "-2400",
+            "+0360",  # Minute part out of range (>=60)
+            "-0360",
+            "+03:60",
+            " +0330",  # Leading space before offset
+            "+0330 ",  # Trailing space after offset (will cause full string match failure)
+            "GMT+0330",  # Non-standard prefix
+        ]
+
+        for tz_str in invalid_z_formats:
+            date_string = f"{base_dt_str} {tz_str}"
+            fmt = f"{fmt_base} %z"
+            with self.subTest(date_string=date_string, fmt=fmt):
+                with self.assertRaises(ValueError, msg=f"Failed for invalid tz string: {tz_str}"):
+                    JalaliDateTime.strptime(date_string, fmt)
+
+        # Test %z without enough characters following
+        with self.assertRaises(ValueError):
+            JalaliDateTime.strptime(f"{base_dt_str} +", f"{fmt_base} %z")
+        with self.assertRaises(ValueError):
+            JalaliDateTime.strptime(f"{base_dt_str} +03", f"{fmt_base} %z")
+
+    def test_strptime_z_directive_locale_independence(self):
+        base_dt_str = "1400-01-01 10:00:00"
+        tz_str = "+0545"
+        fmt = "%Y-%m-%d %H:%M:%S %z"
+        date_string = f"{base_dt_str} {tz_str}"
+        expected_offset = timedelta(hours=5, minutes=45)
+
+        # Test with locale 'en'
+        jdt_en = JalaliDateTime.strptime(date_string, fmt, locale="en")
+        self.assertIsNotNone(jdt_en.tzinfo)
+        self.assertEqual(jdt_en.utcoffset(), expected_offset)
+        self.assertEqual(jdt_en.year, 1400)
+
+        # Test with locale 'fa'
+        jdt_fa = JalaliDateTime.strptime(date_string, fmt, locale="fa")
+        self.assertIsNotNone(jdt_fa.tzinfo)
+        self.assertEqual(jdt_fa.utcoffset(), expected_offset)
+        self.assertEqual(jdt_fa.year, 1400)
+
+        date_string_fa_main = f"۱۴۰۰-۰۱-۰۱ ۱۰:۰۰:۰۰ {tz_str}"
+        jdt_fa_main = JalaliDateTime.strptime(date_string_fa_main, fmt, locale="fa")
+        self.assertIsNotNone(jdt_fa_main.tzinfo)
+        self.assertEqual(jdt_fa_main.utcoffset(), expected_offset)
+        self.assertEqual(jdt_fa_main.year, 1400)
+
     def test_strptime_with_locale_fa(self):
         date_string = "۱۴۰۰-۰۱-۰۱ ۱۲:۳۰:۴۵"
         fmt = "%Y-%m-%d %H:%M:%S"
@@ -612,6 +729,11 @@ class TestJalaliDateTime(TestCase):
         with self.assertRaises(ValueError):
             JalaliDateTime.fromisoformat("invalid-date-time")
 
+        self.assertEqual(JalaliDateTime._find_isoformat_datetime_separator("2021W12"), 7)
+
+        with pytest.raises(ValueError, match="Invalid ISO string"):
+            JalaliDateTime._find_isoformat_datetime_separator("2021-W12-")
+
     def test_find_isoformat_datetime_separator(self):
         separator = JalaliDateTime._find_isoformat_datetime_separator("1403-08-09T02:21:45")
         self.assertEqual(separator, 10)
@@ -637,3 +759,66 @@ class TestJalaliDateTime(TestCase):
         iso_format = original.isoformat()
         parsed = JalaliDateTime.fromisoformat(iso_format)
         self.assertEqual(original, parsed)
+
+    def test_isoformat_timezone_representation(self):
+        # 1. UTC Timezone
+        jdt_utc = JalaliDateTime(1400, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+        self.assertEqual(jdt_utc.isoformat(), "1400-01-01T12:00:00+00:00")
+
+        # 2. Positive Offset Timezones
+        tz_plus_3_30 = timezone(timedelta(hours=3, minutes=30))
+        jdt_plus_3_30 = JalaliDateTime(1401, 2, 15, 10, 30, 0, tzinfo=tz_plus_3_30)
+        self.assertEqual(jdt_plus_3_30.isoformat(), "1401-02-15T10:30:00+03:30")
+
+        tz_plus_5 = timezone(timedelta(hours=5))
+        jdt_plus_5 = JalaliDateTime(1402, 3, 20, 8, 0, 0, tzinfo=tz_plus_5)
+        self.assertEqual(jdt_plus_5.isoformat(), "1402-03-20T08:00:00+05:00")
+
+        # 3. Negative Offset Timezones
+        tz_minus_4_45 = timezone(timedelta(hours=-4, minutes=-45))
+        jdt_minus_4_45 = JalaliDateTime(1403, 4, 10, 16, 15, 0, tzinfo=tz_minus_4_45)
+        self.assertEqual(jdt_minus_4_45.isoformat(), "1403-04-10T16:15:00-04:45")
+
+        tz_minus_4_45 = timezone(timedelta(hours=-4, minutes=45))
+        jdt_minus_4_45 = JalaliDateTime(1403, 4, 10, 16, 15, 0, tzinfo=tz_minus_4_45)
+        self.assertEqual(jdt_minus_4_45.isoformat(), "1403-04-10T16:15:00-03:15")
+
+        tz_direct_minus_4_45 = timezone(timedelta(seconds=-(4 * 3600 + 45 * 60)))
+        jdt_direct_minus_4_45 = JalaliDateTime(1403, 4, 10, 16, 15, 0, tzinfo=tz_direct_minus_4_45)
+        self.assertEqual(jdt_direct_minus_4_45.isoformat(), "1403-04-10T16:15:00-04:45")
+
+        tz_minus_8 = timezone(timedelta(hours=-8))
+        jdt_minus_8 = JalaliDateTime(1399, 12, 29, 23, 30, 59, tzinfo=tz_minus_8)
+        self.assertEqual(jdt_minus_8.isoformat(), "1399-12-29T23:30:59-08:00")
+
+        # 4. Offsets with zero minutes (covered by +05:00 and -08:00 above)
+        self.assertEqual(
+            JalaliDateTime(1402, 3, 20, 8, 0, 0, tzinfo=timezone(timedelta(hours=5))).isoformat(),
+            "1402-03-20T08:00:00+05:00",
+        )
+
+        # 5. Microseconds with timezone offset
+        jdt_utc_ms = JalaliDateTime(1400, 1, 1, 12, 30, 45, 123456, tzinfo=timezone.utc)
+        self.assertEqual(jdt_utc_ms.isoformat(), "1400-01-01T12:30:45.123456+00:00")
+
+        jdt_offset_ms = JalaliDateTime(1400, 6, 10, 10, 20, 30, 654321, tzinfo=tz_plus_3_30)
+        self.assertEqual(jdt_offset_ms.isoformat(), "1400-06-10T10:20:30.654321+03:30")
+
+        # 6. Default Separator 'T' (implicitly tested in all above cases)
+        self.assertIn("T", jdt_utc.isoformat())
+
+        # 7. Custom Separator
+        jdt_custom_sep = JalaliDateTime(1400, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+        self.assertEqual(jdt_custom_sep.isoformat(sep=" "), "1400-01-01 12:00:00+00:00")
+
+        jdt_custom_sep_offset = JalaliDateTime(1401, 5, 5, 10, 10, 10, tzinfo=tz_minus_8)
+        self.assertEqual(jdt_custom_sep_offset.isoformat(sep="_"), "1401-05-05_10:10:10-08:00")
+
+        # 8. Naive JalaliDateTime (no offset string)
+        jdt_naive = JalaliDateTime(1398, 10, 5, 12, 30, 0)
+        self.assertEqual(jdt_naive.isoformat(), "1398-10-05T12:30:00")
+        # With microseconds
+        jdt_naive_ms = JalaliDateTime(1398, 10, 5, 12, 30, 0, 123)
+        self.assertEqual(jdt_naive_ms.isoformat(), "1398-10-05T12:30:00.000123")
+        # With custom separator
+        self.assertEqual(jdt_naive.isoformat(sep=" "), "1398-10-05 12:30:00")