multilingualprogramming 0.2.0__py3-none-any.whl

multilingualprogramming/codegen/runtime_builtins.py

@@ -0,0 +1,308 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""
+Runtime built-in functions for the multilingual programming language.
+
+Provides a namespace dict of built-in functions that are injected into
+the execution environment so that multilingual identifiers (e.g., the
+Hindi word for "print") resolve to Python built-ins.
+"""
+
+import json
+from pathlib import Path
+
+from multilingualprogramming.keyword.keyword_registry import KeywordRegistry
+
+
+class RuntimeBuiltins:
+    """
+    Builds a dict of built-in names that should be available at runtime.
+
+    For a given source language, the keyword used for PRINT, INPUT, and
+    type keywords are mapped to the corresponding Python built-ins.
+
+    Usage:
+        builtins = RuntimeBuiltins("fr").namespace()
+        # {'afficher': <built-in function print>,
+        #  'saisir':   <built-in function input>, ...}
+
+    The returned dict is intended to be merged into the exec() globals
+    so that transpiled code can call built-in functions by their
+    multilingual names.
+    """
+
+    # Mapping from USM concept ID to the Python built-in object
+    _CONCEPT_TO_BUILTIN = {
+        "PRINT": print,
+        "INPUT": input,
+        "TYPE_INT": int,
+        "TYPE_FLOAT": float,
+        "TYPE_STR": str,
+        "TYPE_BOOL": bool,
+        "TYPE_LIST": list,
+        "TYPE_DICT": dict,
+    }
+
+    # Additional Python built-ins available in every language
+    _UNIVERSAL_BUILTINS = {
+        "len": len,
+        "range": range,
+        "abs": abs,
+        "min": min,
+        "max": max,
+        "sum": sum,
+        "sorted": sorted,
+        "reversed": reversed,
+        "enumerate": enumerate,
+        "zip": zip,
+        "map": map,
+        "filter": filter,
+        "isinstance": isinstance,
+        "type": type,
+        "hasattr": hasattr,
+        "getattr": getattr,
+        "setattr": setattr,
+        "repr": repr,
+        "round": round,
+        "open": open,
+        "iter": iter,
+        "next": next,
+        "any": any,
+        "all": all,
+        "chr": chr,
+        "ord": ord,
+        "hex": hex,
+        "oct": oct,
+        "bin": bin,
+        "id": id,
+        "hash": hash,
+        "callable": callable,
+        "dir": dir,
+        "vars": vars,
+        "super": super,
+        "property": property,
+        "staticmethod": staticmethod,
+        "classmethod": classmethod,
+        "print": print,
+        "input": input,
+        "int": int,
+        "float": float,
+        "str": str,
+        "bool": bool,
+        "list": list,
+        "dict": dict,
+        "set": set,
+        "tuple": tuple,
+        "frozenset": frozenset,
+        "bytes": bytes,
+        "bytearray": bytearray,
+        "memoryview": memoryview,
+        "object": object,
+        "Exception": Exception,
+        "ValueError": ValueError,
+        "TypeError": TypeError,
+        "KeyError": KeyError,
+        "IndexError": IndexError,
+        "AttributeError": AttributeError,
+        "RuntimeError": RuntimeError,
+        "StopIteration": StopIteration,
+        "ZeroDivisionError": ZeroDivisionError,
+        "FileNotFoundError": FileNotFoundError,
+        "IOError": IOError,
+        "OSError": OSError,
+        "ImportError": ImportError,
+        "NotImplementedError": NotImplementedError,
+        "True": True,
+        "False": False,
+        "None": None,
+        # Additional built-in functions
+        "pow": pow,
+        "divmod": divmod,
+        "complex": complex,
+        "format": format,
+        "ascii": ascii,
+        "breakpoint": breakpoint,
+        "compile": compile,
+        "eval": eval,
+        "exec": exec,
+        "globals": globals,
+        "locals": locals,
+        "issubclass": issubclass,
+        "delattr": delattr,
+        "slice": slice,
+        # Additional exception types
+        "ArithmeticError": ArithmeticError,
+        "AssertionError": AssertionError,
+        "BufferError": BufferError,
+        "EOFError": EOFError,
+        "FloatingPointError": FloatingPointError,
+        "GeneratorExit": GeneratorExit,
+        "LookupError": LookupError,
+        "NameError": NameError,
+        "OverflowError": OverflowError,
+        "PermissionError": PermissionError,
+        "RecursionError": RecursionError,
+        "ReferenceError": ReferenceError,
+        "SyntaxError": SyntaxError,
+        "SystemError": SystemError,
+        "SystemExit": SystemExit,
+        "TimeoutError": TimeoutError,
+        "UnicodeError": UnicodeError,
+        "UnicodeDecodeError": UnicodeDecodeError,
+        "UnicodeEncodeError": UnicodeEncodeError,
+        "Warning": Warning,
+        "DeprecationWarning": DeprecationWarning,
+        "UserWarning": UserWarning,
+        "FutureWarning": FutureWarning,
+        "ResourceWarning": ResourceWarning,
+        "ConnectionError": ConnectionError,
+        "BrokenPipeError": BrokenPipeError,
+        "BlockingIOError": BlockingIOError,
+        "ChildProcessError": ChildProcessError,
+        "ConnectionAbortedError": ConnectionAbortedError,
+        "ConnectionRefusedError": ConnectionRefusedError,
+        "ConnectionResetError": ConnectionResetError,
+        "FileExistsError": FileExistsError,
+        "InterruptedError": InterruptedError,
+        "IsADirectoryError": IsADirectoryError,
+        "NotADirectoryError": NotADirectoryError,
+        "ProcessLookupError": ProcessLookupError,
+        "StopAsyncIteration": StopAsyncIteration,
+        "UnboundLocalError": UnboundLocalError,
+        # Base exception classes
+        "BaseException": BaseException,
+        "KeyboardInterrupt": KeyboardInterrupt,
+        # Additional exception types (Python 3.12)
+        "ModuleNotFoundError": ModuleNotFoundError,
+        "IndentationError": IndentationError,
+        "TabError": TabError,
+        "UnicodeTranslateError": UnicodeTranslateError,
+        "ExceptionGroup": ExceptionGroup,
+        "BaseExceptionGroup": BaseExceptionGroup,
+        # Additional warning types
+        "BytesWarning": BytesWarning,
+        "EncodingWarning": EncodingWarning,
+        "ImportWarning": ImportWarning,
+        "PendingDeprecationWarning": PendingDeprecationWarning,
+        "RuntimeWarning": RuntimeWarning,
+        "SyntaxWarning": SyntaxWarning,
+        "UnicodeWarning": UnicodeWarning,
+        # Async built-in functions (Python 3.10+)
+        "aiter": aiter,
+        "anext": anext,
+    }
+
+    # Non-callable special values available in exec() namespace
+    _SPECIAL_VALUES = {
+        "Ellipsis": Ellipsis,
+        "NotImplemented": NotImplemented,
+    }
+
+    _BUILTIN_ALIAS_CATALOG = None
+
+    def __init__(self, source_language="en"):
+        self._language = source_language
+        self._registry = KeywordRegistry()
+
+    @classmethod
+    def _load_builtin_alias_catalog(cls):
+        """Load localized built-in aliases from resources."""
+        if cls._BUILTIN_ALIAS_CATALOG is not None:
+            return cls._BUILTIN_ALIAS_CATALOG
+
+        path = (
+            Path(__file__).resolve().parent.parent
+            / "resources" / "usm" / "builtins_aliases.json"
+        )
+        with open(path, "r", encoding="utf-8-sig") as handle:
+            cls._BUILTIN_ALIAS_CATALOG = json.load(handle)
+        return cls._BUILTIN_ALIAS_CATALOG
+
+    @classmethod
+    def _localized_builtin_aliases(cls, language):
+        """Return alias->builtin map for a given language."""
+        catalog = cls._load_builtin_alias_catalog()
+        aliases = {}
+        for canonical, by_language in catalog.get("aliases", {}).items():
+            builtin_obj = cls._UNIVERSAL_BUILTINS.get(canonical)
+            if builtin_obj is None or not isinstance(by_language, dict):
+                continue
+            for alias in by_language.get(language, []):
+                aliases[alias] = builtin_obj
+        return aliases
+
+    def namespace(self):
+        """
+        Return a dict mapping multilingual names to Python built-ins.
+
+        Includes:
+        1. Language-specific keyword mappings (PRINT -> afficher, etc.)
+        2. Universal Python built-ins (len, range, abs, etc.)
+        """
+        ns = dict(self._UNIVERSAL_BUILTINS)
+        ns.update(self._SPECIAL_VALUES)
+
+        # Add language-specific mappings (all variants, not only canonical).
+        concept_map = self._registry.get_concept_map()
+        for concept, builtin_obj in self._CONCEPT_TO_BUILTIN.items():
+            try:
+                translations = concept_map[concept]
+                keyword_value = translations.get(self._language)
+                if keyword_value is None:
+                    continue
+                keywords = (
+                    keyword_value if isinstance(keyword_value, list)
+                    else [keyword_value]
+                )
+                for keyword in keywords:
+                    if keyword not in ns:
+                        ns[keyword] = builtin_obj
+            except Exception:
+                pass  # Skip if concept not found for this language
+        for alias, builtin_obj in self._localized_builtin_aliases(
+            self._language
+        ).items():
+            # Keep canonical names stable if an alias collides.
+            if alias not in ns:
+                ns[alias] = builtin_obj
+
+        return ns
+
+    @classmethod
+    def all_languages_namespace(cls):
+        """
+        Return a namespace containing built-in mappings for ALL supported
+        languages simultaneously. Useful for multi-language environments.
+        """
+        ns = dict(cls._UNIVERSAL_BUILTINS)
+        registry = KeywordRegistry()
+
+        concept_map = registry.get_concept_map()
+        for lang in registry.get_supported_languages():
+            for concept, builtin_obj in cls._CONCEPT_TO_BUILTIN.items():
+                try:
+                    translations = concept_map[concept]
+                    keyword_value = translations.get(lang)
+                    if keyword_value is None:
+                        continue
+                    keywords = (
+                        keyword_value if isinstance(keyword_value, list)
+                        else [keyword_value]
+                    )
+                    for keyword in keywords:
+                        if keyword not in ns:
+                            ns[keyword] = builtin_obj
+                except Exception:
+                    pass
+            for alias, builtin_obj in cls._localized_builtin_aliases(
+                lang
+            ).items():
+                # Keep canonical names stable if an alias collides.
+                if alias not in ns:
+                    ns[alias] = builtin_obj
+
+        return ns

multilingualprogramming/core/__init__.py

@@ -0,0 +1,12 @@
+#
+# SPDX-FileCopyrightText: 2026 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Core IR package for language-agnostic internal representations."""
+
+from multilingualprogramming.core.ir import CoreIRProgram
+from multilingualprogramming.core.lowering import lower_to_core_ir
+
+__all__ = ["CoreIRProgram", "lower_to_core_ir"]

