hyperstellar 0.1.24__tar.gz

hyperstellar-0.1.24/LICENSE

@@ -0,0 +1,27 @@
+<<<<<<< HEAD
+MIT License
+
+Copyright (c) 2024 desktop-hnrtra0\user
+=======
+MIT License
+
+Copyright (c) 2025 Void_unleashed
+>>>>>>> 3fd83288e1496a5a3d4c3e29bdef651eba07de35
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hyperstellar-0.1.24/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: hyperstellar
+Version: 0.1.24
+Summary: GPU-accelerated physics simulation engine
+Author-email: Aiden Jabari <Jabariaiden15@email.com>
+License: <<<<<<< HEAD
+        MIT License
+        
+        Copyright (c) 2024 desktop-hnrtra0\user
+        =======
+        MIT License
+        
+        Copyright (c) 2025 Void_unleashed
+        >>>>>>> 3fd83288e1496a5a3d4c3e29bdef651eba07de35
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Keywords: physics,simulation,gpu,opengl
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Hyperstellar
+### Write math Equations in python
+
+Buckle up, coz this isn't just another preset physics engine. Hyperstellar gives you the mathematical language to define *any* dynamical system, then GPU-accelerates it to thousands of frames per second. From orbital mechanics to fluid dynamics, if you can write the equation, you can simulate it.

hyperstellar-0.1.24/README.md

@@ -0,0 +1,4 @@
+# Hyperstellar
+### Write math Equations in python
+
+Buckle up, coz this isn't just another preset physics engine. Hyperstellar gives you the mathematical language to define *any* dynamical system, then GPU-accelerates it to thousands of frames per second. From orbital mechanics to fluid dynamics, if you can write the equation, you can simulate it.

hyperstellar-0.1.24/hyperstellar/src/hyperstellar/__init__.py

@@ -0,0 +1,88 @@
+# hyperstellar/src/hyperstellar/__init__.py
+import os
+import sys
+import platform
+from pathlib import Path
+
+__version__ = "0.1.0"
+
+# Platform detection
+system = platform.system().lower()
+arch = platform.machine().lower()
+
+if system == "windows" and ("amd64" in arch or "x86_64" in arch):
+    platform_dir = "windows-x64"
+    extension = ".pyd"
+    lib_name = "stellar.pyd"
+else:
+    raise ImportError(f"Unsupported platform: {system} {arch}")
+
+# Get the native module path
+module_dir = Path(__file__).parent / "_native" / platform_dir
+module_path = module_dir / lib_name
+
+if not module_path.exists():
+    raise ImportError(f"Native module not found: {module_path}")
+
+# On Windows, add DLL directory to PATH
+if system == "windows":
+    dll_dir = str(module_dir)
+    
+    # DEBUG: Print what we're doing
+    print(f"[DEBUG] Adding DLL directory: {dll_dir}")
+    
+    # CRITICAL FIX: Save the original PATH
+    original_path = os.environ.get('PATH', '')
+    
+    # Method 1: Add to PATH at the BEGINNING (highest priority)
+    # This must be done BEFORE any attempt to import
+    path_sep = ';'
+    os.environ['PATH'] = dll_dir + path_sep + original_path
+    print(f"[DEBUG] Added to PATH: {dll_dir}")
+    
+    # Method 2: Use AddDllDirectory for explicit loading
+    try:
+        import ctypes
+        # Clear any previous DLL directory cache
+        os.add_dll_directory(dll_dir)
+        print(f"[DEBUG] Used os.add_dll_directory")
+    except Exception as add_dll_error:
+        print(f"[DEBUG] os.add_dll_directory failed: {add_dll_error}")
+
+# Try to import the module
+try:
+    # First, clear stellar from sys.modules if it exists
+    sys.modules.pop('stellar', None)
+    
+    # CRITICAL: Add the module directory to sys.path temporarily
+    sys.path.insert(0, str(module_dir))
+    
+    # Import the module
+    import stellar as _stellar_module
+    
+    # Remove from sys.path
+    sys.path.pop(0)
+    
+    # Copy ALL public attributes to our module
+    for attr_name in dir(_stellar_module):
+        if not attr_name.startswith('__'):
+            globals()[attr_name] = getattr(_stellar_module, attr_name)
+    
+    # Also copy __all__ if it exists
+    if hasattr(_stellar_module, '__all__'):
+        __all__ = _stellar_module.__all__
+    
+    print(f"✓ hyperstellar loaded: {system} {arch}")
+    
+except ImportError as e:
+    # Provide detailed debug info
+    dll_files = list(module_dir.glob('*.dll'))
+    raise ImportError(
+        f"Failed to load native module: {e}\n"
+        f"Module path: {module_path}\n"
+        f"DLL directory: {module_dir}\n"
+        f"DLLs available: {[dll.name for dll in dll_files]}\n"
+        f"Current PATH: {os.environ.get('PATH', '')[:200]}..."
+    )
+except Exception as e:
+    raise ImportError(f"Unexpected error loading module: {e}")

