psr-factory 5.0.0b16__py3-none-win_amd64.whl → 5.0.0b67__py3-none-win_amd64.whl

psr/execqueue/client.py

@@ -28,12 +28,23 @@ def upload_case_file(zip_path, server_url):
         print("Upload failed:", response.text)
         return None
 
+def run_module(case_id: str, module_name: str, server_url: str) -> Optional[str]:
+    """Add a module to the execution queue. Returns the execution id."""
+    data = {"case_id": case_id, "module_name": module_name}
+    response = requests.post(f"{server_url}/run_module",data=data)
+
+    if response.status_code == 200:
+        print("Added to execution queue successfully!")
+        print("Execution ID:", response.json().get('execution_id'))
+        return response.json().get('execution_id')
+    else:
+        print("Module enqueue failed:", response.status_code, response.text)
+        return None
 
 def run_case(case_id: str, server_url: str, cloud_execution: bool = False) -> Optional[str]:
     """Add a case to the execution queue. For server-local run,
     returns the execution id. For cloud run, returns the cloud upload id."""
-    data = {"case_id": case_id,'cloud_execution': cloud_execution}
-    response = requests.post(f"{server_url}/run",data=data)
+    response = requests.post(f"{server_url}/run" , params={'cloud_execution': cloud_execution})
 
     if response.status_code == 200:
         if not cloud_execution:
@@ -45,7 +56,20 @@ def run_case(case_id: str, server_url: str, cloud_execution: bool = False) -> Op
             print("Cloud upload ID:", response.json().get('cloud_upload_id'))
             return response.json().get('cloud_upload_id')
     else:
-        print("Upload failed:", response.text)
+        print("Run case failed:", response.status_code, response.text)
+        return None
+
+
+def get_module_log(case_id: str, server_url: str, module_name: Optional[str] = None) -> Optional[str]:
+    """Fetch the content of a module's fixed log file. If module_name is None, returns last module run log."""
+    params = {}
+    if module_name:
+        params['module'] = module_name
+    response = requests.get(f"{server_url}/module_log/{case_id}", params=params)
+    if response.status_code == 200:
+        return response.text
+    else:
+        print("Fetch module log failed:", response.text)
         return None
 
 
