pymastring 1.0.0__tar.gz

pymastring-1.0.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 ProgVM
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

pymastring-1.0.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: pymastring
+Version: 1.0.0
+Summary: A chaotic monkey-patch library that brings heavy math, matrix operations, and custom weight-based logic to native Python strings.
+Author-email: ProgVM <progvminc@gmail.com>
+Project-URL: Homepage, https://github.com/ProgVM/pymastring
+Project-URL: Bug-Tracker, https://github.com/ProgVM/pymastring/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: forbiddenfruit>=0.1.4
+Dynamic: license-file
+
+# pymastring
+
+`pymastring` is a highly unorthodox utility package that globally overrides the runtime behavior of Python's built-in primitive `str` class via deep C-level monkey-patching. It breaks standard structural limitations to allow direct mathematical calculations, matrix equations, bitwise interactions, and custom serialization paradigms natively on raw string literals.
+
+---
+
+## Technical Concept
+
+Python's built-in `str` instances are hardcoded at the C-API level to prevent arbitrary mutation. `pymastring` bypasses this defense mechanism by using `forbiddenfruit` to overwrite core slots within the `PyTypeObject` of the native string type.
+
+Every mathematical operation maps the characters of the string to their respective **Unicode Code Points** (via `ord()`), runs numerical adjustments, applies an auto-overflow modulo bounds-check (`% 1114112`), and returns the resulting value shifted back into strings (via `chr()`).
+
+---
+
+## Installation
+
+Install the package locally in editable development mode or via local source directory distribution:
+
+```bash
+pip install .
+```
+
+---
+
+## Core Features & Extended API Specification
+
+### 1. Advanced Arithmetic Operators (`**`, `/`, `-`, `%`)
+Standard string literals can be manipulated mathematically with integers and floating-point elements.
+* **Exponentiation (`**`):** Exponentiates the individual internal weight of every distinct character.
+* **Division (`/`):** Divides character codes uniformly.
+* **Subtraction (`-`):** Subtraction by an integer/float dynamically reduces unicode codes. Subtraction by another string removes all structural occurrences of those bytes.
+* **Modulo (`%`):** Determines remainder against character weights. Falls back to default string formatting if `%s`, `%d`, or `%f` structural placeholders are present.
+
+```python
+import pymastring
+
+print("abc" ** 2)      # Exponentiates character codes
+print("xyz" / 2)       # Uniform code points scaling
+print("python" - 5)    # Left-shifts unicode positions
+print("abcdef" - "bd") # Drops exact target slices -> Outputs: "acef"
+print("hello" % 3)     # Inline remainder extraction
+```
+
+### 2. Matrix Cross-Multiplication Vector Behavior (`@`)
+Using the `@` operator evaluates the structural linear algebra dot product between two string arrays. It multiplies the scalar weight vectors of matching index elements and accumulates the mathematical sum. Short strings automatically pad using standard null bytes (`\x00`).
+
+```python
+# Calculates: (ord('a') * ord('b')) -> 97 * 98
+result = "a" @ "b"
+print(result) # Outputs integer: 9506
+```
+
+### 3. Dynamic Structural Weight Evaluation (`len()`)
+The global `len()` invocation is intercepted. Instead of reporting the primitive flat character index array offset count, it computes and returns the complete integrated sum of all unicode sequence code weights.
+
+```python
+# Traditional len("abc") returns 3
+# Patched version evaluates: 97 + 98 + 99
+print(len("abc")) # Outputs integer: 294
+```
+
+### 4. Bitwise Vector Conversions (`<<`, `>>`, `&`, `|`, `^`)
+Direct byte-level array transformations across registers using standard binary operational parameters.
+
+```python
+print("abc" << 2)      # Left shift bit positions
+print("secret" ^ 42)   # XOR encryption mask mapping
+print("hello" & "world") # Matrix intersection overlay
+```
+
+### 5. Total-Weight Context Comparisons (`>`, `<`, `>=`, `<=`)
+Rich comparative sorting algorithms base logic on total calculated inner array vector weight sums, replacing default sequential alphabetic ASCII sorting structures.
+
+```python
+print("short" > "longer") # Strictly evaluates length/weight conditions
+```
+
+### 6. Typified Generator Array Extraction & Iteration
+Loops parsing raw string sequences yield special operational wrappers (`MathChar`) inheriting full operational capabilities rather than flat string parts.
+
+```python
+for char in "xyz":
+    # Loops pull fully functioning MathChar objects allowing immediate manipulation
+    print(char ** 1.5)
+```
+
+### 7. Custom JSON Serialization Engine (`MathJSONEncoder`)
+To prevent internal character objects from breaking standard data transfers, use our targeted serialization mapping profile.
+
+```python
+import json
+
+data = {"payload": "abc" ** 2}
+json_string = json.dumps(data, cls=pymastring.MathJSONEncoder)
+```
+

