azrmooenc 1.0.0__tar.gz

azrmooenc-1.0.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: azrmooenc
+Version: 1.0.0
+Summary: A completely original reversible encoding library using Moo tokens
+Author: azr
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/azrmooenc/
+Keywords: encoding,moo,azrmoo,reversible-encoding
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# AzrMoo Enc v1
+
+A completely original reversible encoding library using Moo tokens.
+
+## Installation
+
+```bash
+pip install azrmooenc
+```
+
+## Usage
+
+```python
+import azrmooenc
+
+# Encode/decode strings
+encoded = azrmooenc.encode("Hello, World!")
+decoded = azrmooenc.decode(encoded)
+
+# Encode/decode bytes
+encoded = azrmooenc.encode_bytes(b"binary data")
+decoded = azrmooenc.decode_bytes(encoded)
+
+# With custom key
+encoded = azrmooenc.encode("Secret", key="mykey")
+decoded = azrmooenc.decode(encoded, key="mykey")
+
+# File support
+azrmooenc.encode_file("photo.jpg", "photo.jpg.azr")
+azrmooenc.decode_file("photo.jpg.azr", "photo.jpg")
+
+# Generate lookup tables
+enc_table, dec_table = azrmooenc.generate_table("AZR")
+
+# Version
+print(azrmooenc.version())
+```
+
+## API
+
+- `encode(text, key="AZR")` - Encode string to AzrMoo format
+- `decode(text, key="AZR")` - Decode AzrMoo string back to text
+- `encode_bytes(data, key="AZR")` - Encode bytes to AzrMoo format
+- `decode_bytes(data, key="AZR")` - Decode AzrMoo bytes back to original
+- `encode_file(input_path, output_path, key="AZR")` - Encode a file
+- `decode_file(input_path, output_path, key="AZR")` - Decode a file
+- `generate_table(key="AZR")` - Generate encoding/decoding lookup tables
+- `version()` - Return version string
+
+## License
+
+MIT

azrmooenc-1.0.0/README.md

@@ -0,0 +1,52 @@
+# AzrMoo Enc v1
+
+A completely original reversible encoding library using Moo tokens.
+
+## Installation
+
+```bash
+pip install azrmooenc
+```
+
+## Usage
+
+```python
+import azrmooenc
+
+# Encode/decode strings
+encoded = azrmooenc.encode("Hello, World!")
+decoded = azrmooenc.decode(encoded)
+
+# Encode/decode bytes
+encoded = azrmooenc.encode_bytes(b"binary data")
+decoded = azrmooenc.decode_bytes(encoded)
+
+# With custom key
+encoded = azrmooenc.encode("Secret", key="mykey")
+decoded = azrmooenc.decode(encoded, key="mykey")
+
+# File support
+azrmooenc.encode_file("photo.jpg", "photo.jpg.azr")
+azrmooenc.decode_file("photo.jpg.azr", "photo.jpg")
+
+# Generate lookup tables
+enc_table, dec_table = azrmooenc.generate_table("AZR")
+
+# Version
+print(azrmooenc.version())
+```
+
+## API
+
+- `encode(text, key="AZR")` - Encode string to AzrMoo format
+- `decode(text, key="AZR")` - Decode AzrMoo string back to text
+- `encode_bytes(data, key="AZR")` - Encode bytes to AzrMoo format
+- `decode_bytes(data, key="AZR")` - Decode AzrMoo bytes back to original
+- `encode_file(input_path, output_path, key="AZR")` - Encode a file
+- `decode_file(input_path, output_path, key="AZR")` - Decode a file
+- `generate_table(key="AZR")` - Generate encoding/decoding lookup tables
+- `version()` - Return version string
+
+## License
+
+MIT

