zexus 1.6.2

package/src/zexus/stdlib/db_mysql.py

@@ -0,0 +1,162 @@
+"""MySQL database driver for Zexus.
+Requires mysql-connector-python: pip install mysql-connector-python
+"""
+
+try:
+    import mysql.connector
+    from mysql.connector import Error
+    MYSQL_AVAILABLE = True
+except ImportError:
+    MYSQL_AVAILABLE = False
+    print("Warning: mysql-connector-python not installed. MySQL support unavailable.")
+    print("Install with: pip install mysql-connector-python")
+
+from typing import Any, List, Dict, Optional, Tuple
+
+
+class MySQLConnection:
+    """MySQL database connection."""
+    
+    def __init__(self, host: str = 'localhost', port: int = 3306,
+                 database: str = 'mysql', user: str = 'root',
+                 password: str = ''):
+        """Create MySQL connection.
+        
+        Args:
+            host: Database host
+            port: Database port
+            database: Database name
+            user: Username
+            password: Password
+        """
+        self.host = host
+        self.port = port
+        self.database = database
+        self.user = user
+        self.password = password
+        self.conn = None
+        self.cursor = None
+        self.in_transaction: bool = False  # Track explicit transaction state
+    
+    def connect(self) -> bool:
+        """Open connection to database."""
+        if not MYSQL_AVAILABLE:
+            print("MySQL driver not available (mysql-connector-python not installed)")
+            return False
+        
+        try:
+            self.conn = mysql.connector.connect(
+                host=self.host,
+                port=self.port,
+                database=self.database,
+                user=self.user,
+                password=self.password
+            )
+            self.cursor = self.conn.cursor(dictionary=True)
+            return True
+        except Error as e:
+            print(f"MySQL connect error: {e}")
+            return False
+    
+    def execute(self, query: str, params: Optional[Tuple] = None) -> bool:
+        """Execute a query (INSERT, UPDATE, DELETE, CREATE, etc)."""
+        try:
+            if not self.cursor or not self.conn:
+                print("MySQL error: Not connected to database")
+                return False
+            
+            if params:
+                self.cursor.execute(query, params)
+            else:
+                self.cursor.execute(query)
+            
+            # Only auto-commit if we're not in an explicit transaction
+            if not self.in_transaction:
+                self.conn.commit()
+            return True
+        except Error as e:
+            print(f"MySQL execute error: {e}")
+            if not self.in_transaction:
+                self.conn.rollback() if self.conn else None
+            return False
+    
+    def query(self, sql: str, params: Optional[Tuple] = None) -> List[Dict[str, Any]]:
+        """Execute a SELECT query and return results."""
+        try:
+            if not self.cursor or not self.conn:
+                print("MySQL error: Not connected to database")
+                return []
+            
+            if params:
+                self.cursor.execute(sql, params)
+            else:
+                self.cursor.execute(sql)
+            
+            # Fetch all rows as dictionaries
+            rows = self.cursor.fetchall()
+            return rows if rows else []
+        
+        except Error as e:
+            print(f"MySQL query error: {e}")
+            return []
+    
+    def query_one(self, sql: str, params: Optional[Tuple] = None) -> Optional[Dict[str, Any]]:
+        """Execute a SELECT query and return first result."""
+        results = self.query(sql, params)
+        return results[0] if results else None
+    
+    def last_insert_id(self) -> int:
+        """Get the last inserted row ID."""
+        return self.cursor.lastrowid if self.cursor else 0
+    
+    def affected_rows(self) -> int:
+        """Get number of affected rows from last query."""
+        return self.cursor.rowcount if self.cursor else 0
+    
+    def begin_transaction(self) -> bool:
+        """Begin a transaction."""
+        try:
+            if self.conn:
+                self.conn.start_transaction()
+                self.in_transaction = True
+                return True
+            return False
+        except Error as e:
+            print(f"MySQL begin transaction error: {e}")
+            return False
+    
+    def commit(self) -> bool:
+        """Commit current transaction."""
+        try:
+            if self.conn:
+                self.conn.commit()
+                self.in_transaction = False
+                return True
+            return False
+        except Error as e:
+            print(f"MySQL commit error: {e}")
+            return False
+    
+    def rollback(self) -> bool:
+        """Rollback current transaction."""
+        try:
+            if self.conn:
+                self.conn.rollback()
+                self.in_transaction = False
+                return True
+            return False
+        except Error as e:
+            print(f"MySQL rollback error: {e}")
+            return False
+    
+    def close(self) -> bool:
+        """Close database connection."""
+        try:
+            if self.cursor:
+                self.cursor.close()
+            if self.conn:
+                self.conn.close()
+            return True
+        except Error as e:
+            print(f"MySQL close error: {e}")
+            return False

