oocana 0.16.9__tar.gz → 0.16.10__tar.gz

{oocana-0.16.9 → oocana-0.16.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: oocana
-Version: 0.16.9
+Version: 0.16.10
 Summary: python implement of oocana to give a context for oocana block
 License: MIT
 Requires-Python: >=3.9

{oocana-0.16.9 → oocana-0.16.10}/oocana/context.py

@@ -36,7 +36,6 @@ class Context:
     __block_info: BlockInfo
     __outputs_def: Dict[str, HandleDef]
     __store: Any
-    __is_done: bool = False
     __keep_alive: OnlyEqualSelf = OnlyEqualSelf()
     __session_dir: str
     __tmp_dir: str
@@ -156,10 +155,6 @@ class Context:
         """
         return os.getenv("OO_HOST_ENDPOINT", None)
 
-    @property
-    def is_done(self) -> bool:
-        return self.__is_done
-
     def __store_ref(self, handle: str):
         return StoreKey(
             executor=EXECUTOR_NAME,
@@ -170,8 +165,67 @@ class Context:
     
     def __is_basic_type(self, value: Any) -> bool:
         return isinstance(value, (int, float, str, bool))
+    
+    def __wrap_output_value(self, handle: str, value: Any):
+        """
+        wrap the output value:
+        if the value is a var handle, store it in the store and return the reference.
+        if the value is a bin handle, store it in the store and return the reference.
+        if the handle is not defined in the block outputs schema, raise an ValueError.
+        otherwise, return the value.
+        :param handle: the handle of the output
+        :param value: the value of the output
+        :return: the wrapped value
+        """
+        # __outputs_def should never be None
+        if self.__outputs_def is None:
+            return value
+        
+        output_def = self.__outputs_def.get(handle)
+        if output_def is None:
+            raise ValueError(
+                f"Output handle key: [{handle}] is not defined in Block outputs schema."
+            )
+        
+        if output_def.is_var_handle() and not self.__is_basic_type(value):
+            ref = self.__store_ref(handle)
+            self.__store[ref] = value
+            var: VarValueDict = {
+                "__OOMOL_TYPE__": "oomol/var",
+                "value": asdict(ref)
+            }
+            return var
+        
+        if output_def.is_bin_handle():
+            if not isinstance(value, bytes):
+                self.send_warning(
+                    f"Output handle key: [{handle}] is defined as binary, but the value is not bytes."
+                )
+                return value
+            
+            bin_file = f"{self.session_dir}/binary/{self.session_id}/{self.job_id}/{handle}"
+            os.makedirs(os.path.dirname(bin_file), exist_ok=True)
+            try:
+                with open(bin_file, "wb") as f:
+                    f.write(value)
+            except IOError as e:
+                raise IOError(
+                    f"Output handle key: [{handle}] is defined as binary, but an error occurred while writing the file: {e}"
+                )
+
+            if os.path.exists(bin_file):
+                bin_value: BinValueDict = {
+                    "__OOMOL_TYPE__": "oomol/bin",
+                    "value": bin_file,
+                }
+                return bin_value
+            else:
+                raise IOError(
+                    f"Output handle key: [{handle}] is defined as binary, but the file is not written."
+                )
+        return value
 
-    def output(self, key: str, value: Any, done: bool = False):
+    def output(self, key: str, value: Any):
         """
         output the value to the next block
 
@@ -179,81 +233,85 @@ class Context:
         value: Any, the value of the output
         """
 
-        v = value
-
-        if self.__outputs_def is not None:
-            output_def = self.__outputs_def.get(key)
-            if (
-                output_def is not None and output_def.is_var_handle() and not self.__is_basic_type(value) # 基础类型即使是变量也不放进 store，直接作为 json 内容传递
-            ):
-                ref = self.__store_ref(key)
-                self.__store[ref] = value
-                d: VarValueDict = {
-                    "__OOMOL_TYPE__": "oomol/var",
-                    "value": asdict(ref)
-                }
-                v = d
-            elif output_def is not None and output_def.is_bin_handle():
-                if not isinstance(value, bytes):
-                    self.send_warning(
-                        f"Output handle key: [{key}] is defined as binary, but the value is not bytes."
-                    )
-                    return
-                
-                bin_file = f"{self.session_dir}/binary/{self.session_id}/{self.job_id}/{key}"
-                os.makedirs(os.path.dirname(bin_file), exist_ok=True)
-                try:
-                    with open(bin_file, "wb") as f:
-                        f.write(value)
-                except IOError as e:
-                    self.send_warning(
-                        f"Output handle key: [{key}] is defined as binary, but an error occurred while writing the file: {e}"
-                    )
-                    return
-
-                if os.path.exists(bin_file):
-                    bin_value: BinValueDict = {
-                        "__OOMOL_TYPE__": "oomol/bin",
-                        "value": bin_file,
-                    }
-                    v = bin_value
-                else:
-                    self.send_warning(
-                        f"Output handle key: [{key}] is defined as binary, but the file is not written."
-                    )
-                    return
-
-        # 如果传入 key 在输出定义中不存在，直接忽略，不发送数据。但是 done 仍然生效。
-        if self.__outputs_def is not None and self.__outputs_def.get(key) is None:
+        try:
+            wrap_value = self.__wrap_output_value(key, value)
+        except ValueError as e:
             self.send_warning(
-                f"Output handle key: [{key}] is not defined in Block outputs schema."
+                f"{e}"
+            )
+            return
+        except IOError as e:
+            self.send_warning(
+                f"{e}"
             )
-            if done:
-                self.done()
             return
 
         node_result = {
             "type": "BlockOutput",
             "handle": key,
-            "output": v,
-            "done": done,
+            "output": wrap_value,
         }
         self.__mainframe.send(self.job_info, node_result)
+    
+    def outputs(self, outputs: Dict[str, Any]):
+        """
+        output the value to the next block
 
-        if done:
-            self.done()
+        map: Dict[str, Any], the key of the output, should be defined in the block schema output defs, the field name is handle
+        """
 
-    def done(self, error: str | None = None):
-        if self.__is_done:
-            self.send_warning("done has been called multiple times, will be ignored.")
-            return
-        self.__is_done = True
-        if error is None:
-            self.__mainframe.send(self.job_info, {"type": "BlockFinished"})
+        values = {}
+        for key, value in outputs.items():
+            try:
+                wrap_value = self.__wrap_output_value(key, value)
+                values[key] = wrap_value
+            except ValueError as e:
+                self.send_warning(
+                    f"{e}"
+                )
+            except IOError as e:
+                self.send_warning(
+                    f"{e}"
+                )
+        self.__mainframe.send(self.job_info, {
+            "type": "BlockOutputs",
+            "outputs": values,
+        })
+
+        
+
+    def finish(self, *, result: Dict[str, Any] | None = None, error: str | None = None):
+        """
+        finish the block, and send the result to oocana.
+        if error is not None, the block will be finished with error.
+        then if result is not None, the block will be finished with result.
+        lastly, if both error and result are None, the block will be finished without any result.
+        """
+
+        if error is not None:
+            self.__mainframe.send(self.job_info, {"type": "BlockFinished", "error": error})
+        elif result is not None:
+            wrap_result = {}
+            if isinstance(result, dict):
+                for key, value in result.items():
+                    try:
+                        wrap_result[key] = self.__wrap_output_value(key, value)
+                    except ValueError as e:
+                        self.send_warning(
+                            f"Output handle key: [{key}] is not defined in Block outputs schema. {e}"
+                        )
+                    except IOError as e:
+                        self.send_warning(
+                            f"Output handle key: [{key}] is not defined in Block outputs schema. {e}"
+                        )
+
+                self.__mainframe.send(self.job_info, {"type": "BlockFinished", "result": wrap_result})
+            else:
+                raise ValueError(
+                    f"result should be a dict, but got {type(result)}"
+                )
         else:
-            self.__mainframe.send(
-                self.job_info, {"type": "BlockFinished", "error": error}
-            )
+            self.__mainframe.send(self.job_info, {"type": "BlockFinished"})
 
     def send_message(self, payload):
         self.__mainframe.report(

{oocana-0.16.9 → oocana-0.16.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "oocana"
-version = "0.16.9"
+version = "0.16.10"
 description = "python implement of oocana to give a context for oocana block"
 dependencies = [
     "paho-mqtt>=2",