iris-pex-embedded-python 3.4.4b5__tar.gz → 3.5.0__tar.gz

{iris_pex_embedded_python-3.4.4b5/src/iris_pex_embedded_python.egg-info → iris_pex_embedded_python-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iris_pex_embedded_python
-Version: 3.4.4b5
+Version: 3.5.0
 Summary: Iris Interoperability based on Embedded Python
 Author-email: grongier <guillaume.rongier@intersystems.com>
 License: MIT License

{iris_pex_embedded_python-3.4.4b5 → iris_pex_embedded_python-3.5.0}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "iris_pex_embedded_python"
-version = "3.4.4b5"
+version = "3.5.0"
 description = "Iris Interoperability based on Embedded Python"
 readme = "README.md"
 authors = [

{iris_pex_embedded_python-3.4.4b5 → iris_pex_embedded_python-3.5.0}/src/iop/_business_host.py

@@ -4,9 +4,10 @@ from typing import Any,List, Optional, Tuple, Union
 from . import _iris
 from ._common import _Common
 from ._message import _Message as Message
-from ._decorators import input_serializer_param, output_deserializer
-from ._dispatch import dispatch_serializer, dispatch_deserializer
+from ._decorators import input_serializer_param, output_deserializer, input_deserializer, output_serializer
+from ._dispatch import dispatch_serializer, dispatch_deserializer, dispach_message
 from ._async_request import AsyncRequest
+from ._generator_request import _GeneratorRequest
 
 class _BusinessHost(_Common):
     """Base class for business components that defines common methods.
@@ -68,6 +69,21 @@ class _BusinessHost(_Common):
         """
         return await AsyncRequest(target, request, timeout, description, self)
 
+    def send_generator_request(self, target: str, request: Union[Message, Any], 
+                              timeout: int = -1, description: Optional[str] = None) -> _GeneratorRequest:
+        """Send message as a generator request to target component.
+        Args:
+            target: Name of target component
+            request: Message to send
+            timeout: Timeout in seconds, -1 means wait forever
+            description: Optional description for logging
+        Returns:
+            _GeneratorRequest: An instance of _GeneratorRequest to iterate over responses
+        Raises:
+            TypeError: If request is not of type Message
+        """
+        return _GeneratorRequest(self, target, request, timeout, description)
+
     def send_multi_request_sync(self, target_request: List[Tuple[str, Union[Message, Any]]], 
                                timeout: int = -1, description: Optional[str] = None) -> List[Tuple[str, Union[Message, Any], Any, int]]:
         """Send multiple messages synchronously to target components.
@@ -179,7 +195,7 @@ class _BusinessHost(_Common):
         """
         ## Parse the class code to find all invocations of send_request_sync and send_request_async
         ## and return the targets
-        targer_list = []
+        target_list = []
         # get the source code of the class
         source = getsource(self.__class__)
         # find all invocations of send_request_sync and send_request_async
@@ -194,29 +210,47 @@ class _BusinessHost(_Common):
                         if target.find("=") != -1:
                             # it's a keyword argument, remove the keyword
                             target = target[target.find("=")+1:].strip()
-                        if target not in targer_list:
-                            targer_list.append(target)
+                        if target not in target_list:
+                            target_list.append(target)
                 i = source.find(method, i+1)
 
-        for target in targer_list:
+        for target in target_list:
             # if target is a string, remove the quotes
             if target[0] == "'" and target[-1] == "'":
-                targer_list[targer_list.index(target)] = target[1:-1]
+                target_list[target_list.index(target)] = target[1:-1]
             elif target[0] == '"' and target[-1] == '"':
-                targer_list[targer_list.index(target)] = target[1:-1]
+                target_list[target_list.index(target)] = target[1:-1]
             # if target is a variable, try to find the value of the variable
             else:
                 self.on_init()
                 try:
                     if target.find("self.") != -1:
                         # it's a class variable
-                        targer_list[targer_list.index(target)] = getattr(self, target[target.find(".")+1:])
+                        target_list[target_list.index(target)] = getattr(self, target[target.find(".")+1:])
                     elif target.find(".") != -1:
                         # it's a class variable
-                        targer_list[targer_list.index(target)] = getattr(getattr(self, target[:target.find(".")]), target[target.find(".")+1:])
+                        target_list[target_list.index(target)] = getattr(getattr(self, target[:target.find(".")]), target[target.find(".")+1:])
                     else:
-                        targer_list[targer_list.index(target)] = getattr(self, target)
+                        target_list[target_list.index(target)] = getattr(self, target)
                 except Exception as e:
                     pass
 
-        return targer_list
+        return target_list
+
+    @input_deserializer
+    def _dispatch_generator_started(self, request: Any) -> Any:
+        """For internal use only."""
+        self._gen = dispach_message(self, request)
+        # check if self._gen is a generator
+        if not hasattr(self._gen, '__iter__'):
+            raise TypeError("Expected a generator or iterable object, got: {}".format(type(self._gen).__name__))
+        
+        return _iris.get_iris().IOP.Generator.Message.Ack._New()
+    
+    @output_serializer
+    def _dispatch_generator_poll(self) -> Any:
+        """For internal use only."""
+        try:
+            return next(self._gen)
+        except StopIteration:
+            return _iris.get_iris().IOP.Generator.Message.Stop._New()

{iris_pex_embedded_python-3.4.4b5 → iris_pex_embedded_python-3.5.0}/src/iop/_business_operation.py

@@ -72,3 +72,4 @@ class _BusinessOperation(_BusinessHost):
         The response object
         """
         return
+    

{iris_pex_embedded_python-3.4.4b5 → iris_pex_embedded_python-3.5.0}/src/iop/_dispatch.py

@@ -1,10 +1,10 @@
 from inspect import signature, Parameter
 from typing import Any, List, Tuple, Callable
 
-from ._serialization import serialize_message, serialize_pickle_message, deserialize_message, deserialize_pickle_message
+from ._serialization import serialize_message, serialize_pickle_message, deserialize_message, deserialize_pickle_message, serialize_message_generator, serialize_pickle_message_generator
 from ._message_validator import is_message_instance, is_pickle_message_instance, is_iris_object_instance
 
-def dispatch_serializer(message: Any) -> Any:
+def dispatch_serializer(message: Any, is_generator: bool = False) -> Any:
     """Serializes the message based on its type.
     
     Args:
@@ -18,8 +18,12 @@ def dispatch_serializer(message: Any) -> Any:
     """
     if message is not None:
         if is_message_instance(message):
+            if is_generator:
+                return serialize_message_generator(message)
             return serialize_message(message)
         elif is_pickle_message_instance(message):
+            if is_generator:
+                return serialize_pickle_message_generator(message)
             return serialize_pickle_message(message)
         elif is_iris_object_instance(message):
             return message
@@ -27,6 +31,9 @@ def dispatch_serializer(message: Any) -> Any:
     if message == "" or message is None:
         return message
 
+    if hasattr(message, '__iter__'):
+        raise TypeError("You may have tried to invoke a generator function without using the 'send_generator_request' method. Please use that method to handle generator functions.")
+
     raise TypeError("The message must be an instance of a class that is a subclass of Message or IRISObject %Persistent class.")
 
 def dispatch_deserializer(serial: Any) -> Any:
@@ -111,8 +118,16 @@ def get_handler_info(host: Any, method_name: str) -> Tuple[str, str] | None:
 
         param: Parameter = next(iter(params.values()))
         annotation = param.annotation
+
+        if isinstance(annotation, str):
+            # return it as is, assuming it's a fully qualified class name
+            return annotation, method_name
+        
+        if is_iris_object_instance(annotation):
+            return f"{type(annotation).__module__}.{type(annotation).__name__}", method_name
         
         if annotation == Parameter.empty or not isinstance(annotation, type):
+
             return None
 
         return f"{annotation.__module__}.{annotation.__name__}", method_name

iris_pex_embedded_python-3.5.0/src/iop/_generator_request.py

@@ -0,0 +1,30 @@
+from typing import Any, Optional, Union
+
+from . import _iris
+from ._dispatch import dispatch_serializer
+
+class _GeneratorRequest:
+    """Generator class to interetate over responses from a request.
+    This class is used to handle the responses from a request in a generator-like manner."""
+
+    def __init__(self, host: Any, target: str, request: Any, 
+                 timeout: int = -1, description: Optional[str] = None) -> None:
+        self.host = host
+        self.target = target
+        self.request = request
+
+        ack_response = self.host.send_request_sync(self.target, dispatch_serializer(self.request, is_generator=True),
+                                                  timeout=timeout, description=description)
+        
+        if ack_response is None or not ack_response._IsA("IOP.Generator.Message.Ack"):
+            raise RuntimeError("Failed to send request, no acknowledgment received.")
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        poll = _iris.get_iris().IOP.Generator.Message.Poll._New()
+        rsp = self.host.send_request_sync(self.target, poll)
+        if rsp is None or (hasattr(rsp, '_IsA') and rsp._IsA("IOP.Generator.Message.Stop")):
+            raise StopIteration("No more responses available.")
+        return rsp

{iris_pex_embedded_python-3.4.4b5 → iris_pex_embedded_python-3.5.0}/src/iop/_message.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
@@ -7,9 +7,13 @@ class _Message:
     This class has no properties or methods. Users subclass Message and add properties.
     The IOP framework provides the persistence to objects derived from the Message class.
     """
-    pass
+    _iris_id: Optional[str] = None
+    
+    def get_iris_id(self) -> Optional[str]:
+        """Get the IRIS ID of the message."""
+        return self._iris_id
 
-class _PickleMessage:
+class _PickleMessage(_Message):
     """ The abstract class that is the superclass for persistent messages sent from one component to another.
     This class has no properties or methods. Users subclass Message and add properties.
     The IOP framework provides the persistence to objects derived from the Message class.
@@ -19,11 +23,18 @@ class _PickleMessage:
 class _PydanticMessage(BaseModel):
     """Base class for Pydantic-based messages that can be serialized to IRIS."""
     
+    _iris_id: Optional[str] = None
+
     def __init__(self, **data: Any):
         super().__init__(**data)
 
-class _PydanticPickleMessage(BaseModel):
+    def get_iris_id(self) -> Optional[str]:
+        """Get the IRIS ID of the message."""
+        return self._iris_id
+
+class _PydanticPickleMessage(_PydanticMessage):
     """Base class for Pydantic-based messages that can be serialized to IRIS."""
-    
+
     def __init__(self, **data: Any):
-        super().__init__(**data)
+        super().__init__(**data)
+

{iris_pex_embedded_python-3.4.4b5 → iris_pex_embedded_python-3.5.0}/src/iop/_serialization.py

@@ -27,27 +27,21 @@ class MessageSerializer:
     """Handles message serialization and deserialization."""
 
     @staticmethod
-    def _convert_to_json_safe(obj: Any) -> Any:
-        """Convert objects to JSON-safe format."""
-        if isinstance(obj, BaseModel):
-            return obj.model_dump_json()
-        elif is_dataclass(obj) and isinstance(obj, _Message):
-            return TempPydanticModel.model_validate(dataclass_to_dict(obj)).model_dump_json()
-        else:
-            raise SerializationError(f"Object {obj} must be a Pydantic model or dataclass Message")
-
-    @staticmethod
-    def serialize(message: Any, use_pickle: bool = False) -> Any:
+    def serialize(message: Any, use_pickle: bool = False, is_generator:bool = False) -> Any:
         """Serializes a message to IRIS format."""
-        if isinstance(message, _PydanticPickleMessage) or use_pickle:
-            return MessageSerializer._serialize_pickle(message)
-        return MessageSerializer._serialize_json(message)
+        message = remove_iris_id(message)
+        if use_pickle:
+            return MessageSerializer._serialize_pickle(message, is_generator)
+        return MessageSerializer._serialize_json(message, is_generator)
 
     @staticmethod
-    def _serialize_json(message: Any) -> Any:
+    def _serialize_json(message: Any, is_generator: bool = False) -> Any:
         json_string = MessageSerializer._convert_to_json_safe(message)
         
-        msg = _iris.get_iris().cls('IOP.Message')._New()
+        if is_generator:
+            msg = _iris.get_iris().cls('IOP.Generator.Message.Start')._New()
+        else:
+            msg = _iris.get_iris().cls('IOP.Message')._New()
         msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
         
         if hasattr(msg, 'buffer') and len(json_string) > msg.buffer:
@@ -55,12 +49,34 @@ class MessageSerializer:
         else:
             msg.json = json_string
         return msg
+    
+    @staticmethod
+    def _serialize_pickle(message: Any, is_generator: bool = False) -> Any:
+        """Serializes a message to IRIS format using pickle."""
+        message = remove_iris_id(message)
+        pickle_string = codecs.encode(pickle.dumps(message), "base64").decode()
+        if is_generator:
+            msg = _iris.get_iris().cls('IOP.Generator.Message.StartPickle')._New()
+        else:
+            msg = _iris.get_iris().cls('IOP.PickleMessage')._New()
+        msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
+        msg.jstr = _Utils.string_to_stream(pickle_string)
+        return msg
 
     @staticmethod
     def deserialize(serial: Any, use_pickle: bool = False) -> Any:
         if use_pickle:
-            return MessageSerializer._deserialize_pickle(serial)
-        return MessageSerializer._deserialize_json(serial)
+            msg=MessageSerializer._deserialize_pickle(serial)
+        else:
+            msg=MessageSerializer._deserialize_json(serial)
+    
+        try:
+            iris_id = serial._Id()
+            msg._iris_id = iris_id if iris_id else None
+        except Exception as e:
+            pass
+
+        return msg
 
     @staticmethod
     def _deserialize_json(serial: Any) -> Any:
@@ -87,14 +103,6 @@ class MessageSerializer:
         except Exception as e:
             raise SerializationError(f"Failed to deserialize JSON: {str(e)}")
 
-    @staticmethod
-    def _serialize_pickle(message: Any) -> Any:
-        pickle_string = codecs.encode(pickle.dumps(message), "base64").decode()
-        msg = _iris.get_iris().cls('IOP.PickleMessage')._New()
-        msg.classname = f"{message.__class__.__module__}.{message.__class__.__name__}"
-        msg.jstr = _Utils.string_to_stream(pickle_string)
-        return msg
-
     @staticmethod
     def _deserialize_pickle(serial: Any) -> Any:
         string = _Utils.stream_to_string(serial.jstr)
@@ -106,6 +114,24 @@ class MessageSerializer:
         if j <= 0:
             raise SerializationError(f"Classname must include a module: {classname}")
         return classname[:j], classname[j+1:]
+    
+    @staticmethod
+    def _convert_to_json_safe(obj: Any) -> Any:
+        """Convert objects to JSON-safe format."""
+        if isinstance(obj, BaseModel):
+            return obj.model_dump_json()
+        elif is_dataclass(obj) and isinstance(obj, _Message):
+            return TempPydanticModel.model_validate(dataclass_to_dict(obj)).model_dump_json()
+        else:
+            raise SerializationError(f"Object {obj} must be a Pydantic model or dataclass Message")
+
+    
+def remove_iris_id(message: Any) -> Any:
+    try:
+        del message._iris_id
+    except AttributeError:
+        pass
+    return message
 
 def dataclass_from_dict(klass: Type | Any, dikt: Dict) -> Any:
     """Converts a dictionary to a dataclass instance.
@@ -165,7 +191,9 @@ def dataclass_to_dict(instance: Any) -> Dict:
     return result
 
 # Maintain backwards compatibility
-serialize_pickle_message = lambda msg: MessageSerializer.serialize(msg, use_pickle=True)
-serialize_message = lambda msg: MessageSerializer.serialize(msg, use_pickle=False)
+serialize_pickle_message = lambda msg: MessageSerializer.serialize(msg, use_pickle=True, is_generator=False)
+serialize_pickle_message_generator = lambda msg: MessageSerializer.serialize(msg, use_pickle=True, is_generator=True)
+serialize_message = lambda msg: MessageSerializer.serialize(msg, use_pickle=False, is_generator=False)
+serialize_message_generator = lambda msg: MessageSerializer.serialize(msg, use_pickle=False, is_generator=True)
 deserialize_pickle_message = lambda serial: MessageSerializer.deserialize(serial, use_pickle=True)
 deserialize_message = lambda serial: MessageSerializer.deserialize(serial, use_pickle=False)

{iris_pex_embedded_python-3.4.4b5 → iris_pex_embedded_python-3.5.0}/src/iop/_utils.py

@@ -1,12 +1,12 @@
 import os
 import sys
-import ast
-import inspect
 import importlib
 import importlib.util
 import importlib.resources
 import json
-from typing import Any, Dict, Optional, Union
+import inspect
+import ast
+from typing import Any, Dict, Optional, Union, Tuple
 
 import xmltodict
 from pydantic import TypeAdapter
@@ -80,6 +80,31 @@ class _Utils():
         """
         _Utils.raise_on_error(_iris.get_iris().cls('IOP.Message.JSONSchema').Import(schema_str,categories,schema_name))
 
+    @staticmethod
+    def get_python_settings() -> Tuple[str,str,str]:
+        import iris_utils._cli
+
+        pythonlib = iris_utils._cli.find_libpython()
+        pythonpath = _Utils._get_python_path()
+        pythonversion = sys.version[:4]
+
+        if not pythonlib:
+            pythonlib = ""
+            
+        return pythonlib, pythonpath, pythonversion
+
+    @staticmethod
+    def _get_python_path() -> str:
+
+        if "VIRTUAL_ENV" in os.environ:
+            return os.path.join(
+                os.environ["VIRTUAL_ENV"],
+                "lib", 
+                f"python{sys.version[:4]}", 
+                "site-packages"
+            )
+        return ""
+
     @staticmethod
     def register_component(module:str,classname:str,path:str,overwrite:int=1,iris_classname:str='Python'):
         """
@@ -99,8 +124,9 @@ class _Utils():
         """
         path = os.path.abspath(os.path.normpath(path))
         fullpath = _Utils.guess_path(module,path)
+        pythonlib, pythonpath, pythonversion = _Utils.get_python_settings()
         try:
-            _iris.get_iris().cls('IOP.Utils').dispatchRegisterComponent(module,classname,path,fullpath,overwrite,iris_classname)
+            _iris.get_iris().cls('IOP.Utils').dispatchRegisterComponent(module,classname,path,fullpath,overwrite,iris_classname,pythonlib,pythonpath,pythonversion)
         except RuntimeError as e:
             # New message error : Make sure the iop package is installed in iris 
             raise RuntimeError("Iris class : IOP.Utils not found. Make sure the iop package is installed in iris eg: iop --init.") from e

{iris_pex_embedded_python-3.4.4b5 → iris_pex_embedded_python-3.5.0}/src/iop/cls/IOP/BusinessProcess.cls

@@ -131,6 +131,18 @@ Storage Default
 <Value name="10">
 <Value>%traceback</Value>
 </Value>
+<Value name="11">
+<Value>%PythonPath</Value>
+</Value>
+<Value name="12">
+<Value>%PythonRuntimeLibrary</Value>
+</Value>
+<Value name="13">
+<Value>%PythonRuntimeLibraryVersion</Value>
+</Value>
+<Value name="14">
+<Value>%Venv</Value>
+</Value>
 </Data>
 <Data name="persistentProperties">
 <Attribute>persistentProperties</Attribute>

{iris_pex_embedded_python-3.4.4b5 → iris_pex_embedded_python-3.5.0}/src/iop/cls/IOP/Common.cls

@@ -7,28 +7,52 @@ Include Ensemble
 Class IOP.Common [ Abstract, ClassType = "", ProcedureBlock, System = 4 ]
 {
 
-/// One or more Classpaths (separated by '|' character) needed in addition to the ones configured in the Java Gateway Service
+/// One or more Classpaths (separated by '|' character)
 Property %classpaths As %String(MAXLEN = "");
 
+/// Classname of the Python class to use
 Property %classname As %String(MAXLEN = "");
 
+/// Module of the Python class to use
 Property %module As %String(MAXLEN = "");
 
+/// Settings for the Python class, in the form of "property=value" pairs, separated by newlines
+/// Example: "property1=value1\nproperty2=value2"
+/// Note: This property is used to set the properties of the Python class dynamically
 Property %settings As %String(MAXLEN = "");
 
 /// Instance of class
 Property %class As %SYS.Python;
 
+/// Enable debugging
+/// If set to 1, the Python class will be debugged using the debugpy module
+/// If set to 0, the Python class will not be debugged
 Property %enable As %Boolean;
 
+/// Timeout in seconds for the an client debugging connection
 Property %timeout As %Numeric [ InitialExpression = 30 ];
 
+/// Port to use for the an client debugging connection
 Property %port As %Numeric [ InitialExpression = 0 ];
 
+/// Path to the Python interpreter for debugpy
 Property %PythonInterpreterPath As %String(MAXLEN = 255);
 
+/// Enable traceback display
 Property %traceback As %Boolean [ InitialExpression = 1 ];
 
+/// Enable virtual environment
+Property %Venv As %Boolean [ InitialExpression = 0 ];
+
+/// Virtual environment site-packages path
+Property %PythonPath As %String(MAXLEN = 255);
+
+/// Path to the Python runtime library
+Property %PythonRuntimeLibrary As %String(MAXLEN = 255);
+
+/// Version of the Python runtime library
+Property %PythonRuntimeLibraryVersion As %String;
+
 /// Get Class
 Method GetClass() As %SYS.Python
 {
@@ -78,18 +102,47 @@ Method DisplayTraceback(ex) As %Status
 Method OnInit() As %Status
 {
     set tSC = $$$OK
+
     try {
+        LOCK +^PythonSettings:5
+
+        if ..%Venv {
+            $$$ThrowOnError(##class(IOP.Utils).SetPythonSettings(..%PythonRuntimeLibrary, ..%PythonPath, ..%PythonRuntimeLibraryVersion))
+        }
+
+        do ..DisplayPythonVersion()
+
         do $system.Python.Debugging(..%traceback)
+
         $$$ThrowOnError(..Connect())
+        LOCK -^PythonSettings
+
         do ..%class."_debugpy"($this)
+
         do ..%class."_dispatch_on_init"($this)
     } catch ex {
 
         set tSC = ..DisplayTraceback(ex)
     }
+    LOCK -^PythonSettings
     quit tSC
 }
 
+Method DisplayPythonVersion()
+{
+    set sys = ##class(%SYS.Python).Import("sys")
+    set version = sys.version
+    set versionInfo = sys."version_info"
+    set major = versionInfo.major
+    set minor = versionInfo.minor
+    set micro = versionInfo.micro
+    set releaseLevel = versionInfo.releaselevel
+    set serial = versionInfo.serial
+
+    $$$LOGINFO("Python Version: "_ version)
+    $$$LOGINFO("Version Info: "_ major_ "."_ minor_ "."_ micro_" ("_ releaseLevel_ ", "_serial_ ")")
+}
+
 ClassMethod SetPythonPath(pClasspaths)
 {
     set sys = ##class(%SYS.Python).Import("sys")
@@ -196,6 +249,11 @@ Method SetPropertyValues()
     set tSQL = tSQL _ " and name <> '%port'"
     set tSQL = tSQL _ " and name <> '%PythonInterpreterPath'"
     set tSQL = tSQL _ " and name <> '%traceback'"
+    set tSQL = tSQL _ " and name <> '%PythonPath'"
+    set tSQL = tSQL _ " and name <> '%PythonRuntimeLibrary'"
+    set tSQL = tSQL _ " and name <> '%PythonRuntimeLibraryVersion'"
+    set tSQL = tSQL _ " and name <> '%settings'"
+    set tSQL = tSQL _ " and name <> '%Venv'"
 
     set tStmt = ##class(%SQL.Statement).%New()
 
@@ -423,4 +481,54 @@ Method dispatchIsRequestDone(
 	quit tSC
 }
 
+XData MessageMap
+{
+<MapItems>
+<MapItem MessageType="IOP.Generator.Message.Start"><Method>OnMsgGeneratorStart</Method></MapItem>
+<MapItem MessageType="IOP.Generator.Message.Stop"><Method>OnMsgGeneratorStop</Method></MapItem>
+<MapItem MessageType="IOP.Generator.Message.Poll"><Method>OnMsgGeneratorPoll</Method></MapItem>
+</MapItems>
+}
+
+Method OnMsgGeneratorStart(
+	pRequest As IOP.Generator.Message.Start,
+	Output pResponse As %Library.Persistent) As %Status
+{
+    #dim tSC As %Status = $$$OK
+	try {
+		set pResponse = ..%class."_dispatch_generator_started"(pRequest)
+	} catch ex {
+		set tSC = ..DisplayTraceback(ex)
+	}
+	quit tSC
+}
+
+Method OnMsgGeneratorStop(
+	pRequest As IOP.Generator.Message.Stop,
+	Output pResponse As %Library.Persistent) As %Status
+{
+    #dim tSC As %Status = $$$OK
+
+	try {
+		set pResponse = ..%class."_dispatch_generator_stopped"(pRequest)
+	} catch ex {
+		set tSC = ..DisplayTraceback(ex)
+	}
+	quit tSC
+}
+
+Method OnMsgGeneratorPoll(
+	pPollIn As IOP.Generator.Message.Poll,
+	Output pResponse As %Library.Persistent) As %Status
+{
+    #dim tSC As %Status = $$$OK
+    set tSC = $$$OK
+    try {
+        set pResponse = ..%class."_dispatch_generator_poll"()
+    } catch ex {
+        set tSC = ..DisplayTraceback(ex)
+    }
+    quit tSC
+}
+
 }

iris_pex_embedded_python-3.5.0/src/iop/cls/IOP/Generator/Message/Ack.cls

@@ -0,0 +1,31 @@
+/* Copyright (c) 2022 by InterSystems Corporation.
+   Cambridge, Massachusetts, U.S.A.  All rights reserved.
+   Confidential property of InterSystems Corporation. */
+
+Class IOP.Generator.Message.Ack Extends (%Persistent, Ens.Util.MessageBodyMethods) [ ClassType = persistent, Inheritance = right, ProcedureBlock, System = 4 ]
+{
+
+Parameter DOMAIN = "Generator";
+
+/// From 'Ens.Util.MessageBodyMethods'
+Method %ShowContents(pZenOutput As %Boolean = 0)
+{
+	Write $$$Text("(session-ack)")
+}
+
+Storage Default
+{
+<Data name="AckDefaultData">
+<Value name="1">
+<Value>%%CLASSNAME</Value>
+</Value>
+</Data>
+<DataLocation>^IOP.Generator.Message.AckD</DataLocation>
+<DefaultData>AckDefaultData</DefaultData>
+<IdLocation>^IOP.Generator.Message.AckD</IdLocation>
+<IndexLocation>^IOP.Generator.Message.AckI</IndexLocation>
+<StreamLocation>^IOP.Generator.Message.AckS</StreamLocation>
+<Type>%Storage.Persistent</Type>
+}
+
+}