psr-factory 5.0.0b69__py3-none-manylinux_2_28_x86_64.whl

psr/apps/__init__.py

@@ -0,0 +1,7 @@
+# PSR Factory. Copyright (C) PSR, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+from .version import __version__
+from .apps import *
+

psr/apps/apps.py

@@ -0,0 +1,225 @@
+# PSR Factory. Copyright (C) PSR, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+import glob
+import os
+import pathlib
+from typing import (
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union
+)
+
+if os.name == "nt":
+    import winreg
+
+
+from psr.runner import (
+    run_sddp,
+    run_sddp_check,
+    run_hydro_estimation,
+    run_sddp_cleanup,
+    get_sddp_version,
+    run_optgen,
+    run_optgen_check,
+    run_optgen_cleanup,
+    run_ncp,
+    run_graph,
+    run_psrcloud,
+    run_tsl,
+)
+
+
+class ModelNotFound(Exception):
+    pass
+
+
+def _get_versions_from_base_path(base_path: Union[str, pathlib.Path], program_name: str) -> Dict[str, str]:
+    program_path = os.path.join(base_path, program_name)
+    if not os.path.exists(program_path):
+        return dict()
+    versions = dict()
+    for entry in os.scandir(program_path):
+        if entry.is_dir():
+            versions[entry.name] = entry.path
+    return versions
+
+def get_program_versions_paths(program_name: str) -> Dict[str, str]:
+    if os.name == "nt":
+        return _get_registry_versions(program_name)
+    else:
+        return _get_versions_from_base_path("/opt/psr/", program_name)
+
+
+def get_latest_version_and_path(program_name: str) -> Tuple[str, str]:
+    versions = get_program_versions_paths(program_name)
+    if not versions:
+        raise ModelNotFound(f"Model {program_name} not found")
+    # sort keys
+    versions_keys = dict(sorted(versions.items()))
+    latest = list(versions_keys.keys())[-1]
+    return latest, versions[latest]
+
+
+def get_latest_version(program_name: str) -> "AppRunner":
+    program_name_lower = program_name.lower()
+    version, path = get_latest_version_and_path(program_name)
+    if program_name_lower == "sddp":
+        return SDDP(path)
+
+    if program_name_lower == "optgen":
+        _, sddp_path = get_latest_version_and_path("sddp")
+        return OptGen(path, sddp_path, version)
+
+    if program_name_lower == "ncp":
+        return NCP(path, version)
+
+    if program_name_lower == "graph":
+        return Graph(path, version)
+
+    if program_name_lower == "psrcloud":
+        return PSRCloud(path, version)
+
+    if program_name_lower == "tsl" or program_name_lower == "timeserieslab":
+        return TSL(path, version)
+
+    raise ModelNotFound(f"Model {program_name} not found")
+
+
+class AppRunner:
+    def __init__(self):
+        pass
+    def run(self, case_path: str, **kwargs):
+        pass
+    def version(self) -> str:
+        pass
+    def install_path(self) -> str:
+        pass
+
+
+class SDDP(AppRunner):
+    def __init__(self, sddp_path: str):
+        super().__init__()
+        self._sddp_path = sddp_path
+
+    def run(self, case_path: str, **kwargs):
+        run_sddp(case_path, self._sddp_path, **kwargs)
+
+    def run_check(self, case_path: str, **kwargs):
+        run_sddp_check(case_path, self._sddp_path, **kwargs)
+
+    def run_cleanup(self, case_path: str, **kwargs):
+        run_sddp_cleanup(case_path, self._sddp_path, **kwargs)
+
+    def run_hydro_estimation(self, case_path: str, **kwargs):
+        run_hydro_estimation(case_path, self._sddp_path, **kwargs)
+
+    def version(self) -> str:
+        return get_sddp_version(self._sddp_path)
+
+    def install_path(self) -> str:
+        return self._sddp_path
+
+
+class OptGen(AppRunner):
+    def __init__(self, optgen_path: str, sddp_path: str, version: str):
+        super().__init__()
+        self._optgen_path = optgen_path
+        self._sddp_path = sddp_path
+        self._version = version
+
+    def run(self, case_path: str, **kwargs):
+        run_optgen(case_path, self._optgen_path, self._sddp_path, **kwargs)
+
+    def run_check(self, case_path: str, **kwargs):
+        run_optgen_check(case_path, self._optgen_path, self._sddp_path, **kwargs)
+
+    def run_cleanup(self, case_path: str, **kwargs):
+        run_optgen_cleanup(case_path, self._optgen_path, self._sddp_path, **kwargs)
+
+    def version(self) -> str:
+        return self._version
+
+
+class NCP(AppRunner):
+    def __init__(self, ncp_path: str, version: str):
+        super().__init__()
+        self._ncp_path = ncp_path
+        self._version = version
+
+    def run(self, case_path: str, **kwargs):
+        run_ncp(case_path, self._ncp_path, **kwargs)
+
+    def version(self) -> str:
+        return self._version
+
+class Graph(AppRunner):
+    def __init__(self, graph_path: str, version: str):
+        super().__init__()
+        self._graph_path = graph_path
+        self._version = version
+
+    def run(self, case_path: str, **kwargs):
+        run_graph(case_path, self._graph_path, **kwargs)
+
+    def version(self) -> str:
+        return self._version
+
+class TSL(AppRunner):
+    def __init__(self, tsl_path: str, version: str):
+        super().__init__()
+        self._tsl_path = tsl_path
+        self._version = version
+
+    def run(self, **kwargs):
+        run_tsl(self._tsl_path, **kwargs)
+
+    def version(self) -> str:
+        return self._version
+
+
+class PSRCloud(AppRunner):
+    def __init__(self, psrcloud_path: str, version: str):
+        super().__init__()
+        self._psrcloud_path = psrcloud_path
+        self._version = version
+
+    def run(self, **kwargs):
+        run_psrcloud(self._psrcloud_path, **kwargs)
+
+    def version(self) -> str:
+        return self._version
+
+
+
+if os.name == "nt":
+    def _get_registry_versions(program_name: str) -> Dict[str, str]:
+        base_key = winreg.HKEY_LOCAL_MACHINE
+        subkey_path = rf"SOFTWARE\PSR\{program_name}"
+        version_paths: Dict[str, str] = dict()
+        try:
+            with winreg.OpenKey(base_key, subkey_path) as key:
+                i = 0
+                while True:
+                    try:
+                        subkey_name = winreg.EnumKey(key, i)
+                        subkey_full_path = f"{subkey_path}\\{subkey_name}"
+
+                        with winreg.OpenKey(base_key, subkey_full_path) as subkey:
+                            try:
+                                path_value, _ = winreg.QueryValueEx(subkey, "Path")
+                                # if subkey ends with .x, replace with blank
+                                subkey_name = subkey_name.replace(".x", "")
+                                version_paths[subkey_name] = path_value
+                            except FileNotFoundError:
+                                pass
+                        i += 1
+                    except OSError:
+                        break
+        except FileNotFoundError:
+            pass
+        return version_paths
+

