multilingualprogramming 0.2.0__py3-none-any.whl

multilingualprogramming/lexer/token.py

@@ -0,0 +1,54 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Token data class for the multilingual lexer."""
+
+from multilingualprogramming.lexer.token_types import TokenType
+
+
+class Token:
+    """
+    Represents a single token produced by the lexer.
+
+    Attributes:
+        type (TokenType): The type of this token
+        value (str): The raw text of the token
+        concept (str | None): USM concept ID (for KEYWORD tokens only)
+        language (str | None): Detected language of the token
+        line (int): Line number (1-based)
+        column (int): Column number (1-based)
+    """
+
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def __init__(self, token_type: TokenType, value, line=1, column=1,
+                 concept=None, language=None):
+        self.type = token_type
+        self.value = value
+        self.line = line
+        self.column = column
+        self.concept = concept
+        self.language = language
+
+    def __repr__(self):
+        parts = [f"Token({self.type.name}, {self.value!r}"]
+        if self.concept:
+            parts.append(f", concept={self.concept!r}")
+        if self.language:
+            parts.append(f", lang={self.language!r}")
+        parts.append(f", {self.line}:{self.column})")
+        return "".join(parts)
+
+    def __eq__(self, other):
+        if isinstance(other, Token):
+            return (
+                self.type == other.type
+                and self.value == other.value
+                and self.concept == other.concept
+            )
+        return NotImplemented
+
+    def __hash__(self):
+        return hash((self.type, self.value, self.concept))

multilingualprogramming/lexer/token_types.py

@@ -0,0 +1,38 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Token type definitions for the multilingual lexer."""
+
+from enum import Enum, auto
+
+
+class TokenType(Enum):
+    """Types of tokens recognized by the lexer."""
+
+    # Keywords and identifiers
+    KEYWORD = auto()
+    IDENTIFIER = auto()
+
+    # Literals
+    NUMERAL = auto()
+    STRING = auto()
+    FSTRING = auto()
+    DATE_LITERAL = auto()
+
+    # Operators
+    OPERATOR = auto()
+
+    # Delimiters
+    DELIMITER = auto()
+
+    # Whitespace-significant tokens
+    NEWLINE = auto()
+    INDENT = auto()
+    DEDENT = auto()
+
+    # Comments and end-of-file
+    COMMENT = auto()
+    EOF = auto()

multilingualprogramming/numeral/__init__.py

