pybioos 0.0.15__py3-none-any.whl → 0.0.19__py3-none-any.whl

bioos/resource/workflows.py

@@ -3,7 +3,7 @@ import os
 import zipfile
 from datetime import datetime
 from io import BytesIO
-from typing import List
+from typing import List, Dict, Optional, Any
 
 import pandas as pd
 from cachetools import TTLCache, cached
@@ -339,6 +339,13 @@ class Submission(metaclass=SingletonType):  # 与run class行为相同
         if not item.get("Status") in ("Running", "Pending"):
             self._finish_time = item.get("FinishTime")
 
+    def delete(self):
+        """Delete this submission from the workspace."""
+        Config.service().delete_submission({
+            "WorkspaceID": self.workspace_id,
+            "ID": self.id,
+        })
+
 
 class WorkflowResource(metaclass=SingletonType):
 
@@ -548,17 +555,62 @@ class WorkflowResource(metaclass=SingletonType):
 
 
 class Workflow(metaclass=SingletonType):
+    """Represents a workflow in Bio-OS.
+    
+    This class encapsulates all the information and operations related to a workflow,
+    including its metadata, inputs, outputs, and execution capabilities.
+    """
 
     def __init__(self,
                  name: str,
                  workspace_id: str,
                  bucket: str,
                  check: bool = False):
+        """Initialize a workflow instance.
+        
+        Args:
+            name: The name of the workflow
+            workspace_id: The ID of the workspace containing this workflow
+            bucket: The S3 bucket associated with this workflow
+            check: Whether to check the workflow existence immediately
+        """
         self.name = name
         self.workspace_id = workspace_id
         self.bucket = bucket
+        self._description: str = ""
+        self._create_time: int = 0
+        self._update_time: int = 0
+        self._language: str = "WDL"
+        self._source: str = ""
+        self._tag: str = ""
+        self._token: Optional[str] = None
+        self._main_workflow_path: str = ""
+        self._status: Dict[str, Optional[str]] = {"Phase": "", "Message": None}
+        self._inputs: List[Dict[str, Any]] = []
+        self._outputs: List[Dict[str, Any]] = []
+        self._owner_name: str = ""
+        self._graph: str = ""
+        self._source_type: str = ""
+        
         if check:
-            self.id
+            self.sync()
+
+    def __repr__(self):
+        """Return a string representation of the workflow."""
+        info_dict = dict_str({
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "language": self.language,
+            "source": self.source,
+            "tag": self.tag,
+            "main_workflow_path": self.main_workflow_path,
+            "status": self.status,
+            "owner_name": self.owner_name,
+            "create_time": self.create_time,
+            "update_time": self.update_time
+        })
+        return f"Workflow:\n{info_dict}"
 
     @property
     @cached(cache=TTLCache(maxsize=100, ttl=1))
@@ -574,6 +626,215 @@ class Workflow(metaclass=SingletonType):
             raise ParameterError("name")
         return res["ID"].iloc[0]
 
