zexus 1.6.2

package/src/zexus/stdlib/compression.py

@@ -0,0 +1,167 @@
+"""Compression module for Zexus standard library."""
+
+import zlib
+import gzip
+import bz2
+import lzma
+import base64
+from typing import Dict, Any
+
+
+class CompressionModule:
+    """Provides compression/decompression operations."""
+
+    # Zlib compression
+    @staticmethod
+    def zlib_compress(data: str, level: int = 6) -> str:
+        """Compress string using zlib (returns base64)."""
+        compressed = zlib.compress(data.encode(), level)
+        return base64.b64encode(compressed).decode('ascii')
+
+    @staticmethod
+    def zlib_decompress(data: str) -> str:
+        """Decompress zlib data (from base64)."""
+        compressed = base64.b64decode(data)
+        return zlib.decompress(compressed).decode('utf-8')
+
+    # Gzip compression
+    @staticmethod
+    def gzip_compress(data: str, level: int = 6) -> str:
+        """Compress string using gzip (returns base64)."""
+        compressed = gzip.compress(data.encode(), compresslevel=level)
+        return base64.b64encode(compressed).decode('ascii')
+
+    @staticmethod
+    def gzip_decompress(data: str) -> str:
+        """Decompress gzip data (from base64)."""
+        compressed = base64.b64decode(data)
+        return gzip.decompress(compressed).decode('utf-8')
+
+    # Bzip2 compression
+    @staticmethod
+    def bzip2_compress(data: str, level: int = 9) -> str:
+        """Compress string using bzip2 (returns base64)."""
+        compressed = bz2.compress(data.encode(), compresslevel=level)
+        return base64.b64encode(compressed).decode('ascii')
+
+    @staticmethod
+    def bzip2_decompress(data: str) -> str:
+        """Decompress bzip2 data (from base64)."""
+        compressed = base64.b64decode(data)
+        return bz2.decompress(compressed).decode('utf-8')
+
+    # LZMA compression
+    @staticmethod
+    def lzma_compress(data: str, preset: int = 6) -> str:
+        """Compress string using LZMA (returns base64)."""
+        compressed = lzma.compress(data.encode(), preset=preset)
+        return base64.b64encode(compressed).decode('ascii')
+
+    @staticmethod
+    def lzma_decompress(data: str) -> str:
+        """Decompress LZMA data (from base64)."""
+        compressed = base64.b64decode(data)
+        return lzma.decompress(compressed).decode('utf-8')
+
+    # File compression helpers
+    @staticmethod
+    def compress_file(input_path: str, output_path: str, method: str = 'gzip', level: int = 6) -> Dict[str, Any]:
+        """Compress file using specified method."""
+        try:
+            with open(input_path, 'rb') as f_in:
+                data = f_in.read()
+            
+            if method == 'gzip':
+                with gzip.open(output_path, 'wb', compresslevel=level) as f_out:
+                    f_out.write(data)
+            elif method == 'bzip2':
+                with bz2.open(output_path, 'wb', compresslevel=level) as f_out:
+                    f_out.write(data)
+            elif method == 'lzma':
+                with lzma.open(output_path, 'wb', preset=level) as f_out:
+                    f_out.write(data)
+            elif method == 'zlib':
+                compressed = zlib.compress(data, level)
+                with open(output_path, 'wb') as f_out:
+                    f_out.write(compressed)
+            else:
+                return {'success': False, 'error': f'Unknown compression method: {method}'}
+            
+            import os
+            original_size = os.path.getsize(input_path)
+            compressed_size = os.path.getsize(output_path)
+            ratio = (1 - compressed_size / original_size) * 100 if original_size > 0 else 0
+            
+            return {
+                'success': True,
+                'original_size': original_size,
+                'compressed_size': compressed_size,
+                'compression_ratio': round(ratio, 2)
+            }
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+
+    @staticmethod
+    def decompress_file(input_path: str, output_path: str, method: str = 'gzip') -> Dict[str, Any]:
+        """Decompress file using specified method."""
+        try:
+            if method == 'gzip':
+                with gzip.open(input_path, 'rb') as f_in:
+                    data = f_in.read()
+            elif method == 'bzip2':
+                with bz2.open(input_path, 'rb') as f_in:
+                    data = f_in.read()
+            elif method == 'lzma':
+                with lzma.open(input_path, 'rb') as f_in:
+                    data = f_in.read()
+            elif method == 'zlib':
+                with open(input_path, 'rb') as f_in:
+                    data = zlib.decompress(f_in.read())
+            else:
+                return {'success': False, 'error': f'Unknown decompression method: {method}'}
+            
+            with open(output_path, 'wb') as f_out:
+                f_out.write(data)
+            
+            import os
+            return {
+                'success': True,
+                'decompressed_size': os.path.getsize(output_path)
+            }
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+
+    # Compression ratio calculation
+    @staticmethod
+    def calculate_ratio(original: str, compressed: str) -> float:
+        """Calculate compression ratio percentage."""
+        if len(original) == 0:
+            return 0.0
+        return (1 - len(compressed) / len(original)) * 100
+
+    # CRC32 checksum for integrity
+    @staticmethod
+    def crc32(data: str) -> int:
+        """Calculate CRC32 checksum."""
+        return zlib.crc32(data.encode()) & 0xffffffff
+
+    @staticmethod
+    def adler32(data: str) -> int:
+        """Calculate Adler32 checksum."""
+        return zlib.adler32(data.encode()) & 0xffffffff
+
+
+# Export functions for easy access
+zlib_compress = CompressionModule.zlib_compress
+zlib_decompress = CompressionModule.zlib_decompress
+gzip_compress = CompressionModule.gzip_compress
+gzip_decompress = CompressionModule.gzip_decompress
+bzip2_compress = CompressionModule.bzip2_compress
+bzip2_decompress = CompressionModule.bzip2_decompress
+lzma_compress = CompressionModule.lzma_compress
+lzma_decompress = CompressionModule.lzma_decompress
+compress_file = CompressionModule.compress_file
+decompress_file = CompressionModule.decompress_file
+calculate_ratio = CompressionModule.calculate_ratio
+crc32 = CompressionModule.crc32
+adler32 = CompressionModule.adler32