azrmooenc-1.0.0/azrmooenc.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: azrmooenc
+Version: 1.0.0
+Summary: A completely original reversible encoding library using Moo tokens
+Author: azr
+License: MIT
+Project-URL: Homepage, https://pypi.org/project/azrmooenc/
+Keywords: encoding,moo,azrmoo,reversible-encoding
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# AzrMoo Enc v1
+
+A completely original reversible encoding library using Moo tokens.
+
+## Installation
+
+```bash
+pip install azrmooenc
+```
+
+## Usage
+
+```python
+import azrmooenc
+
+# Encode/decode strings
+encoded = azrmooenc.encode("Hello, World!")
+decoded = azrmooenc.decode(encoded)
+
+# Encode/decode bytes
+encoded = azrmooenc.encode_bytes(b"binary data")
+decoded = azrmooenc.decode_bytes(encoded)
+
+# With custom key
+encoded = azrmooenc.encode("Secret", key="mykey")
+decoded = azrmooenc.decode(encoded, key="mykey")
+
+# File support
+azrmooenc.encode_file("photo.jpg", "photo.jpg.azr")
+azrmooenc.decode_file("photo.jpg.azr", "photo.jpg")
+
+# Generate lookup tables
+enc_table, dec_table = azrmooenc.generate_table("AZR")
+
+# Version
+print(azrmooenc.version())
+```
+
+## API
+
+- `encode(text, key="AZR")` - Encode string to AzrMoo format
+- `decode(text, key="AZR")` - Decode AzrMoo string back to text
+- `encode_bytes(data, key="AZR")` - Encode bytes to AzrMoo format
+- `decode_bytes(data, key="AZR")` - Decode AzrMoo bytes back to original
+- `encode_file(input_path, output_path, key="AZR")` - Encode a file
+- `decode_file(input_path, output_path, key="AZR")` - Decode a file
+- `generate_table(key="AZR")` - Generate encoding/decoding lookup tables
+- `version()` - Return version string
+
+## License
+
+MIT

azrmooenc-1.0.0/azrmooenc.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+README.md
+azrmooenc.py
+pyproject.toml
+azrmooenc.egg-info/PKG-INFO
+azrmooenc.egg-info/SOURCES.txt
+azrmooenc.egg-info/dependency_links.txt
+azrmooenc.egg-info/top_level.txt

azrmooenc-1.0.0/azrmooenc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

azrmooenc-1.0.0/azrmooenc.egg-info/top_level.txt

@@ -0,0 +1 @@
+azrmooenc

azrmooenc-1.0.0/azrmooenc.py