pymastring-1.0.0/README.md

@@ -0,0 +1,96 @@
+# pymastring
+
+`pymastring` is a highly unorthodox utility package that globally overrides the runtime behavior of Python's built-in primitive `str` class via deep C-level monkey-patching. It breaks standard structural limitations to allow direct mathematical calculations, matrix equations, bitwise interactions, and custom serialization paradigms natively on raw string literals.
+
+---
+
+## Technical Concept
+
+Python's built-in `str` instances are hardcoded at the C-API level to prevent arbitrary mutation. `pymastring` bypasses this defense mechanism by using `forbiddenfruit` to overwrite core slots within the `PyTypeObject` of the native string type.
+
+Every mathematical operation maps the characters of the string to their respective **Unicode Code Points** (via `ord()`), runs numerical adjustments, applies an auto-overflow modulo bounds-check (`% 1114112`), and returns the resulting value shifted back into strings (via `chr()`).
+
+---
+
+## Installation
+
+Install the package locally in editable development mode or via local source directory distribution:
+
+```bash
+pip install .
+```
+
+---
+
+## Core Features & Extended API Specification
+
+### 1. Advanced Arithmetic Operators (`**`, `/`, `-`, `%`)
+Standard string literals can be manipulated mathematically with integers and floating-point elements.
+* **Exponentiation (`**`):** Exponentiates the individual internal weight of every distinct character.
+* **Division (`/`):** Divides character codes uniformly.
+* **Subtraction (`-`):** Subtraction by an integer/float dynamically reduces unicode codes. Subtraction by another string removes all structural occurrences of those bytes.
+* **Modulo (`%`):** Determines remainder against character weights. Falls back to default string formatting if `%s`, `%d`, or `%f` structural placeholders are present.
+
+```python
+import pymastring
+
+print("abc" ** 2)      # Exponentiates character codes
+print("xyz" / 2)       # Uniform code points scaling
+print("python" - 5)    # Left-shifts unicode positions
+print("abcdef" - "bd") # Drops exact target slices -> Outputs: "acef"
+print("hello" % 3)     # Inline remainder extraction
+```
+
+### 2. Matrix Cross-Multiplication Vector Behavior (`@`)
+Using the `@` operator evaluates the structural linear algebra dot product between two string arrays. It multiplies the scalar weight vectors of matching index elements and accumulates the mathematical sum. Short strings automatically pad using standard null bytes (`\x00`).
+
+```python
+# Calculates: (ord('a') * ord('b')) -> 97 * 98
+result = "a" @ "b"
+print(result) # Outputs integer: 9506
+```
+
+### 3. Dynamic Structural Weight Evaluation (`len()`)
+The global `len()` invocation is intercepted. Instead of reporting the primitive flat character index array offset count, it computes and returns the complete integrated sum of all unicode sequence code weights.
+
+```python
+# Traditional len("abc") returns 3
+# Patched version evaluates: 97 + 98 + 99
+print(len("abc")) # Outputs integer: 294
+```
+
+### 4. Bitwise Vector Conversions (`<<`, `>>`, `&`, `|`, `^`)
+Direct byte-level array transformations across registers using standard binary operational parameters.
+
+```python
+print("abc" << 2)      # Left shift bit positions
+print("secret" ^ 42)   # XOR encryption mask mapping
+print("hello" & "world") # Matrix intersection overlay
+```
+
+### 5. Total-Weight Context Comparisons (`>`, `<`, `>=`, `<=`)
+Rich comparative sorting algorithms base logic on total calculated inner array vector weight sums, replacing default sequential alphabetic ASCII sorting structures.
+
+```python
+print("short" > "longer") # Strictly evaluates length/weight conditions
+```
+
+### 6. Typified Generator Array Extraction & Iteration
+Loops parsing raw string sequences yield special operational wrappers (`MathChar`) inheriting full operational capabilities rather than flat string parts.
+
+```python
+for char in "xyz":
+    # Loops pull fully functioning MathChar objects allowing immediate manipulation
+    print(char ** 1.5)
+```
+
+### 7. Custom JSON Serialization Engine (`MathJSONEncoder`)
+To prevent internal character objects from breaking standard data transfers, use our targeted serialization mapping profile.
+
+```python
+import json
+
+data = {"payload": "abc" ** 2}
+json_string = json.dumps(data, cls=pymastring.MathJSONEncoder)
+```
+

