numly 0.2.0__tar.gz → 0.2.1__tar.gz

{numly-0.2.0 → numly-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numly
-Version: 0.2.0
+Version: 0.2.1
 Summary: Convert numbers across numeral systems — Roman, Chinese, Greek, Egyptian, Arabic-Indic and more.
 Home-page: https://github.com/TheMadrasTechie/numly
 Author: TheMadrasTechie

numly-0.2.1/numly/__init__.py

@@ -0,0 +1,97 @@
+"""
+numly
+~~~~~
+A Python library for working with numbers across numeral systems.
+
+Supported systems
+-----------------
+  decimal      : Standard base-10
+  roman        : Roman numerals          (I V X L C D M)
+  arabic_indic : Eastern Arabic digits   (٠ ١ ٢ ٣ ٤ ٥ ٦ ٧ ٨ ٩)
+  chinese      : Traditional Chinese     (零 一 二 三 四 … 万)
+  greek        : Greek alphabetic        (Α Β Γ … Ω  +  ͵ for thousands)
+  egyptian     : Egyptian hieroglyphs    (𓏺 𓎆 𓍢 𓆼 𓂭 𓆐 𓁨)
+  tamil        : Ancient Tamil numerals  (௧ ௨ ௩ … ௰ ௱ ௲)
+  babylonian   : Babylonian cuneiform    (𒁹 𒌋 — base 60)
+  mayan        : Mayan vigesimal         (𝋠 𝋡 𝋢 … 𝋳 — base 20)
+  binary       : Base-2
+  octal        : Base-8
+  hex          : Base-16
+  words        : English words (Western & Indian systems)
+
+Quick start
+-----------
+    import numly
+
+    numly.to_roman(2024)                       # 'MMXXIV'
+    numly.to_chinese(42)                       # '四十二'
+    numly.to_tamil(42)                         # '௪௰௨'
+    numly.to_babylonian(42)                    # '𒌋𒌋𒌋𒌋𒁹𒁹'
+    numly.to_mayan(42)                         # '𝋂 𝋂'
+    numly.to_binary(42)                        # '101010'
+    numly.to_hex(255)                          # 'FF'
+    numly.to_words(1_234_567)                  # 'one million two hundred...'
+    numly.to_words(1_234_567, 'indian')        # 'twelve lakh thirty four thousand...'
+    numly.convert("MMXXIV", "roman", "greek")  # '͵ΒΚΔʹ'
+    numly.to_all(42)                           # dict of every system
+"""
+
+__version__ = "0.2.0"
+__author__  = "TheMadrasTechie"
+__license__ = "MIT"
+
+# ── numeral systems ────────────────────────────────────────────────────────
+from numly.roman        import to_roman,        from_roman,        is_valid as is_valid_roman
+from numly.arabic_indic import to_arabic_indic,  from_arabic_indic, is_valid as is_valid_arabic_indic
+from numly.chinese      import to_chinese,       from_chinese,      is_valid as is_valid_chinese
+from numly.greek        import to_greek,         from_greek,        is_valid as is_valid_greek
+from numly.egyptian     import to_egyptian,      from_egyptian,     is_valid as is_valid_egyptian
+from numly.egyptian     import symbol_breakdown
+from numly.tamil        import to_tamil,         from_tamil,        is_valid as is_valid_tamil
+from numly.babylonian   import to_babylonian,    from_babylonian,   is_valid as is_valid_babylonian
+from numly.mayan        import to_mayan,         from_mayan,        is_valid as is_valid_mayan
+from numly.mayan        import to_mayan_text
+
+# ── base conversions ───────────────────────────────────────────────────────
+from numly.base import (
+    to_binary,  from_binary,
+    to_octal,   from_octal,
+    to_hex,     from_hex,
+    to_base,    from_base,
+)
+
+# ── english words ──────────────────────────────────────────────────────────
+from numly.words import to_words, to_words_western, to_words_indian
+
+# ── universal converter ────────────────────────────────────────────────────
+from numly.convert import convert, to_all, SYSTEMS, supported_systems
+
+__all__ = [
+    # roman
+    "to_roman", "from_roman", "is_valid_roman",
+    # arabic-indic
+    "to_arabic_indic", "from_arabic_indic", "is_valid_arabic_indic",
+    # chinese
+    "to_chinese", "from_chinese", "is_valid_chinese",
+    # greek
+    "to_greek", "from_greek", "is_valid_greek",
+    # egyptian
+    "to_egyptian", "from_egyptian", "is_valid_egyptian", "symbol_breakdown",
+    # tamil
+    "to_tamil", "from_tamil", "is_valid_tamil",
+    # babylonian
+    "to_babylonian", "from_babylonian", "is_valid_babylonian",
+    # mayan
+    "to_mayan", "from_mayan", "is_valid_mayan", "to_mayan_text",
+    # base conversions
+    "to_binary", "from_binary",
+    "to_octal",  "from_octal",
+    "to_hex",    "from_hex",
+    "to_base",   "from_base",
+    # words
+    "to_words", "to_words_western", "to_words_indian",
+    # universal
+    "convert", "to_all", "SYSTEMS", "supported_systems",
+    # meta
+    "__version__",
+]

numly-0.2.1/numly/babylonian.py

@@ -0,0 +1,157 @@
+"""
+numly.babylonian
+~~~~~~~~~~~~~~~~
+Convert integers to Babylonian cuneiform numerals and back.
+
+Babylonian mathematics used a base-60 (sexagesimal) positional system.
+Within each "digit" (0–59), values are written additively:
+  𒁹  = 1   (vertical wedge)       repeated up to 9×
+  𒌋  = 10  (Winkelhaken / corner) repeated up to 5×
+
+Digits are separated by a space. The system has no true zero
+(a blank position is represented by the placeholder 𒑱).
+
+Unicode block: Cuneiform (U+12000–U+123FF)
+
+Range: 1 – 216,000  (60³ — three sexagesimal digits)
+
+Examples
+--------
+    >>> from numly.babylonian import to_babylonian, from_babylonian
+    >>> to_babylonian(42)
+    '𒌋𒌋𒌋𒌋𒁹𒁹'
+    >>> to_babylonian(61)
+    '𒁹 𒁹'
+    >>> from_babylonian('𒁹 𒁹')
+    61
+"""
+
+_ONE   = "𒁹"   # U+12079  CUNEIFORM SIGN DIŠ  (1)
+_TEN   = "𒌋"   # U+1230B  CUNEIFORM SIGN U    (10)
+_ZERO  = "𒑱"   # U+12471  CUNEIFORM PUNCTUATION MARK STACKED DISHES (placeholder 0)
+_SEP   = " "    # digit separator
+
+SYSTEM   = "babylonian"
+BASE     = 60
+MIN, MAX = 1, BASE ** 3   # 1 – 216,000
+
+
+def _encode_digit(n: int) -> str:
+    """Encode one sexagesimal digit (0–59) to cuneiform."""
+    if n == 0:
+        return _ZERO
+    tens  = n // 10
+    ones  = n % 10
+    return _TEN * tens + _ONE * ones
+
+
+def _decode_digit(s: str) -> int:
+    """Decode one sexagesimal digit string to integer."""
+    if s == _ZERO:
+        return 0
+    result = 0
+    for ch in s:
+        if ch == _TEN:
+            result += 10
+        elif ch == _ONE:
+            result += 1
+        else:
+            raise ValueError(f"Unknown cuneiform character: {ch!r}")
+    return result
+
+
+def to_babylonian(num: int) -> str:
+    """
+    Convert an integer to a Babylonian cuneiform numeral string.
+
+    Args:
+        num: Positive integer between 1 and 216,000.
+
+    Returns:
+        Cuneiform string with sexagesimal digits separated by spaces,
+        e.g. '𒌋𒌋𒌋𒌋𒁹𒁹' (42) or '𒁹 𒁹' (61).
+
+    Raises:
+        TypeError:  If num is not an int.
+        ValueError: If num is outside 1–216,000.
+
+    Examples:
+        >>> to_babylonian(1)
+        '𒁹'
+        >>> to_babylonian(10)
+        '𒌋'
+        >>> to_babylonian(42)
+        '𒌋𒌋𒌋𒌋𒁹𒁹'
+        >>> to_babylonian(60)
+        '𒁹 𒑱'
+        >>> to_babylonian(61)
+        '𒁹 𒁹'
+        >>> to_babylonian(3600)
+        '𒁹 𒑱 𒑱'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if not MIN <= num <= MAX:
+        raise ValueError(f"Babylonian numerals support {MIN}–{MAX:,}, got {num}")
+
+    digits = []
+    n = num
+    while n:
+        digits.append(_encode_digit(n % BASE))
+        n //= BASE
+
+    return _SEP.join(reversed(digits))
+
+
+def from_babylonian(s: str) -> int:
+    """
+    Convert a Babylonian cuneiform numeral string to an integer.
+
+    Args:
+        s: Cuneiform string with digits separated by spaces,
+           e.g. '𒁹 𒁹'.
+
+    Returns:
+        Integer value.
+
+    Raises:
+        TypeError:  If s is not a str.
+        ValueError: If s contains unknown characters or is empty.
+
+    Examples:
+        >>> from_babylonian('𒌋𒌋𒌋𒌋𒁹𒁹')
+        42
+        >>> from_babylonian('𒁹 𒁹')
+        61
+        >>> from_babylonian('𒁹 𒑱 𒑱')
+        3600
+    """
+    if not isinstance(s, str):
+        raise TypeError(f"Expected str, got {type(s).__name__!r}")
+    s = s.strip()
+    if not s:
+        raise ValueError("Empty string")
+
+    parts  = s.split(_SEP)
+    result = 0
+    for part in parts:
+        result = result * BASE + _decode_digit(part)
+    return result
+
+
+def is_valid(s: str) -> bool:
+    """Check whether a string is a valid Babylonian cuneiform numeral."""
+    try:
+        from_babylonian(s)
+        return True
+    except (TypeError, ValueError):
+        return False
+
+
+# ── quick demo ─────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    tests = [1, 10, 42, 59, 60, 61, 600, 3600, 3661, 216_000]
+    for n in tests:
+        r = to_babylonian(n)
+        back = from_babylonian(r)
+        print(f"{n:<8} → {r:<30} → {back}")

numly-0.2.1/numly/base.py

@@ -0,0 +1,284 @@
+"""
+numly.base
+~~~~~~~~~~
+Convert integers to Binary, Octal, and Hexadecimal and back.
+
+  binary : base-2   (digits: 0 1)
+  octal  : base-8   (digits: 0–7)
+  hex    : base-16  (digits: 0–9 A–F)
+
+Range: 0 – unlimited (all three support arbitrarily large integers)
+
+Examples
+--------
+    >>> from numly.base import to_binary, to_octal, to_hex
+    >>> to_binary(42)
+    '101010'
+    >>> to_octal(42)
+    '52'
+    >>> to_hex(42)
+    '2A'
+"""
+
+SYSTEM = "base"
+
+
+# ── Binary ─────────────────────────────────────────────────────────────────
+
+def to_binary(num: int, prefix: bool = False) -> str:
+    """
+    Convert an integer to a binary string.
+
+    Args:
+        num:    Non-negative integer.
+        prefix: If True, prepend '0b'. Default False.
+
+    Returns:
+        Binary string, e.g. '101010'.
+
+    Examples:
+        >>> to_binary(0)
+        '0'
+        >>> to_binary(42)
+        '101010'
+        >>> to_binary(42, prefix=True)
+        '0b101010'
+        >>> to_binary(255)
+        '11111111'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if num < 0:
+        raise ValueError("Negative numbers are not supported")
+    result = bin(num)[2:]
+    return ("0b" + result) if prefix else result
+
+
+def from_binary(s: str) -> int:
+    """
+    Convert a binary string to an integer.
+
+    Args:
+        s: Binary string, with or without '0b' prefix.
+
+    Returns:
+        Integer value.
+
+    Examples:
+        >>> from_binary('101010')
+        42
+        >>> from_binary('0b101010')
+        42
+    """
+    if not isinstance(s, str):
+        raise TypeError(f"Expected str, got {type(s).__name__!r}")
+    s = s.strip().lower().removeprefix("0b")
+    if not s:
+        raise ValueError("Empty string")
+    try:
+        return int(s, 2)
+    except ValueError:
+        raise ValueError(f"Invalid binary string: {s!r}")
+
+
+# ── Octal ──────────────────────────────────────────────────────────────────
+
+def to_octal(num: int, prefix: bool = False) -> str:
+    """
+    Convert an integer to an octal string.
+
+    Args:
+        num:    Non-negative integer.
+        prefix: If True, prepend '0o'. Default False.
+
+    Returns:
+        Octal string, e.g. '52'.
+
+    Examples:
+        >>> to_octal(0)
+        '0'
+        >>> to_octal(42)
+        '52'
+        >>> to_octal(42, prefix=True)
+        '0o52'
+        >>> to_octal(255)
+        '377'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if num < 0:
+        raise ValueError("Negative numbers are not supported")
+    result = oct(num)[2:]
+    return ("0o" + result) if prefix else result
+
+
+def from_octal(s: str) -> int:
+    """
+    Convert an octal string to an integer.
+
+    Args:
+        s: Octal string, with or without '0o' prefix.
+
+    Returns:
+        Integer value.
+
+    Examples:
+        >>> from_octal('52')
+        42
+        >>> from_octal('0o52')
+        42
+    """
+    if not isinstance(s, str):
+        raise TypeError(f"Expected str, got {type(s).__name__!r}")
+    s = s.strip().lower().removeprefix("0o")
+    if not s:
+        raise ValueError("Empty string")
+    try:
+        return int(s, 8)
+    except ValueError:
+        raise ValueError(f"Invalid octal string: {s!r}")
+
+
+# ── Hexadecimal ────────────────────────────────────────────────────────────
+
+def to_hex(num: int, prefix: bool = False, upper: bool = True) -> str:
+    """
+    Convert an integer to a hexadecimal string.
+
+    Args:
+        num:    Non-negative integer.
+        prefix: If True, prepend '0x'. Default False.
+        upper:  If True (default), use uppercase A–F.
+
+    Returns:
+        Hexadecimal string, e.g. '2A'.
+
+    Examples:
+        >>> to_hex(0)
+        '0'
+        >>> to_hex(42)
+        '2A'
+        >>> to_hex(255)
+        'FF'
+        >>> to_hex(255, prefix=True)
+        '0xFF'
+        >>> to_hex(255, upper=False)
+        'ff'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if num < 0:
+        raise ValueError("Negative numbers are not supported")
+    result = hex(num)[2:]
+    result = result.upper() if upper else result.lower()
+    return ("0x" + result) if prefix else result
+
+
+def from_hex(s: str) -> int:
+    """
+    Convert a hexadecimal string to an integer.
+
+    Args:
+        s: Hex string, with or without '0x' prefix (case-insensitive).
+
+    Returns:
+        Integer value.
+
+    Examples:
+        >>> from_hex('2A')
+        42
+        >>> from_hex('0xff')
+        255
+        >>> from_hex('FF')
+        255
+    """
+    if not isinstance(s, str):
+        raise TypeError(f"Expected str, got {type(s).__name__!r}")
+    s = s.strip().lower().removeprefix("0x")
+    if not s:
+        raise ValueError("Empty string")
+    try:
+        return int(s, 16)
+    except ValueError:
+        raise ValueError(f"Invalid hexadecimal string: {s!r}")
+
+
+# ── Generic base converter ─────────────────────────────────────────────────
+
+def to_base(num: int, base: int) -> str:
+    """
+    Convert an integer to any base between 2 and 36.
+
+    Args:
+        num:  Non-negative integer.
+        base: Target base (2–36).
+
+    Returns:
+        String representation in the given base.
+
+    Examples:
+        >>> to_base(42, 2)
+        '101010'
+        >>> to_base(42, 16)
+        '2A'
+        >>> to_base(255, 36)
+        '73'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if num < 0:
+        raise ValueError("Negative numbers are not supported")
+    if not 2 <= base <= 36:
+        raise ValueError(f"Base must be between 2 and 36, got {base}")
+    if num == 0:
+        return "0"
+
+    digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    result = ""
+    while num:
+        result = digits[num % base] + result
+        num //= base
+    return result
+
+
+def from_base(s: str, base: int) -> int:
+    """
+    Convert a string in any base (2–36) to an integer.
+
+    Args:
+        s:    String representation.
+        base: Source base (2–36).
+
+    Returns:
+        Integer value.
+
+    Examples:
+        >>> from_base('101010', 2)
+        42
+        >>> from_base('2A', 16)
+        42
+    """
+    if not isinstance(s, str):
+        raise TypeError(f"Expected str, got {type(s).__name__!r}")
+    try:
+        return int(s.strip(), base)
+    except ValueError:
+        raise ValueError(f"Invalid base-{base} string: {s!r}")
+
+
+# ── quick demo ─────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    tests = [0, 1, 10, 42, 255, 1024, 65535]
+
+    print(f"{'Decimal':<10} {'Binary':<20} {'Octal':<10} {'Hex'}")
+    print("─" * 55)
+    for n in tests:
+        print(f"{n:<10} {to_binary(n):<20} {to_octal(n):<10} {to_hex(n)}")
+
+    print()
+    print("Round-trip checks:")
+    for n in tests:
+        assert from_binary(to_binary(n)) == n
+        assert from_octal(to_octal(n))   == n
+        assert from_hex(to_hex(n))       == n
+    print("  All passed ✓")

numly-0.2.1/numly/mayan.py

@@ -0,0 +1,202 @@
+"""
+numly.mayan
+~~~~~~~~~~~
+Convert integers to Mayan numerals and back.
+
+The Mayan vigesimal (base-20) system uses three symbols:
+  •  (dot)   = 1
+  —  (bar)   = 5
+  𝋠  (shell) = 0  (one of the earliest uses of zero in history)
+
+Within each "digit" (0–19):
+  dots stack vertically above bars
+  maximum: 3 bars (15) + 4 dots (4) = 19
+
+Digits are written top-to-bottom (highest power first).
+In this text representation, digits are separated by  |  .
+
+Unicode: The Mayan Numerals block (U+1D2C0–U+1D2FF) has combined
+glyphs 𝋠 (0) through 𝋳 (19). numly uses these for compact output.
+
+Range: 0 – 7,999  (20³ − 1; three vigesimal digits)
+
+Examples
+--------
+    >>> from numly.mayan import to_mayan, from_mayan
+    >>> to_mayan(0)
+    '𝋠'
+    >>> to_mayan(19)
+    '𝋳'
+    >>> to_mayan(20)
+    '𝋡 𝋠'
+    >>> to_mayan(42)
+    '𝋢 𝋡'
+"""
+
+# ── Mayan Numerals Unicode block U+1D2C0–U+1D2E3 ──────────────────────────
+# Each code point represents one complete Mayan digit 0–19.
+
+_GLYPHS = [chr(0x1D2C0 + i) for i in range(20)]   # 𝋠 𝋡 𝋢 … 𝋳
+_GLYPH_VAL = {g: i for i, g in enumerate(_GLYPHS)}
+
+_SEP = " "   # digit separator in multi-digit numbers
+
+SYSTEM   = "mayan"
+BASE     = 20
+MIN, MAX = 0, BASE ** 3 - 1   # 0 – 7,999
+
+
+def to_mayan(num: int) -> str:
+    """
+    Convert an integer to a Mayan numeral string.
+
+    Uses the Unicode Mayan Numerals block (U+1D2C0–U+1D2E3).
+    Multi-digit numbers separate vigesimal digits with a space.
+
+    Args:
+        num: Non-negative integer between 0 and 7,999.
+
+    Returns:
+        Mayan numeral string, e.g. '𝋢 𝋡' for 42.
+
+    Raises:
+        TypeError:  If num is not an int.
+        ValueError: If num is outside 0–7,999.
+
+    Examples:
+        >>> to_mayan(0)
+        '𝋠'
+        >>> to_mayan(1)
+        '𝋡'
+        >>> to_mayan(5)
+        '𝋥'
+        >>> to_mayan(19)
+        '𝋳'
+        >>> to_mayan(20)
+        '𝋡 𝋠'
+        >>> to_mayan(42)
+        '𝋢 𝋡'
+        >>> to_mayan(400)
+        '𝋡 𝋠 𝋠'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if not MIN <= num <= MAX:
+        raise ValueError(f"Mayan numerals support {MIN}–{MAX}, got {num}")
+
+    if num == 0:
+        return _GLYPHS[0]
+
+    digits = []
+    n = num
+    while n:
+        digits.append(_GLYPHS[n % BASE])
+        n //= BASE
+
+    return _SEP.join(reversed(digits))
+
+
+def from_mayan(s: str) -> int:
+    """
+    Convert a Mayan numeral string to an integer.
+
+    Args:
+        s: Mayan numeral string with digits separated by spaces,
+           e.g. '𝋢 𝋡'.
+
+    Returns:
+        Integer value.
+
+    Raises:
+        TypeError:  If s is not a str.
+        ValueError: If s contains unknown characters.
+
+    Examples:
+        >>> from_mayan('𝋠')
+        0
+        >>> from_mayan('𝋳')
+        19
+        >>> from_mayan('𝋡 𝋠')
+        20
+        >>> from_mayan('𝋢 𝋡')
+        42
+    """
+    if not isinstance(s, str):
+        raise TypeError(f"Expected str, got {type(s).__name__!r}")
+    s = s.strip()
+    if not s:
+        raise ValueError("Empty string")
+
+    parts  = s.split(_SEP)
+    result = 0
+    for part in parts:
+        if part not in _GLYPH_VAL:
+            raise ValueError(f"Unknown Mayan glyph: {part!r}")
+        result = result * BASE + _GLYPH_VAL[part]
+    return result
+
+
+def to_mayan_text(num: int) -> str:
+    """
+    Convert an integer to a human-readable Mayan text representation.
+
+    Uses dots (•), bars (━), and shell (◎) for maximum compatibility.
+
+    Args:
+        num: Non-negative integer between 0 and 7,999.
+
+    Returns:
+        Text representation string, e.g. '••━ | •' for 42.
+
+    Examples:
+        >>> to_mayan_text(0)
+        '◎'
+        >>> to_mayan_text(7)
+        '••━'
+        >>> to_mayan_text(19)
+        '••••━━━'
+        >>> to_mayan_text(42)
+        '••━ | •'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if not MIN <= num <= MAX:
+        raise ValueError(f"Mayan numerals support {MIN}–{MAX}, got {num}")
+
+    def _digit_text(d: int) -> str:
+        if d == 0:
+            return "◎"
+        bars = d // 5
+        dots = d % 5
+        return "•" * dots + "━" * bars
+
+    if num == 0:
+        return "◎"
+
+    digits = []
+    n = num
+    while n:
+        digits.append(_digit_text(n % BASE))
+        n //= BASE
+
+    return " | ".join(reversed(digits))
+
+
+def is_valid(s: str) -> bool:
+    """Check whether a string is a valid Mayan numeral."""
+    try:
+        val = from_mayan(s)
+        return to_mayan(val) == s
+    except (TypeError, ValueError):
+        return False
+
+
+# ── quick demo ─────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    tests = [0, 1, 5, 7, 19, 20, 42, 100, 400, 7999]
+    print(f"{'n':<8} {'Unicode':<20} {'Text (dots/bars)'}")
+    print("─" * 50)
+    for n in tests:
+        u = to_mayan(n)
+        t = to_mayan_text(n)
+        print(f"{n:<8} {u:<20} {t}")

numly-0.2.1/numly/tamil.py

@@ -0,0 +1,189 @@
+"""
+numly.tamil
+~~~~~~~~~~~
+Convert integers to Ancient Tamil numerals and back.
+
+Tamil numerals use a positional-additive system with dedicated symbols
+for 1–9, 10, 100, and 1000.
+
+Unicode block: Tamil (U+0BE6–U+0BF2)
+
+  ௦ = 0    ௧ = 1    ௨ = 2    ௩ = 3    ௪ = 4
+  ௫ = 5    ௬ = 6    ௭ = 7    ௮ = 8    ௯ = 9
+  ௰ = 10   ௱ = 100  ௲ = 1000
+
+Range: 0 – 9,999
+
+Examples
+--------
+    >>> from numly.tamil import to_tamil, from_tamil
+    >>> to_tamil(42)
+    '௪௰௨'
+    >>> from_tamil('௪௰௨')
+    42
+"""
+
+# ── symbol tables ──────────────────────────────────────────────────────────
+
+_DIGITS = "௦௧௨௩௪௫௬௭௮௯"   # 0–9  (U+0BE6 – U+0BEF)
+_TEN    = "௰"               # 10   (U+0BF0)
+_HUNDRED = "௱"              # 100  (U+0BF1)
+_THOUSAND = "௲"             # 1000 (U+0BF2)
+
+_CHAR_VALUE = {ch: i for i, ch in enumerate(_DIGITS)}
+_CHAR_VALUE[_TEN]      = 10
+_CHAR_VALUE[_HUNDRED]  = 100
+_CHAR_VALUE[_THOUSAND] = 1000
+
+SYSTEM   = "tamil"
+MIN, MAX = 0, 9_999
+
+
+# ── encode ─────────────────────────────────────────────────────────────────
+
+def to_tamil(num: int) -> str:
+    """
+    Convert an integer to an Ancient Tamil numeral string.
+
+    Tamil numerals use multiplier notation:
+      42  → ௪ (4) × ௰ (10) + ௨ (2)  → '௪௰௨'
+      300 → ௩ (3) × ௱ (100)          → '௩௱'
+      1500→ ௧ (1) × ௲ (1000) + ௫ × ௱ → '௧௲௫௱'
+
+    Args:
+        num: Integer between 0 and 9,999.
+
+    Returns:
+        Tamil numeral string, e.g. '௪௰௨'.
+
+    Raises:
+        TypeError:  If num is not an int.
+        ValueError: If num is outside 0–9999.
+
+    Examples:
+        >>> to_tamil(0)
+        '௦'
+        >>> to_tamil(7)
+        '௭'
+        >>> to_tamil(10)
+        '௰'
+        >>> to_tamil(42)
+        '௪௰௨'
+        >>> to_tamil(100)
+        '௱'
+        >>> to_tamil(999)
+        '௯௱௯௰௯'
+        >>> to_tamil(1234)
+        '௧௲௨௱௩௰௪'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if num == 0:
+        return _DIGITS[0]
+    if not 1 <= num <= MAX:
+        raise ValueError(f"Tamil numerals support 0–{MAX}, got {num}")
+
+    result = ""
+
+    # thousands
+    t = num // 1000
+    if t:
+        result += (_DIGITS[t] if t > 1 else "") + _THOUSAND
+        num %= 1000
+
+    # hundreds
+    h = num // 100
+    if h:
+        result += (_DIGITS[h] if h > 1 else "") + _HUNDRED
+        num %= 100
+
+    # tens
+    d = num // 10
+    if d:
+        result += (_DIGITS[d] if d > 1 else "") + _TEN
+        num %= 10
+
+    # ones
+    if num:
+        result += _DIGITS[num]
+
+    return result
+
+
+# ── decode ─────────────────────────────────────────────────────────────────
+
+def from_tamil(s: str) -> int:
+    """
+    Convert an Ancient Tamil numeral string to an integer.
+
+    Args:
+        s: Tamil numeral string, e.g. '௪௰௨'.
+
+    Returns:
+        Integer value.
+
+    Raises:
+        TypeError:  If s is not a str.
+        ValueError: If s contains unknown characters or is empty.
+
+    Examples:
+        >>> from_tamil('௦')
+        0
+        >>> from_tamil('௪௰௨')
+        42
+        >>> from_tamil('௧௲௨௱௩௰௪')
+        1234
+    """
+    if not isinstance(s, str):
+        raise TypeError(f"Expected str, got {type(s).__name__!r}")
+    s = s.strip()
+    if not s:
+        raise ValueError("Empty string")
+    if s == _DIGITS[0]:
+        return 0
+
+    for ch in s:
+        if ch not in _CHAR_VALUE:
+            raise ValueError(f"Unknown Tamil numeral character: {ch!r}")
+
+    result  = 0
+    pending = 0   # digit waiting to be multiplied by a unit
+
+    for ch in s:
+        v = _CHAR_VALUE[ch]
+        if v in (10, 100, 1000):
+            # multiplier — pending digit × unit (1 if no pending digit)
+            result  += (pending if pending else 1) * v
+            pending  = 0
+        else:
+            # plain digit
+            pending = v
+
+    result += pending   # any trailing ones digit
+    return result
+
+
+def is_valid(s: str) -> bool:
+    """
+    Check whether a string is a valid Ancient Tamil numeral.
+
+    Examples:
+        >>> is_valid('௪௰௨')
+        True
+        >>> is_valid('hello')
+        False
+    """
+    try:
+        val = from_tamil(s)
+        return to_tamil(val) == s
+    except (TypeError, ValueError):
+        return False
+
+
+# ── quick demo ─────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    tests = [0, 1, 7, 10, 11, 42, 100, 110, 999, 1000, 1234, 9999]
+    for n in tests:
+        r = to_tamil(n)
+        back = from_tamil(r)
+        print(f"{n:<8} → {r:<12} → {back}")

numly-0.2.1/numly/words.py

@@ -0,0 +1,207 @@
+"""
+numly.words
+~~~~~~~~~~~
+Convert integers to English words in both Western and Indian systems.
+
+Western system  : thousand, million, billion, trillion …
+Indian system   : thousand, lakh, crore …
+
+Range
+-----
+  Western : 0 – 999,999,999,999,999  (up to 999 trillion)
+  Indian  : 0 – 99,99,99,99,99,999   (up to 99 lakh crore)
+
+Examples
+--------
+    >>> from numly.words import to_words_western, to_words_indian
+    >>> to_words_western(1234567)
+    'one million two hundred thirty four thousand five hundred sixty seven'
+    >>> to_words_indian(1234567)
+    'twelve lakh thirty four thousand five hundred sixty seven'
+"""
+
+# ── lookup tables ──────────────────────────────────────────────────────────
+
+_ONES = [
+    "", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
+    "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen",
+    "seventeen", "eighteen", "nineteen",
+]
+
+_TENS = [
+    "", "", "twenty", "thirty", "forty", "fifty",
+    "sixty", "seventy", "eighty", "ninety",
+]
+
+SYSTEM = "words"
+
+
+# ── internal helpers ───────────────────────────────────────────────────────
+
+def _below_1000(n: int) -> str:
+    """Convert an integer 0–999 to words (no leading/trailing spaces)."""
+    if n == 0:
+        return ""
+    if n < 20:
+        return _ONES[n]
+    if n < 100:
+        rest = _ONES[n % 10]
+        return _TENS[n // 10] + (" " + rest if rest else "")
+    rest = _below_1000(n % 100)
+    return _ONES[n // 100] + " hundred" + (" " + rest if rest else "")
+
+
+# ── Western system ─────────────────────────────────────────────────────────
+
+_WESTERN_SCALE = [
+    (1_000_000_000_000, "trillion"),
+    (1_000_000_000,     "billion"),
+    (1_000_000,         "million"),
+    (1_000,             "thousand"),
+]
+
+
+def to_words_western(num: int) -> str:
+    """
+    Convert an integer to English words using the Western scale.
+
+    Uses: thousand → million → billion → trillion
+
+    Args:
+        num: Integer between 0 and 999,999,999,999,999.
+
+    Returns:
+        English words string, e.g. 'one million two hundred thirty four thousand'.
+
+    Raises:
+        TypeError:  If num is not an int.
+        ValueError: If num is negative or out of range.
+
+    Examples:
+        >>> to_words_western(0)
+        'zero'
+        >>> to_words_western(42)
+        'forty two'
+        >>> to_words_western(1001)
+        'one thousand one'
+        >>> to_words_western(1_000_000)
+        'one million'
+        >>> to_words_western(1_234_567)
+        'one million two hundred thirty four thousand five hundred sixty seven'
+        >>> to_words_western(1_000_000_000)
+        'one billion'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if num < 0:
+        raise ValueError("Negative numbers are not supported")
+    if num > 999_999_999_999_999:
+        raise ValueError("Number too large; maximum is 999,999,999,999,999")
+    if num == 0:
+        return "zero"
+
+    parts = []
+    for scale, name in _WESTERN_SCALE:
+        if num >= scale:
+            parts.append(_below_1000(num // scale) + " " + name)
+            num %= scale
+    if num > 0:
+        parts.append(_below_1000(num))
+
+    return " ".join(parts)
+
+
+# ── Indian system ──────────────────────────────────────────────────────────
+
+_INDIAN_SCALE = [
+    (10_00_00_000, "crore"),
+    (1_00_000,     "lakh"),
+    (1_000,        "thousand"),
+]
+
+
+def to_words_indian(num: int) -> str:
+    """
+    Convert an integer to English words using the Indian numbering scale.
+
+    Uses: thousand → lakh → crore
+
+    Args:
+        num: Integer between 0 and 9,99,99,99,99,99,999.
+
+    Returns:
+        English words string using Indian scale, e.g. 'twelve lakh thirty four thousand'.
+
+    Raises:
+        TypeError:  If num is not an int.
+        ValueError: If num is negative or out of range.
+
+    Examples:
+        >>> to_words_indian(0)
+        'zero'
+        >>> to_words_indian(42)
+        'forty two'
+        >>> to_words_indian(100_000)
+        'one lakh'
+        >>> to_words_indian(1_234_567)
+        'twelve lakh thirty four thousand five hundred sixty seven'
+        >>> to_words_indian(10_000_000)
+        'one crore'
+        >>> to_words_indian(10_000_000_000)
+        'one thousand crore'
+    """
+    if not isinstance(num, int):
+        raise TypeError(f"Expected int, got {type(num).__name__!r}")
+    if num < 0:
+        raise ValueError("Negative numbers are not supported")
+    if num == 0:
+        return "zero"
+
+    parts = []
+    for scale, name in _INDIAN_SCALE:
+        if num >= scale:
+            chunk = num // scale
+            parts.append(_below_1000(chunk) + " " + name)
+            num %= scale
+    if num > 0:
+        parts.append(_below_1000(num))
+
+    return " ".join(parts)
+
+
+def to_words(num: int, system: str = "western") -> str:
+    """
+    Convert an integer to English words.
+
+    Args:
+        num:    Integer to convert.
+        system: 'western' (default) or 'indian'.
+
+    Returns:
+        English words string.
+
+    Examples:
+        >>> to_words(1_234_567, "western")
+        'one million two hundred thirty four thousand five hundred sixty seven'
+        >>> to_words(1_234_567, "indian")
+        'twelve lakh thirty four thousand five hundred sixty seven'
+    """
+    system = system.lower().strip()
+    if system == "western":
+        return to_words_western(num)
+    if system == "indian":
+        return to_words_indian(num)
+    raise ValueError(f"Unknown system {system!r}. Choose 'western' or 'indian'.")
+
+
+# ── quick demo ─────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    tests = [0, 1, 13, 42, 100, 999, 1_000, 10_000, 1_00_000,
+             1_234_567, 10_000_000, 1_000_000_000, 1_234_567_890]
+
+    print(f"{'Number':<20} {'Western':<55} {'Indian'}")
+    print("─" * 120)
+    for n in tests:
+        w = to_words_western(n)
+        i = to_words_indian(n)
+        print(f"{n:<20} {w:<55} {i}")

{numly-0.2.0 → numly-0.2.1}/numly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numly
-Version: 0.2.0
+Version: 0.2.1
 Summary: Convert numbers across numeral systems — Roman, Chinese, Greek, Egyptian, Arabic-Indic and more.
 Home-page: https://github.com/TheMadrasTechie/numly
 Author: TheMadrasTechie

{numly-0.2.0 → numly-0.2.1}/numly.egg-info/SOURCES.txt

@@ -3,11 +3,16 @@ setup.cfg
 setup.py
 numly/__init__.py
 numly/arabic_indic.py
+numly/babylonian.py
+numly/base.py
 numly/chinese.py
 numly/convert.py
 numly/egyptian.py
 numly/greek.py
+numly/mayan.py
 numly/roman.py
+numly/tamil.py
+numly/words.py
 numly.egg-info/PKG-INFO
 numly.egg-info/SOURCES.txt
 numly.egg-info/dependency_links.txt

{numly-0.2.0 → numly-0.2.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name="numly",
-    version="0.2.0",
+    version="0.2.1",
     packages=find_packages(),
     install_requires=[],
     author="TheMadrasTechie",

numly-0.2.0/numly/__init__.py

@@ -1,64 +0,0 @@
-"""
-numly
-~~~~~
-A Python library for working with numbers across numeral systems.
-
-Supported systems
------------------
-  decimal      : Standard base-10
-  roman        : Roman numerals          (I V X L C D M)
-  arabic_indic : Eastern Arabic digits   (٠ ١ ٢ ٣ ٤ ٥ ٦ ٧ ٨ ٩)
-  chinese      : Traditional Chinese     (零 一 二 三 四 … 万)
-  greek        : Greek alphabetic        (Α Β Γ … Ω  +  ͵ for thousands)
-  egyptian     : Egyptian hieroglyphs    (𓏺 𓎆 𓍢 𓆼 𓂭 𓆐 𓁨)
-
-Quick start
------------
-    import numly
-
-    numly.to_roman(2024)                       # 'MMXXIV'
-    numly.to_chinese(42)                       # '四十二'
-    numly.convert("MMXXIV", "roman", "greek")  # '͵ΒΚΔʹ'
-    numly.to_all(42)                           # dict of every system
-
-Individual modules
-------------------
-    from numly.roman        import to_roman, from_roman
-    from numly.arabic_indic import to_arabic_indic, from_arabic_indic
-    from numly.chinese      import to_chinese, from_chinese
-    from numly.greek        import to_greek, from_greek
-    from numly.egyptian     import to_egyptian, from_egyptian, symbol_breakdown
-    from numly.convert      import convert, to_all, SYSTEMS
-"""
-
-__version__ = "0.1.1"
-__author__  = "numly contributors"
-__license__ = "MIT"
-
-# ── individual converters ──────────────────────────────────────────────────
-from numly.roman        import to_roman,        from_roman,        is_valid as is_valid_roman
-from numly.arabic_indic import to_arabic_indic,  from_arabic_indic, is_valid as is_valid_arabic_indic
-from numly.chinese      import to_chinese,       from_chinese,      is_valid as is_valid_chinese
-from numly.greek        import to_greek,         from_greek,        is_valid as is_valid_greek
-from numly.egyptian     import to_egyptian,      from_egyptian,     is_valid as is_valid_egyptian
-from numly.egyptian     import symbol_breakdown
-
-# ── universal converter ────────────────────────────────────────────────────
-from numly.convert import convert, to_all, SYSTEMS, supported_systems
-
-__all__ = [
-    # roman
-    "to_roman", "from_roman", "is_valid_roman",
-    # arabic-indic
-    "to_arabic_indic", "from_arabic_indic", "is_valid_arabic_indic",
-    # chinese
-    "to_chinese", "from_chinese", "is_valid_chinese",
-    # greek
-    "to_greek", "from_greek", "is_valid_greek",
-    # egyptian
-    "to_egyptian", "from_egyptian", "is_valid_egyptian", "symbol_breakdown",
-    # universal
-    "convert", "to_all", "SYSTEMS", "supported_systems",
-    # meta
-    "__version__",
-]