+    @property
+    def description(self) -> str:
+        """Get the workflow description."""
+        if not self._description:
+            self.sync()
+        return self._description
+
+    @property
+    def create_time(self) -> int:
+        """Get the workflow creation timestamp."""
+        if not self._create_time:
+            self.sync()
+        return self._create_time
+
+    @property
+    def update_time(self) -> int:
+        """Get the workflow last update timestamp."""
+        if not self._update_time:
+            self.sync()
+        return self._update_time
+
+    @property
+    def language(self) -> str:
+        """Get the workflow language (e.g., WDL)."""
+        if not self._language:
+            self.sync()
+        return self._language
+
+    @property
+    def source(self) -> str:
+        """Get the workflow source location."""
+        if not self._source:
+            self.sync()
+        return self._source
+
+    @property
+    def tag(self) -> str:
+        """Get the workflow version tag."""
+        if not self._tag:
+            self.sync()
+        return self._tag
+
+    @property
+    def token(self) -> Optional[str]:
+        """Get the workflow access token if any."""
+        if not self._token:
+            self.sync()
+        return self._token
+
+    @property
+    def main_workflow_path(self) -> str:
+        """Get the main workflow file path."""
+        if not self._main_workflow_path:
+            self.sync()
+        return self._main_workflow_path
+
+    @property
+    def status(self) -> Dict[str, Optional[str]]:
+        """Get the workflow status information."""
+        if not self._status["Phase"]:
+            self.sync()
+        return self._status
+    @property
+    def inputs(self) -> List[Dict[str, Any]]:
+        """Get the workflow input parameters."""
+        if not self._inputs:
+            self.sync()
+        return self._inputs
+
+    @property
+    def outputs(self) -> List[Dict[str, Any]]:
+        """Get the workflow output parameters."""
+        if not self._outputs:
+            self.sync()
+        return self._outputs
+
+    @property
+    def owner_name(self) -> str:
+        """Get the workflow owner's name."""
+        if not self._owner_name:
+            self.sync()
+        return self._owner_name
+
+    @property
+    def graph(self) -> str:
+        """Get the workflow graph representation."""
+        if not self._graph:
+            self.sync()
+        return self._graph
+
+    @property
+    def source_type(self) -> str:
+        """Get the workflow source type."""
+        if not self._source_type:
+            self.sync()
+        return self._source_type
+
+    @cached(cache=TTLCache(maxsize=100, ttl=1))
+    def sync(self):
+        """Synchronize workflow information with the remote service."""
+        res = WorkflowResource(self.workspace_id). \
+            list().query(f"Name=='{self.name}'")
+        if res.empty:
+            raise ParameterError("name")
+            
+        # Get detailed workflow information
+        params = {
+            'WorkspaceID': self.workspace_id,
+            'Filter': {
+                'IDs': [res["ID"].iloc[0]]
+            }
+        }
+        workflows = Config.service().list_workflows(params).get('Items')
+        if len(workflows) != 1:
+            raise NotFoundError("workflow", self.name)
+            
+        detail = workflows[0]
+        
+        # Update all properties
+        self._description = detail.get("Description", "")
+        self._create_time = detail.get("CreateTime", 0)
+        self._update_time = detail.get("UpdateTime", 0)
+        self._language = detail.get("Language", "WDL")
+        self._source = detail.get("Source", "")
+        self._tag = detail.get("Tag", "")
+        self._token = detail.get("Token")
+        self._main_workflow_path = detail.get("MainWorkflowPath", "")
+        self._status = detail.get("Status", {"Phase": "", "Message": None})
+        self._inputs = detail.get("Inputs", [])
+        self._outputs = detail.get("Outputs", [])
+        self._owner_name = detail.get("OwnerName", "")
+        self._graph = detail.get("Graph", "")
+        self._source_type = detail.get("SourceType", "")
+
+    def get_input_template(self) -> Dict[str, str]:
+        """Return a readable template of input parameters.
+
+        Each entry maps parameter name to a human-friendly description,
+        e.g. "String (optional, default = \"abc\")" or "Int".
+        """
+        result: Dict[str, str] = {}
+        inputs = self.inputs or []
+        for item in inputs:
+            name = item.get("Name", "")
+            if not name:
+                continue
+            type_str = item.get("Type", "")
+            optional = item.get("Optional", False)
+            default = self._fmt_default(item.get("Default"))
+            if optional:
+                value = f"{type_str} (optional" + (f", default = {default})" if default is not None else ")")
+            else:
+                value = type_str
+            result[name] = value
+        return result
+
+    def get_output_types(self) -> Dict[str, str]:
+        """Return a mapping of output parameter name to its type."""
+        outputs = self.outputs or []
+        return {item.get("Name", ""): item.get("Type", "") for item in outputs if item.get("Name")}
+
+    def get_metadata(self) -> Dict[str, Any]:
+        """Return workflow metadata in a flat dictionary."""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "language": self.language,
+            "source": self.source,
+            "tag": self.tag,
+            "status": self.status,
+            "owner_name": self.owner_name,
+            "create_time": self.create_time,
+            "update_time": self.update_time,
+            "main_workflow_path": self.main_workflow_path,
+            "source_type": self.source_type,
+        }
+
+    @staticmethod
+    def _fmt_default(raw: Any) -> Optional[str]:
+        """Format default values into a readable string.
+
+        - None -> None
+        - bool -> "true" / "false"
+        - int/float -> numeric string
+        - other strings -> quoted string
+        """
+        if raw is None:
+            return None
+        if isinstance(raw, bool):
+            return str(raw).lower()
+        if isinstance(raw, (int, float)):
+            return str(raw)
+        if isinstance(raw, str):
+            lo = raw.lower()
+            if lo in {"true", "false"}:
+                return lo
+            try:
+                int(raw)
+                return raw
+            except ValueError:
+                pass
+            try:
+                float(raw)
+                return raw
+            except ValueError:
+                pass
+            return f'"{raw}"'
+        return str(raw)
+
     @property
     @cached(cache=TTLCache(maxsize=100, ttl=1))
     def get_cluster(self):
