physicsworks 1.0.0__py3-none-any.whl

physicsworks-1.0.0.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: physicsworks
+Version: 1.0.0
+Summary: PhysicsWorks Python Runner - Simulation execution and post-processing framework
+Author: PhysicsWorks
+Author-email: contact@physicsworks.io
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Requires-Dist: setuptools
+Requires-Dist: packaging
+Requires-Dist: GPUtil
+Requires-Dist: numpy
+Requires-Dist: psutil
+Requires-Dist: python-slugify
+Requires-Dist: PyYAML
+Requires-Dist: requests
+Requires-Dist: text-unidecode
+Requires-Dist: urllib3
+Requires-Dist: watchdog
+Requires-Dist: Pillow
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

physicsworks-1.0.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+physicsworks_python/__init__.py,sha256=DbUh10nyKqpqaezaWeWiC8CfzeIV7zXly5bWgpYKgm0,28
+physicsworks_python/greet.py,sha256=Mcwty1YrbkMK7pyBUEW1ql3DZil6-SOCCZKvVzMU2jQ,61
+physicsworks_python/threejs.py,sha256=3d-lZ_tc_thWz8Wg6V7um5nwru18B_poTkzIWCAKcmM,366
+physicsworks_python/events/Geometry.py,sha256=PgkCSrprcaZcwCr7oiYUS28IaaC3pBp--Uw-oivqMGU,330
+physicsworks_python/events/Mesh.py,sha256=AO5_DtRFcfpapkyo0qQUfPLfosMvCdZvfmYRUuwPs_Q,116
+physicsworks_python/events/__init__.py,sha256=EtCn2KXIpTMShKtPHZcphZ4VBnEt_H_018RM9z4yJuU,226
+physicsworks_python/nats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physicsworks_python/nats/listener.py,sha256=npnN8kyZ1LcgWT1GcWl_ug48OJJ50GS6eY8fg2Xgkd4,904
+physicsworks_python/nats/publisher.py,sha256=SlB4jqF3k1iMkzta_YIDAwGRogkebQK7QuyFxPvip4c,438
+physicsworks_python/runner/__init__.py,sha256=e902zSwHyukJPws8kqMnLxDb3kP9zewGylLnQTJghW8,1111
+physicsworks_python/runner/config.py,sha256=6XeEP79prjUOZ4f-lC0-bUXS4rSJ0zxY0ay8wB4FtEw,1663
+physicsworks_python/runner/core.py,sha256=YsuMEw4fq5ro2Srb-CiMr3DWL6paeo87oRAppok8k0E,13235
+physicsworks_python/runner/executor.py,sha256=epYUU-AWltC_QIBTZla9ySw-zbSyD-9rmI9YVbv8BRc,22904
+physicsworks_python/runner/interface.py,sha256=3KrU6lqWayMkI8QK4ECEuG9nt2TjmXPZnGnqMg-W2m8,1158
+physicsworks_python/runner/logger.py,sha256=i8GRWB1d3kSjnBGa0pmg0CAqhS2wDbjYMpDD4oc1bcM,1000
+physicsworks_python/runner/server.py,sha256=2Lu_c0Mo3yl8eo98xL3lrpJcWjbv1VbemfvYcnkUTtc,10309
+physicsworks_python/runner/template.py,sha256=C6L5SJkxtIroHjcifdZkTH4LKlAWEFt9eV4zuG0nK2M,12180
+physicsworks_python/runner/utils.py,sha256=jSfSbjFZI6MhR7zMXfDVKfTWsmNDxBQAZBnmd6INkRY,8467
+physicsworks_python/runner/watcher.py,sha256=cXbRYg47V8TIvR5zz2IOTe12auSfvfqhoKskTlOD2O4,14417
+physicsworks_python/wrappers/MongoClientWrapper.py,sha256=5UGiZzQXz-urp_LplRToYLbmtCXmYgrvc_A8O2yMGyg,547
+physicsworks_python/wrappers/NatsClientWrapper.py,sha256=KfybP9-Baana3j4ESOCSou691kWNIXbcUR6HVFL0Nkc,1452
+physicsworks_python/wrappers/SocketIOClientWrapper.py,sha256=P-UQt_8jAhgHm5mx9RxiincPSK_WwNUd2nEXb8Rw3BA,349
+physicsworks_python/wrappers/SocketIOServerWrapper.py,sha256=o86pVfwOleK-e5lhNHVRAwiWeG5l2Gq9xOsNstaDhko,241
+physicsworks_python/wrappers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+physicsworks-1.0.0.dist-info/METADATA,sha256=LYKaDp7HOtjqIBdF_T2824vUR39qqtvTuMd_xpBjPKo,815
+physicsworks-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+physicsworks-1.0.0.dist-info/top_level.txt,sha256=CXso4CWH4hDi-4UARANfVAUrfYc5kRAYlppQIJbr2Aw,20
+physicsworks-1.0.0.dist-info/RECORD,,