@@ -0,0 +1,460 @@
+
+"""
+AzrMoo Enc v1 - A completely original reversible encoding library.
+
+This library implements a custom encoding scheme that transforms binary data
+into a string of 'Moo' tokens using a unique alphabet and algorithm.
+This is NOT encryption; it is a reversible encoding format similar in purpose
+to Base64 but with a completely original design.
+
+Package: azrmooenc
+"""
+
+import random
+from typing import Dict, List, Tuple
+
+
+# ─── Custom Exceptions ────────────────────────────────────────────────────────
+
+
+class AzrMooError(Exception):
+    """Base exception for all AzrMoo encoding errors."""
+    pass
+
+
+class InvalidHeaderError(AzrMooError):
+    """Raised when the encoded data has an invalid or missing header."""
+    pass
+
+
+class InvalidTokenError(AzrMooError):
+    """Raised when an unrecognized Moo token is encountered."""
+    pass
+
+
+class InvalidChecksumError(AzrMooError):
+    """Raised when checksum validation fails, indicating data corruption."""
+    pass
+
+
+class DecodeError(AzrMooError):
+    """Raised when decoding fails for any reason."""
+    pass
+
+
+# ─── Constants ────────────────────────────────────────────────────────────────
+
+HEADER = "AZRMOOENCV1:"
+DELIMITER = "~"
+CHECKSUM_SIZE = 2
+
+_BASE_TOKENS: List[str] = []
+for _i in range(256):
+    _chars = []
+    for _bit in range(7, -1, -1):
+        _chars.append('m' if (_i >> _bit) & 1 else 'o')
+    _BASE_TOKENS.append(''.join(_chars))
+
+
+# ─── Internal Helpers ─────────────────────────────────────────────────────────
+
+
+def _key_to_seed(key: str) -> int:
+    """Convert a string key to a deterministic 31-bit integer seed."""
+    seed = 0
+    for c in key.encode('utf-8'):
+        seed = ((seed << 5) - seed + c) & 0x7FFFFFFF
+    return seed
+
+
+def _shuffle(items: List[str], key: str) -> List[str]:
+    """Deterministically shuffle a list using Fisher-Yates and a key-derived seed."""
+    rng = random.Random(_key_to_seed(key))
+    result = items.copy()
+    for i in range(len(result) - 1, 0, -1):
+        j = rng.randint(0, i)
+        result[i], result[j] = result[j], result[i]
+    return result
+
+
+# ─── Public API ────────────────────────────────────────────────────────────────
+
+
+def version() -> str:
+    """Return the library version string."""
+    return "AzrMoo Enc v1.0.0"
+
+
+def generate_table(key: str = "AZR") -> Tuple[Dict[int, str], Dict[str, int]]:
+    """Generate encoding and decoding lookup tables.
+
+    The key deterministically shuffles the Moo alphabet so different
+    keys produce different mappings.
+
+    Args:
+        key: The key to seed alphabet generation (default: "AZR").
+
+    Returns:
+        (encode_table, decode_table) where:
+        - encode_table maps byte value (0-255) -> Moo token string
+        - decode_table maps Moo token string -> byte value (0-255)
+    """
+    tokens = _shuffle(_BASE_TOKENS, key)
+    enc: Dict[int, str] = {i: tokens[i] for i in range(256)}
+    dec: Dict[str, int] = {tokens[i]: i for i in range(256)}
+    return enc, dec
+
+
+def _transform(data: bytes, key: str, forward: bool) -> bytes:
+    """Apply or reverse the byte transformation.
+
+    The transformation combines XOR with key bytes, bit rotation, and
+    position-dependent addition modulo 256 to scramble byte values.
+    """
+    k = key.encode('utf-8')
+    kl = len(k)
+    out = bytearray(len(data))
+    for i, b in enumerate(data):
+        if forward:
+            x = b ^ k[i % kl]
+            s = i % 8
+            x = ((x << s) | (x >> (8 - s))) & 0xFF
+            x = (x + i * 19 + 7) & 0xFF
+        else:
+            x = (b - i * 19 - 7) & 0xFF
+            s = i % 8
+            x = ((x >> s) | (x << (8 - s))) & 0xFF
+            x ^= k[i % kl]
+        out[i] = x
+    return bytes(out)
+
+
+def _checksum(data: bytes) -> bytes:
+    """Compute a 2-byte checksum: (sum mod 256, xor of all bytes)."""
+    total = 0
+    xor_val = 0
+    for b in data:
+        total = (total + b) & 0xFF
+        xor_val ^= b
+    return bytes([total, xor_val])
+
+
+def encode_bytes(data: bytes, key: str = "AZR") -> str:
+    """Encode bytes to an AzrMoo Encoded string.
+
+    The input bytes are transformed, checksummed, and converted to
+    Moo tokens joined by the delimiter, prefixed with the format header.
+
+    Args:
+        data: The bytes to encode.
+        key: The encoding key (default: "AZR").
+
+    Returns:
+        An AzrMoo-encoded string.
+    """
+    ck = _checksum(data)
+    payload = data + ck
+    transformed = _transform(payload, key, forward=True)
+    enc, _ = generate_table(key)
+    tokens = [enc[b] for b in transformed]
+    return HEADER + DELIMITER.join(tokens)
+
+
+def decode_bytes(encoded: str, key: str = "AZR") -> bytes:
+    """Decode an AzrMoo Encoded string back to bytes.
+
+    Verifies the header, decodes tokens, reverses the transformation,
+    and validates the checksum.
+
+    Args:
+        encoded: The AzrMoo-encoded string.
+        key: The decoding key (default: "AZR").
+
+    Returns:
+        The original decoded bytes.
+
+    Raises:
+        InvalidHeaderError: If the header is missing or invalid.
+        InvalidTokenError: If an unrecognized token is encountered.
+        InvalidChecksumError: If the checksum does not match.
+        DecodeError: If decoding fails for any other reason.
+    """
+    if not encoded.startswith(HEADER):
+        raise InvalidHeaderError(
+            f"Missing or invalid header: expected '{HEADER}'"
+        )
+    body = encoded[len(HEADER):]
+    if not body:
+        raise DecodeError("No encoded data found after header")
+
+    token_list = body.split(DELIMITER)
+    _, dec = generate_table(key)
+
+    decoded = bytearray()
+    for t in token_list:
+        if t not in dec:
+            raise InvalidTokenError(f"Unrecognized token: '{t}'")
+        decoded.append(dec[t])
+
+    raw = _transform(bytes(decoded), key, forward=False)
+    if len(raw) < CHECKSUM_SIZE:
+        raise DecodeError("Encoded data is too short")
+    data = raw[:-CHECKSUM_SIZE]
+    ck = raw[-CHECKSUM_SIZE:]
+    expected = _checksum(data)
+    if ck != expected:
+        raise InvalidChecksumError(
+            f"Checksum mismatch: expected {expected.hex()}, got {ck.hex()}"
+        )
+    return bytes(data)
+
+
+def encode(text: str, key: str = "AZR") -> str:
+    """Encode a string to an AzrMoo Encoded string.
+
+    The input string is UTF-8 encoded, then encoded with encode_bytes.
+
+    Args:
+        text: The string to encode.
+        key: The encoding key (default: "AZR").
+
+    Returns:
+        An AzrMoo-encoded string.
+    """
+    return encode_bytes(text.encode('utf-8'), key)
+
+
+def decode(text: str, key: str = "AZR") -> str:
+    """Decode an AzrMoo Encoded string back to a string.
+
+    Decodes with decode_bytes then UTF-8 decodes the result.
+
+    Args:
+        text: The AzrMoo-encoded string.
+        key: The decoding key (default: "AZR").
+
+    Returns:
+        The original decoded string.
+
+    Raises:
+        DecodeError: If the decoded bytes are not valid UTF-8.
+    """
+    data = decode_bytes(text, key)
+    try:
+        return data.decode('utf-8')
+    except UnicodeDecodeError as e:
+        raise DecodeError(f"Decoded data is not valid UTF-8: {e}")
+
+
+def encode_file(input_path: str, output_path: str, key: str = "AZR") -> None:
+    """Encode a file to AzrMoo format.
+
+    Reads the input file as binary, encodes it, and writes the
+    encoded string to the output path.
+
+    Args:
+        input_path: Path to the input file (any file type).
+        output_path: Path for the encoded output file.
+        key: The encoding key (default: "AZR").
+    """
+    with open(input_path, 'rb') as f:
+        data = f.read()
+    encoded = encode_bytes(data, key)
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(encoded)
+
+
+def decode_file(input_path: str, output_path: str, key: str = "AZR") -> None:
+    """Decode an AzrMoo-encoded file back to its original format.
+
+    Reads the encoded file, decodes it, and writes the original bytes
+    to the output path.
+
+    Args:
+        input_path: Path to the AzrMoo-encoded file.
+        output_path: Path for the decoded output file.
+        key: The decoding key (default: "AZR").
+    """
+    with open(input_path, 'r', encoding='utf-8') as f:
+        encoded = f.read()
+    data = decode_bytes(encoded, key)
+    with open(output_path, 'wb') as f:
+        f.write(data)
+
+
+# ─── Self-Test ─────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import os
+    import sys
+    import tempfile
+    import random as _random
+
+    _random.seed(42)
+
+    class _T:
+        def __init__(self):
+            self.passed = 0
+            self.failed = 0
+
+        def check(self, name: str, condition: bool) -> None:
+            if condition:
+                self.passed += 1
+                print(f"  \u2713 {name}")
+            else:
+                self.failed += 1
+                print(f"  \u2717 {name}")
+
+    tt = _T()
+
+    print("AzrMoo Enc v1 Self-Test")
+    print("=" * 40)
+
+    # 1: Basic string roundtrip
+    original = "Hello, AzrMoo!"
+    encoded = encode(original)
+    decoded = decode(encoded)
+    tt.check("Basic string roundtrip", original == decoded)
+
+    # 2: Unicode (Arabic)
+    original = "\u0645\u0631\u062d\u0628\u0627 \u0628\u0627\u0644\u0639\u0627\u0644\u0645"
+    encoded = encode(original)
+    decoded = decode(encoded)
+    tt.check("Arabic text roundtrip", original == decoded)
+
+    # 3: Unicode (Emoji)
+    original = "\U0001f680\U00002728\U0001f31f\U0001f389"
+    encoded = encode(original)
+    decoded = decode(encoded)
+    tt.check("Emoji roundtrip", original == decoded)
+
+    # 4: English text with punctuation
+    original = "The quick brown fox jumps over the lazy dog. 1234567890!@#$%^&*()"
+    encoded = encode(original)
+    decoded = decode(encoded)
+    tt.check("English text roundtrip", original == decoded)
+
+    # 5: Empty string
+    original = ""
+    encoded = encode(original)
+    decoded = decode(encoded)
+    tt.check("Empty string roundtrip", original == decoded)
+
+    # 6: encode_bytes / decode_bytes with random bytes (various lengths)
+    test_bytes = _random.randbytes
+    for length in [0, 1, 10, 100, 1000]:
+        data = test_bytes(length)
+        encoded = encode_bytes(data)
+        decoded = decode_bytes(encoded)
+        tt.check(f"Random bytes roundtrip (len={length})", data == decoded)
+
+    # 7: Different keys produce different output
+    data = b"Hello World"
+    e1 = encode_bytes(data, "AZR")
+    e2 = encode_bytes(data, "KEY")
+    tt.check("Different keys produce different output", e1 != e2)
+
+    # 8: Same key produces same output
+    e3 = encode_bytes(data, "AZR")
+    tt.check("Same key produces same output", e1 == e3)
+
+    # 9: Checksum catches corruption
+    encoded = encode("Test data")
+    mid = len(encoded) // 2
+    corrupted = encoded[:mid] + "X" + encoded[mid + 1:]
+    try:
+        decode(corrupted)
+        tt.check("Checksum catches corruption", False)
+    except (InvalidChecksumError, InvalidTokenError, DecodeError):
+        tt.check("Checksum catches corruption", True)
+
+    # 10: Invalid header raises InvalidHeaderError
+    try:
+        decode_bytes("INVALIDHEADER:moo~oom")
+        tt.check("Invalid header raises InvalidHeaderError", False)
+    except InvalidHeaderError:
+        tt.check("Invalid header raises InvalidHeaderError", True)
+
+    # 11: File roundtrip (text)
+    with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
+        f.write("File encoding test content \U0001f4c4")
+        inpath_txt = f.name
+    outpath_txt = inpath_txt + ".azr"
+    decpath_txt = inpath_txt + ".dec"
+    try:
+        encode_file(inpath_txt, outpath_txt)
+        decode_file(outpath_txt, decpath_txt)
+        with open(inpath_txt, 'rb') as f:
+            orig_data = f.read()
+        with open(decpath_txt, 'rb') as f:
+            dec_data = f.read()
+        tt.check("File roundtrip (text)", orig_data == dec_data)
+    finally:
+        for p in [inpath_txt, outpath_txt, decpath_txt]:
+            if os.path.exists(p):
+                os.unlink(p)
+
+    # 12: File roundtrip (binary)
+    with tempfile.NamedTemporaryFile(delete=False) as f:
+        bin_data = test_bytes(500)
+        f.write(bin_data)
+        inpath_bin = f.name
+    outpath_bin = inpath_bin + ".azr"
+    decpath_bin = inpath_bin + ".dec"
+    try:
+        encode_file(inpath_bin, outpath_bin)
+        decode_file(outpath_bin, decpath_bin)
+        with open(decpath_bin, 'rb') as f:
+            result = f.read()
+        tt.check("File roundtrip (binary)", bin_data == result)
+    finally:
+        for p in [inpath_bin, outpath_bin, decpath_bin]:
+            if os.path.exists(p):
+                os.unlink(p)
+
+    # 13: version() returns non-empty string
+    v = version()
+    tt.check("version() returns non-empty string", isinstance(v, str) and len(v) > 0)
+
+    # 14: generate_table() produces valid tables
+    enc, dec = generate_table()
+    tt.check("encode table has 256 entries", len(enc) == 256)
+    tt.check("decode table has 256 entries", len(dec) == 256)
+    for i in range(256):
+        tt.check(f"generate_table roundtrip at {i}", dec[enc[i]] == i)
+
+    # 15: Different key generates different table
+    enc1, _ = generate_table("AZR")
+    enc2, _ = generate_table("DIFFERENT")
+    vals1 = list(enc1.values())
+    vals2 = list(enc2.values())
+    tt.check("Different keys produce different tables", vals1 != vals2)
+
+    # 16: Large data roundtrip
+    large_data = b"AzrMoo" * 10000
+    encoded = encode_bytes(large_data)
+    decoded = decode_bytes(encoded)
+    tt.check("Large data roundtrip (60KB)", large_data == decoded)
+
+    # 17: Key-dependent encoding (different key == different output for same text)
+    text = "Secret message"
+    enc_a = encode(text, "key1")
+    enc_b = encode(text, "key2")
+    tt.check("Key changes encoded output", enc_a != enc_b)
+
+    # 18: Decode with wrong key fails (checksum)
+    enc_c = encode(text, "correct-key")
+    try:
+        decode(enc_c, "wrong-key")
+        tt.check("Wrong key fails decoding", False)
+    except (InvalidChecksumError, DecodeError, InvalidTokenError):
+        tt.check("Wrong key fails decoding", True)
+
+    print(f"\n{'=' * 40}")
+    total = tt.passed + tt.failed
+    print(f"Results: {tt.passed} passed, {tt.failed} failed out of {total}")
+    if tt.failed:
+        print("SOME TESTS FAILED!")
+        sys.exit(1)
+    else:
+        print("All tests passed!")

azrmooenc-1.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "azrmooenc"
+version = "1.0.0"
+description = "A completely original reversible encoding library using Moo tokens"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [{name = "azr"}]
+keywords = ["encoding", "moo", "azrmoo", "reversible-encoding"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Utilities",
+]
+
+[tool.setuptools]
+py-modules = ["azrmooenc"]
+
+[project.urls]
+Homepage = "https://pypi.org/project/azrmooenc/"

azrmooenc-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+