zexus 1.6.2

package/src/zexus/stdlib/fs.py

@@ -0,0 +1,195 @@
+"""File System module for Zexus standard library."""
+
+import os
+import shutil
+import glob as glob_module
+from pathlib import Path
+from typing import List, Dict, Any
+
+
+class FileSystemModule:
+    """Provides file system operations."""
+
+    @staticmethod
+    def read_file(path: str, encoding: str = 'utf-8') -> str:
+        """Read entire file as text."""
+        with open(path, 'r', encoding=encoding) as f:
+            return f.read()
+
+    @staticmethod
+    def write_file(path: str, content: str, encoding: str = 'utf-8') -> None:
+        """Write text to file."""
+        # Create parent directory if it doesn't exist
+        Path(path).parent.mkdir(parents=True, exist_ok=True)
+        with open(path, 'w', encoding=encoding) as f:
+            f.write(content)
+
+    @staticmethod
+    def append_file(path: str, content: str, encoding: str = 'utf-8') -> None:
+        """Append text to file."""
+        # Create parent directory if it doesn't exist (for consistency with write_file)
+        Path(path).parent.mkdir(parents=True, exist_ok=True)
+        with open(path, 'a', encoding=encoding) as f:
+            f.write(content)
+
+    @staticmethod
+    def read_binary(path: str) -> bytes:
+        """Read file as binary."""
+        with open(path, 'rb') as f:
+            return f.read()
+
+    @staticmethod
+    def write_binary(path: str, data: bytes) -> None:
+        """Write binary data to file."""
+        Path(path).parent.mkdir(parents=True, exist_ok=True)
+        with open(path, 'wb') as f:
+            f.write(data)
+
+    @staticmethod
+    def exists(path: str) -> bool:
+        """Check if file or directory exists."""
+        return os.path.exists(path)
+
+    @staticmethod
+    def is_file(path: str) -> bool:
+        """Check if path is a file."""
+        return os.path.isfile(path)
+
+    @staticmethod
+    def is_dir(path: str) -> bool:
+        """Check if path is a directory."""
+        return os.path.isdir(path)
+
+    @staticmethod
+    def mkdir(path: str, parents: bool = True) -> None:
+        """Create directory."""
+        Path(path).mkdir(parents=parents, exist_ok=True)
+
+    @staticmethod
+    def rmdir(path: str, recursive: bool = False) -> None:
+        """Remove directory."""
+        if recursive:
+            shutil.rmtree(path)
+        else:
+            os.rmdir(path)
+
+    @staticmethod
+    def remove(path: str) -> None:
+        """Remove file."""
+        os.remove(path)
+
+    @staticmethod
+    def rename(old_path: str, new_path: str) -> None:
+        """Rename/move file or directory."""
+        os.rename(old_path, new_path)
+
+    @staticmethod
+    def copy_file(src: str, dst: str) -> None:
+        """Copy file."""
+        shutil.copy2(src, dst)
+
+    @staticmethod
+    def copy_dir(src: str, dst: str) -> None:
+        """Copy directory recursively."""
+        shutil.copytree(src, dst)
+
+    @staticmethod
+    def list_dir(path: str = '.') -> List[str]:
+        """List directory contents."""
+        return os.listdir(path)
+
+    @staticmethod
+    def walk(path: str) -> List[Dict[str, Any]]:
+        """Walk directory tree."""
+        result = []
+        for root, dirs, files in os.walk(path):
+            result.append({
+                'root': root,
+                'dirs': dirs,
+                'files': files
+            })
+        return result
+
+    @staticmethod
+    def glob(pattern: str, recursive: bool = False) -> List[str]:
+        """Find files matching pattern."""
+        return glob_module.glob(pattern, recursive=recursive)
+
+    @staticmethod
+    def get_size(path: str) -> int:
+        """Get file size in bytes."""
+        return os.path.getsize(path)
+
+    @staticmethod
+    def get_cwd() -> str:
+        """Get current working directory."""
+        return os.getcwd()
+
+    @staticmethod
+    def chdir(path: str) -> None:
+        """Change current working directory."""
+        os.chdir(path)
+
+    @staticmethod
+    def abs_path(path: str) -> str:
+        """Get absolute path."""
+        return os.path.abspath(path)
+
+    @staticmethod
+    def join(*paths: str) -> str:
+        """Join path components."""
+        return os.path.join(*paths)
+
+    @staticmethod
+    def basename(path: str) -> str:
+        """Get file name from path."""
+        return os.path.basename(path)
+
+    @staticmethod
+    def dirname(path: str) -> str:
+        """Get directory name from path."""
+        return os.path.dirname(path)
+
+    @staticmethod
+    def splitext(path: str) -> tuple:
+        """Split file extension."""
+        return os.path.splitext(path)
+
+    @staticmethod
+    def get_stat(path: str) -> Dict[str, Any]:
+        """Get file statistics."""
+        stat = os.stat(path)
+        return {
+            'size': stat.st_size,
+            'atime': stat.st_atime,
+            'mtime': stat.st_mtime,
+            'ctime': stat.st_ctime,
+            'mode': stat.st_mode,
+        }
+
+
+# Export functions for easy access
+read_file = FileSystemModule.read_file
+write_file = FileSystemModule.write_file
+append_file = FileSystemModule.append_file
+exists = FileSystemModule.exists
+is_file = FileSystemModule.is_file
+is_dir = FileSystemModule.is_dir
+mkdir = FileSystemModule.mkdir
+rmdir = FileSystemModule.rmdir
+remove = FileSystemModule.remove
+rename = FileSystemModule.rename
+copy_file = FileSystemModule.copy_file
+copy_dir = FileSystemModule.copy_dir
+list_dir = FileSystemModule.list_dir
+walk = FileSystemModule.walk
+glob = FileSystemModule.glob
+get_size = FileSystemModule.get_size
+get_cwd = FileSystemModule.get_cwd
+chdir = FileSystemModule.chdir
+abs_path = FileSystemModule.abs_path
+join = FileSystemModule.join
+basename = FileSystemModule.basename
+dirname = FileSystemModule.dirname
+splitext = FileSystemModule.splitext
+get_stat = FileSystemModule.get_stat

