zexus 1.6.2

package/src/zexus/stack_trace.py

@@ -0,0 +1,233 @@
+"""
+Zexus Stack Trace Formatter
+
+Provides beautiful, informative stack traces for runtime errors.
+"""
+
+from typing import List, Optional, Dict, Any
+
+
+class StackFrame:
+    """Represents a single frame in the call stack"""
+    
+    def __init__(
+        self,
+        function_name: str,
+        filename: Optional[str] = None,
+        line: Optional[int] = None,
+        column: Optional[int] = None,
+        source_line: Optional[str] = None,
+        node_type: Optional[str] = None
+    ):
+        self.function_name = function_name
+        self.filename = filename or "<unknown>"
+        self.line = line
+        self.column = column
+        self.source_line = source_line
+        self.node_type = node_type
+    
+    def __str__(self):
+        location = f"{self.filename}"
+        if self.line:
+            location += f":{self.line}"
+            if self.column:
+                location += f":{self.column}"
+        
+        result = f"  at {self.function_name} ({location})"
+        
+        if self.source_line and self.line:
+            # Show source context
+            result += f"\n    {self.line} | {self.source_line.strip()}"
+            if self.column:
+                # Add pointer
+                padding = len(str(self.line)) + 3 + self.column
+                result += f"\n    {' ' * padding}^"
+        
+        return result
+
+
+class StackTraceFormatter:
+    """Formats stack traces for display"""
+    
+    def __init__(self):
+        self.max_frames = 10  # Maximum frames to display
+        self.context_lines = 1  # Lines of context around error
+    
+    def format_stack_trace(
+        self,
+        frames: List[StackFrame],
+        error_message: str,
+        show_full: bool = False
+    ) -> str:
+        """
+        Format a complete stack trace.
+        
+        Args:
+            frames: List of stack frames
+            error_message: The error message
+            show_full: Show all frames or truncate
+        
+        Returns:
+            Formatted stack trace string
+        """
+        if not frames:
+            return error_message
+        
+        parts = []
+        parts.append(f"Traceback (most recent call last):")
+        
+        # Limit frames if not showing full
+        display_frames = frames
+        if not show_full and len(frames) > self.max_frames:
+            # Show first few and last few
+            first_half = self.max_frames // 2
+            second_half = self.max_frames - first_half
+            display_frames = (
+                frames[:first_half] +
+                [None] +  # Marker for truncation
+                frames[-second_half:]
+            )
+        
+        for i, frame in enumerate(display_frames):
+            if frame is None:
+                parts.append(f"  ... {len(frames) - self.max_frames} frames omitted ...")
+            else:
+                parts.append(str(frame))
+        
+        parts.append(f"\n{error_message}")
+        
+        return "\n".join(parts)
+    
+    def format_simple_trace(self, frames: List[StackFrame], limit: int = 3) -> str:
+        """
+        Format a simple stack trace (just function names and locations).
+        
+        Args:
+            frames: List of stack frames
+            limit: Maximum frames to show
+        
+        Returns:
+            Formatted trace string
+        """
+        if not frames:
+            return ""
+        
+        display_frames = frames[-limit:] if len(frames) > limit else frames
+        
+        parts = ["Call stack:"]
+        for frame in display_frames:
+            location = f"{frame.filename}"
+            if frame.line:
+                location += f":{frame.line}"
+            parts.append(f"  {frame.function_name} at {location}")
+        
+        return "\n".join(parts)
+    
+    def create_frame_from_node(
+        self,
+        node,
+        function_name: str,
+        error_reporter=None
+    ) -> StackFrame:
+        """
+        Create a stack frame from an AST node.
+        
+        Args:
+            node: AST node
+            function_name: Name of the function/context
+            error_reporter: Error reporter for source lookup
+        
+        Returns:
+            StackFrame instance
+        """
+        filename = None
+        line = None
+        column = None
+        source_line = None
+        node_type = type(node).__name__ if node else None
+        
+        # Extract location info from node
+        if hasattr(node, 'token') and node.token:
+            token = node.token
+            line = getattr(token, 'line', None)
+            column = getattr(token, 'column', None)
+        
+        # Try to get source line if error reporter available
+        if error_reporter and line:
+            source_line = error_reporter.get_source_line(filename, line)
+        
+        return StackFrame(
+            function_name=function_name,
+            filename=filename,
+            line=line,
+            column=column,
+            source_line=source_line,
+            node_type=node_type
+        )
+
+
+# Global formatter instance
+_stack_trace_formatter = StackTraceFormatter()
+
+
+def get_stack_trace_formatter() -> StackTraceFormatter:
+    """Get the global stack trace formatter"""
+    return _stack_trace_formatter
+
+
+def format_call_stack(frames: List[str], limit: int = 5) -> str:
+    """
+    Format a simple call stack from string frames.
+    
+    Args:
+        frames: List of frame strings
+        limit: Maximum frames to display
+    
+    Returns:
+        Formatted stack string
+    """
+    if not frames:
+        return ""
+    
+    display_frames = frames[-limit:] if len(frames) > limit else frames
+    
+    parts = ["Call stack:"]
+    for frame in display_frames:
+        parts.append(f"  {frame}")
+    
+    if len(frames) > limit:
+        parts.insert(1, f"  ... {len(frames) - limit} frames omitted ...")
+    
+    return "\n".join(parts)
+
+
+def create_frame_info(
+    function_name: str,
+    filename: str = "<unknown>",
+    line: Optional[int] = None,
+    node_type: Optional[str] = None
+) -> str:
+    """
+    Create a simple frame info string.
+    
+    Args:
+        function_name: Name of function
+        filename: Source filename
+        line: Line number
+        node_type: Type of AST node
+    
+    Returns:
+        Frame info string
+    """
+    parts = [function_name]
+    
+    if filename != "<unknown>" or line:
+        location = filename
+        if line:
+            location += f":{line}"
+        parts.append(f"({location})")
+    
+    if node_type:
+        parts.append(f"[{node_type}]")
+    
+    return " ".join(parts)