@@ -594,11 +855,14 @@ class Workflow(metaclass=SingletonType):
                 return info['ID']
         raise NotFoundError("cluster", "workflow")
 
-    def query_data_model_id(self, name: str) -> "":
+    def query_data_model_id(self, name: str) -> str:
         """Gets the id of given data_models among those accessible
 
-        :param name:
-        :return:
+        Args:
+            name: The name of the data model
+
+        Returns:
+            str: The ID of the data model, or empty string if not found
         """
         res = DataModelResource(self.workspace_id).list(). \
             query(f"Name=='{name}'")
@@ -613,7 +877,8 @@ class Workflow(metaclass=SingletonType):
                call_caching: bool,
                submission_name_suffix: str = "",
                row_ids: List[str] = [],
-               data_model_name: str = '') -> List[Run]:
+               data_model_name: str = '',
+               mount_tos: bool = False) -> List[Run]:
         """Submit an existed workflow.
 
         *Example*:
@@ -664,6 +929,7 @@ class Workflow(metaclass=SingletonType):
             'Inputs': inputs,
             'ExposedOptions': {
                 "ReadFromCache": call_caching,
+                "MountTOS": mount_tos,
                 # TODO this may change in the future
                 "ExecutionRootDir": f"s3://{self.bucket}"
             },
@@ -682,3 +948,4 @@ class Workflow(metaclass=SingletonType):
         submission_id = Config.service().create_submission(params).get("ID")
 
         return Submission(self.workspace_id, submission_id).runs
+

bioos/resource/workspaces.py

@@ -1,4 +1,7 @@
 from datetime import datetime
+import os
+import time
+import urllib.request
 
 import pandas as pd
 from cachetools import TTLCache, cached
@@ -7,6 +10,7 @@ from bioos.config import Config
 from bioos.resource.data_models import DataModelResource
 from bioos.resource.files import FileResource
 from bioos.resource.workflows import Workflow, WorkflowResource
+from bioos.resource.iesapp import WebInstanceApp, WebInstanceAppResource
 from bioos.utils.common_tools import SingletonType, dict_str
 
 
@@ -110,6 +114,15 @@ class Workspace(metaclass=SingletonType):
 
         return FileResource(self._id, self._bucket)
 
+    @property
+    def webinstanceapps(self) -> WebInstanceAppResource:
+        """Returns WebInstanceAppResource object.
+
+        :return: WebInstanceAppResource object
+        :rtype: WebInstanceAppResource
+        """
+        return WebInstanceAppResource(self._id)
+
     def workflow(self, name: str) -> Workflow:  # 通过这里执行的选择workflow生成wf的操作
         """Returns the workflow for the given name
 
@@ -121,3 +134,130 @@ class Workspace(metaclass=SingletonType):
         if not self._bucket:
             self._bucket = self.basic_info.get("s3_bucket")
         return Workflow(name, self._id, self._bucket)