multilingualprogramming/core/ir.py

@@ -0,0 +1,29 @@
+#
+# SPDX-FileCopyrightText: 2026 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Typed core IR containers shared by all language frontends."""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from multilingualprogramming.parser.ast_nodes import Program
+
+
+@dataclass
+class CoreIRProgram:
+    """Language-agnostic, forward-only lowered program representation."""
+
+    ast: Program
+    source_language: str
+    core_version: str = "0.1"
+    frontend_metadata: dict[str, Any] = field(default_factory=dict)
+
+    def validate(self):
+        """Validate minimal structural constraints of the core object."""
+        if not isinstance(self.ast, Program):
+            raise TypeError("CoreIRProgram.ast must be a Program AST node")
+        if not isinstance(self.source_language, str) or not self.source_language:
+            raise ValueError("CoreIRProgram.source_language must be a non-empty string")

multilingualprogramming/core/lowering.py

@@ -0,0 +1,24 @@
+#
+# SPDX-FileCopyrightText: 2026 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Lowering boundary between language frontends and the shared core IR."""
+
+from multilingualprogramming.core.ir import CoreIRProgram
+from multilingualprogramming.parser.ast_nodes import Program
+
+
+def lower_to_core_ir(program_ast, source_language, frontend_name="default"):
+    """Lower a frontend AST into the typed core representation."""
+    if not isinstance(program_ast, Program):
+        raise TypeError("lower_to_core_ir expects a Program AST root")
+
+    core = CoreIRProgram(
+        ast=program_ast,
+        source_language=source_language or "en",
+        frontend_metadata={"frontend_name": frontend_name},
+    )
+    core.validate()
+    return core