physicsworks-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

physicsworks-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+physicsworks_python

physicsworks_python/__init__.py

@@ -0,0 +1 @@
+from .greet import SayHello

physicsworks_python/events/Geometry.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class GeometrySubjects(Enum):
+  GeometryUploaded = 'geometry:uploaded'
+  GeometryParsed = 'geometry:parsed'
+  GeometryRemoved = 'geometry:removed'
+
+
+# class GeometryUploaded(Event):
+#   sub
+
+# GeometryUploaded = Event()
+# GeometryUploaded.subject = GeometrySubjects.GeometryUploaded
+# GeometryUploaded.data

physicsworks_python/events/Mesh.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class MeshSubjects(Enum):
+  MeshGenerated = 'mesh:generated'
+  MeshDeleted = 'mesh:deleted'

physicsworks_python/events/__init__.py

@@ -0,0 +1,11 @@
+# from enum import Enum
+
+# from .Geometry import GeometrySubjects
+# from .Mesh import MeshSubjects
+
+# class Subjects(GeometrySubjects, MeshSubjects, Enum):
+#   '''Test'''
+
+# class Event:
+#   subject: Subjects
+#   data: object

physicsworks_python/greet.py

@@ -0,0 +1,3 @@
+def SayHello():
+  print("Hello from MyPyPiPackage")
+  return

physicsworks_python/nats/listener.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+
+from stan.aio.client import Client as STAN
+from stan.aio.client import Msg
+
+
+class Listener(ABC):
+
+  def __init__(self, stan: STAN, subject: str, queueGroupName: str) -> None:
+    self.__client = stan
+
+    self._subject = subject
+    self._queueGroupName = queueGroupName
+
+  @abstractmethod
+  async def onMessage(self, msg: Msg) -> None:
+    print("Received a message (seq={}): {}".format(msg.seq, msg.data))
+
+    await self.__client.ack(msg)
+
+  # async def onError(ex):
+  #   print("NATS: An error occured", ex)
+
+  async def listen(self, ack_wait: int = 30) -> None:
+    await self.__client.subscribe(
+        subject=self._subject,
+        queue=self._queueGroupName,
+        deliver_all_available=True,
+        manual_acks=True,
+        ack_wait=ack_wait,
+        durable_name=self._queueGroupName,
+        cb=self.onMessage,
+        # error_cb=self.onError
+    )

physicsworks_python/nats/publisher.py

@@ -0,0 +1,15 @@
+import json
+from abc import ABC
+from stan.aio.client import Client as STAN
+
+
+class Publisher(ABC):
+
+  def __init__(self, client: STAN, subject: str) -> None:
+    self._client = client
+    self._subject = subject
+
+  async def publish(self, data):
+    bytes_data = json.dumps(data).encode('utf-8')
+    await self._client.publish(subject=self._subject, payload=bytes_data)
+    print(f'[EVENT ->] Event published to subject {self._subject}')

physicsworks_python/runner/__init__.py

