multilingualprogramming 0.2.0__py3-none-any.whl

multilingualprogramming/datetime/mp_date.py

@@ -0,0 +1,210 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Multilingual date handling."""
+# pylint: disable=unsubscriptable-object
+
+import datetime as dt
+from typing import Any, cast
+from multilingualprogramming.datetime.date_parser import DateParser
+from multilingualprogramming.datetime.resource_loader import load_datetime_resource
+from multilingualprogramming.exceptions import InvalidDateError
+from multilingualprogramming.unicode_string import get_unicode_character_string
+
+
+class MPDate:
+    """
+    A date object with multilingual formatting and parsing.
+
+    Internally stores as Python datetime.date (Gregorian).
+    """
+
+    _months_data: dict[str, Any] | None = None
+
+    @classmethod
+    def _load_months(cls):
+        """Load month names from JSON."""
+        if cls._months_data is not None:
+            return
+        cls._months_data = load_datetime_resource("months.json")
+
+    def __init__(self, year=None, month=None, day=None, date=None):
+        """
+        Create an MPDate.
+
+        Parameters:
+            year (int): Year
+            month (int): Month (1-12)
+            day (int): Day (1-31)
+            date (datetime.date): Python date object
+        """
+        if date is not None:
+            self._date = date
+        elif year is not None and month is not None and day is not None:
+            try:
+                self._date = dt.date(year, month, day)
+            except ValueError as e:
+                raise InvalidDateError(str(e)) from e
+        else:
+            raise InvalidDateError(
+                "MPDate requires year/month/day or a date object"
+            )
+
+    @classmethod
+    def from_string(cls, datestr, language=None):
+        """
+        Parse a multilingual date string.
+
+        Parameters:
+            datestr (str): Date string in any supported language
+            language (str): Optional language hint
+
+        Returns:
+            MPDate: Parsed date
+        """
+        year, month, day, _ = DateParser.parse(datestr, language)
+        return cls(year=year, month=month, day=day)
+
+    def to_date(self):
+        """
+        Convert to Python datetime.date.
+
+        Returns:
+            datetime.date: Python date object
+        """
+        return self._date
+
+    @property
+    def year(self):
+        """Return the year."""
+        return self._date.year
+
+    @property
+    def month(self):
+        """Return the month."""
+        return self._date.month
+
+    @property
+    def day(self):
+        """Return the day."""
+        return self._date.day
+
+    def _get_month_name(self, language, abbreviated=False):
+        """Get the month name in a given language."""
+        self._load_months()
+        if self._months_data is None:
+            raise InvalidDateError("Month data not loaded")
+        months_data = cast(dict[str, Any], self._months_data)
+        month_keys = list(months_data["months"].keys())
+        month_key = month_keys[self._date.month - 1]
+        month_data = months_data["months"][month_key]
+        if language in month_data:
+            form = "abbr" if abbreviated else "full"
+            return month_data[language][form]
+        return month_data["en"]["full" if not abbreviated else "abbr"]
+
+    def _format_number(self, number, script=None):
+        """Format a number in the given script."""
+        if script and script not in ("en", "DIGIT"):
+            # Map language codes to Unicode script names
+            script_map = {
+                "hi": "DEVANAGARI",
+                "ar": "ARABIC-INDIC",
+                "bn": "BENGALI",
+                "ta": "TAMIL",
+            }
+            unicode_script = script_map.get(script)
+            if unicode_script:
+                return get_unicode_character_string(unicode_script, number)
+        return str(number)
+
+    def to_string(self, language="en", fmt=None):
+        """
+        Format date in a given language.
+
+        Parameters:
+            language (str): Language code (e.g., "en", "fr", "hi")
+            fmt (str): Optional format override
+
+        Returns:
+            str: Formatted date string
+        """
+        if fmt is not None:
+            return self._date.strftime(fmt)
+
+        month_name = self._get_month_name(language)
+        day_str = self._format_number(self._date.day, language)
+        year_str = self._format_number(self._date.year, language)
+
+        if language in ("zh", "ja"):
+            return f"{year_str}年{self._format_number(self._date.month, language)}月{day_str}日"
+
+        return f"{day_str}-{month_name}-{year_str}"
+
+    def __add__(self, days):
+        """
+        Add days to the date.
+
+        Parameters:
+            days (int): Number of days to add
+
+        Returns:
+            MPDate: New date
+        """
+        if isinstance(days, int):
+            new_date = self._date + dt.timedelta(days=days)
+            return MPDate(date=new_date)
+        return NotImplemented
+
+    def __sub__(self, other):
+        """
+        Subtract another MPDate or days.
+
+        Returns:
+            int: Difference in days (if MPDate)
+            MPDate: New date (if int)
+        """
+        if isinstance(other, MPDate):
+            delta = self._date - other._date
+            return delta.days
+        if isinstance(other, int):
+            new_date = self._date - dt.timedelta(days=other)
+            return MPDate(date=new_date)
+        return NotImplemented
+
+    def __eq__(self, other):
+        if isinstance(other, MPDate):
+            return self._date == other._date
+        return NotImplemented
+
+    def __lt__(self, other):
+        if isinstance(other, MPDate):
+            return self._date < other._date
+        return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, MPDate):
+            return self._date <= other._date
+        return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, MPDate):
+            return self._date > other._date
+        return NotImplemented
+
+    def __ge__(self, other):
+        if isinstance(other, MPDate):
+            return self._date >= other._date
+        return NotImplemented
+
+    def __hash__(self):
+        return hash(self._date)
+
+    def __str__(self):
+        return self.to_string("en")
+
+    def __repr__(self):
+        return f"MPDate({self._date.year}, {self._date.month}, {self._date.day})"

multilingualprogramming/datetime/mp_datetime.py

@@ -0,0 +1,153 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Multilingual datetime handling."""
+
+import datetime as dt
+from multilingualprogramming.datetime.mp_date import MPDate
+from multilingualprogramming.datetime.mp_time import MPTime
+from multilingualprogramming.datetime.date_parser import DateParser
+from multilingualprogramming.exceptions import InvalidDateError
+
+
+class MPDatetime:
+    """
+    A datetime object with multilingual formatting and parsing.
+
+    Combines MPDate and MPTime. Internally stores as Python datetime.datetime.
+    """
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def __init__(self, year=None, month=None, day=None,
+                 hour=0, minute=0, second=0, datetime_obj=None):
+        """
+        Create an MPDatetime.
+
+        Parameters:
+            year (int): Year
+            month (int): Month (1-12)
+            day (int): Day (1-31)
+            hour (int): Hour (0-23)
+            minute (int): Minute (0-59)
+            second (int): Second (0-59)
+            datetime_obj (datetime.datetime): Python datetime object
+        """
+        if datetime_obj is not None:
+            self._datetime = datetime_obj
+        elif year is not None and month is not None and day is not None:
+            try:
+                self._datetime = dt.datetime(
+                    year, month, day, hour, minute, second
+                )
+            except ValueError as e:
+                raise InvalidDateError(str(e)) from e
+        else:
+            raise InvalidDateError(
+                "MPDatetime requires year/month/day or a datetime object"
+            )
+
+    @classmethod
+    def from_string(cls, datestr, language=None):
+        """
+        Parse a multilingual date string into an MPDatetime.
+
+        Parameters:
+            datestr (str): Date string in any supported language
+            language (str): Optional language hint
+
+        Returns:
+            MPDatetime: Parsed datetime (time defaults to 00:00:00)
+        """
+        year, month, day, _ = DateParser.parse(datestr, language)
+        return cls(year=year, month=month, day=day)
+
+    @classmethod
+    def now(cls):
+        """Create an MPDatetime for the current date and time."""
+        return cls(datetime_obj=dt.datetime.now())
+
+    def to_datetime(self):
+        """Convert to Python datetime.datetime."""
+        return self._datetime
+
+    def date(self):
+        """Get the date part as MPDate."""
+        return MPDate(date=self._datetime.date())
+
+    def time(self):
+        """Get the time part as MPTime."""
+        return MPTime(time=self._datetime.time())
+
+    @property
+    def year(self):
+        """Return the year."""
+        return self._datetime.year
+
+    @property
+    def month(self):
+        """Return the month."""
+        return self._datetime.month
+
+    @property
+    def day(self):
+        """Return the day."""
+        return self._datetime.day
+
+    @property
+    def hour(self):
+        """Return the hour."""
+        return self._datetime.hour
+
+    @property
+    def minute(self):
+        """Return the minute."""
+        return self._datetime.minute
+
+    @property
+    def second(self):
+        """Return the second."""
+        return self._datetime.second
+
+    def to_string(self, language="en", fmt=None):
+        """
+        Format datetime in a given language.
+
+        Parameters:
+            language (str): Language code
+            fmt (str): Optional format override
+
+        Returns:
+            str: Formatted datetime string
+        """
+        if fmt is not None:
+            return self._datetime.strftime(fmt)
+
+        date_part = self.date().to_string(language)
+        time_part = self.time().to_string(language)
+        return f"{date_part} {time_part}"
+
+    def __eq__(self, other):
+        if isinstance(other, MPDatetime):
+            return self._datetime == other._datetime
+        return NotImplemented
+
+    def __lt__(self, other):
+        if isinstance(other, MPDatetime):
+            return self._datetime < other._datetime
+        return NotImplemented
+
+    def __hash__(self):
+        return hash(self._datetime)
+
+    def __str__(self):
+        return self.to_string("en")
+
+    def __repr__(self):
+        return (
+            f"MPDatetime({self._datetime.year}, {self._datetime.month}, "
+            f"{self._datetime.day}, {self._datetime.hour}, "
+            f"{self._datetime.minute}, {self._datetime.second})"
+        )

