zexus 1.6.2

package/src/zexus/stdlib/json_module.py

@@ -0,0 +1,61 @@
+"""JSON module for Zexus standard library."""
+
+import json as json_lib
+from typing import Any, Optional
+
+
+class JsonModule:
+    """Provides JSON encoding and decoding operations."""
+
+    @staticmethod
+    def parse(text: str) -> Any:
+        """Parse JSON string to object."""
+        return json_lib.loads(text)
+
+    @staticmethod
+    def stringify(obj: Any, indent: Optional[int] = None, sort_keys: bool = False) -> str:
+        """Convert object to JSON string."""
+        return json_lib.dumps(obj, indent=indent, sort_keys=sort_keys, ensure_ascii=False)
+
+    @staticmethod
+    def load(file_path: str) -> Any:
+        """Load JSON from file."""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            return json_lib.load(f)
+
+    @staticmethod
+    def save(file_path: str, obj: Any, indent: Optional[int] = 2, sort_keys: bool = False) -> None:
+        """Save object to JSON file."""
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json_lib.dump(obj, f, indent=indent, sort_keys=sort_keys, ensure_ascii=False)
+
+    @staticmethod
+    def validate(text: str) -> bool:
+        """Check if string is valid JSON."""
+        try:
+            json_lib.loads(text)
+            return True
+        except (json_lib.JSONDecodeError, ValueError):
+            return False
+
+    @staticmethod
+    def merge(obj1: dict, obj2: dict) -> dict:
+        """Merge two JSON objects."""
+        result = obj1.copy()
+        result.update(obj2)
+        return result
+
+    @staticmethod
+    def pretty_print(obj: Any, indent: int = 2) -> str:
+        """Pretty print JSON with indentation."""
+        return json_lib.dumps(obj, indent=indent, sort_keys=True, ensure_ascii=False)
+
+
+# Export functions for easy access
+parse = JsonModule.parse
+stringify = JsonModule.stringify
+load = JsonModule.load
+save = JsonModule.save
+validate = JsonModule.validate
+merge = JsonModule.merge
+pretty_print = JsonModule.pretty_print

package/src/zexus/stdlib/math.py

