iris-pex-embedded-python 3.7.2b2__py3-none-any.whl → 4.0.0__py3-none-any.whl

iop/_director.py

@@ -1,333 +0,0 @@
-import asyncio
-import datetime
-import functools
-import signal
-from dataclasses import dataclass
-
-from . import _iris
-from ._dispatch import dispatch_deserializer, dispatch_serializer
-from ._utils import _Utils
-
-
-@dataclass
-class SigintHandler:
-    sigint: bool = False
-    sigint_log: bool = False
-    log_only: bool = False
-
-    def signal_handler(self, signal, frame):
-        if self.sigint or self.log_only:
-            self.sigint_log = True
-        self.sigint = True
-
-
-class _Director:
-    """The Directorclass is used for nonpolling business services, that is, business services which are not automatically
-    called by the production framework (through the inbound adapter) at the call interval.
-    Instead these business services are created by a custom application by calling the Director.CreateBusinessService() method.
-    """
-
-    _bs = {}
-
-    def get_business_service(self, target, force_session_id=False):
-        """get the business service
-        Parameters:
-        target: the name of the business service
-        force_session_id: if True, force the session id to be a new one
-        """
-        if target not in self._bs or self._bs[target] is None:
-            self._bs[target] = _Director.create_python_business_service(target)
-        if force_session_id:
-            self._bs[target].iris_handle._SessionId = ""
-            self._bs[target].iris_handle.ForceSessionId()
-        return self._bs[target]
-
-    @staticmethod
-    def CreateBusinessService(target):
-        """DEPRECATED : use create_business_service
-        The CreateBusinessService() method initiates the specifiied business service.
-
-        Parameters:
-        connection: an IRISConnection object that specifies the connection to an IRIS instance for Java.
-        target: a string that specifies the name of the business service in the production definition.
-
-        Returns:
-            an object that contains an instance of IRISBusinessService
-        """
-        return _Director.create_business_service(target)
-
-    @staticmethod
-    def create_business_service(target):
-        """The create_business_service() method initiates the specified business service.
-
-        Parameters:
-        connection: an IRISConnection object that specifies the connection to an IRIS instance for Java.
-        target: a string that specifies the name of the business service in the production definition.
-
-        Returns:
-            an object that contains an instance of IRISBusinessService
-        """
-        iris_object = (
-            _iris.get_iris().cls("IOP.Director").dispatchCreateBusinessService(target)
-        )
-        return iris_object
-
-    @staticmethod
-    def create_python_business_service(target):
-        """The create_business_service() method initiates the specified business service.
-
-        Parameters:
-        connection: an IRISConnection object that specifies the connection to an IRIS instance for Java.
-        target: a string that specifies the name of the business service in the production definition.
-
-        Returns:
-            an object that contains an instance of IRISBusinessService
-        """
-        iris_object = (
-            _iris.get_iris().cls("IOP.Director").dispatchCreateBusinessService(target)
-        )
-        return iris_object.GetClass()
-
-    ### List of function to manage the production
-    ### start production
-    @staticmethod
-    def start_production_with_log(production_name=None):
-        if production_name is None or production_name == "":
-            production_name = _Director.get_default_production()
-        # create two async task
-        loop = asyncio.get_event_loop()
-        # add signal handler
-        handler = SigintHandler()
-        loop.add_signal_handler(
-            signal.SIGINT,
-            functools.partial(handler.signal_handler, signal.SIGINT, loop),
-        )
-        loop.run_until_complete(
-            asyncio.gather(
-                _Director._start_production_async(production_name, handler),
-                _Director._log_production_async(handler),
-            )
-        )
-        loop.close()
-
-    @staticmethod
-    async def _start_production_async(production_name: str, handler: SigintHandler):
-        _Director.start_production(production_name)
-        while True:
-            if handler.sigint:
-                _Director.stop_production()
-                break
-            await asyncio.sleep(1)
-
-    @staticmethod
-    def start_production(production_name=None):
-        if production_name is None or production_name == "":
-            production_name = _Director.get_default_production()
-        _iris.get_iris().cls("Ens.Director").StartProduction(production_name)
-
-    ### stop production
-    @staticmethod
-    def stop_production():
-        _iris.get_iris().cls("Ens.Director").StopProduction()
-
-    ### restart production
-    @staticmethod
-    def restart_production():
-        _iris.get_iris().cls("Ens.Director").RestartProduction()
-
-    ### shutdown production
-    @staticmethod
-    def shutdown_production():
-        _iris.get_iris().cls("Ens.Director").StopProduction(10, 1)
-
-    ### update production
-    @staticmethod
-    def update_production():
-        _iris.get_iris().cls("Ens.Director").UpdateProduction()
-
-    ### list production
-    @staticmethod
-    def list_productions():
-        return _iris.get_iris().cls("IOP.Director").dispatchListProductions()
-
-    ### status production
-    @staticmethod
-    def status_production():
-        dikt = _iris.get_iris().cls("IOP.Director").StatusProduction()
-        if dikt["Production"] is None or dikt["Production"] == "":
-            dikt["Production"] = _Director.get_default_production()
-        return dikt
-
-    ### set default production
-    @staticmethod
-    def set_default_production(production_name=""):
-        # set ^Ens.Configuration("SuperUser","LastProduction")
-        glb = _iris.get_iris().gref("^Ens.Configuration")
-        glb["csp", "LastProduction"] = production_name
-
-    ### get default production
-    @staticmethod
-    def get_default_production():
-        glb = _iris.get_iris().gref("^Ens.Configuration")
-        default_production_name = glb["csp", "LastProduction"]
-        if default_production_name is None or default_production_name == "":
-            default_production_name = "Not defined"
-        return default_production_name
-
-    @staticmethod
-    def format_log(row: list) -> str:
-        # 0,  1,          2,   3,         4,         5,           6,            7,     8,    9,          10,        11
-        # ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
-        # yield all except stack aand tracecat
-        # in first position, the timelogged
-        # cast the result to string
-        # convert Type to its string value
-        # Assert,Error,Warning,Info,Trace,Alert
-        typ = row[11]
-        if typ == 1:
-            typ = "Assert"
-        elif typ == 2:
-            typ = "Error"
-        elif typ == 3:
-            typ = "Warning"
-        elif typ == 4:
-            typ = "Info"
-        elif typ == 5:
-            typ = "Trace"
-        elif typ == 6:
-            typ = "Alert"
-        return (
-            str(row[9])
-            + " "
-            + typ
-            + " "
-            + str(row[1])
-            + " "
-            + str(row[2])
-            + " "
-            + str(row[3])
-            + " "
-            + str(row[4])
-            + " "
-            + str(row[5])
-            + " "
-            + str(row[6])
-            + " "
-            + str(row[8])
-        )
-
-    @staticmethod
-    def read_top_log(top) -> list:
-        sql = """
-        SELECT top ?
-        ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
-        FROM Ens_Util.Log
-        order by id desc
-        """
-        result = []
-        stmt = _iris.get_iris().sql.prepare(sql)
-        rs = stmt.execute(top)
-        for row in rs:
-            result.append(_Director.format_log(row))
-        return result
-
-    @staticmethod
-    def read_log() -> list:
-        sql = """
-        SELECT 
-        ID, ConfigName, Job, MessageId, SessionId, SourceClass, SourceMethod, Stack, Text, TimeLogged, TraceCat, Type
-        FROM Ens_Util.Log
-        where TimeLogged >= ?
-        order by id desc
-        """
-        result = []
-        stmt = _iris.get_iris().sql.prepare(sql)
-        time = datetime.datetime.now() - datetime.timedelta(seconds=1)
-        # convert to utc time
-        time = time.astimezone(datetime.timezone.utc)
-        rs = stmt.execute(time.isoformat(sep=" "))
-        for row in rs:
-            result.append(_Director.format_log(row))
-        return result
-
-    @staticmethod
-    async def _log_production_async(handler):
-        """Log production
-        if ctrl+c is pressed, the log is stopped
-        """
-        while True:
-            for row in reversed(_Director.read_log()):
-                print(row)
-            if handler.sigint_log:
-                break
-            await asyncio.sleep(1)
-
-    @staticmethod
-    def log_production_top(top=10):
-        """
-        Log the top N logs of the production
-        Parameters:
-        top: the number of log to display
-        """
-        for row in reversed(_Director.read_top_log(top)):
-            print(row)
-
-    @staticmethod
-    def log_production():
-        """Log production
-        if ctrl+c is pressed, the log is stopped
-        """
-        loop = asyncio.get_event_loop()
-        handler = SigintHandler(log_only=True)
-        loop.add_signal_handler(
-            signal.SIGINT,
-            functools.partial(handler.signal_handler, signal.SIGINT, loop),
-        )
-
-        for row in reversed(_Director.read_top_log(10)):
-            print(row)
-
-        loop.run_until_complete(_Director._log_production_async(handler))
-        loop.close()
-
-    @staticmethod
-    def test_component(target, message=None, classname=None, body=None):
-        """
-        Test a component
-        Parameters:
-        target: the name of the component
-        classname: the name of the class to test
-        body: the body of the message
-        """
-        iris = _iris.get_iris()
-        if not message:
-            message = iris.cls("Ens.Request")._New()
-        if classname:
-            # if classname start with 'iris.' then create an iris object
-            if classname.startswith("iris."):
-                # strip the iris. prefix
-                classname = classname[5:]
-                if body:
-                    message = iris.cls(classname)._New(body)
-                else:
-                    message = iris.cls(classname)._New()
-            # else create a python object
-            else:
-                # python message are casted to Grongier.PEX.Message
-                message = iris.cls("IOP.Message")._New()
-                message.classname = classname
-                if body:
-                    message.json = body
-                else:
-                    message.json = _Utils.string_to_stream("{}")
-        # serialize the message
-        serial_message = dispatch_serializer(message)
-        response = iris.cls("IOP.Utils").dispatchTestComponent(target, serial_message)
-        try:
-            deserialized_response = dispatch_deserializer(response)
-        except ImportError:
-            # can't import the class, return the string
-            deserialized_response = (
-                f"{response.classname} : {_Utils.stream_to_string(response.jstr)}"
-            )
-        return deserialized_response

