psr-factory 5.0.0b50__py3-none-win_amd64.whl → 5.0.0b52__py3-none-win_amd64.whl

psr/execqueue/client.py

@@ -28,6 +28,18 @@ 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,
@@ -45,7 +57,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
 
 

psr/execqueue/config.py

@@ -43,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

@@ -62,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")
 
@@ -103,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
 
@@ -127,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
@@ -168,6 +191,38 @@ 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()

psr/execqueue/server.py

@@ -1,10 +1,13 @@
 import hashlib
+import os
 import queue
 import shutil
 import sys
 import threading
 import time
 import zipfile
+import subprocess
+import shlex
 from dotenv import load_dotenv
 from flask import (
     Flask,
@@ -64,6 +67,104 @@ def run_local_case(execution_id: str, case_path: str):
     db.update_local_execution_status(session, execution_id, status)
 
 
+def _ensure_case_workdir(case_id: str) -> str:
+    """Ensure a working directory exists at uploads/<case_id> with extracted contents.
+    If it does not exist or is empty, extract the uploaded zip there.
+    Returns the absolute path to the working directory.
+    """
+    workdir = os.path.join(UPLOADS_FOLDER, case_id)
+    zip_upload_path = os.path.join(UPLOADS_FOLDER, f"{case_id}.zip")
+    os.makedirs(workdir, exist_ok=True)
+
+    # If directory is empty or looks incomplete, (re)extract
+    try:
+        if not os.listdir(workdir):
+            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
+                zip_ref.extractall(workdir)
+    except FileNotFoundError:
+        # If there's no zip, still return folder (may be pre-populated)
+        pass
+    return workdir
+
+
+def run_local_module(execution_id: str, case_id: str, module_name: str) -> int:
+    """Run a configured module locally inside the case's upload workdir.
+    Returns process return code (0=success, non-zero=failure).
+    Updates LocalExecution status accordingly.
+    """
+    global session
+    # Fetch module configuration
+    module_cfg = MODULES.get(module_name) if isinstance(MODULES, dict) else None
+    if not module_cfg or 'command' not in module_cfg:
+        print(f"Module '{module_name}' not configured.")
+        db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_ERROR)
+        return 1
+
+    workdir = _ensure_case_workdir(case_id)
+
+    # Build command and log file path
+    cmd_tmpl = module_cfg.get('command')
+    # Allow placeholders
+    cmd = cmd_tmpl.format(case_path=workdir, case_id=case_id, module=module_name)
+    log_name = module_cfg.get('log_file', f"module_{module_name}.log")
+    log_path = os.path.join(workdir, log_name)
+
+    print(f"Running module '{module_name}' for case {case_id} in {workdir}")
+    print(f"Command: {cmd}")
+
+    rc = 1
+    try:
+        # Prefer to run without shell to avoid platform-specific exit code mappings
+        # If the command starts with 'python' or references .py, build argv accordingly
+        argv = None
+        # Heuristic: if command contains .py, run with current Python executable
+        if '.py' in cmd:
+            parts = shlex.split(cmd)
+            # If the command already starts with python, use as-is; else prepend sys.executable
+            if parts[0].endswith('python') or parts[0].endswith('python.exe'):
+                argv = parts
+            else:
+                argv = [sys.executable] + parts
+        else:
+            argv = shlex.split(cmd)
+
+        with open(log_path, 'a', encoding='utf-8', errors='ignore') as logf:
+            proc = subprocess.Popen(
+                argv,
+                cwd=workdir,
+                stdout=logf,
+                stderr=logf,
+            )
+            rc = proc.wait()
+
+        # Now rc follows the subprocess return code semantics: 0 success, non-zero failure
+        status = db.LOCAL_EXECUTION_FINISHED if rc == 0 else db.LOCAL_EXECUTION_ERROR
+        db.update_local_execution_status(session, execution_id, status)
+    except Exception as e:
+        print(f"Error running module {module_name} for case {case_id}: {e}")
+        db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_ERROR)
+        rc = 1
+    return rc
+
+
+def _copy_tree(src: str, dst: str):
+    os.makedirs(dst, exist_ok=True)
+    for root, dirs, files in os.walk(src):
+        rel = os.path.relpath(root, src)
+        target_root = os.path.join(dst, rel) if rel != '.' else dst
+        os.makedirs(target_root, exist_ok=True)
+        for d in dirs:
+            os.makedirs(os.path.join(target_root, d), exist_ok=True)
+        for f in files:
+            s = os.path.join(root, f)
+            t = os.path.join(target_root, f)
+            try:
+                shutil.copy2(s, t)
+            except Exception:
+                # Best-effort copy; skip problematic files
+                pass
+
+
 def initialize_db():
     session, engine = db.initialize()
     return session