@@ -0,0 +1,360 @@
+"""Math module for Zexus standard library."""
+
+import math
+import random
+from typing import List
+
+
+class MathModule:
+    """Provides advanced mathematical operations."""
+
+    # Constants
+    PI = math.pi
+    E = math.e
+    TAU = math.tau
+    INF = math.inf
+    NAN = math.nan
+
+    # Trigonometric functions
+    @staticmethod
+    def sin(x: float) -> float:
+        """Sine of x radians."""
+        return math.sin(x)
+
+    @staticmethod
+    def cos(x: float) -> float:
+        """Cosine of x radians."""
+        return math.cos(x)
+
+    @staticmethod
+    def tan(x: float) -> float:
+        """Tangent of x radians."""
+        return math.tan(x)
+
+    @staticmethod
+    def asin(x: float) -> float:
+        """Arc sine in radians."""
+        return math.asin(x)
+
+    @staticmethod
+    def acos(x: float) -> float:
+        """Arc cosine in radians."""
+        return math.acos(x)
+
+    @staticmethod
+    def atan(x: float) -> float:
+        """Arc tangent in radians."""
+        return math.atan(x)
+
+    @staticmethod
+    def atan2(y: float, x: float) -> float:
+        """Arc tangent of y/x in radians."""
+        return math.atan2(y, x)
+
+    # Hyperbolic functions
+    @staticmethod
+    def sinh(x: float) -> float:
+        """Hyperbolic sine."""
+        return math.sinh(x)
+
+    @staticmethod
+    def cosh(x: float) -> float:
+        """Hyperbolic cosine."""
+        return math.cosh(x)
+
+    @staticmethod
+    def tanh(x: float) -> float:
+        """Hyperbolic tangent."""
+        return math.tanh(x)
+
+    @staticmethod
+    def asinh(x: float) -> float:
+        """Inverse hyperbolic sine."""
+        return math.asinh(x)
+
+    @staticmethod
+    def acosh(x: float) -> float:
+        """Inverse hyperbolic cosine."""
+        return math.acosh(x)
+
+    @staticmethod
+    def atanh(x: float) -> float:
+        """Inverse hyperbolic tangent."""
+        return math.atanh(x)
+
+    # Power and logarithmic functions
+    @staticmethod
+    def exp(x: float) -> float:
+        """e raised to power x."""
+        return math.exp(x)
+
+    @staticmethod
+    def log(x: float, base: float = math.e) -> float:
+        """Logarithm of x to given base."""
+        return math.log(x, base)
+
+    @staticmethod
+    def log10(x: float) -> float:
+        """Base-10 logarithm."""
+        return math.log10(x)
+
+    @staticmethod
+    def log2(x: float) -> float:
+        """Base-2 logarithm."""
+        return math.log2(x)
+
+    @staticmethod
+    def log1p(x: float) -> float:
+        """Natural logarithm of 1+x."""
+        return math.log1p(x)
+
+    @staticmethod
+    def pow(x: float, y: float) -> float:
+        """x raised to power y."""
+        return math.pow(x, y)
+
+    @staticmethod
+    def sqrt(x: float) -> float:
+        """Square root."""
+        return math.sqrt(x)
+
+    @staticmethod
+    def cbrt(x: float) -> float:
+        """Cube root."""
+        return math.copysign(1, x) * abs(x) ** (1/3)
+
+    # Rounding and absolute functions
+    @staticmethod
+    def ceil(x: float) -> int:
+        """Ceiling (smallest integer >= x)."""
+        return math.ceil(x)
+
+    @staticmethod
+    def floor(x: float) -> int:
+        """Floor (largest integer <= x)."""
+        return math.floor(x)
+
+    @staticmethod
+    def trunc(x: float) -> int:
+        """Truncate to integer."""
+        return math.trunc(x)
+
+    @staticmethod
+    def round(x: float, ndigits: int = 0) -> float:
+        """Round to n digits."""
+        return round(x, ndigits)
+
+    @staticmethod
+    def abs(x: float) -> float:
+        """Absolute value."""
+        return abs(x)
+
+    # Other functions
+    @staticmethod
+    def factorial(n: int) -> int:
+        """Factorial of n."""
+        return math.factorial(n)
+
+    @staticmethod
+    def gcd(a: int, b: int) -> int:
+        """Greatest common divisor."""
+        return math.gcd(a, b)
+
+    @staticmethod
+    def lcm(a: int, b: int) -> int:
+        """Least common multiple."""
+        return abs(a * b) // math.gcd(a, b) if a and b else 0
+
+    @staticmethod
+    def degrees(x: float) -> float:
+        """Convert radians to degrees."""
+        return math.degrees(x)
+
+    @staticmethod
+    def radians(x: float) -> float:
+        """Convert degrees to radians."""
+        return math.radians(x)
+
+    @staticmethod
+    def copysign(x: float, y: float) -> float:
+        """Return x with sign of y."""
+        return math.copysign(x, y)
+
+    @staticmethod
+    def fmod(x: float, y: float) -> float:
+        """Floating point remainder of x/y."""
+        return math.fmod(x, y)
+
+    @staticmethod
+    def modf(x: float) -> tuple:
+        """Return fractional and integer parts."""
+        return math.modf(x)
+
+    @staticmethod
+    def isnan(x: float) -> bool:
+        """Check if x is NaN."""
+        return math.isnan(x)
+
+    @staticmethod
+    def isinf(x: float) -> bool:
+        """Check if x is infinite."""
+        return math.isinf(x)
+
+    @staticmethod
+    def isfinite(x: float) -> bool:
+        """Check if x is finite."""
+        return math.isfinite(x)
+
+    # Statistics functions
+    @staticmethod
+    def sum(numbers: List[float]) -> float:
+        """Sum of numbers."""
+        return sum(numbers)
+
+    @staticmethod
+    def mean(numbers: List[float]) -> float:
+        """Arithmetic mean."""
+        return sum(numbers) / len(numbers) if numbers else 0
+
+    @staticmethod
+    def median(numbers: List[float]) -> float:
+        """Median value."""
+        sorted_nums = sorted(numbers)
+        n = len(sorted_nums)
+        if n == 0:
+            return 0
+        mid = n // 2
+        if n % 2 == 0:
+            return (sorted_nums[mid - 1] + sorted_nums[mid]) / 2
+        return sorted_nums[mid]
+
+    @staticmethod
+    def mode(numbers: List[float]) -> float:
+        """Most common value."""
+        if not numbers:
+            return 0
+        from collections import Counter
+        return Counter(numbers).most_common(1)[0][0]
+
+    @staticmethod
+    def variance(numbers: List[float]) -> float:
+        """Population variance."""
+        if not numbers:
+            return 0
+        m = MathModule.mean(numbers)
+        return sum((x - m) ** 2 for x in numbers) / len(numbers)
+
+    @staticmethod
+    def stdev(numbers: List[float]) -> float:
+        """Population standard deviation."""
+        return math.sqrt(MathModule.variance(numbers))
+
+    @staticmethod
+    def min(numbers: List[float]) -> float:
+        """Minimum value."""
+        return min(numbers) if numbers else 0
+
+    @staticmethod
+    def max(numbers: List[float]) -> float:
+        """Maximum value."""
+        return max(numbers) if numbers else 0
+
+    @staticmethod
+    def clamp(x: float, min_val: float, max_val: float) -> float:
+        """Clamp x between min and max."""
+        return max(min_val, min(max_val, x))
+
+    @staticmethod
+    def lerp(a: float, b: float, t: float) -> float:
+        """Linear interpolation between a and b."""
+        return a + (b - a) * t
+
+    # Random functions
+    @staticmethod
+    def random() -> float:
+        """Random float in [0, 1)."""
+        return random.random()
+
+    @staticmethod
+    def randint(a: int, b: int) -> int:
+        """Random integer in [a, b]."""
+        return random.randint(a, b)
+
+    @staticmethod
+    def randrange(start: int, stop: int = None, step: int = 1) -> int:
+        """Random integer from range."""
+        if stop is None:
+            return random.randrange(start)
+        return random.randrange(start, stop, step)
+
+    @staticmethod
+    def choice(seq: List) -> any:
+        """Random element from sequence."""
+        return random.choice(seq) if seq else None
+
+    @staticmethod
+    def shuffle(seq: List) -> List:
+        """Shuffle sequence (returns new list)."""
+        result = seq.copy()
+        random.shuffle(result)
+        return result
+
+
+# Export all functions and constants
+PI = MathModule.PI
+E = MathModule.E
+TAU = MathModule.TAU
+INF = MathModule.INF
+NAN = MathModule.NAN
+sin = MathModule.sin
+cos = MathModule.cos
+tan = MathModule.tan
+asin = MathModule.asin
+acos = MathModule.acos
+atan = MathModule.atan
+atan2 = MathModule.atan2
+sinh = MathModule.sinh
+cosh = MathModule.cosh
+tanh = MathModule.tanh
+asinh = MathModule.asinh
+acosh = MathModule.acosh
+atanh = MathModule.atanh
+exp = MathModule.exp
+log = MathModule.log
+log10 = MathModule.log10
+log2 = MathModule.log2
+log1p = MathModule.log1p
+pow = MathModule.pow
+sqrt = MathModule.sqrt
+cbrt = MathModule.cbrt
+ceil = MathModule.ceil
+floor = MathModule.floor
+trunc = MathModule.trunc
+round = MathModule.round
+abs = MathModule.abs
+factorial = MathModule.factorial
+gcd = MathModule.gcd
+lcm = MathModule.lcm
+degrees = MathModule.degrees
+radians = MathModule.radians
+copysign = MathModule.copysign
+fmod = MathModule.fmod
+modf = MathModule.modf
+isnan = MathModule.isnan
+isinf = MathModule.isinf
+isfinite = MathModule.isfinite
+sum = MathModule.sum
+mean = MathModule.mean
+median = MathModule.median
+mode = MathModule.mode
+variance = MathModule.variance
+stdev = MathModule.stdev
+min = MathModule.min
+max = MathModule.max
+clamp = MathModule.clamp
+lerp = MathModule.lerp
+random = MathModule.random
+randint = MathModule.randint
+randrange = MathModule.randrange
+choice = MathModule.choice
+shuffle = MathModule.shuffle