iop/_dispatch.py

@@ -1,194 +0,0 @@
-from inspect import signature, Parameter
-from typing import Any, List, Tuple
-
-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,
-)
-from ._persistent_message import (
-    deserialize_persistent_message,
-    get_iris_object_classname,
-    is_persistent_message_instance,
-    serialize_persistent_message,
-)
-
-
-_MESSAGE_CLASSES = {
-    "IOP.Message",
-    "Grongier.PEX.Message",
-    "IOP.Generator.Message.Start",
-}
-_PICKLE_MESSAGE_CLASSES = {
-    "IOP.PickleMessage",
-    "Grongier.PEX.PickleMessage",
-    "IOP.Generator.Message.StartPickle",
-}
-
-
-def dispatch_serializer(message: Any, is_generator: bool = False) -> Any:
-    """Serializes the message based on its type.
-
-    Args:
-        message: The message to serialize
-
-    Returns:
-        The serialized message
-
-    Raises:
-        TypeError: If message is invalid type
-    """
-    if message is not None:
-        if is_persistent_message_instance(message):
-            return serialize_persistent_message(message, is_generator=is_generator)
-        elif 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
-
-    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:
-    """Deserializes the message based on its type.
-
-    Args:
-        serial: The serialized message
-
-    Returns:
-        The deserialized message
-    """
-    if serial is None or not type(serial).__module__.startswith("iris"):
-        return serial
-
-    iris_classname = get_iris_object_classname(serial)
-
-    if iris_classname in _MESSAGE_CLASSES:
-        return deserialize_message(serial)
-
-    if iris_classname in _PICKLE_MESSAGE_CLASSES:
-        return deserialize_pickle_message(serial)
-
-    deserialized = deserialize_persistent_message(serial, iris_classname=iris_classname)
-    if deserialized is not serial:
-        return deserialized
-
-    if serial._IsA("IOP.Message") or serial._IsA("Grongier.PEX.Message"):
-        return deserialize_message(serial)
-
-    if serial._IsA("IOP.PickleMessage") or serial._IsA("Grongier.PEX.PickleMessage"):
-        return deserialize_pickle_message(serial)
-
-    return serial
-
-
-def dispach_message(host: Any, request: Any) -> Any:
-    """Dispatches the message to the appropriate method.
-
-    Args:
-        request: The request object
-
-    Returns:
-        The response object
-    """
-    call = "on_message"
-
-    module = request.__class__.__module__
-    classname = request.__class__.__name__
-
-    for msg, method in host.DISPATCH:
-        if msg == module + "." + classname:
-            call = method
-
-    return getattr(host, call)(request)
-
-
-def create_dispatch(host: Any) -> None:
-    """Creates a dispatch table mapping class names to their handler methods.
-    The dispatch table consists of tuples of (fully_qualified_class_name, method_name).
-    Only methods that take a single typed parameter are considered as handlers.
-    """
-    dispatch = _declared_dispatch(host)
-
-    for method_name in get_callable_methods(host):
-        handler_info = get_handler_info(host, method_name)
-        if handler_info and handler_info not in dispatch:
-            dispatch.append(handler_info)
-
-    host.DISPATCH = dispatch
-
-
-def _declared_dispatch(host: Any) -> List[Tuple[str, str]]:
-    if "DISPATCH" in getattr(host, "__dict__", {}):
-        return list(host.__dict__["DISPATCH"])
-
-    class_dispatch = host.__class__.__dict__.get("DISPATCH")
-    if class_dispatch is not None:
-        return list(class_dispatch)
-
-    return []
-
-
-def get_callable_methods(host: Any) -> List[str]:
-    """Returns a list of callable method names that don't start with underscore."""
-    return [
-        func
-        for func in dir(host)
-        if callable(getattr(host, func)) and not func.startswith("_")
-    ]
-
-
-def get_handler_info(host: Any, method_name: str) -> Tuple[str, str] | None:
-    """Analyzes a method to determine if it's a valid message handler.
-    Returns a tuple of (fully_qualified_class_name, method_name) if valid,
-    None otherwise.
-    """
-    try:
-        params = signature(getattr(host, method_name)).parameters
-        if len(params) != 1:
-            return 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
-
-    except ValueError:
-        return None