package/src/zexus/stdlib/db_postgres.py

@@ -0,0 +1,163 @@
+"""PostgreSQL database driver for Zexus.
+Requires psycopg2: pip install psycopg2-binary
+"""
+
+try:
+    import psycopg2
+    from psycopg2.extras import RealDictCursor
+    POSTGRES_AVAILABLE = True
+except ImportError:
+    POSTGRES_AVAILABLE = False
+    print("Warning: psycopg2 not installed. PostgreSQL support unavailable.")
+    print("Install with: pip install psycopg2-binary")
+
+from typing import Any, List, Dict, Optional, Tuple
+
+
+class PostgreSQLConnection:
+    """PostgreSQL database connection."""
+    
+    def __init__(self, host: str = 'localhost', port: int = 5432, 
+                 database: str = 'postgres', user: str = 'postgres', 
+                 password: str = ''):
+        """Create PostgreSQL connection.
+        
+        Args:
+            host: Database host
+            port: Database port
+            database: Database name
+            user: Username
+            password: Password
+        """
+        self.host = host
+        self.port = port
+        self.database = database
+        self.user = user
+        self.password = password
+        self.conn = None
+        self.cursor = None
+        self.in_transaction: bool = False  # Track explicit transaction state
+    
+    def connect(self) -> bool:
+        """Open connection to database."""
+        if not POSTGRES_AVAILABLE:
+            print("PostgreSQL driver not available (psycopg2 not installed)")
+            return False
+        
+        try:
+            self.conn = psycopg2.connect(
+                host=self.host,
+                port=self.port,
+                database=self.database,
+                user=self.user,
+                password=self.password
+            )
+            self.cursor = self.conn.cursor(cursor_factory=RealDictCursor)
+            return True
+        except Exception as e:
+            print(f"PostgreSQL connect error: {e}")
+            return False
+    
+    def execute(self, query: str, params: Optional[Tuple] = None) -> bool:
+        """Execute a query (INSERT, UPDATE, DELETE, CREATE, etc)."""
+        try:
+            if not self.cursor or not self.conn:
+                print("PostgreSQL error: Not connected to database")
+                return False
+            
+            if params:
+                self.cursor.execute(query, params)
+            else:
+                self.cursor.execute(query)
+            
+            # Only auto-commit if we're not in an explicit transaction
+            if not self.in_transaction:
+                self.conn.commit()
+            return True
+        except Exception as e:
+            print(f"PostgreSQL execute error: {e}")
+            if not self.in_transaction:
+                self.conn.rollback() if self.conn else None
+            return False
+    
+    def query(self, sql: str, params: Optional[Tuple] = None) -> List[Dict[str, Any]]:
+        """Execute a SELECT query and return results."""
+        try:
+            if not self.cursor or not self.conn:
+                print("PostgreSQL error: Not connected to database")
+                return []
+            
+            if params:
+                self.cursor.execute(sql, params)
+            else:
+                self.cursor.execute(sql)
+            
+            # Convert rows to dictionaries
+            rows = self.cursor.fetchall()
+            return [dict(row) for row in rows]
+        
+        except Exception as e:
+            print(f"PostgreSQL query error: {e}")
+            return []
+    
+    def query_one(self, sql: str, params: Optional[Tuple] = None) -> Optional[Dict[str, Any]]:
+        """Execute a SELECT query and return first result."""
+        results = self.query(sql, params)
+        return results[0] if results else None
+    
+    def last_insert_id(self) -> int:
+        """Get the last inserted row ID (requires RETURNING id clause)."""
+        return self.cursor.lastrowid if self.cursor and hasattr(self.cursor, 'lastrowid') else 0
+    
+    def affected_rows(self) -> int:
+        """Get number of affected rows from last query."""
+        return self.cursor.rowcount if self.cursor else 0
+    
+    def begin_transaction(self) -> bool:
+        """Begin a transaction."""
+        try:
+            if self.conn:
+                # PostgreSQL auto-starts transactions, just ensure we're not in autocommit
+                self.conn.autocommit = False
+                self.in_transaction = True
+                return True
+            return False
+        except Exception as e:
+            print(f"PostgreSQL begin transaction error: {e}")
+            return False
+    
+    def commit(self) -> bool:
+        """Commit current transaction."""
+        try:
+            if self.conn:
+                self.conn.commit()
+                self.in_transaction = False
+                return True
+            return False
+        except Exception as e:
+            print(f"PostgreSQL commit error: {e}")
+            return False
+    
+    def rollback(self) -> bool:
+        """Rollback current transaction."""
+        try:
+            if self.conn:
+                self.conn.rollback()
+                self.in_transaction = False
+                return True
+            return False
+        except Exception as e:
+            print(f"PostgreSQL rollback error: {e}")
+            return False
+    
+    def close(self) -> bool:
+        """Close database connection."""
+        try:
+            if self.cursor:
+                self.cursor.close()
+            if self.conn:
+                self.conn.close()
+            return True
+        except Exception as e:
+            print(f"PostgreSQL close error: {e}")
+            return False