@@ -0,0 +1,44 @@
+"""
+SPRIME Runner Package
+
+A comprehensive package for running physics simulations with remote and native support.
+Provides a clean, modular architecture for solver execution with debugging capabilities.
+"""
+
+from .core import UnifiedRunner
+from .template import (
+    load_run_inputs,
+    reconstruct_tree_from_run_inputs,
+    get_input_value_by_slug,
+    get_input_values_by_slug,
+    get_input_value_by_slugs,
+    get_input_values_by_slugs,
+    update_solver_progress,
+    add_to_simulation_results,
+    replace_placeholders_in_file,
+    pre_remote,
+    remote,
+    post_remote,
+    run_solver
+)
+
+__version__ = "1.0.0"
+__all__ = [
+  # Main runner class
+  "UnifiedRunner",
+  
+  # Template functions for solver scripts (all exported)
+  "load_run_inputs",
+  "reconstruct_tree_from_run_inputs",
+  "get_input_value_by_slug",
+  "get_input_values_by_slug",
+  "get_input_value_by_slugs",
+  "get_input_values_by_slugs",
+  "update_solver_progress",
+  "add_to_simulation_results",
+  "replace_placeholders_in_file",
+  "pre_remote",
+  "remote",
+  "post_remote",
+  "run_solver"
+]

physicsworks_python/runner/config.py