iop/_local.py

@@ -1,106 +0,0 @@
-"""Local director: thin instance-method wrapper around static _Director calls.
-
-This gives the CLI a uniform interface so it can swap between
-_LocalDirector and _RemoteDirector without any branching.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-from typing import Optional
-
-from ._director import _Director
-from ._utils import _Utils
-from ._director_protocol import DirectorProtocol as _DirectorProtocol  # noqa: F401 --- IGNORE ---
-
-
-class _LocalDirector(_DirectorProtocol):
-    """Local director: thin instance-method wrapper around static _Director calls."""
-
-    # ------------------------------------------------------------------
-    # Production lifecycle
-    # ------------------------------------------------------------------
-
-    def get_default_production(self) -> str:
-        return _Director.get_default_production()
-
-    def set_default_production(self, production_name: str = "") -> None:
-        _Director.set_default_production(production_name)
-
-    def list_productions(self) -> dict:
-        return _Director.list_productions()
-
-    def status_production(self) -> dict:
-        return _Director.status_production()
-
-    def start_production(self, production_name: Optional[str] = None) -> None:
-        _Director.start_production(production_name)
-
-    def start_production_with_log(self, production_name: Optional[str] = None) -> None:
-        _Director.start_production_with_log(production_name)
-
-    def stop_production(self) -> None:
-        _Director.stop_production()
-
-    def shutdown_production(self) -> None:
-        _Director.shutdown_production()
-
-    def restart_production(self) -> None:
-        _Director.restart_production()
-
-    def update_production(self) -> None:
-        _Director.update_production()
-
-    # ------------------------------------------------------------------
-    # Logging
-    # ------------------------------------------------------------------
-
-    def log_production_top(self, top: int = 10) -> None:
-        _Director.log_production_top(top)
-
-    def log_production(self) -> None:
-        _Director.log_production()
-
-    # ------------------------------------------------------------------
-    # Test
-    # ------------------------------------------------------------------
-
-    def test_component(
-        self,
-        target: Optional[str],
-        message=None,
-        classname: Optional[str] = None,
-        body: "str | dict | None" = None,
-        restart: bool = True,  # ignored locally — included to satisfy DirectorProtocol
-    ):
-        return _Director.test_component(target, message, classname, body)
-
-    # ------------------------------------------------------------------
-    # Export
-    # ------------------------------------------------------------------
-
-    def export_production(self, production_name: str) -> dict:
-        return json.loads(_Utils.export_production(production_name))
-
-    # ------------------------------------------------------------------
-    # Init / setup
-    # ------------------------------------------------------------------
-
-    def setup(self, path: Optional[str] = None) -> None:
-        _Utils.setup(path)
-
-    # ------------------------------------------------------------------
-    # Migrate
-    # ------------------------------------------------------------------
-
-    def migrate(self, path: str) -> None:
-        _Utils.migrate(path, mode="LOCAL", namespace=self.namespace)
-
-    # ------------------------------------------------------------------
-    # Metadata
-    # ------------------------------------------------------------------
-
-    @property
-    def namespace(self) -> str:
-        return os.getenv("IRISNAMESPACE", "not set")

iop/_message.py

@@ -1,45 +0,0 @@
-from typing import Any, Optional
-
-from pydantic import BaseModel
-
-
-class _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.
-    """
-
-    _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(_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.
-    """
-
-    pass
-
-
-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)
-
-    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)

iop/_polling_business_service.py

@@ -1,6 +0,0 @@
-class _PollingBusinessServiceMixin:
-    """Mixin for services polled by the default IRIS inbound adapter."""
-
-    @staticmethod
-    def get_adapter_type() -> str:
-        return "Ens.InboundAdapter"