🤖 I've added comprehensive unit tests for calendar converters and base …

src/undate/converters/calendars/hebrew/converter.py

@@ -28,9 +28,13 @@
         """Smallest numeric month for this calendar."""
         return 1
 
-    def max_month(self, year: int) -> int:
+    def max_month(self, year: int = None) -> int: # Added default None for year
         """Maximum numeric month for this calendar. In Hebrew calendar, this is 12 or 13
-        depending on whether it is a leap year."""
+        depending on whether it is a leap year.
+        If year is None, defaults to 12 (non-leap year)."""
+        if year is None:
+            # Default to a non-leap year's number of months if year is not specified
+            return 12 
         return hebrew.year_months(year)
 
     def first_month(self) -> int:
@@ -42,10 +46,24 @@
         Elul is the month before Tishri."""
         return hebrew.ELUL
 
-    def max_day(self, year: int, month: int) -> int:
+    def max_day(self, year: int = None, month: int = None) -> int: # Added default None
         """maximum numeric day for the specified year and month in this calendar"""
         # NOTE: unreleased v2.4.1 of convertdate standardizes month_days to month_length
-        return hebrew.month_days(year, month)
+
+        # Handle None year/month by defaulting to a common non-leap scenario
+        # Default year to a known non-leap year if None, e.g. 5783
+        # Default month to Nisan (1) if None, as it's the first biblical month and always has 30 days.
+        effective_year = year if year is not None else 5783 # 5783 is a non-leap year
+        effective_month = month if month is not None else hebrew.NISAN # Nisan is 1
+
+        # Ensure year is not None for leap check if month is Adar related and year was originally None
+        if year is None and (effective_month == 12 or effective_month == 13): # Adar, Adar I or Adar II
+             # hebrew.month_days needs a concrete year to determine leap month lengths correctly.
+             # We've defaulted to 5783 (non-leap).
+             pass
+
+
+        return hebrew.month_days(effective_year, effective_month)
 
     def to_gregorian(self, year: int, month: int, day: int) -> tuple[int, int, int]:
         """Convert a Hebrew date, specified by year, month, and day,

src/undate/converters/calendars/islamic/converter.py

@@ -24,9 +24,15 @@ class IslamicDateConverter(BaseCalendarConverter):
     def __init__(self):
         self.transformer = IslamicDateTransformer()
 
-    def max_day(self, year: int, month: int) -> int:
-        """maximum numeric day for the specified year and month in this calendar"""
-        return islamic.month_length(year, month)
+    def max_day(self, year: int = None, month: int = None) -> int: # Added default None
+        """maximum numeric day for the specified year and month in this calendar.
+        If year or month is None, defaults will be used (non-leap year, month 1)."""
+        # Default year to a known non-leap year if None (e.g., 1446 AH)
+        effective_year = year if year is not None else 1446 
+        # Default month to 1 (Muharram) if None
+        effective_month = month if month is not None else 1
+
+        return islamic.month_length(effective_year, effective_month)
 
     def min_month(self) -> int:
         """smallest numeric month for this calendar."""

src/undate/converters/calendars/seleucid.py

@@ -1,5 +1,11 @@
+from typing import Union # Added for type hints
+from lark.exceptions import UnexpectedCharacters # Added for specific exception
+from undate import Undate, UndateInterval # Added for type hints
+
 from undate.converters.calendars import HebrewDateConverter
 from undate.undate import Calendar
+# Moved hebrew_parser import to top level for use in parse method
+from undate.converters.calendars.hebrew.parser import hebrew_parser
 
 
 class SeleucidDateConverter(HebrewDateConverter):
@@ -15,10 +21,56 @@ def __init__(self):
         # override hebrew calendar to initialize undates with seleucid
         # calendar; this triggers Seleucid calendar to_gregorian method use
         self.transformer.calendar = Calendar.SELEUCID
+        # The parser is inherited from HebrewDateConverter. If Seleucid has a distinct
+        # string format that hebrew_parser can't handle, a seleucid_parser would be needed.
+        # For now, assume string format compatibility for parsing, error message is the primary fix.
+        # Ensure transformer is correctly set up from parent and then modified
+        super().__init__() # Call parent __init__ first
+        self.transformer.calendar = Calendar.SELEUCID
+
+
+    def max_month(self, year: int = None) -> int:
+        """Maximum numeric month for this calendar. Adjusted for Seleucid year."""
+        if year is not None:
+            am_year = year + self.SELEUCID_OFFSET
+        else:
+            am_year = None # Let parent handle None AM year if applicable (it defaults to non-leap)
+        return super().max_month(am_year)
+
+    def max_day(self, year: int = None, month: int = None) -> int:
+        """Maximum numeric day for the specified year and month. Adjusted for Seleucid year."""
+        if year is not None:
+            am_year = year + self.SELEUCID_OFFSET
+        else:
+            am_year = None # Parent's max_day handles None year by defaulting
+
+        # Parent's max_day handles None month by defaulting, so pass month as is.
+        return super().max_day(am_year, month)
 
     def to_gregorian(self, year: int, month: int, day: int) -> tuple[int, int, int]:
         """Convert a Seleucid date, specified by year, month, and day,
         to the Gregorian equivalent date. Uses hebrew calendar conversion
         logic with :attr:`SELEUCID_OFFSET`. Returns a tuple of year, month, day.
         """
         return super().to_gregorian(year + self.SELEUCID_OFFSET, month, day)
+
+    def parse(self, value: str) -> Union[Undate, UndateInterval]:
+        """
+        Parse a Seleucid date string and return an :class:`~undate.undate.Undate` or
+        :class:`~undate.undate.UndateInterval`.
+        The Seleucid date string is preserved in the undate label.
+        Uses Hebrew parser logic with Seleucid calendar context.
+        """
+        if not value:
+            raise ValueError("Parsing empty string is not supported")
+
+        try:
+            # Uses the hebrew_parser (imported at module level)
+            # and self.transformer (calendar set to SELEUCID in __init__)
+            parsetree = hebrew_parser.parse(value)
+            undate_obj = self.transformer.transform(parsetree)
+            undate_obj.label = f"{value} {self.calendar_name}"
+            return undate_obj
+        except UnexpectedCharacters as err:
+            # Catch specific parsing error and raise with custom message
+            raise ValueError(f"Could not parse '{value}' as a Seleucid date") from err