psr/apps/version.py

@@ -0,0 +1,5 @@
+# PSR Factory. Copyright (C) PSR, Inc - All Rights Reserved
+# Unauthorized copying of this file, via any medium is strictly prohibited
+# Proprietary and confidential
+
+__version__ = "0.1.0"

psr/execqueue/client.py

@@ -0,0 +1,126 @@
+import os
+import zipfile
+import requests
+from typing import List, Optional, Tuple
+
+
+def zip_directory(directory_path, output_zip):
+    """Compress a directory into a zip file."""
+    with zipfile.ZipFile(output_zip, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        for root, _, files in os.walk(directory_path):
+            for file in files:
+                file_path = os.path.join(root, file)
+                arcname = os.path.relpath(file_path, start=directory_path)
+                zipf.write(file_path, arcname=arcname)
+
+
+def upload_case_file(zip_path, server_url):
+    """Upload a zip file to the server."""
+    with open(zip_path, 'rb') as f:
+        files = {'file': (os.path.basename(zip_path), f)}
+        response = requests.post(f"{server_url}/upload", files=files)
+
+    if response.status_code == 200:
+        print("Upload successful!")
+        print("Case ID:", response.json().get('case_id'))
+        return response.json().get('case_id')
+    else:
+        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."""
+    response = requests.post(f"{server_url}/run" , params={'cloud_execution': cloud_execution})
+
+    if response.status_code == 200:
+        if not cloud_execution:
+            print("Added to queue successfully!")
+            print("Execution ID:", response.json().get('execution_id'))
+            return response.json().get('execution_id')
+        else:
+            print("Cloud execution queued!")
+            print("Cloud upload ID:", response.json().get('cloud_upload_id'))
+            return response.json().get('cloud_upload_id')
+    else:
+        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
+
+
+def upload_and_run_file(zip_path: str, server_url: str, cloud_execution: bool = False):
+    """Upload a zip file to the server."""
+    with open(zip_path, 'rb') as f:
+        files = {'file': (os.path.basename(zip_path), f)}
+        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.")
+
+        if cloud_execution:
+            print("Cloud upload ID:", response.json().get('cloud_upload_id'))
+            return response.json().get('cloud_upload_id')
+        else:
+            print("Local execution ID:", response.json().get('execution_id'))
+            return response.json().get('execution_id')
+    else:
+        print("Upload failed:", response.text)
+        return None
+
+
+def get_execution_status(execution_id: str, server_url: str, cloud_execution: bool = False) -> Optional[tuple[int, str]]:
+    """Get the status of an execution."""
+    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 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}", params={'cloud_execution': cloud_execution})
+
+    if response.status_code == 200:
+        print("Results downloaded successfully!")
+        files = response.json().get('files')
+        print("Files:", files)
+        return files
+    else:
+        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."""
+    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:
+        with open(os.path.join(download_path, file), 'wb') as f:
+            f.write(response.content)
+    else:
+        print("Download failed:", response.text)

psr/execqueue/config.py

@@ -0,0 +1,52 @@
+import os
+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"
+
+if os.name == 'nt':
+    _DEFAULT_SDDP_PATH = r"C:/PSR/Sddp17.3"
+else:
+    _DEFAULT_SDDP_PATH = "/opt/psr/sddp"
+DEFAULT_CLUSTER_NAME = "server"
+DEFAULT_PSRCLOUD_CLUSTER = "external"
+DEFAULT_PSRCLOUD_CLUSTER_URL = ""
+
+
+# read toml settings file
+with open(os.path.join(os.getcwd(), _SETTINGS_FILE_PATH), 'rb') as f:
+    settings = tomllib.load(f)
+
+
+sddp_path = settings.get("sddp_path", _DEFAULT_SDDP_PATH)
+
+cluster_name = settings.get("cluster_name", DEFAULT_CLUSTER_NAME)
+psrcloud_cluster = settings.get("psrcloud_cluster", DEFAULT_PSRCLOUD_CLUSTER)
+psrcloud_cluster_url = settings.get("psrcloud_cluster", DEFAULT_PSRCLOUD_CLUSTER_URL)
+
+# Base server data storage path.
+STORAGE_PATH = settings.get("storage_path", os.path.join(os.getcwd(), 'serverdata'))
+
+# Where uploaded (received) cases will be stored.
+UPLOADS_FOLDER = os.path.join(STORAGE_PATH, 'uploads')
+
+# Where results of local runs will be stored.
+LOCAL_RESULTS_FOLDER = os.path.join(STORAGE_PATH, 'local_results')
+
+# Where results of cloud runs will be stored.
+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", {})
+