+
+    def webinstanceapp(self, name: str) -> WebInstanceApp:
+        """Returns the webinstanceapp for the given name
+
+        :param name: WebInstanceApp name
+        :type name: str
+        :return: Specified webinstanceapp object
+        :rtype: WebInstanceApp
+        """
+        return WebInstanceApp(name, self._id)
+
+    def bind_cluster(self, cluster_id: str, type_: str = "workflow") -> dict:
+        """把当前 Workspace 绑定到指定集群"""
+        params = {"ClusterID": cluster_id, "Type": type_, "ID": self._id}
+        return Config.service().bind_cluster_to_workspace(params)
+
+
+    def export_workspace_v2(self, 
+                           download_path: str = "./", 
+                           monitor: bool = True,
+                           monitor_interval: int = 5,
+                           max_retries: int = 60) -> dict:
+        """导出当前 Workspace 的所有元信息并下载到本地
+        
+        :param download_path: 下载文件保存路径，默认当前目录
+        :type download_path: str
+        :param monitor: 是否监控导出状态直到完成，默认 True
+        :type monitor: bool
+        :param monitor_interval: 轮询间隔（秒），默认 5 秒
+        :type monitor_interval: int
+        :param max_retries: 最大重试次数，默认 60 次（5 分钟）
+        :type max_retries: int
+        :return: 导出结果信息，包含 status、schema_id、file_path 等
+        :rtype: dict
+        """
+        params = {"WorkspaceID": self._id}
+        result = Config.service().export_workspace_v2(params)
+        schema_id = result.get('ID')
+        
+        if not schema_id:
+            raise Exception("Failed to create export task: No schema ID returned")
+        
+        # 如果不监控，直接返回任务 ID
+        if not monitor:
+            return {
+                "status": "submitted",
+                "schema_id": schema_id,
+                "message": "Export task submitted. Use list_schemas to check status."
+            }
+        
+        # 步骤 2: 轮询查询导出状态
+        Config.Logger.info(f"Export task created with schema ID: {schema_id}")
+        Config.Logger.info(f"Monitoring export status (checking every {monitor_interval}s, max {max_retries} retries)...")
+        
+        retry_count = 0
+        schema_key = None
+        
+        while retry_count < max_retries:
+            # 查询所有 schemas
+            schemas_result = Config.service().list_schemas({"Filter": {}})
+            schemas = schemas_result.get("Items", [])
+            
+            # 查找当前导出任务
+            for schema in schemas:
+                if schema.get("ID") == schema_id:
+                    phase = schema.get("Status", {}).get("Phase", "")
+                    message = schema.get("Status", {}).get("Message", "")
+                    
+                    if phase == "Succeeded":
+                        Config.Logger.info("Export task succeeded!")
+                        schema_key = schema.get("SchemaKey")
+                        break
+                    elif phase == "Failed":
+                        error_msg = f"Export task failed: {message}"
+                        Config.Logger.error(error_msg)
+                        raise Exception(error_msg)
+                    else:
+                        Config.Logger.info(f"Export task status: {phase}")
+            
+            # 如果成功找到文件，跳出循环
+            if schema_key:
+                break
+            
+            # 继续等待
+            time.sleep(monitor_interval)
+            retry_count += 1
+        
+        # 超时检查
+        if not schema_key:
+            raise Exception(f"Export task timeout after {max_retries * monitor_interval} seconds")
+        
+        # 步骤 3: 获取预签名 URL
+        Config.Logger.info(f"Getting presigned URL for schema: {schema_id}")
+        presigned_params = {
+            "ID": schema_id,
+            "WorkspaceID": self._id
+        }
+        presigned_result = Config.service().get_export_workspace_presigned_url(presigned_params)
+        presigned_url = presigned_result.get("PreSignedURL")
+        
+        if not presigned_url:
+            raise Exception("Failed to get presigned URL for export file")
+        
+        Config.Logger.info(f"Downloading export file from presigned URL...")
+        
+        # 步骤 4: 使用 HTTP 请求下载文件
+        # 确保下载目录存在
+        os.makedirs(download_path, exist_ok=True)
+        
+        # 从 URL 中提取文件名
+        filename = os.path.basename(schema_key)
+        local_file_path = os.path.join(download_path, filename)
+        
+        try:
+            # 使用 urllib 下载文件
+            urllib.request.urlretrieve(presigned_url, local_file_path)
+            Config.Logger.info(f"Export file downloaded successfully to: {local_file_path}")
+        except Exception as e:
+            raise Exception(f"Failed to download export file from presigned URL: {str(e)}")
+        
+        return {
+            "status": "success",
+            "schema_id": schema_id,
+            "schema_key": schema_key,
+            "file_path": local_file_path,
+            "message": f"Workspace exported and downloaded successfully"
+        }

