oocana 0.16.9__tar.gz → 0.16.11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: oocana
-Version: 0.16.9
+Version: 0.16.11
 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.11}/oocana/context.py

@@ -11,8 +11,33 @@ from .preview import PreviewPayload, TablePreviewData, DataFrame, ShapeDataFrame
 from .data import EXECUTOR_NAME
 import os.path
 import logging
+import copy
 
-__all__ = ["Context"]
+__all__ = ["Context", "HandleDefDict"]
+
+class HandleDefDict(TypedDict):
+    """a dict that represents the handle definition, used in the block schema output and input defs.
+    """
+
+    handle: str
+    """the handle of the output, should be defined in the block schema output defs, the field name is handle
+    """
+
+    description: str | None
+    """the description of the output, should be defined in the block schema output defs, the field name is description
+    """
+
+    json_schema: Dict[str, Any] | None
+    """the schema of the output, should be defined in the block schema output defs, the field name is json_schema
+    """
+
+    kind: str | None
+    """the kind of the output, should be defined in the block schema output defs, the field name is kind
+    """
+
+    nullable: bool
+    """if the output can be None, should be defined in the block schema output defs, the field name is nullable
+    """
 
 class OnlyEqualSelf:
     def __eq__(self, value: object) -> bool:
@@ -35,8 +60,8 @@ class Context:
 
     __block_info: BlockInfo
     __outputs_def: Dict[str, HandleDef]
+    __inputs_def: Dict[str, Any]
     __store: Any
-    __is_done: bool = False
     __keep_alive: OnlyEqualSelf = OnlyEqualSelf()
     __session_dir: str
     __tmp_dir: str
@@ -45,7 +70,7 @@ class Context:
     __pkg_dir: str
 
     def __init__(
-        self, inputs: Dict[str, Any], blockInfo: BlockInfo, mainframe: Mainframe, store, outputs, session_dir: str, tmp_dir: str, package_name: str, pkg_dir: str
+        self, *, inputs: Dict[str, Any], blockInfo: BlockInfo, mainframe: Mainframe, store, inputs_def, outputs_def, session_dir: str, tmp_dir: str, package_name: str, pkg_dir: str
     ) -> None:
 
         self.__block_info = blockInfo
@@ -55,10 +80,11 @@ class Context:
         self.__inputs = inputs
 
         outputs_defs = {}
-        if outputs is not None:
-            for k, v in outputs.items():
+        if outputs_def is not None:
+            for k, v in outputs_def.items():
                 outputs_defs[k] = HandleDef(**v)
         self.__outputs_def = outputs_defs
+        self.__inputs_def = inputs_def
         self.__session_dir = session_dir
         self.__tmp_dir = tmp_dir
         self.__package_name = package_name
@@ -105,6 +131,17 @@ class Context:
     @property
     def inputs(self):
         return self.__inputs
+    
+    @property
+    def inputs_def(self) -> Dict[str, HandleDefDict]:
+        return copy.deepcopy(self.__inputs_def) if self.__inputs_def is not None else {}
+
+    @property
+    def outputs_def(self) -> Dict[str, HandleDefDict]:
+        outputs = {}
+        for k, v in self.__outputs_def.items():
+            outputs[k] = asdict(v)
+        return outputs
 
     @property
     def session_id(self):
@@ -156,10 +193,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 +203,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 +271,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.11}/oocana/handle_data.py

@@ -11,12 +11,18 @@ class HandleDef:
     handle: str
     """The name of the handle. it should be unique in handle list."""
 
+    """The description of the handle. It is used to display in the UI."""
+    description: Optional[str] = None
+
     json_schema: Optional[FieldSchema] = None
     """The schema of the handle. It is used to validate the handle's content."""
 
-    name: Optional[str] = None
+    kind: Optional[str] = None
     """A alias of the handle's type name. It is used to display in the UI and connect to the other handle match"""
 
+    nullable: bool = False
+    """If the handle value can be None. If True, the handle can be None, otherwise it must have a value."""
+
     def __init__(self, **kwargs):
         for key, value in kwargs.items():
             object.__setattr__(self, key, value)

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

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