multilingualprogramming/datetime/mp_time.py

@@ -0,0 +1,147 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Multilingual time handling."""
+
+import datetime as dt
+from multilingualprogramming.exceptions import InvalidDateError
+from multilingualprogramming.unicode_string import get_unicode_character_string
+
+
+class MPTime:
+    """
+    A time object with multilingual formatting.
+
+    Internally stores as Python datetime.time.
+    """
+
+    # Script mapping for numeral conversion
+    SCRIPT_MAP = {
+        "hi": "DEVANAGARI",
+        "ar": "ARABIC-INDIC",
+        "bn": "BENGALI",
+        "ta": "TAMIL",
+    }
+
+    def __init__(self, hour=0, minute=0, second=0, time=None):
+        """
+        Create an MPTime.
+
+        Parameters:
+            hour (int): Hour (0-23)
+            minute (int): Minute (0-59)
+            second (int): Second (0-59)
+            time (datetime.time): Python time object
+        """
+        if time is not None:
+            self._time = time
+        else:
+            try:
+                self._time = dt.time(hour, minute, second)
+            except ValueError as e:
+                raise InvalidDateError(str(e)) from e
+
+    def to_time(self):
+        """Convert to Python datetime.time."""
+        return self._time
+
+    @property
+    def hour(self):
+        """Return the hour."""
+        return self._time.hour
+
+    @property
+    def minute(self):
+        """Return the minute."""
+        return self._time.minute
+
+    @property
+    def second(self):
+        """Return the second."""
+        return self._time.second
+
+    def _format_number(self, number, language, pad=True):
+        """Format a number in the given script, zero-padded to 2 digits."""
+        unicode_script = self.SCRIPT_MAP.get(language)
+        if unicode_script:
+            numstr = get_unicode_character_string(unicode_script, number)
+            if pad and number < 10:
+                zero = get_unicode_character_string(unicode_script, 0)
+                numstr = zero + numstr
+            return numstr
+        if pad:
+            return f"{number:02d}"
+        return str(number)
+
+    def to_string(self, language="en", use_24h=True):
+        """
+        Format time in a given language.
+
+        Parameters:
+            language (str): Language code
+            use_24h (bool): Use 24-hour format (default True)
+
+        Returns:
+            str: Formatted time string
+        """
+        if use_24h:
+            h = self._format_number(self._time.hour, language)
+            m = self._format_number(self._time.minute, language)
+            s = self._format_number(self._time.second, language)
+            return f"{h}:{m}:{s}"
+
+        # 12-hour format
+        hour_12 = self._time.hour % 12
+        if hour_12 == 0:
+            hour_12 = 12
+        is_pm = self._time.hour >= 12
+
+        h = self._format_number(hour_12, language)
+        m = self._format_number(self._time.minute, language)
+        s = self._format_number(self._time.second, language)
+        time_str = f"{h}:{m}:{s}"
+
+        am_pm_map = {
+            "en": ("AM", "PM"),
+            "fr": ("", ""),
+            "es": ("a.m.", "p.m."),
+            "de": ("", ""),
+            "hi": ("पूर्वाह्न", "अपराह्न"),
+            "ar": ("ص", "م"),
+            "bn": ("পূর্বাহ্ন", "অপরাহ্ন"),
+            "ta": ("முற்பகல்", "பிற்பகல்"),
+            "zh": ("上午", "下午"),
+            "ja": ("午前", "午後"),
+        }
+        am, pm = am_pm_map.get(language, ("AM", "PM"))
+        suffix = pm if is_pm else am
+
+        if language in ("zh", "ja"):
+            return f"{suffix} {time_str}"
+        if suffix:
+            return f"{time_str} {suffix}"
+        return time_str
+
+    def __eq__(self, other):
+        if isinstance(other, MPTime):
+            return self._time == other._time
+        return NotImplemented
+
+    def __lt__(self, other):
+        if isinstance(other, MPTime):
+            return self._time < other._time
+        return NotImplemented
+
+    def __hash__(self):
+        return hash(self._time)
+
+    def __str__(self):
+        return self.to_string("en")
+
+    def __repr__(self):
+        return (
+            f"MPTime({self._time.hour}, {self._time.minute}, {self._time.second})"
+        )

multilingualprogramming/datetime/resource_loader.py

@@ -0,0 +1,18 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Shared helpers for datetime resource loading."""
+
+import json
+from pathlib import Path
+
+
+def load_datetime_resource(filename):
+    """Load a JSON resource from multilingual datetime resources."""
+    resources_dir = Path(__file__).parent.parent / "resources" / "datetime"
+    resource_path = resources_dir / filename
+    with open(resource_path, "r", encoding="utf-8") as resource_file:
+        return json.load(resource_file)