package/src/zexus/stdlib/os_module.py

@@ -0,0 +1,265 @@
+"""OS module for Zexus standard library."""
+
+import os
+import sys
+import platform
+import subprocess
+from typing import Dict, List, Any
+
+
+class OSModule:
+    """Provides OS-specific operations."""
+
+    @staticmethod
+    def name() -> str:
+        """Get OS name."""
+        return os.name
+
+    @staticmethod
+    def platform_system() -> str:
+        """Get platform system (Linux, Windows, Darwin, etc.)."""
+        return platform.system()
+
+    @staticmethod
+    def platform_release() -> str:
+        """Get platform release version."""
+        return platform.release()
+
+    @staticmethod
+    def platform_version() -> str:
+        """Get platform version."""
+        return platform.version()
+
+    @staticmethod
+    def platform_machine() -> str:
+        """Get machine type."""
+        return platform.machine()
+
+    @staticmethod
+    def platform_processor() -> str:
+        """Get processor name."""
+        return platform.processor()
+
+    @staticmethod
+    def python_version() -> str:
+        """Get Python version."""
+        return platform.python_version()
+
+    @staticmethod
+    def getcwd() -> str:
+        """Get current working directory."""
+        return os.getcwd()
+
+    @staticmethod
+    def chdir(path: str) -> None:
+        """Change current working directory."""
+        os.chdir(path)
+
+    @staticmethod
+    def getenv(name: str, default: str = "") -> str:
+        """Get environment variable."""
+        return os.getenv(name, default)
+
+    @staticmethod
+    def setenv(name: str, value: str) -> None:
+        """Set environment variable."""
+        os.environ[name] = value
+
+    @staticmethod
+    def unsetenv(name: str) -> None:
+        """Unset environment variable."""
+        if name in os.environ:
+            del os.environ[name]
+
+    @staticmethod
+    def listenv() -> Dict[str, str]:
+        """List all environment variables."""
+        return dict(os.environ)
+
+    @staticmethod
+    def get_home_dir() -> str:
+        """Get user home directory."""
+        return os.path.expanduser("~")
+
+    @staticmethod
+    def get_temp_dir() -> str:
+        """Get temporary directory."""
+        import tempfile
+        return tempfile.gettempdir()
+
+    @staticmethod
+    def get_username() -> str:
+        """Get current username."""
+        return os.getlogin() if hasattr(os, 'getlogin') else os.getenv('USER', os.getenv('USERNAME', 'unknown'))
+
+    @staticmethod
+    def get_hostname() -> str:
+        """Get hostname."""
+        return platform.node()
+
+    @staticmethod
+    def get_pid() -> int:
+        """Get current process ID."""
+        return os.getpid()
+
+    @staticmethod
+    def get_ppid() -> int:
+        """Get parent process ID."""
+        return os.getppid()
+
+    @staticmethod
+    def cpu_count() -> int:
+        """Get number of CPUs."""
+        return os.cpu_count() or 1
+
+    @staticmethod
+    def execute(command: str, shell: bool = True, capture_output: bool = True) -> Dict[str, Any]:
+        """Execute shell command."""
+        try:
+            result = subprocess.run(
+                command,
+                shell=shell,
+                capture_output=capture_output,
+                text=True,
+                timeout=30
+            )
+            return {
+                'returncode': result.returncode,
+                'stdout': result.stdout if capture_output else '',
+                'stderr': result.stderr if capture_output else '',
+                'success': result.returncode == 0
+            }
+        except subprocess.TimeoutExpired:
+            return {
+                'returncode': -1,
+                'stdout': '',
+                'stderr': 'Command timed out',
+                'success': False
+            }
+        except Exception as e:
+            return {
+                'returncode': -1,
+                'stdout': '',
+                'stderr': str(e),
+                'success': False
+            }
+
+    @staticmethod
+    def path_join(*parts: str) -> str:
+        """Join path components."""
+        return os.path.join(*parts)
+
+    @staticmethod
+    def path_split(path: str) -> tuple:
+        """Split path into directory and file."""
+        return os.path.split(path)
+
+    @staticmethod
+    def path_dirname(path: str) -> str:
+        """Get directory name from path."""
+        return os.path.dirname(path)
+
+    @staticmethod
+    def path_basename(path: str) -> str:
+        """Get base name from path."""
+        return os.path.basename(path)
+
+    @staticmethod
+    def path_exists(path: str) -> bool:
+        """Check if path exists."""
+        return os.path.exists(path)
+
+    @staticmethod
+    def path_isfile(path: str) -> bool:
+        """Check if path is a file."""
+        return os.path.isfile(path)
+
+    @staticmethod
+    def path_isdir(path: str) -> bool:
+        """Check if path is a directory."""
+        return os.path.isdir(path)
+
+    @staticmethod
+    def path_abspath(path: str) -> str:
+        """Get absolute path."""
+        return os.path.abspath(path)
+
+    @staticmethod
+    def path_realpath(path: str) -> str:
+        """Get real path (resolving symlinks)."""
+        return os.path.realpath(path)
+
+    @staticmethod
+    def get_file_size(path: str) -> int:
+        """Get file size in bytes."""
+        return os.path.getsize(path)
+
+    @staticmethod
+    def get_file_mtime(path: str) -> float:
+        """Get file modification time."""
+        return os.path.getmtime(path)
+
+    @staticmethod
+    def get_file_atime(path: str) -> float:
+        """Get file access time."""
+        return os.path.getatime(path)
+
+    @staticmethod
+    def get_file_ctime(path: str) -> float:
+        """Get file creation time."""
+        return os.path.getctime(path)
+
+    @staticmethod
+    def get_path_separator() -> str:
+        """Get path separator for current OS."""
+        return os.sep
+
+    @staticmethod
+    def get_path_delimiter() -> str:
+        """Get path delimiter for current OS."""
+        return os.pathsep
+
+    @staticmethod
+    def get_line_separator() -> str:
+        """Get line separator for current OS."""
+        return os.linesep
+
+
+# Export functions for easy access
+name = OSModule.name
+platform_system = OSModule.platform_system
+platform_release = OSModule.platform_release
+platform_version = OSModule.platform_version
+platform_machine = OSModule.platform_machine
+platform_processor = OSModule.platform_processor
+python_version = OSModule.python_version
+getcwd = OSModule.getcwd
+chdir = OSModule.chdir
+getenv = OSModule.getenv
+setenv = OSModule.setenv
+unsetenv = OSModule.unsetenv
+listenv = OSModule.listenv
+get_home_dir = OSModule.get_home_dir
+get_temp_dir = OSModule.get_temp_dir
+get_username = OSModule.get_username
+get_hostname = OSModule.get_hostname
+get_pid = OSModule.get_pid
+get_ppid = OSModule.get_ppid
+cpu_count = OSModule.cpu_count
+execute = OSModule.execute
+path_join = OSModule.path_join
+path_split = OSModule.path_split
+path_dirname = OSModule.path_dirname
+path_basename = OSModule.path_basename
+path_exists = OSModule.path_exists
+path_isfile = OSModule.path_isfile
+path_isdir = OSModule.path_isdir
+path_abspath = OSModule.path_abspath
+path_realpath = OSModule.path_realpath
+get_file_size = OSModule.get_file_size
+get_file_mtime = OSModule.get_file_mtime
+get_file_atime = OSModule.get_file_atime
+get_file_ctime = OSModule.get_file_ctime
+get_path_separator = OSModule.get_path_separator
+get_path_delimiter = OSModule.get_path_delimiter
+get_line_separator = OSModule.get_line_separator