package/src/zexus/stdlib/crypto.py

@@ -0,0 +1,124 @@
+"""Crypto module for Zexus standard library."""
+
+import hashlib
+import secrets
+import hmac
+
+
+class CryptoModule:
+    """Provides cryptographic operations."""
+
+    @staticmethod
+    def hash_sha256(data: str) -> str:
+        """Calculate SHA-256 hash."""
+        return hashlib.sha256(data.encode()).hexdigest()
+
+    @staticmethod
+    def hash_sha512(data: str) -> str:
+        """Calculate SHA-512 hash."""
+        return hashlib.sha512(data.encode()).hexdigest()
+
+    @staticmethod
+    def hash_md5(data: str) -> str:
+        """Calculate MD5 hash (not recommended for security)."""
+        return hashlib.md5(data.encode()).hexdigest()
+
+    @staticmethod
+    def hash_blake2b(data: str, digest_size: int = 32) -> str:
+        """Calculate BLAKE2b hash."""
+        return hashlib.blake2b(data.encode(), digest_size=digest_size).hexdigest()
+
+    @staticmethod
+    def hash_blake2s(data: str, digest_size: int = 32) -> str:
+        """Calculate BLAKE2s hash."""
+        return hashlib.blake2s(data.encode(), digest_size=digest_size).hexdigest()
+
+    @staticmethod
+    def hmac_sha256(data: str, key: str) -> str:
+        """Calculate HMAC-SHA256."""
+        return hmac.new(key.encode(), data.encode(), hashlib.sha256).hexdigest()
+
+    @staticmethod
+    def hmac_sha512(data: str, key: str) -> str:
+        """Calculate HMAC-SHA512."""
+        return hmac.new(key.encode(), data.encode(), hashlib.sha512).hexdigest()
+
+    @staticmethod
+    def random_bytes(size: int = 32) -> str:
+        """Generate random bytes (hex encoded)."""
+        return secrets.token_hex(size)
+
+    @staticmethod
+    def random_int(min_val: int = 0, max_val: int = 2**32) -> int:
+        """Generate random integer."""
+        return secrets.randbelow(max_val - min_val) + min_val
+
+    @staticmethod
+    def compare_digest(a: str, b: str) -> bool:
+        """Constant-time string comparison."""
+        return hmac.compare_digest(a, b)
+
+    @staticmethod
+    def keccak256(data: str) -> str:
+        """Calculate Keccak-256 hash (Ethereum-style)."""
+        try:
+            from Crypto.Hash import keccak
+            k = keccak.new(digest_bits=256)
+            k.update(data.encode())
+            return k.hexdigest()
+        except ImportError:
+            # Fallback to SHA3-256 if pycryptodome not available
+            return hashlib.sha3_256(data.encode()).hexdigest()
+
+    @staticmethod
+    def sha3_256(data: str) -> str:
+        """Calculate SHA3-256 hash."""
+        return hashlib.sha3_256(data.encode()).hexdigest()
+
+    @staticmethod
+    def sha3_512(data: str) -> str:
+        """Calculate SHA3-512 hash."""
+        return hashlib.sha3_512(data.encode()).hexdigest()
+
+    @staticmethod
+    def pbkdf2(password: str, salt: str, iterations: int = 100000, 
+               key_length: int = 32, algorithm: str = 'sha256') -> str:
+        """Derive key from password using PBKDF2."""
+        hash_name = algorithm.lower().replace('-', '')
+        derived_key = hashlib.pbkdf2_hmac(
+            hash_name,
+            password.encode(),
+            salt.encode(),
+            iterations,
+            dklen=key_length
+        )
+        return derived_key.hex()
+
+    @staticmethod
+    def generate_salt(size: int = 16) -> str:
+        """Generate random salt."""
+        return secrets.token_hex(size)
+
+    @staticmethod
+    def constant_time_compare(a: str, b: str) -> bool:
+        """Constant-time comparison (alias for compare_digest)."""
+        return hmac.compare_digest(a, b)
+
+
+# Export functions for easy access
+hash_sha256 = CryptoModule.hash_sha256
+hash_sha512 = CryptoModule.hash_sha512
+hash_md5 = CryptoModule.hash_md5
+hash_blake2b = CryptoModule.hash_blake2b
+hash_blake2s = CryptoModule.hash_blake2s
+hmac_sha256 = CryptoModule.hmac_sha256
+hmac_sha512 = CryptoModule.hmac_sha512
+random_bytes = CryptoModule.random_bytes
+random_int = CryptoModule.random_int
+compare_digest = CryptoModule.compare_digest
+keccak256 = CryptoModule.keccak256
+sha3_256 = CryptoModule.sha3_256
+sha3_512 = CryptoModule.sha3_512
+pbkdf2 = CryptoModule.pbkdf2
+generate_salt = CryptoModule.generate_salt
+constant_time_compare = CryptoModule.constant_time_compare