bioos/service/BioOsService.py

@@ -47,6 +47,11 @@ class BioOsService(Service):
                 'Action': 'ListWorkspaces',
                 'Version': '2021-03-04'
             }, {}, {}),
+            'CreateWorkspace':
+            ApiInfo('POST', '/', {
+                'Action': 'CreateWorkspace',
+                'Version': '2021-03-04'
+            }, {}, {}),
             'CreateDataModel':
             ApiInfo('POST', '/', {
                 'Action': 'CreateDataModel',
@@ -127,12 +132,74 @@ class BioOsService(Service):
                 'Action': 'DeleteWorkflow',
                 'Version': '2021-03-04'
             }, {}, {}),
+            'BindClusterToWorkspace':
+            ApiInfo('POST', '/', {
+                'Action': 'BindClusterToWorkspace',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'ListWebappInstances':
+            ApiInfo('POST', '/', {
+                'Action': 'ListWebappInstances',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'CreateWebappInstance':
+            ApiInfo('POST', '/', {
+                'Action': 'CreateWebappInstance',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'CheckCreateWebappInstance':
+            ApiInfo('POST', '/', {
+                'Action': 'CheckCreateWebappInstance',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'DeleteWebappInstance':
+            ApiInfo('POST', '/', {
+                'Action': 'DeleteWebappInstance',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'StartWebappInstance':
+            ApiInfo('POST', '/', {
+                'Action': 'StartWebappInstance',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'StopWebappInstance':
+            ApiInfo('POST', '/', {
+                'Action': 'StopWebappInstance',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'ListWebappInstanceEvents':
+            ApiInfo('POST', '/', {
+                'Action': 'ListWebappInstanceEvents',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'CommitIESImage':
+            ApiInfo('POST', '/', {
+                'Action': 'CommitIESImage',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'ExportWorkspaceV2':
+            ApiInfo('POST', '/', {
+                'Action': 'ExportWorkspaceV2',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'ListSchemas':
+            ApiInfo('POST', '/', {
+                'Action': 'ListSchemas',
+                'Version': '2021-03-04'
+            }, {}, {}),
+            'GetExportWorkspacePreSignedURL':
+            ApiInfo('POST', '/', {
+                'Action': 'GetExportWorkspacePreSignedURL',
+                'Version': '2021-03-04'
+            }, {}, {}),
         }
         return api_info
 
     def list_workspaces(self, params):  # 以下各方法的params需要在外部使用时构建
         return self.__request('ListWorkspaces', params)
 
+    def create_workspace(self, params):
+        return self.__request('CreateWorkspace', params)
     def create_data_model(self, params):
         return self.__request('CreateDataModel', params)
 
@@ -181,6 +248,42 @@ class BioOsService(Service):
     def delete_workflow(self, params):
         return self.__request("DeleteWorkflow", params)
 
+    def bind_cluster_to_workspace(self, params):
+        return self.__request("BindClusterToWorkspace", params)
+
+    def list_webinstance_apps(self, params):
+        return self.__request('ListWebappInstances', params)
+
+    def create_webinstance_app(self, params):
+        return self.__request('CreateWebappInstance', params)
+
+    def check_webinstance_app(self, params):
+        return self.__request("CheckCreateWebappInstance", params)
+
+    def delete_webinstance_app(self, params):
+        return self.__request("DeleteWebappInstance", params)
+
+    def start_webinstance_app(self, params):
+        return self.__request("StartWebappInstance", params)
+
+    def stop_webinstance_app(self, params):
+        return self.__request("StopWebappInstance", params)
+
+    def list_webinstance_events(self, params):
+        return self.__request("ListWebappInstanceEvents", params)
+
+    def commit_ies_image(self, params):
+        return self.__request("CommitIESImage", params)
+
+    def export_workspace_v2(self, params):
+        return self.__request("ExportWorkspaceV2", params)
+
+    def list_schemas(self, params):
+        return self.__request("ListSchemas", params)
+
+    def get_export_workspace_presigned_url(self, params):
+        return self.__request("GetExportWorkspacePreSignedURL", params)
+
     def __request(self, action, params):
         res = self.json(
             action, dict(),