@@ -91,22 +192,59 @@ def run_cloud_case(execution_id: str, case_path: str):
 def process_local_execution_queue():
     global session
     while True:
-        execution_id, case_id = _execution_queue.get()
+        item = _execution_queue.get()
         try:
-            print(f"Processing {execution_id}...")
-            # Unzip the file
-            execution_extraction_path = os.path.join(LOCAL_RESULTS_FOLDER, execution_id)
-            os.makedirs(execution_extraction_path, exist_ok=True)
-
-            zip_upload_path = os.path.join(UPLOADS_FOLDER, case_id + ".zip")
-
-            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
-                zip_ref.extractall(execution_extraction_path)
-            # Run SDDP
-            run_local_case(execution_id, execution_extraction_path)
+            # Detect item type (backward compatibility for tuple)
+            if isinstance(item, dict) and item.get('type') == 'module':
+                execution_id = item['execution_id']
+                case_id = item['case_id']
+                module_name = item['module']
+                print(f"Processing module {module_name} for case {case_id} (exec {execution_id})...")
+                run_local_module(execution_id, case_id, module_name)
+            else:
+                if isinstance(item, (list, tuple)):
+                    execution_id, case_id = item
+                else:
+                    execution_id = item.get('execution_id')
+                    case_id = item.get('case_id')
+
+                print(f"Processing case execution {execution_id} for case {case_id}...")
+
+                # Wait for running modules to finish; abort if any failed
+                wait_loops = 0
+                while db.any_running_modules_for_case(session, case_id):
+                    print(f"Case {case_id} has running modules; waiting...")
+                    time.sleep(5)
+                    wait_loops += 1
+                    # Safety: avoid infinite wait in worker
+                    if wait_loops > 240:  # ~20 minutes
+                        break
+
+                # Check last execution per distinct module: if any last module execution failed, mark error
+                failing_modules = []
+                for mname in db.get_distinct_module_names_for_case(session, case_id):
+                    last = db.last_module_execution_for_case(session, case_id, mname)
+                    if last and last.status == db.LOCAL_EXECUTION_ERROR:
+                        failing_modules.append(mname)
+
+                if failing_modules:
+                    print(f"Case {case_id} has failed modules {failing_modules}; marking local execution {execution_id} as error and skipping run")
+                    db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_ERROR)
+                else:
+                    # Prepare a dedicated results folder copying the current working directory (with module changes)
+                    execution_extraction_path = os.path.join(LOCAL_RESULTS_FOLDER, execution_id)
+                    os.makedirs(execution_extraction_path, exist_ok=True)
+                    workdir = _ensure_case_workdir(case_id)
+                    _copy_tree(workdir, execution_extraction_path)
+                    # Run SDDP
+                    run_local_case(execution_id, execution_extraction_path)
 
         except Exception as e:
-            print(f"Error processing {execution_id}: {e}")
+            # Use safe prints in case execution_id isn't available
+            try:
+                print(f"Error processing {execution_id}: {e}")
+            except Exception:
+                print(f"Error processing item: {e}")
         finally:
             _execution_queue.task_done()
 
@@ -121,13 +259,31 @@ def process_cloud_execution_queue():
         cloud_upload_id, case_id = _cloud_upload_queue.get()
         try:
             print(f"Processing {cloud_upload_id}...")