package/src/zexus/stdlib/datetime.py

@@ -0,0 +1,163 @@
+"""DateTime module for Zexus standard library."""
+
+from datetime import datetime, timedelta, timezone
+from typing import Dict, Any
+import time
+
+
+class DateTimeModule:
+    """Provides date and time operations."""
+
+    @staticmethod
+    def now() -> datetime:
+        """Get current datetime."""
+        return datetime.now()
+
+    @staticmethod
+    def utc_now() -> datetime:
+        """Get current UTC datetime."""
+        return datetime.now(timezone.utc)
+
+    @staticmethod
+    def timestamp() -> float:
+        """Get current Unix timestamp."""
+        return time.time()
+
+    @staticmethod
+    def from_timestamp(ts: float, utc: bool = False) -> datetime:
+        """Create datetime from Unix timestamp."""
+        if utc:
+            return datetime.fromtimestamp(ts, timezone.utc)
+        return datetime.fromtimestamp(ts)
+
+    @staticmethod
+    def parse(date_string: str, format: str = '%Y-%m-%d %H:%M:%S') -> datetime:
+        """Parse date string to datetime."""
+        return datetime.strptime(date_string, format)
+
+    @staticmethod
+    def format(dt: datetime, format: str = '%Y-%m-%d %H:%M:%S') -> str:
+        """Format datetime to string."""
+        return dt.strftime(format)
+
+    @staticmethod
+    def iso_format(dt: datetime) -> str:
+        """Format datetime to ISO 8601 string."""
+        return dt.isoformat()
+
+    @staticmethod
+    def to_dict(dt: datetime) -> Dict[str, Any]:
+        """Convert datetime to dictionary."""
+        return {
+            'year': dt.year,
+            'month': dt.month,
+            'day': dt.day,
+            'hour': dt.hour,
+            'minute': dt.minute,
+            'second': dt.second,
+            'microsecond': dt.microsecond,
+            'weekday': dt.weekday(),
+            'timestamp': dt.timestamp()
+        }
+
+    @staticmethod
+    def add_days(dt: datetime, days: int) -> datetime:
+        """Add days to datetime."""
+        return dt + timedelta(days=days)
+
+    @staticmethod
+    def add_hours(dt: datetime, hours: int) -> datetime:
+        """Add hours to datetime."""
+        return dt + timedelta(hours=hours)
+
+    @staticmethod
+    def add_minutes(dt: datetime, minutes: int) -> datetime:
+        """Add minutes to datetime."""
+        return dt + timedelta(minutes=minutes)
+
+    @staticmethod
+    def add_seconds(dt: datetime, seconds: int) -> datetime:
+        """Add seconds to datetime."""
+        return dt + timedelta(seconds=seconds)
+
+    @staticmethod
+    def diff_days(dt1: datetime, dt2: datetime) -> int:
+        """Get difference in days between two datetimes."""
+        return (dt2 - dt1).days
+
+    @staticmethod
+    def diff_seconds(dt1: datetime, dt2: datetime) -> float:
+        """Get difference in seconds between two datetimes."""
+        return (dt2 - dt1).total_seconds()
+
+    @staticmethod
+    def is_before(dt1: datetime, dt2: datetime) -> bool:
+        """Check if dt1 is before dt2."""
+        return dt1 < dt2
+
+    @staticmethod
+    def is_after(dt1: datetime, dt2: datetime) -> bool:
+        """Check if dt1 is after dt2."""
+        return dt1 > dt2
+
+    @staticmethod
+    def is_between(dt: datetime, start: datetime, end: datetime) -> bool:
+        """Check if datetime is between start and end."""
+        return start <= dt <= end
+
+    @staticmethod
+    def start_of_day(dt: datetime) -> datetime:
+        """Get start of day (00:00:00)."""
+        return dt.replace(hour=0, minute=0, second=0, microsecond=0)
+
+    @staticmethod
+    def end_of_day(dt: datetime) -> datetime:
+        """Get end of day (23:59:59)."""
+        return dt.replace(hour=23, minute=59, second=59, microsecond=999999)
+
+    @staticmethod
+    def start_of_month(dt: datetime) -> datetime:
+        """Get start of month."""
+        return dt.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+
+    @staticmethod
+    def sleep(seconds: float) -> None:
+        """Sleep for specified seconds."""
+        time.sleep(seconds)
+
+    @staticmethod
+    def weekday_name(dt: datetime) -> str:
+        """Get weekday name."""
+        days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
+        return days[dt.weekday()]
+
+    @staticmethod
+    def month_name(dt: datetime) -> str:
+        """Get month name."""
+        return dt.strftime('%B')
+
+
+# Export functions for easy access
+now = DateTimeModule.now
+utc_now = DateTimeModule.utc_now
+timestamp = DateTimeModule.timestamp
+from_timestamp = DateTimeModule.from_timestamp
+parse = DateTimeModule.parse
+format_dt = DateTimeModule.format
+iso_format = DateTimeModule.iso_format
+to_dict = DateTimeModule.to_dict
+add_days = DateTimeModule.add_days
+add_hours = DateTimeModule.add_hours
+add_minutes = DateTimeModule.add_minutes
+add_seconds = DateTimeModule.add_seconds
+diff_days = DateTimeModule.diff_days
+diff_seconds = DateTimeModule.diff_seconds
+is_before = DateTimeModule.is_before
+is_after = DateTimeModule.is_after
+is_between = DateTimeModule.is_between
+start_of_day = DateTimeModule.start_of_day
+end_of_day = DateTimeModule.end_of_day
+start_of_month = DateTimeModule.start_of_month
+sleep = DateTimeModule.sleep
+weekday_name = DateTimeModule.weekday_name
+month_name = DateTimeModule.month_name