package/src/zexus/stdlib/db_sqlite.py

@@ -0,0 +1,133 @@
+"""SQLite database driver for Zexus."""
+
+import sqlite3
+from typing import Any, List, Dict, Optional, Tuple
+
+
+class SQLiteConnection:
+    """SQLite database connection."""
+    
+    def __init__(self, database: str):
+        """Create SQLite connection.
+        
+        Args:
+            database: Path to SQLite database file, or ':memory:' for in-memory DB
+        """
+        self.database = database
+        self.conn: Optional[sqlite3.Connection] = None
+        self.cursor: Optional[sqlite3.Cursor] = None
+        self.in_transaction: bool = False  # Track explicit transaction state
+    
+    def connect(self) -> bool:
+        """Open connection to database."""
+        try:
+            self.conn = sqlite3.connect(self.database)
+            # Disable automatic transaction management - we'll handle it manually
+            self.conn.isolation_level = None  
+            self.conn.row_factory = sqlite3.Row  # Enable column access by name
+            self.cursor = self.conn.cursor()
+            return True
+        except Exception as e:
+            print(f"SQLite connect error: {e}")
+            return False
+    
+    def execute(self, query: str, params: Optional[Tuple] = None) -> bool:
+        """Execute a query (INSERT, UPDATE, DELETE, CREATE, etc)."""
+        try:
+            if not self.cursor or not self.conn:
+                print("SQLite error: Not connected to database")
+                return False
+            
+            if params:
+                self.cursor.execute(query, params)
+            else:
+                self.cursor.execute(query)
+            
+            # Only auto-commit if we're not in an explicit transaction
+            if not self.in_transaction:
+                self.conn.commit()
+            return True
+        except Exception as e:
+            print(f"SQLite execute error: {e}")
+            if not self.in_transaction:
+                self.conn.rollback() if self.conn else None
+            return False
+    
+    def query(self, sql: str, params: Optional[Tuple] = None) -> List[Dict[str, Any]]:
+        """Execute a SELECT query and return results."""
+        try:
+            if not self.cursor or not self.conn:
+                print("SQLite error: Not connected to database")
+                return []
+            
+            if params:
+                self.cursor.execute(sql, params)
+            else:
+                self.cursor.execute(sql)
+            
+            # Convert rows to dictionaries
+            rows = self.cursor.fetchall()
+            return [dict(row) for row in rows]
+        
+        except Exception as e:
+            print(f"SQLite query error: {e}")
+            return []
+    
+    def query_one(self, sql: str, params: Optional[Tuple] = None) -> Optional[Dict[str, Any]]:
+        """Execute a SELECT query and return first result."""
+        results = self.query(sql, params)
+        return results[0] if results else None
+    
+    def last_insert_id(self) -> int:
+        """Get the last inserted row ID."""
+        return self.cursor.lastrowid if self.cursor else 0
+    
+    def affected_rows(self) -> int:
+        """Get number of affected rows from last query."""
+        return self.cursor.rowcount if self.cursor else 0
+    
+    def begin_transaction(self) -> bool:
+        """Begin a transaction."""
+        try:
+            # SQLite doesn't support nested transactions
+            # If we're already in a transaction, just return True
+            if self.in_transaction:
+                return True
+            self.conn.execute("BEGIN TRANSACTION")
+            self.in_transaction = True
+            return True
+        except Exception as e:
+            print(f"SQLite begin transaction error: {e}")
+            return False
+    
+    def commit(self) -> bool:
+        """Commit current transaction."""
+        try:
+            self.conn.commit()
+            self.in_transaction = False
+            return True
+        except Exception as e:
+            print(f"SQLite commit error: {e}")
+            return False
+    
+    def rollback(self) -> bool:
+        """Rollback current transaction."""
+        try:
+            self.conn.rollback()
+            self.in_transaction = False
+            return True
+        except Exception as e:
+            print(f"SQLite rollback error: {e}")
+            return False
+    
+    def close(self) -> bool:
+        """Close database connection."""
+        try:
+            if self.cursor:
+                self.cursor.close()
+            if self.conn:
+                self.conn.close()
+            return True
+        except Exception as e:
+            print(f"SQLite close error: {e}")
+            return False