@@ -0,0 +1,11 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Numeral subpackage for multilingual programming."""
+
+from multilingualprogramming.numeral.mp_numeral import MPNumeral
+from multilingualprogramming.numeral.unicode_numeral import UnicodeNumeral
+from multilingualprogramming.numeral.roman_numeral import RomanNumeral

multilingualprogramming/numeral/abstract_numeral.py

@@ -0,0 +1,232 @@
+#
+# SPDX-FileCopyrightText: 2022 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Abstract Numeral class and methods
+"""
+
+from abc import ABC, abstractmethod
+
+
+class AbstractNumeral(ABC):
+    """
+    Methods related to numerals
+    """
+
+    def __init__(self, numstr: str):
+        pass
+
+    @abstractmethod
+    def to_decimal(self):
+        """
+        Returns the decimal number associated with the number string
+        given by the user
+
+        return:
+           number: number associated with the number string
+        """
+
+    def __str__(self):
+        """
+        Returns the original number string
+
+        return:
+           numstr: original number string
+        """
+
+    def __repr__(self):
+        """
+        Returns the representation of an instance
+
+        return:
+           reprstr: representation of an instance
+        """
+
+    @abstractmethod
+    def __lshift__(self, numeral):
+        """
+        Left-shifting
+
+        return:
+           AbstractNumeral: returns the left shifted value
+        """
+
+    @abstractmethod
+    def __rshift__(self, numeral):
+        """
+        Right-shifting
+
+        return:
+           AbstractNumeral: returns the right shifted value
+        """
+
+    @abstractmethod
+    def __add__(self, numeral):
+        """
+        Add a AbstractNumeral with a numeral or another AbstractNumeral
+
+        return:
+           AbstractNumeral: returns the sum of a AbstractNumeral
+        """
+
+    @abstractmethod
+    def __mul__(self, numeral):
+        """
+        Multiplication
+
+        return:
+           AbstractNumeral: returns the product
+        """
+
+    @abstractmethod
+    def __sub__(self, numeral):
+        """
+        Substraction
+
+        return:
+           AbstractNumeral: returns the difference
+        """
+
+    @abstractmethod
+    def __truediv__(self, numeral):
+        """
+        True division
+
+        return:
+           AbstractNumeral: returns the value after true division
+        """
+
+    @abstractmethod
+    def __floordiv__(self, numeral):
+        """
+        Floor division
+
+        return:
+           AbstractNumeral: returns the value after floor division
+        """
+
+    @abstractmethod
+    def __neg__(self):
+        """
+        Negation
+
+        return:
+           AbstractNumeral: returns the negation
+        """
+
+    @abstractmethod
+    def __pow__(self, numeral):
+        """
+        Power
+
+        return:
+           AbstractNumeral: returns the power
+        """
+
+    @abstractmethod
+    def __mod__(self, numeral):
+        """
+        Modulus
+
+        return:
+           AbstractNumeral: returns the modulus value
+        """
+
+    @abstractmethod
+    def __xor__(self, numeral):
+        """
+        XOR value
+
+        return:
+           AbstractNumeral: returns the XOR value
+        """
+
+    @abstractmethod
+    def __invert__(self):
+        """
+        Bitwise inversion value
+
+        return:
+           AbstractNumeral: returns the bitwise-inverted value
+        """
+
+    @abstractmethod
+    def __or__(self, numeral):
+        """
+        OR value
+
+        return:
+           AbstractNumeral: returns the OR value
+        """
+
+    def __eq__(self, other):
+        """
+        Equality comparison
+
+        return:
+           bool: True if both numerals have equal decimal values
+        """
+        if isinstance(other, AbstractNumeral):
+            return self.to_decimal() == other.to_decimal()
+        return NotImplemented
+
+    def __lt__(self, other):
+        """
+        Less-than comparison
+
+        return:
+           bool: True if this numeral is less than the other
+        """
+        if isinstance(other, AbstractNumeral):
+            return self.to_decimal() < other.to_decimal()
+        return NotImplemented
+
+    def __le__(self, other):
+        """
+        Less-than-or-equal comparison
+
+        return:
+           bool: True if this numeral is less than or equal to the other
+        """
+        if isinstance(other, AbstractNumeral):
+            return self.to_decimal() <= other.to_decimal()
+        return NotImplemented
+
+    def __gt__(self, other):
+        """
+        Greater-than comparison
+
+        return:
+           bool: True if this numeral is greater than the other
+        """
+        if isinstance(other, AbstractNumeral):
+            return self.to_decimal() > other.to_decimal()
+        return NotImplemented
+
+    def __ge__(self, other):
+        """
+        Greater-than-or-equal comparison
+
+        return:
+           bool: True if this numeral is greater than or equal to the other
+        """
+        if isinstance(other, AbstractNumeral):
+            return self.to_decimal() >= other.to_decimal()
+        return NotImplemented
+
+    def __hash__(self):
+        """
+        Hash based on decimal value for consistency with __eq__
+        """
+        return hash(self.to_decimal())
+
+    def __abs__(self):
+        """
+        Absolute value
+
+        return:
+           AbstractNumeral: returns the absolute value
+        """
+        raise NotImplementedError("Subclasses must implement __abs__")

multilingualprogramming/numeral/complex_numeral.py