package/src/zexus/stdlib/http.py

@@ -0,0 +1,219 @@
+"""HTTP module for Zexus standard library."""
+
+import urllib.request
+import urllib.parse
+import urllib.error
+import json as json_lib
+from typing import Dict, Any, Optional
+
+
+class HttpModule:
+    """Provides HTTP client operations."""
+
+    @staticmethod
+    def get(url: str, headers: Optional[Dict[str, str]] = None, timeout: int = 30) -> Dict[str, Any]:
+        """Make HTTP GET request."""
+        if headers is None:
+            headers = {}
+        
+        req = urllib.request.Request(url, headers=headers, method='GET')
+        
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as response:
+                body = response.read().decode('utf-8')
+                return {
+                    'status': response.status,
+                    'headers': dict(response.headers),
+                    'body': body
+                }
+        except urllib.error.HTTPError as e:
+            try:
+                error_body = e.read().decode('utf-8')
+            except UnicodeDecodeError:
+                error_body = e.read().decode('utf-8', errors='replace')
+            return {
+                'status': e.code,
+                'headers': dict(e.headers),
+                'body': error_body,
+                'error': str(e)
+            }
+        except Exception as e:
+            return {
+                'status': 0,
+                'headers': {},
+                'body': '',
+                'error': str(e)
+            }
+
+    @staticmethod
+    def post(url: str, data: Any = None, headers: Optional[Dict[str, str]] = None, 
+             json: bool = False, timeout: int = 30) -> Dict[str, Any]:
+        """Make HTTP POST request."""
+        if headers is None:
+            headers = {}
+        
+        if json and data is not None:
+            data = json_lib.dumps(data).encode('utf-8')
+            headers['Content-Type'] = 'application/json'
+        elif isinstance(data, str):
+            data = data.encode('utf-8')
+        elif isinstance(data, dict):
+            data = urllib.parse.urlencode(data).encode('utf-8')
+        
+        req = urllib.request.Request(url, data=data, headers=headers, method='POST')
+        
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as response:
+                body = response.read().decode('utf-8')
+                return {
+                    'status': response.status,
+                    'headers': dict(response.headers),
+                    'body': body
+                }
+        except urllib.error.HTTPError as e:
+            try:
+                error_body = e.read().decode('utf-8')
+            except UnicodeDecodeError:
+                error_body = e.read().decode('utf-8', errors='replace')
+            return {
+                'status': e.code,
+                'headers': dict(e.headers),
+                'body': error_body,
+                'error': str(e)
+            }
+        except Exception as e:
+            return {
+                'status': 0,
+                'headers': {},
+                'body': '',
+                'error': str(e)
+            }
+
+    @staticmethod
+    def put(url: str, data: Any = None, headers: Optional[Dict[str, str]] = None,
+            json: bool = False, timeout: int = 30) -> Dict[str, Any]:
+        """Make HTTP PUT request."""
+        if headers is None:
+            headers = {}
+        
+        if json and data is not None:
+            data = json_lib.dumps(data).encode('utf-8')
+            headers['Content-Type'] = 'application/json'
+        elif isinstance(data, str):
+            data = data.encode('utf-8')
+        elif isinstance(data, dict):
+            data = urllib.parse.urlencode(data).encode('utf-8')
+        
+        req = urllib.request.Request(url, data=data, headers=headers, method='PUT')
+        
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as response:
+                body = response.read().decode('utf-8')
+                return {
+                    'status': response.status,
+                    'headers': dict(response.headers),
+                    'body': body
+                }
+        except urllib.error.HTTPError as e:
+            try:
+                error_body = e.read().decode('utf-8')
+            except UnicodeDecodeError:
+                error_body = e.read().decode('utf-8', errors='replace')
+            return {
+                'status': e.code,
+                'headers': dict(e.headers),
+                'body': error_body,
+                'error': str(e)
+            }
+        except Exception as e:
+            return {
+                'status': 0,
+                'headers': {},
+                'body': '',
+                'error': str(e)
+            }
+
+    @staticmethod
+    def delete(url: str, headers: Optional[Dict[str, str]] = None, timeout: int = 30) -> Dict[str, Any]:
+        """Make HTTP DELETE request."""
+        if headers is None:
+            headers = {}
+        
+        req = urllib.request.Request(url, headers=headers, method='DELETE')
+        
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as response:
+                body = response.read().decode('utf-8')
+                return {
+                    'status': response.status,
+                    'headers': dict(response.headers),
+                    'body': body
+                }
+        except urllib.error.HTTPError as e:
+            try:
+                error_body = e.read().decode('utf-8')
+            except UnicodeDecodeError:
+                error_body = e.read().decode('utf-8', errors='replace')
+            return {
+                'status': e.code,
+                'headers': dict(e.headers),
+                'body': error_body,
+                'error': str(e)
+            }
+        except Exception as e:
+            return {
+                'status': 0,
+                'headers': {},
+                'body': '',
+                'error': str(e)
+            }
+
+    @staticmethod
+    def request(method: str, url: str, data: Any = None, headers: Optional[Dict[str, str]] = None,
+                timeout: int = 30) -> Dict[str, Any]:
+        """Make HTTP request with custom method."""
+        if headers is None:
+            headers = {}
+        
+        if data is not None:
+            if isinstance(data, str):
+                data = data.encode('utf-8')
+            elif isinstance(data, dict):
+                data = urllib.parse.urlencode(data).encode('utf-8')
+        
+        req = urllib.request.Request(url, data=data, headers=headers, method=method.upper())
+        
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as response:
+                body = response.read().decode('utf-8')
+                return {
+                    'status': response.status,
+                    'headers': dict(response.headers),
+                    'body': body
+                }
+        except urllib.error.HTTPError as e:
+            try:
+                error_body = e.read().decode('utf-8')
+            except UnicodeDecodeError:
+                error_body = e.read().decode('utf-8', errors='replace')
+            return {
+                'status': e.code,
+                'headers': dict(e.headers),
+                'body': error_body,
+                'error': str(e)
+            }
+        except Exception as e:
+            return {
+                'status': 0,
+                'headers': {},
+                'body': '',
+                'error': str(e)
+            }
+
+
+# Export functions for easy access
+get = HttpModule.get
+post = HttpModule.post
+put = HttpModule.put
+delete = HttpModule.delete
+request = HttpModule.request

