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

Ice/Router.py

@@ -0,0 +1,322 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Object import Object
+
+from Ice.ObjectProxySeq import _Ice_ObjectProxySeq_t
+
+from Ice.ObjectPrx import ObjectPrx
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.ObjectPrx_forward import _Ice_ObjectPrx_t
+
+from Ice.OperationMode import OperationMode
+
+from Ice.Router_forward import _Ice_RouterPrx_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 Sequence
+
+
+class RouterPrx(ObjectPrx):
+    """
+    Represents an intermediary object that routes requests and replies between clients and Ice objects that are not
+    directly reachable from these clients.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Ice::Router``.
+    """
+
+    def getClientProxy(self, context: dict[str, str] | None = None) -> tuple[ObjectPrx | None, bool | None]:
+        """
+        Gets the router's client proxy, i.e. the proxy to use for forwarding requests from the client to the
+        router. If a null proxy is returned, the client will forward requests to the router's endpoints.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        tuple[ObjectPrx | None, bool | None]
+        
+            A tuple containing:
+                - ObjectPrx | None The router's client proxy.
+                - bool | None Indicates whether or not the router supports a routing table. If ``true``, the Ice
+                  runtime will call :meth:`Ice.RouterPrx.addProxiesAsync` to populate the routing table. The Ice runtime assumes the router has
+                  a routing table when ``hasRoutingTable`` is not set.
+        
+        Notes
+        -----
+            Introduced in Ice 3.7.
+        """
+        return Router._op_getClientProxy.invoke(self, ((), context))
+
+    def getClientProxyAsync(self, context: dict[str, str] | None = None) -> Awaitable[tuple[ObjectPrx | None, bool | None]]:
+        """
+        Gets the router's client proxy, i.e. the proxy to use for forwarding requests from the client to the
+        router. If a null proxy is returned, the client will forward requests to the router's endpoints.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[tuple[ObjectPrx | None, bool | None]]
+        
+            A tuple containing:
+                - ObjectPrx | None The router's client proxy.
+                - bool | None Indicates whether or not the router supports a routing table. If ``true``, the Ice
+                  runtime will call :meth:`Ice.RouterPrx.addProxiesAsync` to populate the routing table. The Ice runtime assumes the router has
+                  a routing table when ``hasRoutingTable`` is not set.
+        
+        Notes
+        -----
+            Introduced in Ice 3.7.
+        """
+        return Router._op_getClientProxy.invokeAsync(self, ((), context))
+
+    def getServerProxy(self, context: dict[str, str] | None = None) -> ObjectPrx | None:
+        """
+        Gets the router's server proxy, i.e. the proxy to use for forwarding requests from the server to the
+        router. The Ice runtime uses the endpoints of this proxy as the published endpoints of bi-dir object
+        adapters.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        ObjectPrx | None
+            The router's server proxy.
+        """
+        return Router._op_getServerProxy.invoke(self, ((), context))
+
+    def getServerProxyAsync(self, context: dict[str, str] | None = None) -> Awaitable[ObjectPrx | None]:
+        """
+        Gets the router's server proxy, i.e. the proxy to use for forwarding requests from the server to the
+        router. The Ice runtime uses the endpoints of this proxy as the published endpoints of bi-dir object
+        adapters.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[ObjectPrx | None]
+            The router's server proxy.
+        """
+        return Router._op_getServerProxy.invokeAsync(self, ((), context))
+
+    def addProxies(self, proxies: Sequence[ObjectPrx | None], context: dict[str, str] | None = None) -> list[ObjectPrx | None]:
+        """
+        Adds new proxy information to the router's routing table.
+        
+        Parameters
+        ----------
+        proxies : Sequence[ObjectPrx | None]
+            The proxies to add. Adding a null proxy is an error.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        list[ObjectPrx | None]
+            Proxies discarded by the router. These proxies are all non-null.
+        """
+        return Router._op_addProxies.invoke(self, ((proxies, ), context))
+
+    def addProxiesAsync(self, proxies: Sequence[ObjectPrx | None], context: dict[str, str] | None = None) -> Awaitable[list[ObjectPrx | None]]:
+        """
+        Adds new proxy information to the router's routing table.
+        
+        Parameters
+        ----------
+        proxies : Sequence[ObjectPrx | None]
+            The proxies to add. Adding a null proxy is an error.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[list[ObjectPrx | None]]
+            Proxies discarded by the router. These proxies are all non-null.
+        """
+        return Router._op_addProxies.invokeAsync(self, ((proxies, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> RouterPrx | None:
+        return checkedCast(RouterPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[RouterPrx | None ]:
+        return checkedCastAsync(RouterPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> RouterPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> RouterPrx | None:
+        return uncheckedCast(RouterPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::Router"
+
+IcePy.defineProxy("::Ice::Router", RouterPrx)
+
+class Router(Object, ABC):
+    """
+    Represents an intermediary object that routes requests and replies between clients and Ice objects that are not
+    directly reachable from these clients.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Ice::Router``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::Ice::Router", )
+    _op_getClientProxy: IcePy.Operation
+    _op_getServerProxy: IcePy.Operation
+    _op_addProxies: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::Router"
+
+    @abstractmethod
+    def getClientProxy(self, current: Current) -> tuple[ObjectPrx | None, bool | None] | Awaitable[tuple[ObjectPrx | None, bool | None]]:
+        """
+        Gets the router's client proxy, i.e. the proxy to use for forwarding requests from the client to the
+        router. If a null proxy is returned, the client will forward requests to the router's endpoints.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        tuple[ObjectPrx | None, bool | None] | Awaitable[tuple[ObjectPrx | None, bool | None]]
+        
+            A tuple containing:
+                - ObjectPrx | None The router's client proxy.
+                - bool | None Indicates whether or not the router supports a routing table. If ``true``, the Ice
+                  runtime will call :meth:`Ice.RouterPrx.addProxiesAsync` to populate the routing table. The Ice runtime assumes the router has
+                  a routing table when ``hasRoutingTable`` is not set.
+        
+        Notes
+        -----
+            Introduced in Ice 3.7.
+        """
+        pass
+
+    @abstractmethod
+    def getServerProxy(self, current: Current) -> ObjectPrx | None | Awaitable[ObjectPrx | None]:
+        """
+        Gets the router's server proxy, i.e. the proxy to use for forwarding requests from the server to the
+        router. The Ice runtime uses the endpoints of this proxy as the published endpoints of bi-dir object
+        adapters.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        ObjectPrx | None | Awaitable[ObjectPrx | None]
+            The router's server proxy.
+        """
+        pass
+
+    @abstractmethod
+    def addProxies(self, proxies: list[ObjectPrx | None], current: Current) -> Sequence[ObjectPrx | None] | Awaitable[Sequence[ObjectPrx | None]]:
+        """
+        Adds new proxy information to the router's routing table.
+        
+        Parameters
+        ----------
+        proxies : list[ObjectPrx | None]
+            The proxies to add. Adding a null proxy is an error.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        Sequence[ObjectPrx | None] | Awaitable[Sequence[ObjectPrx | None]]
+            Proxies discarded by the router. These proxies are all non-null.
+        """
+        pass
+
+Router._op_getClientProxy = IcePy.Operation(
+    "getClientProxy",
+    "getClientProxy",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (((), IcePy._t_bool, True, 1),),
+    ((), _Ice_ObjectPrx_t, False, 0),
+    ())
+
+Router._op_getServerProxy = IcePy.Operation(
+    "getServerProxy",
+    "getServerProxy",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), _Ice_ObjectPrx_t, False, 0),
+    ())
+
+Router._op_addProxies = IcePy.Operation(
+    "addProxies",
+    "addProxies",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _Ice_ObjectProxySeq_t, False, 0),),
+    (),
+    ((), _Ice_ObjectProxySeq_t, False, 0),
+    ())
+
+__all__ = ["Router", "RouterPrx", "_Ice_RouterPrx_t"]

Ice/RouterFinder.py

@@ -0,0 +1,163 @@
+# 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.RouterFinder_forward import _Ice_RouterFinderPrx_t
+
+from Ice.Router_forward import _Ice_RouterPrx_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.Router import RouterPrx
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class RouterFinderPrx(ObjectPrx):
+    """
+    Provides access to a :class:`Ice.RouterPrx` object via a fixed identity.
+    A RouterFinder is always registered with identity ``Ice/RouterFinder``. This allows clients to obtain the
+    associated Router proxy with just the endpoint information of the object. For example, you can use the
+    RouterFinder proxy ``Ice/RouterFinder:tcp -h somehost -p 4061`` to get the Router proxy
+    ``MyGlacier2/Router:tcp -h somehost -p 4061``.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Ice::RouterFinder``.
+    """
+
+    def getRouter(self, context: dict[str, str] | None = None) -> RouterPrx | None:
+        """
+        Gets a proxy to the associated :class:`Ice.RouterPrx`. The proxy might point to several replicas.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        RouterPrx | None
+            The router proxy. This proxy is never null.
+        """
+        return RouterFinder._op_getRouter.invoke(self, ((), context))
+
+    def getRouterAsync(self, context: dict[str, str] | None = None) -> Awaitable[RouterPrx | None]:
+        """
+        Gets a proxy to the associated :class:`Ice.RouterPrx`. The proxy might point to several replicas.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[RouterPrx | None]
+            The router proxy. This proxy is never null.
+        """
+        return RouterFinder._op_getRouter.invokeAsync(self, ((), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> RouterFinderPrx | None:
+        return checkedCast(RouterFinderPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[RouterFinderPrx | None ]:
+        return checkedCastAsync(RouterFinderPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> RouterFinderPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> RouterFinderPrx | None:
+        return uncheckedCast(RouterFinderPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::RouterFinder"
+
+IcePy.defineProxy("::Ice::RouterFinder", RouterFinderPrx)
+
+class RouterFinder(Object, ABC):
+    """
+    Provides access to a :class:`Ice.RouterPrx` object via a fixed identity.
+    A RouterFinder is always registered with identity ``Ice/RouterFinder``. This allows clients to obtain the
+    associated Router proxy with just the endpoint information of the object. For example, you can use the
+    RouterFinder proxy ``Ice/RouterFinder:tcp -h somehost -p 4061`` to get the Router proxy
+    ``MyGlacier2/Router:tcp -h somehost -p 4061``.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Ice::RouterFinder``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::Ice::RouterFinder", )
+    _op_getRouter: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Ice::RouterFinder"
+
+    @abstractmethod
+    def getRouter(self, current: Current) -> RouterPrx | None | Awaitable[RouterPrx | None]:
+        """
+        Gets a proxy to the associated :class:`Ice.RouterPrx`. The proxy might point to several replicas.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        RouterPrx | None | Awaitable[RouterPrx | None]
+            The router proxy. This proxy is never null.
+        """
+        pass
+
+RouterFinder._op_getRouter = IcePy.Operation(
+    "getRouter",
+    "getRouter",
+    OperationMode.Normal,
+    None,
+    (),
+    (),
+    (),
+    ((), _Ice_RouterPrx_t, False, 0),
+    ())
+
+__all__ = ["RouterFinder", "RouterFinderPrx", "_Ice_RouterFinderPrx_t"]

Ice/RouterFinder_forward.py

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

Ice/Router_forward.py

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

Ice/SSLEndpointType.py

@@ -0,0 +1,18 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+SSLEndpointType = 2
+"""
+Identifies SSL endpoints.
+
+Notes
+-----
+    The Slice compiler generated this constant from Slice constant ``::Ice::SSLEndpointType``.
+"""
+
+__all__ = ["SSLEndpointType"]

Ice/ServantLocator.py

@@ -0,0 +1,88 @@
+# Copyright (c) ZeroC, Inc.
+
+from abc import ABC, abstractmethod
+
+from .Current import Current
+from .Object import Object
+
+
+class ServantLocator(ABC):
+    """
+    An application-provided class that an object adapter uses to locate servants.
+
+    Notes
+    -----
+    For simple cases, you should consider using a default servant instead (see :func:`ObjectAdapter.addDefaultServant`).
+    """
+
+    @abstractmethod
+    def locate(self, current: Current) -> tuple[Object | None, object | None]:
+        """
+        Asks this servant locator to find and return a servant.
+
+        Notes
+        -----
+        The caller (the object adapter) does not insert the returned servant into its Active Servant Map.
+        This must be done by the servant locator implementation, if this is desired.
+
+        The implementation can raise any exception, including :class:`UserException`.
+        The Ice runtime will marshal this exception in the response.
+
+        If you call :func:`locate` from your own code, you must also call :func:`finished` when you have finished using
+        the servant, provided that :func:`locate` did not return ``None``.
+
+        Parameters
+        ----------
+        current : Current
+            Information about the incoming request for which a servant is required.
+
+        Returns
+        -------
+        tuple[Object | None, object | None]
+
+            A tuple containing the following:
+                - retval : Object or None
+                    The located servant, or ``None`` if no suitable servant was found.
+                - cookie : object | None
+                    A "cookie" that will be passed to :func:`finished`.
+        """
+        pass
+
+    @abstractmethod
+    def finished(self, current: Current, servant: Object, cookie: object | None):
+        """
+        Notifies this servant locator that the dispatch on the servant returned by :func:`locate` is complete.
+        The object adapter calls this function only when :func:`locate` didn't return ``None``.
+
+        Notes
+        -----
+
+        The implementation can raise any exception, including :class:`UserException`.
+        The Ice runtime will marshal this exception in the response. If both the dispatch and :func:`finished` raise
+        an exception, the exception raised by :func:`finished` prevails and is marshaled back to the client.
+
+        Parameters
+        ----------
+        current : Current
+            Information about the incoming request for which a servant was located.
+        servant : Object
+            The servant that was returned by :func:`locate`.
+        cookie : object | None
+            The cookie that was returned by :func:`locate`.
+        """
+        pass
+
+    @abstractmethod
+    def deactivate(self, category: str):
+        """
+        Notifies this servant locator that the object adapter in which it's installed is being deactivated.
+
+        Parameters
+        ----------
+        category : str
+            The category with which this servant locator was registered.
+        """
+        pass
+
+
+__all__ = ["ServantLocator"]

Ice/ServerNotFoundException.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 ServerNotFoundException(UserException):
+    """
+    The exception that is thrown when a server was not found.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::Ice::ServerNotFoundException``.
+    """
+
+    _ice_id = "::Ice::ServerNotFoundException"
+
+_Ice_ServerNotFoundException_t = IcePy.defineException(
+    "::Ice::ServerNotFoundException",
+    ServerNotFoundException,
+    (),
+    None,
+    ())
+
+setattr(ServerNotFoundException, '_ice_type', _Ice_ServerNotFoundException_t)
+
+__all__ = ["ServerNotFoundException", "_Ice_ServerNotFoundException_t"]

Ice/ShortSeq.py

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

Ice/SliceChecksumDict.py

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

Ice/SliceInfo.py

@@ -0,0 +1,22 @@
+# Copyright (c) ZeroC, Inc.
+
+
+class SliceInfo:
+    """
+    Encapsulates the details of a class slice with an unknown type.
+
+    Attributes
+    ----------
+    typeId : str
+        The Slice type ID for this slice. It's empty when ``compactId`` is set (not ``-1``).
+    compactId : int
+        The Slice compact type ID for this slice, or ``-1`` if the slice has no compact ID.
+    bytes : bytes
+        The encoded bytes for this slice, including the leading size integer.
+    hasOptionalMembers : bool
+        Whether or not the slice contains optional members.
+    isLastSlice : bool
+        Whether or not this is the last slice.
+    """
+
+    pass