zeroc-ice 3.7.11__cp314-cp314-macosx_10_15_universal2.whl → 3.8.0.post1__cp314-cp314-macosx_10_15_universal2.whl

Ice/ProtocolVersion.py

@@ -0,0 +1,39 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from dataclasses import dataclass
+
+
+@dataclass(order=True, unsafe_hash=True)
+class ProtocolVersion:
+    """
+    Represents a version of the Ice protocol. The only version implemented and supported by Ice is version 1.0.
+    
+    Attributes
+    ----------
+    major : int
+        The major version of the Ice protocol.
+    minor : int
+        The minor version of the Ice protocol.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::Ice::ProtocolVersion``.
+    """
+    major: int = 0
+    minor: int = 0
+
+_Ice_ProtocolVersion_t = IcePy.defineStruct(
+    "::Ice::ProtocolVersion",
+    ProtocolVersion,
+    (),
+    (
+        ("major", (), IcePy._t_byte),
+        ("minor", (), IcePy._t_byte)
+    ))
+
+__all__ = ["ProtocolVersion", "_Ice_ProtocolVersion_t"]

Ice/Proxy.py

@@ -0,0 +1,126 @@
+# Copyright (c) ZeroC, Inc.
+
+import IcePy
+
+from .ObjectPrx import ObjectPrx
+
+IcePy._t_ObjectPrx = IcePy.defineProxy("::Ice::Object", IcePy.ObjectPrx)
+
+__name__ = "Ice"
+
+
+#
+# Proxy comparison functions.
+#
+
+
+def proxyIdentityEqual(lhs: ObjectPrx | None, rhs: ObjectPrx | None) -> bool:
+    """
+    Checks if the object identities of two proxies are equal.
+
+    Parameters
+    ----------
+    lhs : Ice.ObjectPrx | None
+        A proxy.
+    rhs : Ice.ObjectPrx | None
+        A proxy.
+
+    Returns
+    -------
+    bool
+        ``True`` if the identity in ``lhs`` is equal to the identity in ``rhs``,
+        ``False`` otherwise.
+    """
+    return proxyIdentityCompare(lhs, rhs) == 0
+
+
+def proxyIdentityCompare(lhs: ObjectPrx | None, rhs: ObjectPrx | None) -> int:
+    """
+    Compares the object identities of two proxies.
+
+    Parameters
+    ----------
+    lhs : Ice.ObjectPrx | None
+        A proxy.
+    rhs : Ice.ObjectPrx | None
+        A proxy.
+
+    Returns
+    -------
+    int
+        ``-1`` if the identity in ``lhs`` compares less than the identity in ``rhs``;
+        ``0`` if the identities compare equal; ``1``, otherwise.
+    """
+    if (lhs and not isinstance(lhs, ObjectPrx)) or (rhs and not isinstance(rhs, ObjectPrx)):
+        raise ValueError("argument is not a proxy")
+    if not lhs and not rhs:
+        return 0
+    elif not lhs and rhs:
+        return -1
+    elif lhs and not rhs:
+        return 1
+    else:
+        assert lhs is not None and rhs is not None
+        lid = lhs.ice_getIdentity()
+        rid = rhs.ice_getIdentity()
+        return (lid > rid) - (lid < rid)
+
+
+def proxyIdentityAndFacetEqual(lhs: ObjectPrx | None, rhs: ObjectPrx | None) -> bool:
+    """
+    Checks if the object identities and facets of two proxies are equal.
+
+    Parameters
+    ----------
+    lhs : Ice.ObjectPrx | None
+        A proxy.
+    rhs : Ice.ObjectPrx | None
+        A proxy.
+
+    Returns
+    -------
+    bool
+        ``True`` if the identity and facet in ``lhs`` are equal to the identity and facet in ``rhs``,
+        ``False`` otherwise.
+    """
+    return proxyIdentityAndFacetCompare(lhs, rhs) == 0
+
+
+def proxyIdentityAndFacetCompare(lhs: ObjectPrx | None, rhs: ObjectPrx | None) -> int:
+    """
+    Compares the object identities and facets of two proxies.
+
+    Parameters
+    ----------
+    lhs : Ice.ObjectPrx | None
+        A proxy.
+    rhs : Ice.ObjectPrx | None
+        A proxy.
+
+    Returns
+    -------
+    int
+        ``-1`` if the identity and facet in ``lhs`` compare less than the identity and
+        facet in ``rhs``; ``0`` if the identities and facets compare equal; ``1``, otherwise.
+    """
+    if (lhs and not isinstance(lhs, ObjectPrx)) or (rhs and not isinstance(rhs, ObjectPrx)):
+        raise ValueError("argument is not a proxy")
+    if lhs is None and rhs is None:
+        return 0
+    elif lhs is None and rhs is not None:
+        return -1
+    elif lhs is not None and rhs is None:
+        return 1
+    else:
+        assert lhs is not None and rhs is not None
+        if lhs.ice_getIdentity() != rhs.ice_getIdentity():
+            lid = lhs.ice_getIdentity()
+            rid = rhs.ice_getIdentity()
+            return (lid > rid) - (lid < rid)
+        else:
+            lf = lhs.ice_getFacet()
+            rf = rhs.ice_getFacet()
+            return (lf > rf) - (lf < rf)
+
+
+__all__ = ["proxyIdentityEqual", "proxyIdentityCompare", "proxyIdentityAndFacetEqual", "proxyIdentityAndFacetCompare"]