package/src/zexus/stdlib/http_server.py

@@ -0,0 +1,248 @@
+"""HTTP Server module for Zexus standard library.
+Built on top of the socket primitives."""
+
+import socket
+import threading
+import re
+from typing import Dict, List, Callable, Optional, Any, Tuple
+from urllib.parse import parse_qs, urlparse
+
+
+class HTTPRequest:
+    """Represents an HTTP request."""
+    
+    def __init__(self, method: str, path: str, headers: Dict[str, str], 
+                 body: str, query: Dict[str, List[str]]):
+        self.method = method
+        self.path = path
+        self.headers = headers
+        self.body = body
+        self.query = query
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for Zexus."""
+        return {
+            'method': self.method,
+            'path': self.path,
+            'headers': self.headers,
+            'body': self.body,
+            'query': self.query
+        }
+
+
+class HTTPResponse:
+    """Represents an HTTP response."""
+    
+    def __init__(self):
+        self.status = 200
+        self.headers: Dict[str, str] = {'Content-Type': 'text/plain'}
+        self.body = ''
+    
+    def set_status(self, code: int) -> 'HTTPResponse':
+        """Set response status code."""
+        self.status = code
+        return self
+    
+    def set_header(self, name: str, value: str) -> 'HTTPResponse':
+        """Set response header."""
+        self.headers[name] = value
+        return self
+    
+    def send(self, body: str) -> 'HTTPResponse':
+        """Set response body."""
+        self.body = body
+        return self
+    
+    def json(self, data: Any) -> 'HTTPResponse':
+        """Send JSON response."""
+        import json
+        self.headers['Content-Type'] = 'application/json'
+        self.body = json.dumps(data)
+        return self
+    
+    def build(self) -> str:
+        """Build HTTP response string."""
+        status_messages = {
+            200: 'OK',
+            201: 'Created',
+            400: 'Bad Request',
+            404: 'Not Found',
+            500: 'Internal Server Error'
+        }
+        
+        status_msg = status_messages.get(self.status, 'OK')
+        response = f"HTTP/1.1 {self.status} {status_msg}\r\n"
+        
+        # Add Content-Length
+        self.headers['Content-Length'] = str(len(self.body.encode('utf-8')))
+        
+        # Add headers
+        for name, value in self.headers.items():
+            response += f"{name}: {value}\r\n"
+        
+        response += "\r\n"
+        response += self.body
+        
+        return response
+
+
+class HTTPServer:
+    """Simple HTTP server with routing."""
+    
+    def __init__(self, host: str = '0.0.0.0', port: int = 8080):
+        self.host = host
+        self.port = port
+        self.routes: Dict[Tuple[str, str], Callable] = {}  # (method, path) -> handler
+        self.socket: Optional[socket.socket] = None
+        self.running = False
+        self.thread: Optional[threading.Thread] = None
+    
+    def route(self, method: str, path: str, handler: Callable):
+        """Register a route handler."""
+        self.routes[(method.upper(), path)] = handler
+    
+    def get(self, path: str, handler: Callable):
+        """Register GET route."""
+        self.route('GET', path, handler)
+    
+    def post(self, path: str, handler: Callable):
+        """Register POST route."""
+        self.route('POST', path, handler)
+    
+    def put(self, path: str, handler: Callable):
+        """Register PUT route."""
+        self.route('PUT', path, handler)
+    
+    def delete(self, path: str, handler: Callable):
+        """Register DELETE route."""
+        self.route('DELETE', path, handler)
+    
+    def _parse_request(self, raw_request: str) -> Optional[HTTPRequest]:
+        """Parse raw HTTP request."""
+        try:
+            lines = raw_request.split('\r\n')
+            if not lines:
+                return None
+            
+            # Parse request line
+            request_line = lines[0]
+            parts = request_line.split(' ')
+            if len(parts) < 3:
+                return None
+            
+            method, full_path, _ = parts
+            
+            # Parse path and query string
+            parsed = urlparse(full_path)
+            path = parsed.path
+            query = parse_qs(parsed.query)
+            
+            # Parse headers
+            headers = {}
+            body_start = 0
+            for i, line in enumerate(lines[1:], 1):
+                if line == '':
+                    body_start = i + 1
+                    break
+                if ': ' in line:
+                    name, value = line.split(': ', 1)
+                    headers[name] = value
+            
+            # Parse body
+            body = '\r\n'.join(lines[body_start:]) if body_start > 0 else ''
+            
+            return HTTPRequest(method, path, headers, body, query)
+        
+        except Exception as e:
+            print(f"Request parse error: {e}")
+            return None
+    
+    def _handle_connection(self, client_socket: socket.socket, address: tuple):
+        """Handle a client connection."""
+        try:
+            # Receive request
+            raw_request = client_socket.recv(8192).decode('utf-8')
+            
+            if not raw_request:
+                return
+            
+            # Parse request
+            request = self._parse_request(raw_request)
+            if not request:
+                response = HTTPResponse().set_status(400).send("Bad Request")
+                client_socket.sendall(response.build().encode('utf-8'))
+                return
+            
+            # Find matching route
+            route_key = (request.method, request.path)
+            handler = self.routes.get(route_key)
+            
+            if not handler:
+                response = HTTPResponse().set_status(404).send("Not Found")
+                client_socket.sendall(response.build().encode('utf-8'))
+                return
+            
+            # Create response object
+            response = HTTPResponse()
+            
+            # Call handler
+            try:
+                handler(request, response)
+            except Exception as e:
+                print(f"Handler error: {e}")
+                response = HTTPResponse().set_status(500).send(f"Internal Server Error: {str(e)}")
+            
+            # Send response
+            client_socket.sendall(response.build().encode('utf-8'))
+        
+        except Exception as e:
+            print(f"Connection handler error: {e}")
+        
+        finally:
+            try:
+                client_socket.close()
+            except:
+                pass
+    
+    def listen(self):
+        """Start the HTTP server."""
+        if self.running:
+            raise RuntimeError("Server is already running")
+        
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.socket.bind((self.host, self.port))
+        self.socket.listen(10)
+        self.running = True
+        
+        print(f"HTTP Server listening on {self.host}:{self.port}")
+        
+        # Accept connections
+        while self.running:
+            try:
+                self.socket.settimeout(1.0)
+                client_socket, address = self.socket.accept()
+                
+                # Handle in new thread
+                handler_thread = threading.Thread(
+                    target=self._handle_connection,
+                    args=(client_socket, address),
+                    daemon=True
+                )
+                handler_thread.start()
+            
+            except socket.timeout:
+                continue
+            except Exception as e:
+                if self.running:
+                    print(f"Accept error: {e}")
+                break
+    
+    def stop(self):
+        """Stop the server."""
+        self.running = False
+        if self.socket:
+            try:
+                self.socket.close()
+            except:
+                pass