package/src/zexus/stdlib/db_mongo.py

@@ -0,0 +1,199 @@
+"""MongoDB database driver for Zexus.
+Requires pymongo: pip install pymongo
+"""
+
+try:
+    from pymongo import MongoClient
+    from pymongo.errors import PyMongoError
+    from bson.objectid import ObjectId
+    MONGO_AVAILABLE = True
+except ImportError:
+    MONGO_AVAILABLE = False
+    print("Warning: pymongo not installed. MongoDB support unavailable.")
+    print("Install with: pip install pymongo")
+
+from typing import Any, List, Dict, Optional
+
+
+class MongoDBConnection:
+    """MongoDB database connection."""
+    
+    def __init__(self, host: str = 'localhost', port: int = 27017,
+                 database: str = 'test', username: Optional[str] = None,
+                 password: Optional[str] = None):
+        """Create MongoDB connection.
+        
+        Args:
+            host: Database host
+            port: Database port
+            database: Database name
+            username: Optional username
+            password: Optional password
+        """
+        self.host = host
+        self.port = port
+        self.database_name = database
+        self.username = username
+        self.password = password
+        self.client = None
+        self.db = None
+    
+    def connect(self) -> bool:
+        """Open connection to database."""
+        if not MONGO_AVAILABLE:
+            print("MongoDB driver not available (pymongo not installed)")
+            return False
+        
+        try:
+            if self.username and self.password:
+                uri = f"mongodb://{self.username}:{self.password}@{self.host}:{self.port}/{self.database_name}"
+            else:
+                uri = f"mongodb://{self.host}:{self.port}/"
+            
+            self.client = MongoClient(uri, serverSelectionTimeoutMS=5000)
+            # Test connection
+            self.client.server_info()
+            self.db = self.client[self.database_name]
+            return True
+        except Exception as e:
+            print(f"MongoDB connect error: {e}")
+            return False
+    
+    def collection(self, name: str):
+        """Get a collection."""
+        if self.db is None:
+            print("MongoDB error: Not connected to database")
+            return None
+        return self.db[name]
+    
+    def insert_one(self, collection: str, document: Dict[str, Any]) -> Optional[str]:
+        """Insert a single document."""
+        try:
+            coll = self.collection(collection)
+            if coll is None:
+                return None
+            result = coll.insert_one(document)
+            return str(result.inserted_id)
+        except PyMongoError as e:
+            print(f"MongoDB insert_one error: {e}")
+            return None
+    
+    def insert_many(self, collection: str, documents: List[Dict[str, Any]]) -> Optional[List[str]]:
+        """Insert multiple documents."""
+        try:
+            coll = self.collection(collection)
+            if coll is None:
+                return None
+            result = coll.insert_many(documents)
+            return [str(id) for id in result.inserted_ids]
+        except PyMongoError as e:
+            print(f"MongoDB insert_many error: {e}")
+            return None
+    
+    def find(self, collection: str, query: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+        """Find documents matching query."""
+        try:
+            coll = self.collection(collection)
+            if coll is None:
+                return []
+            
+            query = query or {}
+            results = list(coll.find(query))
+            
+            # Convert ObjectId to string for Zexus
+            for doc in results:
+                if '_id' in doc and isinstance(doc['_id'], ObjectId):
+                    doc['_id'] = str(doc['_id'])
+            
+            return results
+        except PyMongoError as e:
+            print(f"MongoDB find error: {e}")
+            return []
+    
+    def find_one(self, collection: str, query: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
+        """Find a single document matching query."""
+        try:
+            coll = self.collection(collection)
+            if coll is None:
+                return None
+            
+            query = query or {}
+            doc = coll.find_one(query)
+            
+            if doc and '_id' in doc and isinstance(doc['_id'], ObjectId):
+                doc['_id'] = str(doc['_id'])
+            
+            return doc
+        except PyMongoError as e:
+            print(f"MongoDB find_one error: {e}")
+            return None
+    
+    def update_one(self, collection: str, query: Dict[str, Any], update: Dict[str, Any]) -> int:
+        """Update a single document."""
+        try:
+            coll = self.collection(collection)
+            if coll is None:
+                return 0
+            result = coll.update_one(query, update)
+            return result.modified_count
+        except PyMongoError as e:
+            print(f"MongoDB update_one error: {e}")
+            return 0
+    
+    def update_many(self, collection: str, query: Dict[str, Any], update: Dict[str, Any]) -> int:
+        """Update multiple documents."""
+        try:
+            coll = self.collection(collection)
+            if coll is None:
+                return 0
+            result = coll.update_many(query, update)
+            return result.modified_count
+        except PyMongoError as e:
+            print(f"MongoDB update_many error: {e}")
+            return 0
+    
+    def delete_one(self, collection: str, query: Dict[str, Any]) -> int:
+        """Delete a single document."""
+        try:
+            coll = self.collection(collection)
+            if coll is None:
+                return 0
+            result = coll.delete_one(query)
+            return result.deleted_count
+        except PyMongoError as e:
+            print(f"MongoDB delete_one error: {e}")
+            return 0
+    
+    def delete_many(self, collection: str, query: Dict[str, Any]) -> int:
+        """Delete multiple documents."""
+        try:
+            coll = self.collection(collection)
+            if coll is None:
+                return 0
+            result = coll.delete_many(query)
+            return result.deleted_count
+        except PyMongoError as e:
+            print(f"MongoDB delete_many error: {e}")
+            return 0
+    
+    def count(self, collection: str, query: Optional[Dict[str, Any]] = None) -> int:
+        """Count documents matching query."""
+        try:
+            coll = self.collection(collection)
+            if coll is None:
+                return 0
+            query = query or {}
+            return coll.count_documents(query)
+        except PyMongoError as e:
+            print(f"MongoDB count error: {e}")
+            return 0
+    
+    def close(self) -> bool:
+        """Close database connection."""
+        try:
+            if self.client:
+                self.client.close()
+            return True
+        except Exception as e:
+            print(f"MongoDB close error: {e}")
+            return False