@@ -0,0 +1,68 @@
+"""
+Configuration and enums for the runner package.
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List, Optional, Any
+
+
+class ExecutionMode(Enum):
+  """Execution mode for the solver"""
+  REMOTE = "remote"
+  NATIVE = "native"
+
+
+class Stage(Enum):
+  """Available execution stages"""
+  START = "start"
+  INPUT = "input" 
+  DOWNLOAD = "download"
+  UPLOAD = "upload"
+  POSTPROCESS = "postprocess"
+
+
+@dataclass
+class Configuration:
+  """Configuration container for the wrapper"""
+  config_path: str
+  work_dir: str
+  inputs_path: str
+  outputs_path: str
+  downloads_path: str
+  raw_path: Optional[str] = None
+  debug_path: Optional[str] = None
+  scripts_path: Optional[str] = None
+  starting_stage: Stage = Stage.START
+  skip_stages: List[Stage] = None
+  debug_mode: bool = False
+  execution_mode: ExecutionMode = ExecutionMode.NATIVE
+  config: Dict[str, Any] = None
+
+  def __post_init__(self):
+    if self.skip_stages is None:
+      self.skip_stages = []
+
+
+class RuntimeAttributes:
+  """Runtime state tracking"""
+  def __init__(self):
+    self.status = ""
+    self.progress = 0
+    self.status_label = ""
+    self.log_paths = []
+    self.logs_status = {}
+    self.logs = {}
+    self.plots_paths = []
+    self.plots = {}
+    self.media_paths = []
+    self.media = {}
+    self.fields = {}
+    self.point_clouds = {}
+    self.output_files = []
+    self.filenames = {}
+    self.run_id = ""
+    self.compression = {"withCompression": False}
+    self.current_uploads = []
+    self.run_succeeded = False
+    self.aborted = False  # Flag to indicate abort was requested

physicsworks_python/runner/core.py

@@ -0,0 +1,357 @@
+"""
+Core runner implementation for the SPRIME runner package.
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+import traceback
+
+from .config import Configuration, RuntimeAttributes, Stage
+from .logger import DebugLogger
+from .server import ServerCommunicator
+from .watcher import FileSystemWatcher
+from .executor import StageExecutor
+from .interface import append_status, StepStatus
+
+
+class UnifiedRunner:
+  """Main runner class that orchestrates the execution"""
+  
+  def __init__(self, on_abort_callback=None):
+    self.config = None
+    self.runtime_attrs = RuntimeAttributes()
+    self.logger = DebugLogger()
+    self.server_comm = ServerCommunicator(self.runtime_attrs, self.logger)
+    self.watcher = None  # Will be initialized after config is loaded
+    self.executor = None
+    self.on_abort_callback = on_abort_callback
+    self.main_process = None  # Reference to running subprocess for abort handling
+  
+  def _parse_arguments(self, args=None) -> Configuration:
+    """Parse command line arguments"""
+    parser = argparse.ArgumentParser(
+      description="Unified PhysicsWorks Solver Template Runner",
+      formatter_class=argparse.RawDescriptionHelpFormatter,
+      epilog="""
+Examples:
+  # Normal execution
+  python runner.py --configPath=config.json
+  
+  # Start from download stage
+  python runner.py --configPath=config.json --startingStage=download
+  
+  # Skip stages for debugging
+  python runner.py --configPath=config.json --skipStages=watch,upload
+  
+  # Debug mode with verbose logging
+  python runner.py --configPath=config.json --debugMode
+      """
+    )
+    
+    parser.add_argument(
+      "--configPath", 
+      required=True,
+      help="Path to the configuration JSON file"
+    )
+    
+    parser.add_argument(
+      "--startingStage", 
+      choices=[stage.value for stage in Stage],
+      default=Stage.START.value,
+      help="Starting stage for execution (default: start)"
+    )
+    
+    parser.add_argument(
+      "--skipStages",
+      help="Comma-separated list of stages to skip (e.g., watch,upload)"
+    )
+    
+    parser.add_argument(
+      "--debugMode",
+      action='store_true',
+      help="Enable debug mode with verbose logging"
+    )
+    
+    parsed_args = parser.parse_args(args)
+    
+    # Parse configuration file
+    try:
+      with open(parsed_args.configPath) as config_file:
+        config_dict = json.load(config_file)
+    except Exception as e:
+      print(f"Error loading configuration file: {e}")
+      sys.exit(1)
+    
+    # Parse skip stages
+    skip_stages = []
+    if parsed_args.skipStages:
+      skip_stage_names = [s.strip() for s in parsed_args.skipStages.split(',')]
+      for stage_name in skip_stage_names:
+        try:
+          skip_stages.append(Stage(stage_name))
+        except ValueError:
+          print(f"Warning: Unknown stage '{stage_name}' in skipStages")
+    
+    # Create configuration
+    work_dir = config_dict['workDir']
+    
+    config = Configuration(
+      config_path=parsed_args.configPath,
+      work_dir=work_dir,
+      inputs_path=os.path.join(work_dir, "inputs"),
+      outputs_path=os.path.join(work_dir, "outputs"),
+      downloads_path=os.path.join(work_dir, "inputs"),
+      raw_path=os.path.join(work_dir, "raw"),
+      debug_path=os.path.join(work_dir, "debug"),
+      scripts_path=os.path.join(work_dir, "scripts"),
+      starting_stage=Stage(parsed_args.startingStage),
+      skip_stages=skip_stages,
+      debug_mode=parsed_args.debugMode,
+      config=config_dict
+    )
+    
+    return config
+  
+  def run(self, args=None):
+    """Main execution method"""
+    try:
+      # 1. Initialize (parse arguments and create directories)
+      self.config = self._parse_arguments(args)
+      self._create_directories()
+      
+      self.logger = DebugLogger(self.config.debug_mode)
+      self.server_comm = ServerCommunicator(self.runtime_attrs, self.logger)
+      # Create watcher with reference to get main process for abort handling
+      self.watcher = FileSystemWatcher(
+        self.runtime_attrs, 
+        self.server_comm, 
+        self.logger, 
+        on_abort_callback=self.on_abort_callback,
+        main_process_ref=lambda: self.main_process
+      )
+      self.executor = StageExecutor(
+        self.config, self.runtime_attrs, self.server_comm, self.watcher, self.logger
+      )
+      
+      self.logger.info(f"Starting unified runner in {self.config.starting_stage.value} mode")
+      self.logger.debug(f"Work directory: {self.config.work_dir}")
+      
+      if self.config.skip_stages:
+        self.logger.info(f"Skipping stages: {[s.value for s in self.config.skip_stages]}")
+      
+      # Initialize status file
+      append_status(self.config.outputs_path, 0, "Initializing simulation", "initialization", StepStatus.RUNNING)
+      
+      # 2. Download inputs from server (0-10%)
+      append_status(self.config.outputs_path, 0, "Starting preprocessing", "preprocessing", StepStatus.RUNNING)
+      
+      if not self.executor.execute_stage(Stage.DOWNLOAD):
+        self.logger.error("Download stage failed")
+        self.server_comm.set_status("error", 0, "Failed at download")
+        append_status(self.config.outputs_path, 0, "Error in preprocessing: Download stage failed", "preprocessing", StepStatus.FAILED)
+        return False
+      
+      append_status(self.config.outputs_path, 10, "Preprocessing complete", "preprocessing", StepStatus.FINISHED)
+      
+      # 3. Start file watcher on a separate thread
+      self._start_file_watcher()
+      
+      # 4. Run the main.py script under scripts (10-90%)
+      append_status(self.config.outputs_path, 10, "Starting solver execution", "solver", StepStatus.RUNNING)
+      
+      if not self._run_main_script():
+        self.logger.error("Main script execution failed")
+        self.server_comm.set_status("error", 0, "Failed at script execution")
+        append_status(self.config.outputs_path, 0, "Error in solver: Main script execution failed", "solver", StepStatus.FAILED)
+        return False
+      
+      append_status(self.config.outputs_path, 90, "Solver execution complete", "solver", StepStatus.FINISHED)
+      
+      # Check if aborted before post-processing
+      if self.runtime_attrs.aborted:
+        self.logger.error("Execution aborted by user")
+        return False
+      
+      # 5. Post processing (90-100%)
+      append_status(self.config.outputs_path, 90, "Starting postprocessing", "postprocessing", StepStatus.RUNNING)
+      
+      if not self.executor.execute_stage(Stage.POSTPROCESS):
+        self.logger.error("Post-processing stage failed")
+        self.server_comm.set_status("error", 0, "Failed at post-processing")
+        append_status(self.config.outputs_path, 0, "Error in postprocessing: Post-processing stage failed", "postprocessing", StepStatus.FAILED)
+        return False
+      
+      append_status(self.config.outputs_path, 100, "Simulation completed successfully", "postprocessing", StepStatus.FINISHED)
+      
+      # Final status
+      append_status(self.config.outputs_path, 100, "Simulation completed successfully")
+      
+      self.logger.info("Runner execution completed successfully")
+      return True
+      
+    except KeyboardInterrupt:
+      self.logger.info("Execution interrupted by user")
+      self.server_comm.set_status("error", 0, "Interrupted by user")
+      return False
+    except Exception as e:
+      self.logger.error(f"Runner execution failed: {e}")
+      if self.config and self.config.debug_mode:
+        traceback.print_exc()
+      self.server_comm.set_status("error", 0, "error")
+      return False
+    finally:
+      # Stop file watcher
+      if hasattr(self, 'watcher'):
+        self.watcher.stop_watching()
+  
+  def _create_directories(self):
+    """Create required directories: debug, inputs, outputs, raw, scripts and outputs subdirectories"""
+    directories = [
+      self.config.debug_path,
+      self.config.inputs_path,
+      self.config.outputs_path,
+      self.config.raw_path,
+      self.config.scripts_path
+    ]
+    
+    # Create output subdirectories
+    output_subdirs = ["files", "graphics", "logs", "media", "plots"]
+    for subdir in output_subdirs:
+      directories.append(os.path.join(self.config.outputs_path, subdir))
+    
+    for directory in directories:
+      try:
+        os.makedirs(directory, exist_ok=True)
+        self.logger.debug(f"Created directory: {directory}")
+      except Exception as e:
+        self.logger.error(f"Failed to create directory {directory}: {e}")
+        raise
+  
+  def _start_file_watcher(self):
+    """Start file watcher on a separate thread for outputs monitoring and config.json abort signals"""
+    try:
+      # Watch outputs directory for state.txt changes and file uploads
+      watch_paths = [
+        self.config.outputs_path,
+        os.path.join(self.config.outputs_path, "logs"),
+        os.path.join(self.config.outputs_path, "media"), 
+        os.path.join(self.config.outputs_path, "plots")
+      ]
+      
+      # Also watch config directory for config.json changes (abort signals)
+      config_dir = os.path.dirname(self.config.config_path)
+      if config_dir and os.path.isdir(config_dir):
+        watch_paths.append(config_dir)
+        self.logger.debug(f"Watching config directory for abort signals: {config_dir}")
+      
+      self.watcher.start_watching(watch_paths)
+      self.logger.info("File watcher started on separate thread")
+      
+    except Exception as e:
+      self.logger.error(f"Failed to start file watcher: {e}")
+      raise
+  
+  def _run_main_script(self):
+    """Run the main.py script under scripts directory"""
+    try:
+      main_script_path = os.path.join(self.config.scripts_path, "main.py")
+      
+      if not os.path.exists(main_script_path):
+        self.logger.error(f"Main script not found at {main_script_path}")
+        return False
+      
+      self.logger.info(f"Executing main script: {main_script_path}")
+      
+      # Set environment variables for the script
+      # Convert all paths to use forward slashes for cross-platform compatibility
+      script_env = os.environ.copy()
+      script_env["PHYSICSWORKS_INPUTS_DIR"] = self.config.inputs_path.replace('\\', '/')
+      script_env["PHYSICSWORKS_OUTPUTS_DIR"] = self.config.outputs_path.replace('\\', '/')
+      script_env["PHYSICSWORKS_RAW_DIR"] = self.config.raw_path.replace('\\', '/')
+      script_env["PHYSICSWORKS_WORK_DIR"] = self.config.work_dir.replace('\\', '/')
+      script_env["PHYSICSWORKS_RUN_ID"] = self.runtime_attrs.run_id
+      
+      # Build command to run main.py with proper arguments
+      command = [
+        "python",
+        main_script_path,
+        f"--inputsPath={self.config.inputs_path}",
+        f"--outputsPath={self.config.outputs_path}",
+        f"--rawPath={self.config.raw_path}"
+      ]
+      
+      # Execute the main script with environment variables
+      import subprocess
+      self.main_process = subprocess.Popen(
+        command, 
+        cwd=self.config.scripts_path, 
+        stdout=subprocess.PIPE, 
+        stderr=subprocess.PIPE,
+        text=True,
+        env=script_env
+      )
+      
+      # Poll the process instead of blocking, checking for abort
+      while self.main_process.poll() is None:
+        # Check if abort was requested
+        if self.runtime_attrs.aborted:
+          self.logger.error("Main script execution was aborted")
+          self.main_process = None
+          return False
+        time.sleep(0.5)  # Check every 500ms
+      
+      # Process completed, get output
+      stdout, stderr = self.main_process.communicate()
+      result_code = self.main_process.returncode
+      self.main_process = None
+      
+      # Check if aborted during execution (redundant but safe)
+      if self.runtime_attrs.aborted:
+        self.logger.error("Main script execution was aborted")
+        return False
+      
+      # Create result object for compatibility
+      class Result:
+        def __init__(self, stdout, stderr, returncode):
+          self.stdout = stdout
+          self.stderr = stderr
+          self.returncode = returncode
+      
+      result = Result(stdout, stderr, result_code)
+      
+      # Write logs to debug/main.txt
+      log_file_path = os.path.join(self.config.debug_path, "main.txt")
+      try:
+        with open(log_file_path, 'w') as log_file:
+          log_file.write("=== STDOUT ===\n")
+          log_file.write(result.stdout)
+          log_file.write("\n=== STDERR ===\n")
+          log_file.write(result.stderr)
+        self.logger.debug(f"Main script logs written to {log_file_path}")
+      except Exception as log_error:
+        self.logger.error(f"Failed to write main script logs: {log_error}")
+      
+      if result.returncode == 0:
+        self.logger.info("Main script executed successfully")
+        self.runtime_attrs.run_succeeded = True
+        return True
+      else:
+        self.logger.error(f"Main script failed with exit code: {result.returncode}")
+        self.runtime_attrs.run_succeeded = False
+        return False
+        
+    except Exception as e:
+      self.logger.error(f"Error executing main script: {e}")
+      return False
+
+def main():
+  """Entry point for the runner"""
+  runner = UnifiedRunner()
+  success = runner.run()
+  sys.exit(0 if success else 1)
+
+if __name__ == "__main__":
+  main()