package/src/zexus/stdlib/encoding.py

@@ -0,0 +1,230 @@
+"""Encoding module for Zexus standard library."""
+
+import base64
+import binascii
+import json
+from typing import Dict, Any
+
+
+class EncodingModule:
+    """Provides encoding/decoding operations."""
+
+    # Base64 encoding/decoding
+    @staticmethod
+    def base64_encode(data: str) -> str:
+        """Encode string to base64."""
+        return base64.b64encode(data.encode()).decode('ascii')
+
+    @staticmethod
+    def base64_decode(data: str) -> str:
+        """Decode base64 to string."""
+        return base64.b64decode(data).decode('utf-8')
+
+    @staticmethod
+    def base64_urlsafe_encode(data: str) -> str:
+        """Encode string to URL-safe base64."""
+        return base64.urlsafe_b64encode(data.encode()).decode('ascii')
+
+    @staticmethod
+    def base64_urlsafe_decode(data: str) -> str:
+        """Decode URL-safe base64 to string."""
+        return base64.urlsafe_b64decode(data).decode('utf-8')
+
+    # Base32 encoding/decoding
+    @staticmethod
+    def base32_encode(data: str) -> str:
+        """Encode string to base32."""
+        return base64.b32encode(data.encode()).decode('ascii')
+
+    @staticmethod
+    def base32_decode(data: str) -> str:
+        """Decode base32 to string."""
+        return base64.b32decode(data).decode('utf-8')
+
+    # Base16/Hex encoding/decoding
+    @staticmethod
+    def hex_encode(data: str) -> str:
+        """Encode string to hexadecimal."""
+        return data.encode().hex()
+
+    @staticmethod
+    def hex_decode(data: str) -> str:
+        """Decode hexadecimal to string."""
+        return bytes.fromhex(data).decode('utf-8')
+
+    @staticmethod
+    def base16_encode(data: str) -> str:
+        """Encode string to base16."""
+        return base64.b16encode(data.encode()).decode('ascii')
+
+    @staticmethod
+    def base16_decode(data: str) -> str:
+        """Decode base16 to string."""
+        return base64.b16decode(data).decode('utf-8')
+
+    # Base85 encoding/decoding
+    @staticmethod
+    def base85_encode(data: str) -> str:
+        """Encode string to base85."""
+        return base64.b85encode(data.encode()).decode('ascii')
+
+    @staticmethod
+    def base85_decode(data: str) -> str:
+        """Decode base85 to string."""
+        return base64.b85decode(data).decode('utf-8')
+
+    # ASCII85 encoding/decoding
+    @staticmethod
+    def ascii85_encode(data: str) -> str:
+        """Encode string to ASCII85."""
+        return base64.a85encode(data.encode()).decode('ascii')
+
+    @staticmethod
+    def ascii85_decode(data: str) -> str:
+        """Decode ASCII85 to string."""
+        return base64.a85decode(data).decode('utf-8')
+
+    # URL encoding/decoding
+    @staticmethod
+    def url_encode(data: str) -> str:
+        """URL encode string."""
+        import urllib.parse
+        return urllib.parse.quote(data)
+
+    @staticmethod
+    def url_decode(data: str) -> str:
+        """URL decode string."""
+        import urllib.parse
+        return urllib.parse.unquote(data)
+
+    @staticmethod
+    def url_encode_plus(data: str) -> str:
+        """URL encode with + for spaces."""
+        import urllib.parse
+        return urllib.parse.quote_plus(data)
+
+    @staticmethod
+    def url_decode_plus(data: str) -> str:
+        """URL decode with + for spaces."""
+        import urllib.parse
+        return urllib.parse.unquote_plus(data)
+
+    # HTML encoding/decoding
+    @staticmethod
+    def html_encode(data: str) -> str:
+        """HTML encode string."""
+        import html
+        return html.escape(data)
+
+    @staticmethod
+    def html_decode(data: str) -> str:
+        """HTML decode string."""
+        import html
+        return html.unescape(data)
+
+    # Unicode operations
+    @staticmethod
+    def unicode_encode(data: str, encoding: str = 'utf-8') -> str:
+        """Encode string to bytes (hex representation)."""
+        return data.encode(encoding).hex()
+
+    @staticmethod
+    def unicode_decode(data: str, encoding: str = 'utf-8') -> str:
+        """Decode bytes (hex representation) to string."""
+        return bytes.fromhex(data).decode(encoding)
+
+    @staticmethod
+    def unicode_normalize(data: str, form: str = 'NFC') -> str:
+        """Normalize Unicode string (NFC, NFD, NFKC, NFKD)."""
+        import unicodedata
+        return unicodedata.normalize(form, data)
+
+    # Binary/ASCII operations
+    @staticmethod
+    def to_binary(data: str) -> str:
+        """Convert string to binary representation."""
+        return ' '.join(format(ord(c), '08b') for c in data)
+
+    @staticmethod
+    def from_binary(data: str) -> str:
+        """Convert binary representation to string."""
+        binary_values = data.split()
+        return ''.join(chr(int(b, 2)) for b in binary_values)
+
+    @staticmethod
+    def to_ascii_codes(data: str) -> list:
+        """Convert string to ASCII codes."""
+        return [ord(c) for c in data]
+
+    @staticmethod
+    def from_ascii_codes(codes: list) -> str:
+        """Convert ASCII codes to string."""
+        return ''.join(chr(code) for code in codes)
+
+    # ROT13
+    @staticmethod
+    def rot13(data: str) -> str:
+        """ROT13 encoding/decoding."""
+        import codecs
+        return codecs.encode(data, 'rot_13')
+
+    # CRC32 checksum
+    @staticmethod
+    def crc32(data: str) -> int:
+        """Calculate CRC32 checksum."""
+        return binascii.crc32(data.encode()) & 0xffffffff
+
+    # Adler32 checksum
+    @staticmethod
+    def adler32(data: str) -> int:
+        """Calculate Adler32 checksum."""
+        import zlib
+        return zlib.adler32(data.encode()) & 0xffffffff
+
+    # JSON encoding/decoding (for convenience)
+    @staticmethod
+    def json_encode(obj: Any, pretty: bool = False) -> str:
+        """Encode object to JSON."""
+        if pretty:
+            return json.dumps(obj, indent=2, ensure_ascii=False)
+        return json.dumps(obj, ensure_ascii=False)
+
+    @staticmethod
+    def json_decode(data: str) -> Any:
+        """Decode JSON to object."""
+        return json.loads(data)
+
+
+# Export functions for easy access
+base64_encode = EncodingModule.base64_encode
+base64_decode = EncodingModule.base64_decode
+base64_urlsafe_encode = EncodingModule.base64_urlsafe_encode
+base64_urlsafe_decode = EncodingModule.base64_urlsafe_decode
+base32_encode = EncodingModule.base32_encode
+base32_decode = EncodingModule.base32_decode
+hex_encode = EncodingModule.hex_encode
+hex_decode = EncodingModule.hex_decode
+base16_encode = EncodingModule.base16_encode
+base16_decode = EncodingModule.base16_decode
+base85_encode = EncodingModule.base85_encode
+base85_decode = EncodingModule.base85_decode
+ascii85_encode = EncodingModule.ascii85_encode
+ascii85_decode = EncodingModule.ascii85_decode
+url_encode = EncodingModule.url_encode
+url_decode = EncodingModule.url_decode
+url_encode_plus = EncodingModule.url_encode_plus
+url_decode_plus = EncodingModule.url_decode_plus
+html_encode = EncodingModule.html_encode
+html_decode = EncodingModule.html_decode
+unicode_encode = EncodingModule.unicode_encode
+unicode_decode = EncodingModule.unicode_decode
+unicode_normalize = EncodingModule.unicode_normalize
+to_binary = EncodingModule.to_binary
+from_binary = EncodingModule.from_binary
+to_ascii_codes = EncodingModule.to_ascii_codes
+from_ascii_codes = EncodingModule.from_ascii_codes
+rot13 = EncodingModule.rot13
+crc32 = EncodingModule.crc32
+adler32 = EncodingModule.adler32
+json_encode = EncodingModule.json_encode
+json_decode = EncodingModule.json_decode