-            # Unzip the file
-            zip_upload_path = os.path.join(UPLOADS_FOLDER, case_id + ".zip")
+            # Wait for running modules to finish; abort if any failed
+            wait_loops = 0
+            while db.any_running_modules_for_case(session, case_id):
+                print(f"Case {case_id} has running modules; waiting before cloud run...")
+                time.sleep(5)
+                wait_loops += 1
+                if wait_loops > 240:  # ~20 minutes
+                    break
+            # Block if the last execution of any distinct module failed
+            failing_modules = []
+            for mname in db.get_distinct_module_names_for_case(session, case_id):
+                last = db.last_module_execution_for_case(session, case_id, mname)
+                if last and last.status == db.LOCAL_EXECUTION_ERROR:
+                    failing_modules.append(mname)
+            if failing_modules:
+                print(f"Case {case_id} has failing modules in last execution {failing_modules}; skipping cloud run for upload {cloud_upload_id}")
+                # Nothing else to do; do not run in the cloud
+                continue
+            # Prepare temp folder by copying current working directory (with module changes)
             tmp_extraction_path = os.path.join(TEMPORARY_UPLOAD_FOLDER, cloud_upload_id)
-
+            workdir = _ensure_case_workdir(case_id)
+            if os.path.isdir(tmp_extraction_path):
+                shutil.rmtree(tmp_extraction_path, ignore_errors=True)
             os.makedirs(tmp_extraction_path, exist_ok=True)
-            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
-                zip_ref.extractall(tmp_extraction_path)
+            _copy_tree(workdir, tmp_extraction_path)
 
             # Run SDDP
             repository_id = run_cloud_case(cloud_upload_id, tmp_extraction_path)
@@ -136,9 +292,10 @@ def process_cloud_execution_queue():
             shutil.rmtree(tmp_extraction_path)
 
             execution_extraction_path = os.path.join(CLOUD_RESULTS_FOLDER, repository_id)
+            if os.path.isdir(execution_extraction_path):
+                shutil.rmtree(execution_extraction_path, ignore_errors=True)
             os.makedirs(execution_extraction_path, exist_ok=True)
-            with zipfile.ZipFile(zip_upload_path, 'r') as zip_ref:
-                zip_ref.extractall(execution_extraction_path)
+            _copy_tree(workdir, execution_extraction_path)
 
             db.register_cloud_execution(session, repository_id, cloud_upload_id, case_id)
 
@@ -234,6 +391,15 @@ def run_endpoint():
     if not os.path.exists(zip_case_path):
         return jsonify({'error': 'Upload file for this case ID not found'}), 404
 
+    # Pre-check: for each distinct module, if the last execution failed, block the run
+    failing_modules = []
+    for mname in db.get_distinct_module_names_for_case(session, case_id):
+        last = db.last_module_execution_for_case(session, case_id, mname)
+        if last and last.status == db.LOCAL_EXECUTION_ERROR:
+            failing_modules.append(mname)
+    if failing_modules:
+        return jsonify({'error': 'Case has failed modules in last execution', 'modules': failing_modules}), 409
+
     if cloud_execution:
         cloud_upload_id = str(ulid.ULID())
         _cloud_upload_queue.put((cloud_upload_id, case_id))
@@ -246,10 +412,40 @@ def run_endpoint():
         _execution_queue.put((execution_id, case_id))
 
         db.register_local_execution(session, case_id, execution_id)
+        # Mark as running explicitly
+        db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_RUNNING)
 
         return jsonify({'case_id': case_id, 'execution_id': execution_id}), 200
 
 