pymastring-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pymastring"
+version = "1.0.0"
+authors = [
+    { name = "ProgVM", email = "progvminc@gmail.com" }
+]
+description = "A chaotic monkey-patch library that brings heavy math, matrix operations, and custom weight-based logic to native Python strings."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+]
+dependencies = [
+    "forbiddenfruit>=0.1.4"
+]
+
+[project.urls]
+Homepage = "https://github.com/ProgVM/pymastring"
+Bug-Tracker = "https://github.com/ProgVM/pymastring/issues"
+

pymastring-1.0.0/setup.cfg

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

pymastring-1.0.0/src/pymastring/__init__.py

@@ -0,0 +1,8 @@
+# Standard internal python structure for package initialization
+from .core import patch_strings, MathJSONEncoder, MathChar
+
+# Automatically apply forbiddenfruit patches on package import
+patch_strings()
+
+__all__ = ["MathJSONEncoder", "MathChar"]
+

pymastring-1.0.0/src/pymastring/core.py

@@ -0,0 +1,261 @@
+import json
+from forbiddenfruit import curse
+
+# --- Custom String Elements for Advanced Iteration ---
+
+class MathChar(str):
+    """
+    A single-character string wrapper that retains all custom mathematical properties 
+    when extracting or iterating over string elements.
+    """
+    pass
+
+class StringMathIterator:
+    """
+    Custom iterator to yield MathChar instances instead of standard primitive strings.
+    """
+    def __init__(self, text):
+        # Store as standard primitive to avoid recursion during internal processing
+        self.text = str(text)
+        self.index = 0
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.index < len(self.text):
+            char = self.text[self.index]
+            self.index += 1
+            return MathChar(char)
+        raise StopIteration
+
+
+# --- Custom JSON Serialization Support ---
+
+class MathJSONEncoder(json.JSONEncoder):
+    """
+    Custom JSON Encoder to ensure MathChar objects and heavily mutated strings 
+    serialize safely into standard JSON representations without metadata corruption.
+    """
+    def default(self, obj):
+        if isinstance(obj, MathChar):
+            return str(obj)
+        return super().default(obj)
+
+
+# --- Core Mathematical Operators ---
+
+def string_pow(self, power):
+    """ Hook function to replace the standard behavior of str.__pow__ (**). """
+    if not isinstance(power, (int, float)):
+        class_name = self.__class__.__name__
+        power_name = type(power).__name__
+        raise TypeError(f"unsupported operand type(s) for ** or pow(): '{class_name}' and '{power_name}'")
+    
+    result_chars = []
+    for char in self:
+        char_code = ord(char)
+        powered_code = char_code ** power
+        final_code = int(powered_code) % 1114112
+        result_chars.append(chr(final_code))
+    return "".join(result_chars)
+
+def string_truediv(self, divisor):
+    """ Hook function to replace the standard behavior of str.__truediv__ (/). """
+    if not isinstance(divisor, (int, float)):
+        class_name = self.__class__.__name__
+        divisor_name = type(divisor).__name__
+        raise TypeError(f"unsupported operand type(s) for /: '{class_name}' and '{divisor_name}'")
+    
+    if divisor == 0:
+        raise ZeroDivisionError("string division by zero")
+        
+    result_chars = []
+    for char in self:
+        char_code = ord(char)
+        divided_code = int(char_code / divisor) % 1114112
+        result_chars.append(chr(divided_code))
+    return "".join(result_chars)
+
+def string_sub(self, other):
+    """ Hook function to replace the standard behavior of str.__sub__ (-). """
+    if isinstance(other, str):
+        result = self
+        for char in other:
+            result = result.replace(char, "")
+        return result
+    elif isinstance(other, (int, float)):
+        result_chars = []
+        for char in self:
+            final_code = int(ord(char) - int(other)) % 1114112
+            result_chars.append(chr(final_code))
+        return "".join(result_chars)
+    else:
+        class_name = self.__class__.__name__
+        other_name = type(other).__name__
+        raise TypeError(f"unsupported operand type(s) for -: '{class_name}' and '{other_name}'")
+
+def string_mod(self, other):
+    """ Hook function to patch str.__mod__ (%). """
+    if "%s" in self or "%d" in self or "%f" in self:
+        # Fallback to standard C-level string formatting if placeholders exist
+        return NotImplemented
+        
+    if not isinstance(other, (int, float)):
+        class_name = self.__class__.__name__
+        other_name = type(other).__name__
+        raise TypeError(f"unsupported operand type(s) for %: '{class_name}' and '{other_name}'")
+        
+    if other == 0:
+        raise ZeroDivisionError("string modulo by zero")
+        
+    result_chars = []
+    for char in self:
+        final_code = int(ord(char) % other) % 1114112
+        result_chars.append(chr(final_code))
+    return "".join(result_chars)
+
+
+# --- Matrix Multiplication (@) ---
+
+def string_matmul(self, other):
+    """ Hook function to patch str.__matmul__ (@). Calculates scalar dot product. """
+    if not isinstance(other, str):
+        class_name = self.__class__.__name__
+        other_name = type(other).__name__
+        raise TypeError(f"unsupported operand type(s) for @: '{class_name}' and '{other_name}'")
+        
+    max_len = max(len(self), len(other))
+    s1 = self.ljust(max_len, '\x00')
+    s2 = other.ljust(max_len, '\x00')
+    
+    # Secure raw length call bypassing our patched __len__ to prevent semantic mess here
+    dot_product = sum(ord(c1) * ord(c2) for c1, c2 in zip(s1, s2))
+    return dot_product
+
+
+# --- Custom Advanced Length Hook (len()) ---
+
+def string_len(self):
+    """
+    Hook function to dynamically modify the native behavior of len(str).
+    Calculates total Unicode weight instead of counting raw character positions.
+    Uses continuous native generation to strictly prevent deep recursion loops.
+    """
+    total_weight = 0
+    # Use standard C-level character iteration to bypass custom Python __iter__ hook
+    for i in range(super(str, self).__len__()):
+        total_weight += ord(self[i])
+    return total_weight
+
+
+# --- Bitwise Operators (<<, >>, &, |, ^) ---
+
+def string_lshift(self, shift):
+    """ Hook function to patch str.__lshift__ (<<). """
+    if not isinstance(shift, int):
+        class_name = self.__class__.__name__
+        shift_name = type(shift).__name__
+        raise TypeError(f"unsupported operand type(s) for <<: '{class_name}' and '{shift_name}'")
+    
+    result_chars = []
+    for char in self:
+        final_code = (ord(char) << shift) % 1114112
+        result_chars.append(chr(final_code))
+    return "".join(result_chars)
+
+def string_rshift(self, shift):
+    """ Hook function to patch str.__rshift__ (>>). """
+    if not isinstance(shift, int):
+        class_name = self.__class__.__name__
+        shift_name = type(shift).__name__
+        raise TypeError(f"unsupported operand type(s) for >>: '{class_name}' and '{shift_name}'")
+    
+    result_chars = []
+    for char in self:
+        final_code = (ord(char) >> shift) % 1114112
+        result_chars.append(chr(final_code))
+    return "".join(result_chars)
+
+def _bitwise_base(self, other, op_func, op_symbol):
+    if isinstance(other, int):
+        result_chars = []
+        for char in self:
+            final_code = op_func(ord(char), other) % 1114112
+            result_chars.append(chr(final_code))
+        return "".join(result_chars)
+    elif isinstance(other, str):
+        max_len = max(super(str, self).__len__(), super(str, other).__len__())
+        s1 = self.ljust(max_len, '\x00')
+        s2 = other.ljust(max_len, '\x00')
+        
+        result_chars = []
+        for c1, c2 in zip(s1, s2):
+            final_code = op_func(ord(c1), ord(c2)) % 1114112
+            result_chars.append(chr(final_code))
+        return "".join(result_chars)
+    else:
+        class_name = self.__class__.__name__
+        other_name = type(other).__name__
+        raise TypeError(f"unsupported operand type(s) for {op_symbol}: '{class_name}' and '{other_name}'")
+
+def string_and(self, other): return _bitwise_base(self, other, lambda x, y: x & y, '&')
+def string_or(self, other):  return _bitwise_base(self, other, lambda x, y: x | y, '|')
+def string_xor(self, other): return _bitwise_base(self, other, lambda x, y: x ^ y, '^')
+
+
+# --- Logical Comparison Operators ---
+
+def _compare_strings(self, other, op):
+    if not isinstance(other, str):
+        class_name = self.__class__.__name__
+        other_name = type(other).__name__
+        raise TypeError(f"not supported between instances of '{class_name}' and '{other_name}'")
+        
+    return op(string_len(self), string_len(other))
+
+def string_gt(self, other): return _compare_strings(self, other, lambda x, y: x > y)
+def string_lt(self, other): return _compare_strings(self, other, lambda x, y: x < y)
+def string_ge(self, other): return _compare_strings(self, other, lambda x, y: x >= y)
+def string_le(self, other): return _compare_strings(self, other, lambda x, y: x <= y)
+
+
+# --- Custom Iteration Hook ---
+
+def string_iter(self):
+    """ Hook function to replace standard str.__iter__. """
+    return StringMathIterator(self)
+
+
+# --- Global Monkey-Patch Executor ---
+
+def patch_strings():
+    """ Injects all mathematical, matrix, bitwise, logical, length and iteration hooks into native 'str'. """
+    # Math & Matrix
+    curse(str, "__pow__", string_pow)
+    curse(str, "__truediv__", string_truediv)
+    curse(str, "__sub__", string_sub)
+    curse(str, "__mod__", string_mod)
+    curse(str, "__matmul__", string_matmul)
+    # Custom Length
+    curse(str, "__len__", string_len)
+    # Bitwise
+    curse(str, "__lshift__", string_lshift)
+    curse(str, "__rshift__", string_rshift)
+    curse(str, "__and__", string_and)
+    curse(str, "__or__", string_or)
+    curse(str, "__xor__", string_xor)
+    # Logic
+    curse(str, "__gt__", string_gt)
+    curse(str, "__lt__", string_lt)
+    curse(str, "__ge__", string_ge)
+    curse(str, "__le__", string_le)
+    # Iteration
+    curse(str, "__iter__", string_iter)
+
+# Dynamically synchronize the custom MathChar fallback operations
+for method in ["__pow__", "__truediv__", "__sub__", "__mod__", "__matmul__", "__len__",
+               "__lshift__", "__rshift__", "__and__", "__or__", "__xor__",
+               "__gt__", "__lt__", "__ge__", "__le__", "__iter__"]:
+    setattr(MathChar, method, locals()[f"string_{method.strip('_')}"])
+