@@ -0,0 +1,190 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Functions to handle complex numbers in multiple languages"""
+from multilingualprogramming.numeral.unicode_numeral import UnicodeNumeral
+from multilingualprogramming.exceptions import (
+    InvalidNumeralCharacterError,
+    MultipleLanguageCharacterMixError,
+)
+from multilingualprogramming.unicode_string import get_unicode_character_string
+
+
+class ComplexNumeral:
+    """
+    Handling complex numbers with multilingual numeral support.
+
+    Stores real and imaginary parts as UnicodeNumeral instances.
+    Format: "real+imaginaryi" or "real-imaginaryi" in any supported script.
+    """
+
+    IMAGINARY_MARKERS = ["i", "ⅈ", "ⅉ"]
+
+    def __init__(self, numstr=None, real=None, imaginary=None):
+        """
+        Create a ComplexNumeral.
+
+        Parameters:
+            numstr (str): A complex number string like "3+4i" or "൩+൪i"
+            real (UnicodeNumeral): The real part
+            imaginary (UnicodeNumeral): The imaginary part
+        """
+        if real is not None and imaginary is not None:
+            self.real = real
+            self.imaginary = imaginary
+            self.language_name = real.language_name
+        elif numstr is not None:
+            self._parse(numstr)
+        else:
+            raise InvalidNumeralCharacterError(
+                "ComplexNumeral requires either numstr or both real and imaginary"
+            )
+
+    def _parse(self, numstr):
+        """Parse a complex number string."""
+        # Remove spaces
+        numstr = numstr.strip()
+
+        # Check for imaginary marker at end
+        has_imaginary = False
+        for marker in self.IMAGINARY_MARKERS:
+            if numstr.endswith(marker):
+                numstr = numstr[: -len(marker)]
+                has_imaginary = True
+                break
+
+        if not has_imaginary:
+            # Pure real number
+            self.real = UnicodeNumeral(numstr)
+            self.imaginary = UnicodeNumeral("0")
+            self.language_name = self.real.language_name
+            return
+
+        # Find the split between real and imaginary parts
+        # Look for + or - that is not at the start
+        split_pos = None
+        for i in range(len(numstr) - 1, 0, -1):
+            if numstr[i] in ("+", "-"):
+                split_pos = i
+                break
+
+        if split_pos is not None:
+            real_str = numstr[:split_pos]
+            imag_str = numstr[split_pos:]
+            # Strip leading '+' since UnicodeNumeral only accepts '-' as sign
+            if imag_str.startswith("+"):
+                imag_str = imag_str[1:]
+            self.real = UnicodeNumeral(real_str)
+            self.imaginary = UnicodeNumeral(imag_str)
+        else:
+            # Pure imaginary (e.g., "4i")
+            self.real = UnicodeNumeral("0")
+            self.imaginary = UnicodeNumeral(numstr)
+
+        # Determine language from whichever part has a non-DIGIT language
+        self.language_name = self.real.language_name
+        if self.language_name == "DIGIT" and self.imaginary.language_name != "DIGIT":
+            self.language_name = self.imaginary.language_name
+        elif self.imaginary.language_name is not None:
+            if (
+                self.real.language_name is not None
+                and self.real.language_name != "DIGIT"
+                and self.imaginary.language_name != "DIGIT"
+                and self.real.language_name != self.imaginary.language_name
+            ):
+                raise MultipleLanguageCharacterMixError(
+                    "Real and imaginary parts use different scripts"
+                )
+            if self.imaginary.language_name != "DIGIT":
+                self.language_name = self.imaginary.language_name
+
+    def to_complex(self):
+        """
+        Convert to Python complex number.
+
+        Returns:
+            complex: Python complex number
+        """
+        return complex(self.real.to_decimal(), self.imaginary.to_decimal())
+
+    def _make_result(self, result_complex):
+        """Create a new ComplexNumeral from a Python complex result."""
+        lang = self.language_name or "DIGIT"
+        real_val = result_complex.real
+        imag_val = result_complex.imag
+
+        # Convert to int if possible
+        if real_val == int(real_val):
+            real_val = int(real_val)
+        if imag_val == int(imag_val):
+            imag_val = int(imag_val)
+
+        real_str = get_unicode_character_string(lang, real_val)
+        imag_str = get_unicode_character_string(lang, imag_val)
+
+        return ComplexNumeral(
+            real=UnicodeNumeral(real_str),
+            imaginary=UnicodeNumeral(imag_str),
+        )
+
+    def __add__(self, other):
+        """Add two ComplexNumerals."""
+        result = self.to_complex() + other.to_complex()
+        return self._make_result(result)
+
+    def __sub__(self, other):
+        """Subtract two ComplexNumerals."""
+        result = self.to_complex() - other.to_complex()
+        return self._make_result(result)
+
+    def __mul__(self, other):
+        """Multiply two ComplexNumerals."""
+        result = self.to_complex() * other.to_complex()
+        return self._make_result(result)
+
+    def __truediv__(self, other):
+        """Divide two ComplexNumerals."""
+        result = self.to_complex() / other.to_complex()
+        return self._make_result(result)
+
+    def __abs__(self):
+        """Return the magnitude as a UnicodeNumeral."""
+        magnitude = abs(self.to_complex())
+        if magnitude == int(magnitude):
+            magnitude = int(magnitude)
+        lang = self.language_name or "DIGIT"
+        return UnicodeNumeral(get_unicode_character_string(lang, magnitude))
+
+    def conjugate(self):
+        """Return the complex conjugate."""
+        result = self.to_complex().conjugate()
+        return self._make_result(result)
+
+    def __eq__(self, other):
+        if isinstance(other, ComplexNumeral):
+            return self.to_complex() == other.to_complex()
+        return NotImplemented
+
+    def __hash__(self):
+        return hash(self.to_complex())
+
+    def __str__(self):
+        """Return string representation in the original script."""
+        real_str = str(self.real)
+        imag_str = str(self.imaginary)
+        imag_val = self.imaginary.to_decimal()
+
+        if imag_val == 0:
+            return real_str
+        if self.real.to_decimal() == 0:
+            return f"{imag_str}i"
+
+        if imag_val >= 0:
+            return f"{real_str}+{imag_str}i"
+        return f"{real_str}{imag_str}i"
+
+    def __repr__(self):
+        return f'ComplexNumeral("{self}")'

multilingualprogramming/numeral/fraction_numeral.py

@@ -0,0 +1,165 @@
+#
+# SPDX-FileCopyrightText: 2024 John Samuel <johnsamuelwrites@gmail.com>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+"""Functions to handle fractions in multiple languages"""
+
+from fractions import Fraction
+from multilingualprogramming.numeral.unicode_numeral import UnicodeNumeral
+from multilingualprogramming.exceptions import InvalidNumeralCharacterError
+from multilingualprogramming.unicode_string import (
+    UNICODE_FRACTION_MAP,
+    get_unicode_character_string,
+)
+
+
+class FractionNumeral:
+    """
+    Handling fractions with multilingual numeral support.
+
+    Supports:
+    - Unicode vulgar fractions: ½, ⅓, ¼, etc.
+    - Constructed fractions: "3/4", "൩/൪" (in any script)
+    """
+
+    def __init__(self, numstr):
+        """
+        Create a FractionNumeral.
+
+        Parameters:
+            numstr (str): A fraction string like "½", "3/4", or "൩/൪"
+        """
+        self.numstr = numstr
+        self.language_name = None
+        self._fraction = None
+        self._parse(numstr)
+
+    def _parse(self, numstr):
+        """Parse a fraction string into a Fraction object."""
+        numstr = numstr.strip()
+
+        # Check for Unicode vulgar fraction characters
+        if len(numstr) == 1 and numstr in UNICODE_FRACTION_MAP:
+            numerator, denominator = UNICODE_FRACTION_MAP[numstr]
+            self._fraction = Fraction(numerator, denominator)
+            self.language_name = "DIGIT"
+            return
+
+        # Check for "numerator/denominator" format
+        if "/" in numstr:
+            parts = numstr.split("/", 1)
+            if len(parts) == 2:
+                num_part = UnicodeNumeral(parts[0].strip())
+                den_part = UnicodeNumeral(parts[1].strip())
+                self.language_name = num_part.language_name
+                numerator = num_part.to_decimal()
+                denominator = den_part.to_decimal()
+                if denominator == 0:
+                    raise InvalidNumeralCharacterError(
+                        "Division by zero in fraction"
+                    )
+                self._fraction = Fraction(numerator, denominator)
+                return
+
+        raise InvalidNumeralCharacterError(
+            f"Cannot parse fraction: {numstr}"
+        )
+
+    def to_fraction(self):
+        """
+        Convert to Python Fraction.
+
+        Returns:
+            Fraction: Python Fraction object
+        """
+        return self._fraction
+
+    def to_decimal(self):
+        """
+        Convert to decimal float.
+
+        Returns:
+            float: The decimal value
+        """
+        return float(self._fraction)
+
+    def simplify(self):
+        """
+        Return a simplified version of this fraction.
+
+        Returns:
+            FractionNumeral: Simplified fraction
+        """
+        simplified = Fraction(
+            self._fraction.numerator, self._fraction.denominator
+        )
+        lang = self.language_name or "DIGIT"
+        num_str = get_unicode_character_string(lang, simplified.numerator)
+        den_str = get_unicode_character_string(lang, simplified.denominator)
+        return FractionNumeral(f"{num_str}/{den_str}")
+
+    def _make_result(self, result_fraction):
+        """Create a new FractionNumeral from a Python Fraction."""
+        lang = self.language_name or "DIGIT"
+        num_str = get_unicode_character_string(lang, result_fraction.numerator)
+        den_str = get_unicode_character_string(
+            lang, result_fraction.denominator
+        )
+        return FractionNumeral(f"{num_str}/{den_str}")
+
+    def __add__(self, other):
+        """Add two FractionNumerals."""
+        result = self._fraction + other._fraction
+        return self._make_result(result)
+
+    def __sub__(self, other):
+        """Subtract two FractionNumerals."""
+        result = self._fraction - other._fraction
+        return self._make_result(result)
+
+    def __mul__(self, other):
+        """Multiply two FractionNumerals."""
+        result = self._fraction * other._fraction
+        return self._make_result(result)
+
+    def __truediv__(self, other):
+        """Divide two FractionNumerals."""
+        result = self._fraction / other._fraction
+        return self._make_result(result)
+
+    def __eq__(self, other):
+        if isinstance(other, FractionNumeral):
+            return self._fraction == other._fraction
+        return NotImplemented
+
+    def __lt__(self, other):
+        if isinstance(other, FractionNumeral):
+            return self._fraction < other._fraction
+        return NotImplemented
+
+    def __le__(self, other):
+        if isinstance(other, FractionNumeral):
+            return self._fraction <= other._fraction
+        return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, FractionNumeral):
+            return self._fraction > other._fraction
+        return NotImplemented
+
+    def __ge__(self, other):
+        if isinstance(other, FractionNumeral):
+            return self._fraction >= other._fraction
+        return NotImplemented
+
+    def __hash__(self):
+        return hash(self._fraction)
+
+    def __str__(self):
+        """Return string representation."""
+        return self.numstr
+
+    def __repr__(self):
+        return f'FractionNumeral("{self.numstr}")'