+@app.route('/run_module', methods=['POST'])
+def run_module_endpoint():
+    global session
+    case_id = request.form.get('case_id')
+    module_name = request.form.get('module') or request.form.get('module_name')
+
+    if not case_id or not module_name:
+        return jsonify({'error': 'case_id and module are required'}), 400
+
+    # Validate case zip exists
+    zip_case_path = os.path.join(UPLOADS_FOLDER, f"{case_id}.zip")
+    workdir = os.path.join(UPLOADS_FOLDER, case_id)
+    if not os.path.exists(zip_case_path) and not os.path.isdir(workdir):
+        return jsonify({'error': 'Upload file or working directory for this case ID not found'}), 404
+
+    # Validate module exists in config
+    module_cfg = MODULES.get(module_name) if isinstance(MODULES, dict) else None
+    if not module_cfg or 'command' not in module_cfg:
+        return jsonify({'error': f"Module '{module_name}' not configured"}), 400
+
+    execution_id = str(ulid.ULID())
+    _execution_queue.put({'type': 'module', 'execution_id': execution_id, 'case_id': case_id, 'module': module_name})
+    db.register_local_execution(session, case_id, execution_id, is_module=1, module=module_name)
+    db.update_local_execution_status(session, execution_id, db.LOCAL_EXECUTION_RUNNING)
+
+    return jsonify({'case_id': case_id, 'module': module_name, 'execution_id': execution_id}), 200
+
+
 @app.route('/upload_and_run', methods=['POST'])
 def upload_and_run_file():
     global session
@@ -371,6 +567,41 @@ def get_results(execution_id: str):
     return jsonify({'execution_id': execution_id, 'files': result_files}), 200
 
 
+@app.route('/module_log/<case_id>', methods=['GET'])
+def get_module_log(case_id: str):
+    """Return the content of the module's fixed log file for the last module run of the case,
+    or for a specific module if provided as query parameter ?module=<name>.
+    """
+    global session
+    module_name = request.args.get('module') or request.args.get('module_name')
+
+    # Determine module and log file name
+    if not module_name:
+        last = db.last_module_execution_for_case(session, case_id)
+        if not last or not last.module:
+            return jsonify({'error': 'No module execution found for this case'}), 404
+        module_name = last.module
+    module_cfg = MODULES.get(module_name) if isinstance(MODULES, dict) else None
+    if not module_cfg:
+        return jsonify({'error': f"Module '{module_name}' not configured"}), 400
+    log_name = module_cfg.get('log_file', f"module_{module_name}.log")
+
+    workdir = os.path.join(UPLOADS_FOLDER, case_id)
+    if not os.path.isdir(workdir):
+        # Ensure workdir is created (may extract zip if needed)
+        workdir = _ensure_case_workdir(case_id)
+    log_path = os.path.join(workdir, log_name)
+    if not os.path.exists(log_path):
+        return jsonify({'error': 'Log file not found', 'module': module_name, 'log': log_name}), 404
+
+    try:
+        with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+        return content, 200, {'Content-Type': 'text/plain; charset=utf-8'}
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
 @app.route('/results/<execution_id>/<file>', methods=['GET'])
 def download_file(execution_id: str, file):
     global session

psr/factory/__init__.py

@@ -2,6 +2,6 @@
 # Unauthorized copying of this file, via any medium is strictly prohibited
 # Proprietary and confidential
 
-__version__ = "5.0.0b50"
+__version__ = "5.0.0b52"
 
 from .api import *

psr/factory/factory.pmd

@@ -5065,7 +5065,6 @@ DEFINE_MODEL MODL:SDDP_ConsumoCombustivel
     DIMENSION         block
     DIMENSION         segment
     VETOR DATE        Data
-    VETOR REAL        GerMax INDEX Data
     VETOR REAL        O&MCost INDEX Data
     VETOR REAL        G DIM(segment) INDEX Data
     VETOR REAL        CTransp INDEX Data
@@ -5681,6 +5680,7 @@ DEFINE_MODEL MODL:SDDP_Execution_Options
     PARM INTEGER GAME
     PARM INTEGER TRUP
     PARM INTEGER HINS
+    PARM INTEGER HOTM
 
     PARM REAL NCPL_MIPR DEFAULT 0.005
     PARM REAL NCPL_LTOL

psr/runner/runner.py