@@ -53,8 +77,7 @@ def upload_and_run_file(zip_path: str, server_url: str, cloud_execution: bool =
     """Upload a zip file to the server."""
     with open(zip_path, 'rb') as f:
         files = {'file': (os.path.basename(zip_path), f)}
-        data = {'cloud_execution': cloud_execution}
-        response = requests.post(f"{server_url}/upload_and_run", files=files, data=data)
+        response = requests.post(f"{server_url}/upload_and_run", files=files , params={'cloud_execution': cloud_execution} )
 
     if response.status_code == 200:
         print("Upload successful! Waiting for execution.")
@@ -70,17 +93,16 @@ def upload_and_run_file(zip_path: str, server_url: str, cloud_execution: bool =
         return None
 
 
-def get_execution_status(execution_id: str, server_url: str, cloud_execution: bool = False, return_status_id: bool = False) -> Tuple[bool, dict]:
+def get_execution_status(execution_id: str, server_url: str, cloud_execution: bool = False) -> Optional[tuple[int, str]]:
     """Get the status of an execution."""
-    data = {'cloud_execution': cloud_execution, 'return_status_id': return_status_id}
-    response = requests.get(f"{server_url}/status/{execution_id}", data=data)
+    print("Getting status for execution ID:", execution_id)
+    response = requests.get(f"{server_url}/status/{execution_id}", params={'cloud_execution': cloud_execution})
     result = response.status_code == 200
-    return result, response.json()
-
+    return response.json().get('status_id'), response.json().get('status_msg') if result else None
 
 def get_results(execution_id, server_url, cloud_execution=False) -> Optional[List[str]]:
     """Download the results of an execution."""
-    response = requests.get(f"{server_url}/results/{execution_id}", data={'cloud_execution': cloud_execution})
+    response = requests.get(f"{server_url}/results/{execution_id}", params={'cloud_execution': cloud_execution})
 
     if response.status_code == 200:
         print("Results downloaded successfully!")
@@ -88,14 +110,13 @@ def get_results(execution_id, server_url, cloud_execution=False) -> Optional[Lis
         print("Files:", files)
         return files
     else:
-        print("Download failed:", response.text)
+        print("Results download failed:", response.text)
         return None
 
 
 def download_execution_file(execution_id: str, server_url: str, file: str, download_path: str, cloud_execution: bool = False):
     """Download the results of an execution."""
-    data = {'cloud_execution': cloud_execution}
-    response = requests.get(f"{server_url}/results/{execution_id}/{file}", data=data)
+    response = requests.get(f"{server_url}/results/{execution_id}/{file}", params={'cloud_execution': cloud_execution})
 
     # TODO: add validation for download_path existence.
     if response.status_code == 200:

psr/execqueue/config.py

@@ -4,6 +4,7 @@ import tomllib
 __version__ = "0.3.0"
 _app_name = "PSR Factory ExecQueue"
 DEFAULT_PORT = 5000
+DEFAULT_HOST = "127.0.0.1"
 FLASK_DEBUG = False
 _SETTINGS_FILE_PATH = "server_settings.toml"
 
@@ -42,3 +43,10 @@ CLOUD_RESULTS_FOLDER = os.path.join(STORAGE_PATH, 'cloud_results')
 # Where temporary extracted case files will be stored
 TEMPORARY_UPLOAD_FOLDER = os.path.join(STORAGE_PATH, 'tmp')
 
+# Optional: modules configuration
+# Expected format in server_settings.toml:
+# [modules.<name>]
+# command = "python some_script.py --case \"{case_path}\""
+# log_file = "<optional fixed log file name>"
+MODULES = settings.get("modules", {})
+

psr/execqueue/db.py

@@ -24,6 +24,7 @@ class CloudStatus(Enum):
     FINISHED = 3
     ERROR = 4
     RESULTS_AVAILABLE = 5
+    LOGS_AVAILABLE_ERROR = 6
 
 
 DB_NAME = "app.db"
@@ -61,7 +62,10 @@ class LocalExecution(Base):
     case_id = Column(String(26), ForeignKey('cases.case_id'))
     start_time = Column(TIMESTAMP, default=datetime.datetime.utcnow)
     finish_time = Column(TIMESTAMP)
-    status = Column(Integer, default=CloudStatus.RUNNING.value)
+    status = Column(Integer, default=LOCAL_EXECUTION_RUNNING)
+    # Module-related fields
+    is_module = Column(Integer, default=0)  # 0 = no, 1 = yes
+    module = Column(String(128))  # optional module name
 
     case = relationship("Case", back_populates="local_executions")
 
@@ -102,6 +106,23 @@ def initialize():
     if _create_db:
         Base.metadata.create_all(engine)
         _first_time_setup(session)
+    else:
+        # Basic migration: add columns if missing
+        # Note: SQLite supports limited ALTERs; use simple try/except for idempotency
+        from sqlalchemy import inspect
+        inspector = inspect(engine)
+        cols = {c['name'] for c in inspector.get_columns('local_executions')}
+        with engine.connect() as conn:
+            if 'is_module' not in cols:
+                try:
+                    conn.execute("ALTER TABLE local_executions ADD COLUMN is_module INTEGER DEFAULT 0")
+                except Exception:
+                    pass
+            if 'module' not in cols:
+                try:
+                    conn.execute("ALTER TABLE local_executions ADD COLUMN module VARCHAR(128)")
+                except Exception:
+                    pass
 
     return session, engine
 
@@ -126,12 +147,15 @@ def register_case(session, case_id, checksum):
     return case
 
 
-def register_local_execution(session, case_id: str, execution_id: str):
+def register_local_execution(session, case_id: str, execution_id: str, *, is_module: int = 0, module: Optional[str] = None):
     case = session.query(Case).filter(Case.case_id == case_id).first()
-    local_execution = LocalExecution(execution_id=execution_id,
-                                     case_id=case_id,
-                                     start_time=datetime.datetime.utcnow()
-                                     )
+    local_execution = LocalExecution(
+        execution_id=execution_id,
+        case_id=case_id,
+        start_time=datetime.datetime.utcnow(),
+        is_module=is_module,
+        module=module,
+    )
     case.local_executions.append(local_execution)
     session.commit()
     return local_execution
@@ -142,7 +166,7 @@ def get_case_id_from_execution_id(session, execution_id: str) -> Optional[str]:
     return local_execution.case_id if local_execution else None
 
 
-def update_local_execution_status(session, execution_id: str, status: int):
+def update_local_execution_status(session, execution_id: str, status: int) -> bool:
     local_execution = session.query(LocalExecution).filter(LocalExecution.execution_id == execution_id).first()
     if local_execution:
         if status not in [LOCAL_EXECUTION_FINISHED, LOCAL_EXECUTION_ERROR,
@@ -153,21 +177,60 @@ def update_local_execution_status(session, execution_id: str, status: int):
             local_execution.finish_time = datetime.datetime.utcnow()
         session.commit()
         return True
+    return True
 
-def update_cloud_execution_status(session, repository_id: int, status: int):
+
+def update_cloud_execution_status(session, repository_id: int, status: int) -> bool:
     cloud_execution = session.query(CloudExecution).filter(CloudExecution.repository_id == repository_id).first()
     if cloud_execution:
-        if status not in CloudStatus:
+        if CloudStatus(status) not in CloudStatus:
             raise ValueError("Wrong status for update.")
         cloud_execution.status = status
         session.commit()
         return True
-    
+    return False
+
+
 def get_local_execution_status(session, execution_id: str) -> Optional[int]:
     local_execution = session.query(LocalExecution).filter(LocalExecution.execution_id == execution_id).first()
     return local_execution.status if local_execution else None
 
 
+def any_running_modules_for_case(session, case_id: str) -> bool:
+    return session.query(LocalExecution).filter(
+        LocalExecution.case_id == case_id,
+        LocalExecution.is_module == 1,
+        LocalExecution.status == LOCAL_EXECUTION_RUNNING
+    ).count() > 0
+
+
+def any_failed_modules_for_case(session, case_id: str) -> bool:
+    return session.query(LocalExecution).filter(
+        LocalExecution.case_id == case_id,
+        LocalExecution.is_module == 1,
+        LocalExecution.status == LOCAL_EXECUTION_ERROR
+    ).count() > 0
+
+
+def last_module_execution_for_case(session, case_id: str, module: Optional[str] = None) -> Optional[LocalExecution]:
+    q = session.query(LocalExecution).filter(
+        LocalExecution.case_id == case_id,
+        LocalExecution.is_module == 1
+    )
+    if module:
+        q = q.filter(LocalExecution.module == module)
+    return q.order_by(LocalExecution.start_time.desc()).first()
+
+def get_distinct_module_names_for_case(session, case_id: str) -> List[str]:
+    rows = session.query(LocalExecution.module).filter(
+        LocalExecution.case_id == case_id,
+        LocalExecution.is_module == 1,
+        LocalExecution.module.isnot(None)
+    ).distinct().all()
+    # rows is a list of tuples [(module,), ...]
+    return [r[0] for r in rows if r and r[0]]
+
+
 def register_cloud_upload(session, case_id: str, cloud_upload_id: str):
     case = session.query(Case).filter(Case.case_id == case_id).first()
     cloud_upload = CloudUpload(cloud_upload_id=cloud_upload_id,
@@ -217,4 +280,7 @@ def get_cloud_execution_status(session, repository_id: int) -> Optional[int]:
     return cloud_execution.status if cloud_execution else None
 
 def get_cloud_finished_executions(session) -> List[CloudExecution]:
-    return session.query(CloudExecution).filter(CloudExecution.status == CloudStatus.FINISHED.value).all()
+    return session.query(CloudExecution).filter(CloudExecution.status == CloudStatus.FINISHED.value).all()
+
+def get_cloud_failed_executions(session) -> List[CloudExecution]:
+    return session.query(CloudExecution).filter(CloudExecution.status == CloudStatus.ERROR.value).all()