package/src/zexus/stdlib/__init__.py

@@ -0,0 +1,27 @@
+"""Zexus Standard Library."""
+
+from .fs import FileSystemModule
+from .http import HttpModule
+from .json_module import JsonModule
+from .datetime import DateTimeModule
+from .crypto import CryptoModule
+from .blockchain import BlockchainModule
+from .os_module import OSModule
+from .regex import RegexModule
+from .math import MathModule
+from .encoding import EncodingModule
+from .compression import CompressionModule
+
+__all__ = [
+    'FileSystemModule', 
+    'HttpModule', 
+    'JsonModule', 
+    'DateTimeModule',
+    'CryptoModule',
+    'BlockchainModule',
+    'OSModule',
+    'RegexModule',
+    'MathModule',
+    'EncodingModule',
+    'CompressionModule'
+]

package/src/zexus/stdlib/blockchain.py

@@ -0,0 +1,341 @@
+"""Blockchain utilities module for Zexus standard library."""
+
+from typing import Any, Dict, List, Optional
+import hashlib
+import time
+
+
+# Proof of work maximum iterations constant
+MAX_POW_ITERATIONS = 10_000_000
+
+
+class BlockchainModule:
+    """Provides blockchain utility functions."""
+
+    @staticmethod
+    def quantum_resistant_hash(data: str, algorithm: str = 'shake256', output_length: int = 64) -> str:
+        """Calculate quantum-resistant hash using SHAKE256 or SHA3.
+        
+        Args:
+            data: Data to hash
+            algorithm: 'shake256', 'shake128', 'sha3_512', 'sha3_384', 'sha3_256'
+            output_length: Output length in bytes for SHAKE (default: 64)
+        
+        Returns:
+            Hexadecimal hash string
+        
+        Note: SHAKE256 and SHA3 are quantum-resistant hash functions from the SHA-3 family.
+        """
+        if algorithm == 'shake256':
+            return hashlib.shake_256(data.encode()).hexdigest(output_length)
+        elif algorithm == 'shake128':
+            return hashlib.shake_128(data.encode()).hexdigest(output_length)
+        elif algorithm == 'sha3_512':
+            return hashlib.sha3_512(data.encode()).hexdigest()
+        elif algorithm == 'sha3_384':
+            return hashlib.sha3_384(data.encode()).hexdigest()
+        elif algorithm == 'sha3_256':
+            return hashlib.sha3_256(data.encode()).hexdigest()
+        elif algorithm == 'sha3_224':
+            return hashlib.sha3_224(data.encode()).hexdigest()
+        else:
+            raise ValueError(f"Unknown algorithm: {algorithm}")
+
+    @staticmethod
+    def quantum_safe_address(public_key: str, prefix: str = "0x") -> str:
+        """Create quantum-safe address from public key using SHAKE256.
+        
+        Uses SHAKE256 (SHA-3 family) which is quantum-resistant.
+        """
+        # Use SHAKE256 for quantum resistance
+        shake_hash = hashlib.shake_256(public_key.encode()).hexdigest(20)  # 20 bytes = 40 hex chars
+        return f"{prefix}{shake_hash}"
+
+    @staticmethod
+    def create_quantum_block(index: int, timestamp: float, data: Any, 
+                            previous_hash: str, nonce: int = 0) -> Dict[str, Any]:
+        """Create a quantum-resistant blockchain block using SHA3-256."""
+        block = {
+            'index': index,
+            'timestamp': timestamp,
+            'data': data,
+            'previous_hash': previous_hash,
+            'nonce': nonce
+        }
+        
+        # Calculate block hash using SHA3-256 (quantum-resistant)
+        block_string = str(block['index']) + str(block['timestamp']) + \
+                      str(block['data']) + block['previous_hash'] + str(block['nonce'])
+        block['hash'] = hashlib.sha3_256(block_string.encode()).hexdigest()
+        
+        return block
+
+    @staticmethod
+    def quantum_proof_of_work(block_data: str, difficulty: int = 4, 
+                             max_iterations: int = MAX_POW_ITERATIONS) -> tuple:
+        """Quantum-resistant proof-of-work using SHA3-256.
+        
+        Args:
+            block_data: Data to hash
+            difficulty: Number of leading zeros required
+            max_iterations: Maximum iterations before giving up
+        
+        Returns:
+            Tuple of (nonce, hash) or (nonce, "") if max iterations reached
+        """
+        nonce = 0
+        prefix = '0' * difficulty
+        
+        while nonce < max_iterations:
+            hash_attempt = hashlib.sha3_256(f"{block_data}{nonce}".encode()).hexdigest()
+            
+            if hash_attempt.startswith(prefix):
+                return nonce, hash_attempt
+            
+            nonce += 1
+        
+        return nonce, ""
+
+    @staticmethod
+    def validate_quantum_proof_of_work(block_data: str, nonce: int, hash_value: str, 
+                                      difficulty: int = 4) -> bool:
+        """Validate quantum-resistant proof-of-work."""
+        prefix = '0' * difficulty
+        calculated_hash = hashlib.sha3_256(f"{block_data}{nonce}".encode()).hexdigest()
+        return calculated_hash == hash_value and hash_value.startswith(prefix)
+
+    @staticmethod
+    def create_address(public_key: str, prefix: str = "0x") -> str:
+        """Create address from public key (Ethereum-style).
+        
+        Note: Requires pycryptodome for true Keccak-256 hashing.
+        Raises RuntimeError if pycryptodome is not available.
+        """
+        try:
+            # Try to use Keccak-256 (Ethereum standard)
+            from Crypto.Hash import keccak
+            k = keccak.new(digest_bits=256)
+            k.update(public_key.encode())
+            hash_hex = k.hexdigest()
+        except ImportError as exc:
+            # Keccak-256 implementation not available; cannot create
+            # Ethereum-compatible address without pycryptodome.
+            raise RuntimeError(
+                "Ethereum-compatible address generation requires the "
+                "'pycryptodome' package providing Crypto.Hash.keccak. "
+                "Install with: pip install pycryptodome"
+            ) from exc
+        
+        address = hash_hex[-40:]  # Last 20 bytes (40 hex chars)
+        return f"{prefix}{address}"
+
+    @staticmethod
+    def validate_address(address: str, prefix: str = "0x") -> bool:
+        """Validate blockchain address format."""
+        if not address.startswith(prefix):
+            return False
+        
+        hex_part = address[len(prefix):]
+        
+        # Check if it's valid hex
+        try:
+            int(hex_part, 16)
+        except ValueError:
+            return False
+        
+        # Check length (40 hex chars for Ethereum-style)
+        return len(hex_part) == 40
+
+    @staticmethod
+    def calculate_merkle_root(hashes: List[str]) -> str:
+        """Calculate Merkle root from list of hashes."""
+        if not hashes:
+            return hashlib.sha256(b'').hexdigest()
+        
+        if len(hashes) == 1:
+            return hashes[0]
+        
+        # Build merkle tree
+        current_level = hashes[:]
+        
+        while len(current_level) > 1:
+            next_level = []
+            
+            for i in range(0, len(current_level), 2):
+                if i + 1 < len(current_level):
+                    # Combine two hashes
+                    combined = current_level[i] + current_level[i + 1]
+                    parent_hash = hashlib.sha256(combined.encode()).hexdigest()
+                else:
+                    # Odd number, duplicate last hash
+                    combined = current_level[i] + current_level[i]
+                    parent_hash = hashlib.sha256(combined.encode()).hexdigest()
+                
+                next_level.append(parent_hash)
+            
+            current_level = next_level
+        
+        return current_level[0]
+
+    @staticmethod
+    def create_block(index: int, timestamp: float, data: Any, 
+                     previous_hash: str, nonce: int = 0) -> Dict[str, Any]:
+        """Create a blockchain block."""
+        block = {
+            'index': index,
+            'timestamp': timestamp,
+            'data': data,
+            'previous_hash': previous_hash,
+            'nonce': nonce
+        }
+        
+        # Calculate block hash
+        block_string = str(block['index']) + str(block['timestamp']) + \
+                      str(block['data']) + block['previous_hash'] + str(block['nonce'])
+        block['hash'] = hashlib.sha256(block_string.encode()).hexdigest()
+        
+        return block
+
+    @staticmethod
+    def hash_block(block: Dict[str, Any]) -> str:
+        """Calculate hash of a block."""
+        block_string = str(block.get('index', 0)) + \
+                      str(block.get('timestamp', 0)) + \
+                      str(block.get('data', '')) + \
+                      str(block.get('previous_hash', '')) + \
+                      str(block.get('nonce', 0))
+        return hashlib.sha256(block_string.encode()).hexdigest()
+
+    @staticmethod
+    def validate_block(block: Dict[str, Any], previous_block: Optional[Dict[str, Any]] = None) -> bool:
+        """Validate a blockchain block."""
+        # Check if block has required fields
+        required_fields = ['index', 'timestamp', 'data', 'previous_hash', 'hash']
+        if not all(field in block for field in required_fields):
+            return False
+        
+        # Verify hash is correct
+        calculated_hash = BlockchainModule.hash_block(block)
+        if calculated_hash != block['hash']:
+            return False
+        
+        # If previous block provided, check linkage
+        if previous_block:
+            if block['previous_hash'] != previous_block['hash']:
+                return False
+            if block['index'] != previous_block['index'] + 1:
+                return False
+        
+        return True
+
+    @staticmethod
+    def proof_of_work(block_data: str, difficulty: int = 4, max_iterations: int = MAX_POW_ITERATIONS) -> tuple:
+        """Simple proof-of-work mining (find nonce).
+        
+        Args:
+            block_data: Data to hash
+            difficulty: Number of leading zeros required
+            max_iterations: Maximum iterations before giving up (default: 10,000,000)
+        
+        Returns:
+            Tuple of (nonce, hash) or (nonce, "") if max iterations reached
+        """
+        nonce = 0
+        prefix = '0' * difficulty
+        
+        while nonce < max_iterations:
+            hash_attempt = hashlib.sha256(f"{block_data}{nonce}".encode()).hexdigest()
+            
+            if hash_attempt.startswith(prefix):
+                return nonce, hash_attempt
+            
+            nonce += 1
+        
+        return nonce, ""
+
+    @staticmethod
+    def validate_proof_of_work(block_data: str, nonce: int, hash_value: str, difficulty: int = 4) -> bool:
+        """Validate proof-of-work."""
+        prefix = '0' * difficulty
+        calculated_hash = hashlib.sha256(f"{block_data}{nonce}".encode()).hexdigest()
+        return calculated_hash == hash_value and hash_value.startswith(prefix)
+
+    @staticmethod
+    def create_transaction(sender: str, recipient: str, amount: float, 
+                          timestamp: Optional[float] = None) -> Dict[str, Any]:
+        """Create a transaction."""
+        if timestamp is None:
+            timestamp = time.time()
+        
+        tx = {
+            'sender': sender,
+            'recipient': recipient,
+            'amount': amount,
+            'timestamp': timestamp
+        }
+        
+        # Calculate transaction hash
+        tx_string = f"{tx['sender']}{tx['recipient']}{tx['amount']}{tx['timestamp']}"
+        tx['hash'] = hashlib.sha256(tx_string.encode()).hexdigest()
+        
+        return tx
+
+    @staticmethod
+    def hash_transaction(tx: Dict[str, Any]) -> str:
+        """Calculate hash of a transaction."""
+        tx_string = f"{tx.get('sender', '')}{tx.get('recipient', '')}" \
+                   f"{tx.get('amount', 0)}{tx.get('timestamp', 0)}"
+        return hashlib.sha256(tx_string.encode()).hexdigest()
+
+    @staticmethod
+    def create_genesis_block() -> Dict[str, Any]:
+        """Create the genesis block (first block in chain)."""
+        return BlockchainModule.create_block(
+            index=0,
+            timestamp=time.time(),
+            data="Genesis Block",
+            previous_hash="0" * 64,
+            nonce=0
+        )
+
+    @staticmethod
+    def validate_chain(chain: List[Dict[str, Any]]) -> bool:
+        """Validate entire blockchain."""
+        if not chain:
+            return False
+        
+        # Validate genesis block
+        if chain[0]['previous_hash'] != "0" * 64:
+            return False
+        
+        # Validate each block
+        for i in range(len(chain)):
+            if i == 0:
+                if not BlockchainModule.validate_block(chain[i]):
+                    return False
+            else:
+                if not BlockchainModule.validate_block(chain[i], chain[i-1]):
+                    return False
+        
+        return True
+
+
+# Export functions for easy access
+create_address = BlockchainModule.create_address
+validate_address = BlockchainModule.validate_address
+calculate_merkle_root = BlockchainModule.calculate_merkle_root
+create_block = BlockchainModule.create_block
+hash_block = BlockchainModule.hash_block
+validate_block = BlockchainModule.validate_block
+proof_of_work = BlockchainModule.proof_of_work
+validate_proof_of_work = BlockchainModule.validate_proof_of_work
+create_transaction = BlockchainModule.create_transaction
+hash_transaction = BlockchainModule.hash_transaction
+create_genesis_block = BlockchainModule.create_genesis_block
+validate_chain = BlockchainModule.validate_chain
+# Quantum-resistant functions
+quantum_resistant_hash = BlockchainModule.quantum_resistant_hash
+quantum_safe_address = BlockchainModule.quantum_safe_address
+create_quantum_block = BlockchainModule.create_quantum_block
+quantum_proof_of_work = BlockchainModule.quantum_proof_of_work
+validate_quantum_proof_of_work = BlockchainModule.validate_quantum_proof_of_work