hyperstellar-0.1.24/hyperstellar/src/hyperstellar/__init__.pyi

@@ -0,0 +1,267 @@
+# Type stubs for hyperstellar package
+import typing
+from typing import Any, List, Dict, Optional, Union, Callable
+
+class SkinType:
+    """Visual representation type for objects."""
+    CIRCLE: int
+    RECTANGLE: int
+    POLYGON: int
+
+class ConstraintType:
+    """Type of physics constraint."""
+    DISTANCE: int
+    BOUNDARY: int
+
+class ObjectState:
+    """Complete state of a physics object."""
+    x: float
+    y: float
+    vx: float
+    vy: float
+    mass: float
+    charge: float
+    rotation: float
+    angular_velocity: float
+    width: float
+    height: float
+    radius: float
+    polygon_sides: int
+    skin_type: SkinType
+    r: float
+    g: float
+    b: float
+    a: float
+    
+    def __init__(self) -> None: ...
+    def __repr__(self) -> str: ...
+
+class ObjectConfig:
+    """Configuration for creating objects in batch mode."""
+    x: float
+    y: float
+    vx: float
+    vy: float
+    mass: float
+    charge: float
+    rotation: float
+    angular_velocity: float
+    skin: SkinType
+    size: float
+    width: float
+    height: float
+    r: float
+    g: float
+    b: float
+    a: float
+    polygon_sides: int
+    equation: str
+    
+    def __init__(self) -> None: ...
+    def __repr__(self) -> str: ...
+
+class ConstraintConfig:
+    """Constraint configuration for batch mode."""
+    type: ConstraintType
+    target: int
+    param1: float
+    param2: float
+    param3: float
+    param4: float
+    
+    def __init__(self) -> None: ...
+
+class BatchConfig:
+    """Configuration for batch simulations."""
+    objects: List[ObjectConfig]
+    duration: float
+    dt: float
+    output_file: str
+    
+    def __init__(self) -> None: ...
+
+# NEW: Batch data structures
+class BatchGetData:
+    """Batch get data structure for fetching multiple objects at once."""
+    x: float
+    y: float
+    vx: float
+    vy: float
+    mass: float
+    charge: float
+    rotation: float
+    angular_velocity: float
+    width: float
+    height: float
+    radius: float
+    polygon_sides: int
+    skin_type: int
+    r: float
+    g: float
+    b: float
+    a: float
+    
+    def __init__(self) -> None: ...
+
+class BatchUpdateData:
+    """Batch update data structure for updating multiple objects at once."""
+    index: int
+    x: float
+    y: float
+    vx: float
+    vy: float
+    mass: float
+    charge: float
+    rotation: float
+    angular_velocity: float
+    width: float
+    height: float
+    r: float
+    g: float
+    b: float
+    a: float
+    
+    def __init__(self) -> None: ...
+
+class DistanceConstraint:
+    """Maintain distance between two objects."""
+    target_object: int
+    rest_length: float
+    stiffness: float
+    
+    def __init__(self, target_object: int = 0, rest_length: float = 5.0, stiffness: float = 100.0) -> None: ...
+    def __repr__(self) -> str: ...
+
+class BoundaryConstraint:
+    """Keep object within a rectangular boundary."""
+    min_x: float
+    max_x: float
+    min_y: float
+    max_y: float
+    
+    def __init__(self, min_x: float = -10.0, max_x: float = 10.0, min_y: float = -10.0, max_y: float = 10.0) -> None: ...
+    def __repr__(self) -> str: ...
+
+class Simulation:
+    """Main physics simulation class."""
+    
+    def __init__(self, 
+                 headless: bool = True, 
+                 width: int = 1280, 
+                 height: int = 720, 
+                 title: str = "Physics Simulation",
+                 enable_grid: bool = True) -> None: ...
+    
+    # Window management
+    def render(self) -> None: ...
+    def process_input(self) -> None: ...
+    def should_close(self) -> bool: ...
+    
+    # NEW: Grid control
+    def set_grid_enabled(self, enabled: bool) -> None: ...
+    def get_grid_enabled(self) -> bool: ...
+    
+    # Core simulation
+    def update(self, dt: float = 0.016) -> None: ...
+    
+    # Object management
+    def add_object(
+        self,
+        x: float = 0.0,
+        y: float = 0.0,
+        vx: float = 0.0,
+        vy: float = 0.0,
+        mass: float = 1.0,
+        charge: float = 0.0,
+        rotation: float = 0.0,
+        angular_velocity: float = 0.0,
+        skin: SkinType = SkinType.CIRCLE,
+        size: float = 0.3,
+        width: float = 0.5,
+        height: float = 0.3,
+        r: float = 1.0,
+        g: float = 1.0,
+        b: float = 1.0,
+        a: float = 1.0,
+        polygon_sides: int = 6
+    ) -> int: ...
+    
+    def update_object(
+        self,
+        index: int,
+        x: float, y: float,
+        vx: float, vy: float,
+        mass: float, charge: float,
+        rotation: float, angular_velocity: float,
+        width: float, height: float,
+        r: float, g: float, b: float, a: float
+    ) -> None: ...
+    
+    # NEW: Batch operations
+    def batch_get(self, indices: List[int]) -> List[BatchGetData]: ...
+    def batch_update(self, updates: List[BatchUpdateData]) -> None: ...
+    
+    def remove_object(self, index: int) -> None: ...
+    def object_count(self) -> int: ...
+    def get_object(self, index: int) -> ObjectState: ...
+    
+    # Convenience methods
+    def set_rotation(self, index: int, rotation: float) -> None: ...
+    def set_angular_velocity(self, index: int, angular_velocity: float) -> None: ...
+    def set_dimensions(self, index: int, width: float, height: float) -> None: ...
+    def set_radius(self, index: int, radius: float) -> None: ...
+    def get_rotation(self, index: int) -> float: ...
+    def get_angular_velocity(self, index: int) -> float: ...
+    
+    # Equations
+    def set_equation(self, object_index: int, equation_string: str) -> None: ...
+    
+    # Constraints
+    def add_distance_constraint(self, object_index: int, constraint: DistanceConstraint) -> None: ...
+    def add_boundary_constraint(self, object_index: int, constraint: BoundaryConstraint) -> None: ...
+    def clear_constraints(self, object_index: int) -> None: ...
+    def clear_all_constraints(self) -> None: ...
+    
+    # Batch processing
+    def run_batch(
+        self,
+        configs: List[BatchConfig],
+        callback: Optional[Callable[[int, List[ObjectState]], None]] = None
+    ) -> None: ...
+    
+    # Parameters
+    def set_parameter(self, name: str, value: float) -> None: ...
+    def get_parameter(self, name: str) -> float: ...
+    
+    # Simulation control
+    def set_paused(self, paused: bool) -> None: ...
+    def is_paused(self) -> bool: ...
+    
+    def update_shader_loading(self) -> None: ...
+    def are_all_shaders_ready(self) -> bool: ...
+    def get_shader_load_progress(self) -> float: ...
+    def get_shader_load_status(self) -> str: ...
+    
+    def reset(self) -> None: ...
+    def cleanup(self) -> None: ...
+    
+    # File I/O
+    def save_to_file(
+        self,
+        filename: str,
+        title: str = "",
+        author: str = "",
+        description: str = ""
+    ) -> None: ...
+    
+    def load_from_file(self, filename: str) -> None: ...
+    
+    # Properties
+    @property
+    def is_headless(self) -> bool: ...
+    
+    @property
+    def is_initialized(self) -> bool: ...
+
+# Module-level exports
+__version__: str