multilingualprogramming/datetime/__init__.py

@@ -0,0 +1,11 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Datetime subpackage for multilingual programming."""
+
+from multilingualprogramming.datetime.mp_date import MPDate
+from multilingualprogramming.datetime.mp_time import MPTime
+from multilingualprogramming.datetime.mp_datetime import MPDatetime

multilingualprogramming/datetime/date_parser.py

@@ -0,0 +1,190 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Parser for multilingual date strings."""
+
+import unicodedata
+from typing import Any, cast
+from multilingualprogramming.datetime.resource_loader import load_datetime_resource
+from multilingualprogramming.exceptions import InvalidDateError
+from multilingualprogramming.unicode_string import get_language_from_character
+
+
+# pylint: disable=too-few-public-methods
+class DateParser:
+    """
+    Parses multilingual date strings into (year, month, day) tuples.
+
+    Supports date strings with:
+    - Month names in any of the 10 pilot languages
+    - Numerals in any Unicode script
+    - Various separator characters (-, /, .)
+    """
+
+    _months_data: dict[str, Any] | None = None
+    _month_lookup: dict[str, dict[str, int]] | None = None
+
+    @classmethod
+    def _load(cls):
+        """Load month names from JSON."""
+        if cls._months_data is not None and cls._month_lookup is not None:
+            return
+
+        months_data = load_datetime_resource("months.json")
+        if not isinstance(months_data, dict):
+            raise InvalidDateError("Invalid months data format")
+
+        # Build lookup: {lang: {month_name_lower: month_number}}
+        month_lookup: dict[str, dict[str, int]] = {}
+        month_names = list(months_data["months"].keys())
+        for idx, month_key in enumerate(month_names, 1):
+            month_data = months_data["months"][month_key]
+            for lang, names in month_data.items():
+                if lang not in month_lookup:
+                    month_lookup[lang] = {}
+                month_lookup[lang][names["full"].lower()] = idx
+                month_lookup[lang][names["abbr"].lower()] = idx
+
+        cls._months_data = months_data
+        cls._month_lookup = month_lookup
+
+    @classmethod
+    def _extract_number(cls, token):
+        """
+        Extract a numeric value from a token that may contain Unicode digits.
+
+        Returns:
+            int | None: The numeric value, or None if not a number
+        """
+        if not token:
+            return None
+        try:
+            return int(token)
+        except ValueError:
+            pass
+
+        result = 0
+        for char in token:
+            if unicodedata.category(char) == "Nd":
+                result = result * 10 + unicodedata.decimal(char)
+            else:
+                return None
+        return result
+
+    @classmethod
+    def _find_month(cls, token):
+        """
+        Find a month number from a token string.
+
+        Returns:
+            tuple(int, str) | None: (month_number, language) or None
+        """
+        if cls._month_lookup is None:
+            return None
+
+        token_lower = token.lower()
+        for lang, months in cls._month_lookup.items():
+            if token_lower in months:
+                return (months[token_lower], lang)
+        return None
+
+    @classmethod
+    # pylint: disable=too-many-locals,too-many-return-statements,too-many-branches,too-many-statements
+    def parse(cls, datestr, language=None):
+        """
+        Parse a multilingual date string.
+
+        Parameters:
+            datestr (str): Date string (e.g., "15-January-2024")
+            language (str): Optional language hint
+
+        Returns:
+            tuple(int, int, int, str): (year, month, day, detected_language)
+
+        Raises:
+            InvalidDateError: If the date cannot be parsed
+        """
+        cls._load()
+        datestr = datestr.strip()
+
+        separators = ["-", "/", ".", " ", "年", "月", "日"]
+        tokens = []
+        current = ""
+        for char in datestr:
+            if char in separators:
+                if current:
+                    tokens.append(current)
+                current = ""
+            else:
+                current += char
+        if current:
+            tokens.append(current)
+
+        if len(tokens) < 2:
+            raise InvalidDateError(f"Cannot parse date: {datestr}")
+
+        numbers = []
+        month_info = None
+        detected_lang = language
+
+        for token in tokens:
+            num = cls._extract_number(token)
+            if num is not None:
+                numbers.append(num)
+                if detected_lang is None:
+                    for char in token:
+                        lang_name = get_language_from_character(char)
+                        if lang_name and lang_name != "DIGIT":
+                            detected_lang = lang_name
+                            break
+                continue
+
+            result = cls._find_month(token)
+            if result is None:
+                raise InvalidDateError(f"Cannot identify token: {token}")
+
+            month_num = result[0]
+            lang = result[1]
+            month_info = month_num
+            if detected_lang is None:
+                detected_lang = lang
+
+        if detected_lang is None:
+            detected_lang = "en"
+
+        if month_info is not None:
+            if len(numbers) == 2:
+                first = numbers[0]
+                second = numbers[1]
+                if first > 31:
+                    year, day = first, second
+                elif second > 31:
+                    day, year = first, second
+                elif first > 12:
+                    day, year = first, second
+                else:
+                    day, year = first, second
+                return (year, month_info, day, detected_lang)
+
+            if len(numbers) == 1:
+                value = cast(int, numbers[0])
+                if value > 31:
+                    return (value, month_info, 1, detected_lang)
+                return (2024, month_info, value, detected_lang)
+
+        if len(numbers) == 3:
+            a = numbers[0]
+            b = numbers[1]
+            c = numbers[2]
+            if a > 31:
+                return (a, b, c, detected_lang)
+            if c > 31:
+                if a > 12:
+                    return (c, b, a, detected_lang)
+                return (c, a, b, detected_lang)
+            return (c, b, a, detected_lang)
+
+        raise InvalidDateError(f"Cannot determine date components: {datestr}")