multilingualprogramming/exceptions.py

@@ -0,0 +1,158 @@
+#
+# SPDX-FileCopyrightText: 2022 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Exceptions"""
+
+
+class InvalidNumeralCharacterError(Exception):
+    """
+    Exception raised when a character is not a valid digit
+    """
+
+    def __init__(self, message):
+        message = "Invalid numeral: " + message
+        super().__init__(message)
+
+
+class MultipleLanguageCharacterMixError(Exception):
+    """
+    Exception raised when a numeral string contains mix of characters
+    from different languages
+    """
+
+    def __init__(self, message):
+        message = "Mix of characters: " + message
+        super().__init__(message)
+
+
+class DifferentNumeralTypeError(Exception):
+    """
+    Exception raised when an operation is performed on different
+    types of numeral type
+    """
+
+    def __init__(self, message):
+        message = "Invalid operation (different numeral type): " + message
+        super().__init__(message)
+
+
+class UnknownKeywordError(Exception):
+    """
+    Exception raised when a keyword string is not found in any language
+    """
+
+    def __init__(self, message):
+        message = "Unknown keyword: " + message
+        super().__init__(message)
+
+
+class AmbiguousKeywordError(Exception):
+    """
+    Exception raised when a keyword matches multiple concepts
+    """
+
+    def __init__(self, message):
+        message = "Ambiguous keyword: " + message
+        super().__init__(message)
+
+
+class UnsupportedLanguageError(Exception):
+    """
+    Exception raised when a requested language is not in the registry
+    """
+
+    def __init__(self, message):
+        message = "Unsupported language: " + message
+        super().__init__(message)
+
+
+class InvalidDateError(Exception):
+    """
+    Exception raised for malformed multilingual dates
+    """
+
+    def __init__(self, message):
+        message = "Invalid date: " + message
+        super().__init__(message)
+
+
+class LexerError(Exception):
+    """
+    Base exception for lexer errors
+    """
+
+    def __init__(self, message, line=None, column=None):
+        location = ""
+        if line is not None:
+            location = f" at line {line}"
+            if column is not None:
+                location += f", column {column}"
+        message = "Lexer error" + location + ": " + message
+        self.line = line
+        self.column = column
+        super().__init__(message)
+
+
+class UnexpectedTokenError(LexerError):
+    """
+    Exception raised for unexpected tokens during lexing
+    """
+
+    def __init__(self, message, line=None, column=None):
+        super().__init__("Unexpected token: " + message, line, column)
+
+
+class ParseError(LexerError):
+    """
+    Base exception for parser errors
+    """
+
+    def __init__(self, message, line=None, column=None):
+        super().__init__("Parse error: " + message, line, column)
+
+
+class SemanticError(Exception):
+    """
+    Exception for semantic analysis errors
+    """
+
+    def __init__(self, message, line=None, column=None):
+        location = ""
+        if line is not None:
+            location = f" at line {line}"
+            if column is not None:
+                location += f", column {column}"
+        self.line = line
+        self.column = column
+        message = "Semantic error" + location + ": " + message
+        super().__init__(message)
+
+
+class CodeGenerationError(Exception):
+    """
+    Exception for code generation errors
+    """
+
+    def __init__(self, message, line=None, column=None):
+        location = ""
+        if line is not None:
+            location = f" at line {line}"
+            if column is not None:
+                location += f", column {column}"
+        self.line = line
+        self.column = column
+        message = "Code generation error" + location + ": " + message
+        super().__init__(message)
+
+
+class RuntimeExecutionError(Exception):
+    """
+    Exception for runtime execution errors
+    """
+
+    def __init__(self, message):
+        message = "Runtime error: " + message
+        super().__init__(message)