@@ -595,6 +595,20 @@ def run_tslconsole(tsl_path: Union[str, pathlib.Path], script_path: Union[str, p
         cmd = f'TimeSeriesConsole.exe "{str(script_path)}"'
         exec_cmd(cmd, **kwargs)
 
+def run_tsl_generate_inflow_from_external_natural(case_path: Union[str, pathlib.Path], tsl_path: Union[str, pathlib.Path], **kwargs):
+    commands = ["generate_inflow_from_external_natural"]
+    case_path = os.path.abspath(str(case_path))
+    tsl_path = str(tsl_path)
+    _run_tslconsole_command(tsl_path, case_path, commands)
+
+
+def run_tsl_generate_inflow_from_external_incremental(case_path: Union[str, pathlib.Path], tsl_path: Union[str, pathlib.Path], **kwargs):
+    commands = ["generate_inflow_from_external_incremental"]
+    case_path = os.path.abspath(str(case_path))
+    tsl_path = str(tsl_path)
+    _run_tslconsole_command(tsl_path, case_path, commands)
+
+
 def run_tsl(case_path: Union[str, pathlib.Path], tsl_path: Union[str, pathlib.Path], base_type: str, **kwargs):
     if os.name != 'nt':
         raise NotImplementedError("Running TimeSeriesLab is only available on Windows")

{psr_factory-5.0.0b50.dist-info → psr_factory-5.0.0b52.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psr-factory
-Version: 5.0.0b50
+Version: 5.0.0b52
 Summary: PSR database management module.
 Author-email: "PSR Inc." <psrfactory@psr-inc.com>
 License-Expression: MIT

{psr_factory-5.0.0b50.dist-info → psr_factory-5.0.0b52.dist-info}/RECORD

@@ -11,18 +11,18 @@ psr/cloud/status.py,sha256=vcI4B9S6wCt9maT5NNrVwYaEgGIvy6kkC1UVpJjYbtw,3607
 psr/cloud/tempfile.py,sha256=1IOeye0eKWnmBynK5K5FMWiTaEVhn4GbQ8_y0THEva0,3893
 psr/cloud/version.py,sha256=-oC5DNaS_iYTfpsusfmeG-WGktZ5b-x8xT-4zszWvz8,193
 psr/cloud/xml.py,sha256=ac2lyflOQm8khPvJn0zmI26I4sfUDY6A_OTsxzbMQEs,1896
-psr/execqueue/client.py,sha256=P89Yt76W2GqRXaG_MLsa0kXf0jPp-weBd3aSTRcDzcs,4443
-psr/execqueue/config.py,sha256=rUOzO5dtTkwWoZlZfk06K9RE94xCx53T1bJ1h5JaDUo,1446
-psr/execqueue/db.py,sha256=sNr_StNEgZZQCKcyCWiB1WrQJIhE9UvLUxPA2tWiXGs,8498
-psr/execqueue/server.py,sha256=LolYERWRt96P_ip4yKU7DsN7M_n9d_pbflbT0ckUV0E,15782
+psr/execqueue/client.py,sha256=xw08nwLEsfEXe5TvTRonWDWnhfvn1PW1CwIpVZzro2o,5617
+psr/execqueue/config.py,sha256=F8sp-JGeoRspQRR63SjSKV5wDz0OVGnA-cNm1UDYHBY,1693
+psr/execqueue/db.py,sha256=UvGjex6DpnVrfTtq1z78ZKS4tHkzp08cn8wdrImYRaM,10796
+psr/execqueue/server.py,sha256=aeNzdZabXR5MSE0KDPxTWzr78PHklUVpvzDQRFNus0I,26872
 psr/execqueue/watcher.py,sha256=R1dyXJ-OYn_QjqdItBwbLJZQ2LcbtdHqnRaYkyphi4w,5637
-psr/factory/__init__.py,sha256=-L7Nsdfu8QUH_LuI-u2r0qi7QF9BmNSVxKAL8XN5zNo,219
+psr/factory/__init__.py,sha256=akpsaiZNbTA_pC27H6hXlTPZ_E7kYLlYlWbF5pbVPpQ,219
 psr/factory/api.py,sha256=tezioW1Dqv6m7Ozvc0AOTpZcb1q7rLsICqB58twEG5c,106100
-psr/factory/factory.dll,sha256=skIvvA5KlKhUOZp1GA8CwStyGyHsBFJ7kCdhzNpbXsM,18727248
-psr/factory/factory.pmd,sha256=b9yPyDmkfwMC1BVnLwcM8UqV3jJTuMkfhWdMFwbFlEc,252219
+psr/factory/factory.dll,sha256=wOq4KWgelawH1G3pd64Y3WQBOfH0mhEknfm-d0zEshg,18719744
+psr/factory/factory.pmd,sha256=frnwgnN0daxVlKdJTiILYTVH1m-2VXVhDGxGZWo41C0,252201
 psr/factory/factory.pmk,sha256=gM05-6muZmJJhrceHhlDIIaMMM6FJe6y1ERaHaWJQJc,601130
 psr/factory/factorylib.py,sha256=HCjHezBrzf2hTrHpszhXOREsQ022I0CZvPjigYFxWeE,28799
-psr/factory/libcurl-x64.dll,sha256=bWNvOzKyZjLmn6tMZ_Om6NCwYLKkj0WB__-cNHQmW6Q,5317968
+psr/factory/libcurl-x64.dll,sha256=6WGBmqX4q_eD8Vc0E2VpCvVrFV3W7TQoaKqSdbhXBu0,5313096
 psr/factory/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 psr/factory/samples/__init__.py,sha256=xxOch5Fokzjy571a6OHD87FWM17qKgvfcbr8xn-n36I,80
 psr/factory/samples/sddp_case01.py,sha256=h8MDJ6ajXMH_ngiUFSCVFG3XCKDRys6y78vFYyfCMmE,5038
@@ -34,10 +34,10 @@ psr/psrfcommon/__init__.py,sha256=WXR560XQllIjtFpWd0jiJEbUAQIyh5-6lwj-42_J95c,20
 psr/psrfcommon/psrfcommon.py,sha256=NABM5ahvyfSizDC9c0Vu9dVK1pD_vOzIGFHL1oz2E1o,1464
 psr/psrfcommon/tempfile.py,sha256=5S13wa2DCLYTUdwbLm_KMBRnDRJ0WDlu8GO2BmZoNdg,3939
 psr/runner/__init__.py,sha256=kI9HDX-B_LMQJUHHylFHas2rNpWfNNa0pZXoIvX_Alw,230
-psr/runner/runner.py,sha256=hCVH62HAZK_M9YUiHQgqCkMevN17utegjfRIw49MdvM,27542
+psr/runner/runner.py,sha256=qs7Gabo531-GWxgU1MneJYCiio8A2QXUYmct29b7e18,28222
 psr/runner/version.py,sha256=mch2Y8anSXGMn9w72Z78PhSRhOyn55EwaoLAYhY4McE,194
-psr_factory-5.0.0b50.dist-info/licenses/LICENSE.txt,sha256=N6mqZK2Ft3iXGHj-by_MHC_dJo9qwn0URjakEPys3H4,1089
-psr_factory-5.0.0b50.dist-info/METADATA,sha256=KBExsLitxgZIySxowtsO3jvGcKf417CsSja0rTd94-M,3486
-psr_factory-5.0.0b50.dist-info/WHEEL,sha256=ZjXRCNaQ9YSypEK2TE0LRB0sy2OVXSszb4Sx1XjM99k,97
-psr_factory-5.0.0b50.dist-info/top_level.txt,sha256=Jb393O96WQk3b5D1gMcrZBLKJJgZpzNjTPoldUi00ck,4
-psr_factory-5.0.0b50.dist-info/RECORD,,
+psr_factory-5.0.0b52.dist-info/licenses/LICENSE.txt,sha256=N6mqZK2Ft3iXGHj-by_MHC_dJo9qwn0URjakEPys3H4,1089
+psr_factory-5.0.0b52.dist-info/METADATA,sha256=rdCDq-KIHR1eTccNUCRllq5xSDlqzLWqEyyqV6CjVZU,3486
+psr_factory-5.0.0b52.dist-info/WHEEL,sha256=ZjXRCNaQ9YSypEK2TE0LRB0sy2OVXSszb4Sx1XjM99k,97
+psr_factory-5.0.0b52.dist-info/top_level.txt,sha256=Jb393O96WQk3b5D1gMcrZBLKJJgZpzNjTPoldUi00ck,4
+psr_factory-5.0.0b52.dist-info/RECORD,,