pymastring-1.0.0/src/pymastring.egg-info/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: pymastring
+Version: 1.0.0
+Summary: A chaotic monkey-patch library that brings heavy math, matrix operations, and custom weight-based logic to native Python strings.
+Author-email: ProgVM <progvminc@gmail.com>
+Project-URL: Homepage, https://github.com/ProgVM/pymastring
+Project-URL: Bug-Tracker, https://github.com/ProgVM/pymastring/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: forbiddenfruit>=0.1.4
+Dynamic: license-file
+
+# pymastring
+
+`pymastring` is a highly unorthodox utility package that globally overrides the runtime behavior of Python's built-in primitive `str` class via deep C-level monkey-patching. It breaks standard structural limitations to allow direct mathematical calculations, matrix equations, bitwise interactions, and custom serialization paradigms natively on raw string literals.
+
+---
+
+## Technical Concept
+
+Python's built-in `str` instances are hardcoded at the C-API level to prevent arbitrary mutation. `pymastring` bypasses this defense mechanism by using `forbiddenfruit` to overwrite core slots within the `PyTypeObject` of the native string type.
+
+Every mathematical operation maps the characters of the string to their respective **Unicode Code Points** (via `ord()`), runs numerical adjustments, applies an auto-overflow modulo bounds-check (`% 1114112`), and returns the resulting value shifted back into strings (via `chr()`).
+
+---
+
+## Installation
+
+Install the package locally in editable development mode or via local source directory distribution:
+
+```bash
+pip install .
+```
+
+---
+
+## Core Features & Extended API Specification
+
+### 1. Advanced Arithmetic Operators (`**`, `/`, `-`, `%`)
+Standard string literals can be manipulated mathematically with integers and floating-point elements.
+* **Exponentiation (`**`):** Exponentiates the individual internal weight of every distinct character.
+* **Division (`/`):** Divides character codes uniformly.
+* **Subtraction (`-`):** Subtraction by an integer/float dynamically reduces unicode codes. Subtraction by another string removes all structural occurrences of those bytes.
+* **Modulo (`%`):** Determines remainder against character weights. Falls back to default string formatting if `%s`, `%d`, or `%f` structural placeholders are present.
+
+```python
+import pymastring
+
+print("abc" ** 2)      # Exponentiates character codes
+print("xyz" / 2)       # Uniform code points scaling
+print("python" - 5)    # Left-shifts unicode positions
+print("abcdef" - "bd") # Drops exact target slices -> Outputs: "acef"
+print("hello" % 3)     # Inline remainder extraction
+```
+
+### 2. Matrix Cross-Multiplication Vector Behavior (`@`)
+Using the `@` operator evaluates the structural linear algebra dot product between two string arrays. It multiplies the scalar weight vectors of matching index elements and accumulates the mathematical sum. Short strings automatically pad using standard null bytes (`\x00`).
+
+```python
+# Calculates: (ord('a') * ord('b')) -> 97 * 98
+result = "a" @ "b"
+print(result) # Outputs integer: 9506
+```
+
+### 3. Dynamic Structural Weight Evaluation (`len()`)
+The global `len()` invocation is intercepted. Instead of reporting the primitive flat character index array offset count, it computes and returns the complete integrated sum of all unicode sequence code weights.
+
+```python
+# Traditional len("abc") returns 3
+# Patched version evaluates: 97 + 98 + 99
+print(len("abc")) # Outputs integer: 294
+```
+
+### 4. Bitwise Vector Conversions (`<<`, `>>`, `&`, `|`, `^`)
+Direct byte-level array transformations across registers using standard binary operational parameters.
+
+```python
+print("abc" << 2)      # Left shift bit positions
+print("secret" ^ 42)   # XOR encryption mask mapping
+print("hello" & "world") # Matrix intersection overlay
+```
+
+### 5. Total-Weight Context Comparisons (`>`, `<`, `>=`, `<=`)
+Rich comparative sorting algorithms base logic on total calculated inner array vector weight sums, replacing default sequential alphabetic ASCII sorting structures.
+
+```python
+print("short" > "longer") # Strictly evaluates length/weight conditions
+```
+
+### 6. Typified Generator Array Extraction & Iteration
+Loops parsing raw string sequences yield special operational wrappers (`MathChar`) inheriting full operational capabilities rather than flat string parts.
+
+```python
+for char in "xyz":
+    # Loops pull fully functioning MathChar objects allowing immediate manipulation
+    print(char ** 1.5)
+```
+
+### 7. Custom JSON Serialization Engine (`MathJSONEncoder`)
+To prevent internal character objects from breaking standard data transfers, use our targeted serialization mapping profile.
+
+```python
+import json
+
+data = {"payload": "abc" ** 2}
+json_string = json.dumps(data, cls=pymastring.MathJSONEncoder)
+```
+

pymastring-1.0.0/src/pymastring.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/pymastring/__init__.py
+src/pymastring/core.py
+src/pymastring.egg-info/PKG-INFO
+src/pymastring.egg-info/SOURCES.txt
+src/pymastring.egg-info/dependency_links.txt
+src/pymastring.egg-info/requires.txt
+src/pymastring.egg-info/top_level.txt

pymastring-1.0.0/src/pymastring.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pymastring-1.0.0/src/pymastring.egg-info/requires.txt

@@ -0,0 +1 @@
+forbiddenfruit>=0.1.4

pymastring-1.0.0/src/pymastring.egg-info/top_level.txt

@@ -0,0 +1 @@
+pymastring