zeroc-ice 3.7.10__cp312-cp312-win_amd64.whl → 3.8.0__cp312-cp312-win_amd64.whl

Ice/PropertiesAdmin.py

@@ -0,0 +1,302 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+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.PropertiesAdmin_forward import _Ice_PropertiesAdminPrx_t
+
+from Ice.PropertyDict import _Ice_PropertyDict_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 collections.abc import Awaitable
+    from collections.abc import Mapping
+    from collections.abc import Sequence
+
+
+class PropertiesAdminPrx(ObjectPrx):
+    """
+    Provides remote access to the properties of a communicator.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Ice::PropertiesAdmin``.
+    """
+
+    def getProperty(self, key: str, context: dict[str, str] | None = None) -> str:
+        """
+        Gets a property by key.
+        
+        Parameters
+        ----------
+        key : str
+            The property key.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        str
+            The property value. This value is empty if the property is not set.
+        """
+        return PropertiesAdmin._op_getProperty.invoke(self, ((key, ), context))
+
+    def getPropertyAsync(self, key: str, context: dict[str, str] | None = None) -> Awaitable[str]:
+        """
+        Gets a property by key.
+        
+        Parameters
+        ----------
+        key : str
+            The property key.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[str]
+            The property value. This value is empty if the property is not set.
+        """
+        return PropertiesAdmin._op_getProperty.invokeAsync(self, ((key, ), context))
+
+    def getPropertiesForPrefix(self, prefix: str, context: dict[str, str] | None = None) -> dict[str, str]:
+        """
+        Gets all properties whose keys begin with ``prefix``. If ``prefix`` is the empty string then all properties
+        are returned.
+        
+        Parameters
+        ----------
+        prefix : str
+            The prefix to search for. May be empty.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        dict[str, str]
+            The matching property set.
+        """
+        return PropertiesAdmin._op_getPropertiesForPrefix.invoke(self, ((prefix, ), context))
+
+    def getPropertiesForPrefixAsync(self, prefix: str, context: dict[str, str] | None = None) -> Awaitable[dict[str, str]]:
+        """
+        Gets all properties whose keys begin with ``prefix``. If ``prefix`` is the empty string then all properties
+        are returned.
+        
+        Parameters
+        ----------
+        prefix : str
+            The prefix to search for. May be empty.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[dict[str, str]]
+            The matching property set.
+        """
+        return PropertiesAdmin._op_getPropertiesForPrefix.invokeAsync(self, ((prefix, ), context))
+
+    def setProperties(self, newProperties: Mapping[str, str], context: dict[str, str] | None = None) -> None:
+        """
+        Updates the communicator's properties with the given property set. If an entry in ``newProperties`` matches
+        the name of an existing property, that property's value is replaced with the new value. If the new value is
+        the empty string, the property is removed. Existing properties that are not modified or removed by the
+        entries in ``newProperties`` are not affected by this update.
+        
+        Parameters
+        ----------
+        newProperties : Mapping[str, str]
+            Properties to add, change, or remove.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return PropertiesAdmin._op_setProperties.invoke(self, ((newProperties, ), context))
+
+    def setPropertiesAsync(self, newProperties: Mapping[str, str], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Updates the communicator's properties with the given property set. If an entry in ``newProperties`` matches
+        the name of an existing property, that property's value is replaced with the new value. If the new value is
+        the empty string, the property is removed. Existing properties that are not modified or removed by the
+        entries in ``newProperties`` are not affected by this update.
+        
+        Parameters
+        ----------
+        newProperties : Mapping[str, str]
+            Properties to add, change, or remove.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return PropertiesAdmin._op_setProperties.invokeAsync(self, ((newProperties, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> PropertiesAdminPrx | None:
+        return checkedCast(PropertiesAdminPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[PropertiesAdminPrx | None ]:
+        return checkedCastAsync(PropertiesAdminPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> PropertiesAdminPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> PropertiesAdminPrx | None:
+        return uncheckedCast(PropertiesAdminPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::PropertiesAdmin"
+
+IcePy.defineProxy("::Ice::PropertiesAdmin", PropertiesAdminPrx)
+
+class PropertiesAdmin(Object, ABC):
+    """
+    Provides remote access to the properties of a communicator.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Ice::PropertiesAdmin``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::Ice::PropertiesAdmin", )
+    _op_getProperty: IcePy.Operation
+    _op_getPropertiesForPrefix: IcePy.Operation
+    _op_setProperties: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::PropertiesAdmin"
+
+    @abstractmethod
+    def getProperty(self, key: str, current: Current) -> str | Awaitable[str]:
+        """
+        Gets a property by key.
+        
+        Parameters
+        ----------
+        key : str
+            The property key.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        str | Awaitable[str]
+            The property value. This value is empty if the property is not set.
+        """
+        pass
+
+    @abstractmethod
+    def getPropertiesForPrefix(self, prefix: str, current: Current) -> Mapping[str, str] | Awaitable[Mapping[str, str]]:
+        """
+        Gets all properties whose keys begin with ``prefix``. If ``prefix`` is the empty string then all properties
+        are returned.
+        
+        Parameters
+        ----------
+        prefix : str
+            The prefix to search for. May be empty.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        Mapping[str, str] | Awaitable[Mapping[str, str]]
+            The matching property set.
+        """
+        pass
+
+    @abstractmethod
+    def setProperties(self, newProperties: dict[str, str], current: Current) -> None | Awaitable[None]:
+        """
+        Updates the communicator's properties with the given property set. If an entry in ``newProperties`` matches
+        the name of an existing property, that property's value is replaced with the new value. If the new value is
+        the empty string, the property is removed. Existing properties that are not modified or removed by the
+        entries in ``newProperties`` are not affected by this update.
+        
+        Parameters
+        ----------
+        newProperties : dict[str, str]
+            Properties to add, change, or remove.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+PropertiesAdmin._op_getProperty = IcePy.Operation(
+    "getProperty",
+    "getProperty",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0),),
+    (),
+    ((), IcePy._t_string, False, 0),
+    ())
+
+PropertiesAdmin._op_getPropertiesForPrefix = IcePy.Operation(
+    "getPropertiesForPrefix",
+    "getPropertiesForPrefix",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0),),
+    (),
+    ((), _Ice_PropertyDict_t, False, 0),
+    ())
+
+PropertiesAdmin._op_setProperties = IcePy.Operation(
+    "setProperties",
+    "setProperties",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _Ice_PropertyDict_t, False, 0),),
+    (),
+    None,
+    ())
+
+__all__ = ["PropertiesAdmin", "PropertiesAdminPrx", "_Ice_PropertiesAdminPrx_t"]

Ice/PropertiesAdmin_forward.py

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

Ice/PropertyDict.py

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

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,63 @@
+# Copyright (c) ZeroC, Inc.
+
+import IcePy
+
+IcePy._t_ObjectPrx = IcePy.defineProxy("::Ice::Object", IcePy.ObjectPrx)
+
+__name__ = "Ice"
+
+#
+# Proxy comparison functions.
+#
+
+
+def proxyIdentityEqual(lhs: IcePy.ObjectPrx | None, rhs: IcePy.ObjectPrx | None) -> bool:
+    """Determines whether the identities of two proxies are equal."""
+    return proxyIdentityCompare(lhs, rhs) == 0
+
+
+def proxyIdentityCompare(lhs: IcePy.ObjectPrx | None, rhs: IcePy.ObjectPrx | None) -> int:
+    """Compares the identities of two proxies."""
+    if (lhs and not isinstance(lhs, IcePy.ObjectPrx)) or (rhs and not isinstance(rhs, IcePy.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: IcePy.ObjectPrx | None, rhs: IcePy.ObjectPrx | None) -> bool:
+    """Determines whether the identities and facets of two proxies are equal."""
+    return proxyIdentityAndFacetCompare(lhs, rhs) == 0
+
+
+def proxyIdentityAndFacetCompare(lhs: IcePy.ObjectPrx | None, rhs: IcePy.ObjectPrx | None) -> int:
+    """Compares the identities and facets of two proxies."""
+    if (lhs and not isinstance(lhs, IcePy.ObjectPrx)) or (rhs and not isinstance(rhs, IcePy.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"]