Ice/RemoteLogger.py

@@ -0,0 +1,238 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.LogMessage import _Ice_LogMessage_t
+
+from Ice.LogMessageSeq import _Ice_LogMessageSeq_t
+
+from Ice.Object import Object
+
+from Ice.ObjectPrx import ObjectPrx
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.OperationMode import OperationMode
+
+from Ice.RemoteLogger_forward import _Ice_RemoteLoggerPrx_t
+
+from abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Ice.Current import Current
+    from Ice.LogMessage import LogMessage
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class RemoteLoggerPrx(ObjectPrx):
+    """
+    Represents an Ice object that accepts log messages. It's called by the implementation of :class:`Ice.LoggerAdminPrx`.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Ice::RemoteLogger``.
+    """
+
+    def init(self, prefix: str, logMessages: Sequence[LogMessage], context: dict[str, str] | None = None) -> None:
+        """
+        Attaches a remote logger to the local logger.
+        
+        Parameters
+        ----------
+        prefix : str
+            The prefix of the associated local Logger.
+        logMessages : Sequence[LogMessage]
+            Old log messages generated before "now".
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return RemoteLogger._op_init.invoke(self, ((prefix, logMessages), context))
+
+    def initAsync(self, prefix: str, logMessages: Sequence[LogMessage], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Attaches a remote logger to the local logger.
+        
+        Parameters
+        ----------
+        prefix : str
+            The prefix of the associated local Logger.
+        logMessages : Sequence[LogMessage]
+            Old log messages generated before "now".
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return RemoteLogger._op_init.invokeAsync(self, ((prefix, logMessages), context))
+
+    def log(self, message: LogMessage, context: dict[str, str] | None = None) -> None:
+        """
+        Logs a LogMessage.
+        
+        Parameters
+        ----------
+        message : LogMessage
+            The message to log.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Notes
+        -----
+            :meth:`Ice.RemoteLoggerPrx.logAsync` may be called by :class:`Ice.LoggerAdminPrx` before :meth:`Ice.RemoteLoggerPrx.initAsync`.
+        """
+        return RemoteLogger._op_log.invoke(self, ((message, ), context))
+
+    def logAsync(self, message: LogMessage, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Logs a LogMessage.
+        
+        Parameters
+        ----------
+        message : LogMessage
+            The message to log.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        
+        Notes
+        -----
+            :meth:`Ice.RemoteLoggerPrx.logAsync` may be called by :class:`Ice.LoggerAdminPrx` before :meth:`Ice.RemoteLoggerPrx.initAsync`.
+        """
+        return RemoteLogger._op_log.invokeAsync(self, ((message, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> RemoteLoggerPrx | None:
+        return checkedCast(RemoteLoggerPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[RemoteLoggerPrx | None ]:
+        return checkedCastAsync(RemoteLoggerPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> RemoteLoggerPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> RemoteLoggerPrx | None:
+        return uncheckedCast(RemoteLoggerPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::RemoteLogger"
+
+IcePy.defineProxy("::Ice::RemoteLogger", RemoteLoggerPrx)
+
+class RemoteLogger(Object, ABC):
+    """
+    Represents an Ice object that accepts log messages. It's called by the implementation of :class:`Ice.LoggerAdminPrx`.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Ice::RemoteLogger``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::Ice::RemoteLogger", )
+    _op_init: IcePy.Operation
+    _op_log: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::RemoteLogger"
+
+    @abstractmethod
+    def init(self, prefix: str, logMessages: list[LogMessage], current: Current) -> None | Awaitable[None]:
+        """
+        Attaches a remote logger to the local logger.
+        
+        Parameters
+        ----------
+        prefix : str
+            The prefix of the associated local Logger.
+        logMessages : list[LogMessage]
+            Old log messages generated before "now".
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+    @abstractmethod
+    def log(self, message: LogMessage, current: Current) -> None | Awaitable[None]:
+        """
+        Logs a LogMessage.
+        
+        Parameters
+        ----------
+        message : LogMessage
+            The message to log.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        
+        Notes
+        -----
+            :meth:`Ice.RemoteLoggerPrx.logAsync` may be called by :class:`Ice.LoggerAdminPrx` before :meth:`Ice.RemoteLoggerPrx.initAsync`.
+        """
+        pass
+
+RemoteLogger._op_init = IcePy.Operation(
+    "init",
+    "init",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0), ((), _Ice_LogMessageSeq_t, False, 0)),
+    (),
+    None,
+    ())
+
+RemoteLogger._op_log = IcePy.Operation(
+    "log",
+    "log",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _Ice_LogMessage_t, False, 0),),
+    (),
+    None,
+    ())
+
+__all__ = ["RemoteLogger", "RemoteLoggerPrx", "_Ice_RemoteLoggerPrx_t"]

Ice/RemoteLoggerAlreadyAttachedException.py

@@ -0,0 +1,34 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.UserException import UserException
+
+from dataclasses import dataclass
+
+
+@dataclass
+class RemoteLoggerAlreadyAttachedException(UserException):
+    """
+    Thrown when the provided :class:`Ice.RemoteLoggerPrx` was previously attached to a :class:`Ice.LoggerAdminPrx`.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::Ice::RemoteLoggerAlreadyAttachedException``.
+    """
+
+    _ice_id = "::Ice::RemoteLoggerAlreadyAttachedException"
+
+_Ice_RemoteLoggerAlreadyAttachedException_t = IcePy.defineException(
+    "::Ice::RemoteLoggerAlreadyAttachedException",
+    RemoteLoggerAlreadyAttachedException,
+    (),
+    None,
+    ())
+
+setattr(RemoteLoggerAlreadyAttachedException, '_ice_type', _Ice_RemoteLoggerAlreadyAttachedException_t)
+
+__all__ = ["RemoteLoggerAlreadyAttachedException", "_Ice_RemoteLoggerAlreadyAttachedException_t"]

Ice/RemoteLogger_forward.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+_Ice_RemoteLoggerPrx_t = IcePy.declareProxy("::Ice::RemoteLogger")
+
+__all__ = ["_Ice_RemoteLoggerPrx_t"]

Ice/ReplyStatus.py

@@ -0,0 +1,91 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from enum import Enum
+
+class ReplyStatus(Enum):
+    """
+    Represents the status of a reply.
+    A reply status can have any value in the range 0..255. Do not use this enum to marshal or unmarshal a reply
+    status unless you know its value corresponds to one of the enumerators defined below.
+    
+    Notes
+    -----
+        The Slice compiler generated this enum class from Slice enumeration ``::Ice::ReplyStatus``.
+    """
+
+    Ok = 0
+    """
+    The dispatch completed successfully.
+    """
+
+    UserException = 1
+    """
+    The dispatch completed with a Slice user exception.
+    """
+
+    ObjectNotExist = 2
+    """
+    The dispatch could not find an implementation for the target object.
+    """
+
+    FacetNotExist = 3
+    """
+    The dispatch found an implementation for the target object but could not find the requested facet.
+    """
+
+    OperationNotExist = 4
+    """
+    The dispatch found an implementation for the target object but could not find the requested operation.
+    """
+
+    UnknownLocalException = 5
+    """
+    The dispatch failed with an Ice local exception.
+    """
+
+    UnknownUserException = 6
+    """
+    The dispatch failed with a Slice user exception that does not conform to the exception specification of
+    the operation.
+    """
+
+    UnknownException = 7
+    """
+    The dispatch failed with some other exception (neither an Ice local exception nor a Slice user exception).
+    """
+
+    InvalidData = 8
+    """
+    The dispatch failed because the request payload could not be unmarshaled. It is typically due to a mismatch
+    in the Slice definitions used by the client and the server.
+    """
+
+    Unauthorized = 9
+    """
+    The caller is not authorized to access the requested resource.
+    """
+
+_Ice_ReplyStatus_t = IcePy.defineEnum(
+    "::Ice::ReplyStatus",
+    ReplyStatus,
+    (),
+    {
+        0: ReplyStatus.Ok,
+        1: ReplyStatus.UserException,
+        2: ReplyStatus.ObjectNotExist,
+        3: ReplyStatus.FacetNotExist,
+        4: ReplyStatus.OperationNotExist,
+        5: ReplyStatus.UnknownLocalException,
+        6: ReplyStatus.UnknownUserException,
+        7: ReplyStatus.UnknownException,
+        8: ReplyStatus.InvalidData,
+        9: ReplyStatus.Unauthorized,
+    }
+)
+
+__all__ = ["ReplyStatus", "_Ice_ReplyStatus_t"]