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

Glacier2/SessionControl.py

@@ -0,0 +1,407 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Glacier2.IdentitySet_forward import _Glacier2_IdentitySetPrx_t
+
+from Glacier2.SessionControl_forward import _Glacier2_SessionControlPrx_t
+
+from Glacier2.StringSet_forward import _Glacier2_StringSetPrx_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 abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Glacier2.IdentitySet import IdentitySetPrx
+    from Glacier2.StringSet import StringSetPrx
+    from Ice.Current import Current
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class SessionControlPrx(ObjectPrx):
+    """
+    Represents a router-provided object that allows an application-provided session manager to configure the
+    routing constraints for a session.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Glacier2::SessionControl``.
+    
+    See Also
+    --------
+        :class:`Glacier2.SessionManagerPrx`
+    """
+
+    def categories(self, context: dict[str, str] | None = None) -> StringSetPrx | None:
+        """
+        Gets a proxy to the object that manages the allowable categories for object identities for this session.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        StringSetPrx | None
+            A proxy to a :class:`Glacier2.StringSetPrx` object. This proxy is never null.
+        """
+        return SessionControl._op_categories.invoke(self, ((), context))
+
+    def categoriesAsync(self, context: dict[str, str] | None = None) -> Awaitable[StringSetPrx | None]:
+        """
+        Gets a proxy to the object that manages the allowable categories for object identities for this session.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[StringSetPrx | None]
+            A proxy to a :class:`Glacier2.StringSetPrx` object. This proxy is never null.
+        """
+        return SessionControl._op_categories.invokeAsync(self, ((), context))
+
+    def adapterIds(self, context: dict[str, str] | None = None) -> StringSetPrx | None:
+        """
+        Gets a proxy to the object that manages the allowable adapter identities for objects for this session.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        StringSetPrx | None
+            A proxy to a :class:`Glacier2.StringSetPrx` object. This proxy is never null.
+        """
+        return SessionControl._op_adapterIds.invoke(self, ((), context))
+
+    def adapterIdsAsync(self, context: dict[str, str] | None = None) -> Awaitable[StringSetPrx | None]:
+        """
+        Gets a proxy to the object that manages the allowable adapter identities for objects for this session.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[StringSetPrx | None]
+            A proxy to a :class:`Glacier2.StringSetPrx` object. This proxy is never null.
+        """
+        return SessionControl._op_adapterIds.invokeAsync(self, ((), context))
+
+    def identities(self, context: dict[str, str] | None = None) -> IdentitySetPrx | None:
+        """
+        Gets a proxy to the object that manages the allowable object identities for this session.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        IdentitySetPrx | None
+            A proxy to an :class:`Glacier2.IdentitySetPrx` object. This proxy is never null.
+        """
+        return SessionControl._op_identities.invoke(self, ((), context))
+
+    def identitiesAsync(self, context: dict[str, str] | None = None) -> Awaitable[IdentitySetPrx | None]:
+        """
+        Gets a proxy to the object that manages the allowable object identities for this session.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[IdentitySetPrx | None]
+            A proxy to an :class:`Glacier2.IdentitySetPrx` object. This proxy is never null.
+        """
+        return SessionControl._op_identities.invokeAsync(self, ((), context))
+
+    def getSessionTimeout(self, context: dict[str, str] | None = None) -> int:
+        """
+        Gets the session timeout.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        int
+            The timeout.
+        """
+        return SessionControl._op_getSessionTimeout.invoke(self, ((), context))
+
+    def getSessionTimeoutAsync(self, context: dict[str, str] | None = None) -> Awaitable[int]:
+        """
+        Gets the session timeout.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[int]
+            The timeout.
+        """
+        return SessionControl._op_getSessionTimeout.invokeAsync(self, ((), context))
+
+    def destroy(self, context: dict[str, str] | None = None) -> None:
+        """
+        Destroys the associated session.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return SessionControl._op_destroy.invoke(self, ((), context))
+
+    def destroyAsync(self, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Destroys the associated session.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return SessionControl._op_destroy.invokeAsync(self, ((), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> SessionControlPrx | None:
+        return checkedCast(SessionControlPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[SessionControlPrx | None ]:
+        return checkedCastAsync(SessionControlPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> SessionControlPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> SessionControlPrx | None:
+        return uncheckedCast(SessionControlPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::SessionControl"
+
+IcePy.defineProxy("::Glacier2::SessionControl", SessionControlPrx)
+
+class SessionControl(Object, ABC):
+    """
+    Represents a router-provided object that allows an application-provided session manager to configure the
+    routing constraints for a session.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Glacier2::SessionControl``.
+    
+    See Also
+    --------
+        :class:`Glacier2.SessionManagerPrx`
+    """
+
+    _ice_ids: Sequence[str] = ("::Glacier2::SessionControl", "::Ice::Object", )
+    _op_categories: IcePy.Operation
+    _op_adapterIds: IcePy.Operation
+    _op_identities: IcePy.Operation
+    _op_getSessionTimeout: IcePy.Operation
+    _op_destroy: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::SessionControl"
+
+    @abstractmethod
+    def categories(self, current: Current) -> StringSetPrx | None | Awaitable[StringSetPrx | None]:
+        """
+        Gets a proxy to the object that manages the allowable categories for object identities for this session.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        StringSetPrx | None | Awaitable[StringSetPrx | None]
+            A proxy to a :class:`Glacier2.StringSetPrx` object. This proxy is never null.
+        """
+        pass
+
+    @abstractmethod
+    def adapterIds(self, current: Current) -> StringSetPrx | None | Awaitable[StringSetPrx | None]:
+        """
+        Gets a proxy to the object that manages the allowable adapter identities for objects for this session.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        StringSetPrx | None | Awaitable[StringSetPrx | None]
+            A proxy to a :class:`Glacier2.StringSetPrx` object. This proxy is never null.
+        """
+        pass
+
+    @abstractmethod
+    def identities(self, current: Current) -> IdentitySetPrx | None | Awaitable[IdentitySetPrx | None]:
+        """
+        Gets a proxy to the object that manages the allowable object identities for this session.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        IdentitySetPrx | None | Awaitable[IdentitySetPrx | None]
+            A proxy to an :class:`Glacier2.IdentitySetPrx` object. This proxy is never null.
+        """
+        pass
+
+    @abstractmethod
+    def getSessionTimeout(self, current: Current) -> int | Awaitable[int]:
+        """
+        Gets the session timeout.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        int | Awaitable[int]
+            The timeout.
+        """
+        pass
+
+    @abstractmethod
+    def destroy(self, current: Current) -> None | Awaitable[None]:
+        """
+        Destroys the associated session.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+SessionControl._op_categories = IcePy.Operation(
+    "categories",
+    "categories",
+    OperationMode.Normal,
+    None,
+    (),
+    (),
+    (),
+    ((), _Glacier2_StringSetPrx_t, False, 0),
+    ())
+
+SessionControl._op_adapterIds = IcePy.Operation(
+    "adapterIds",
+    "adapterIds",
+    OperationMode.Normal,
+    None,
+    (),
+    (),
+    (),
+    ((), _Glacier2_StringSetPrx_t, False, 0),
+    ())
+
+SessionControl._op_identities = IcePy.Operation(
+    "identities",
+    "identities",
+    OperationMode.Normal,
+    None,
+    (),
+    (),
+    (),
+    ((), _Glacier2_IdentitySetPrx_t, False, 0),
+    ())
+
+SessionControl._op_getSessionTimeout = IcePy.Operation(
+    "getSessionTimeout",
+    "getSessionTimeout",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), IcePy._t_int, False, 0),
+    ())
+
+SessionControl._op_destroy = IcePy.Operation(
+    "destroy",
+    "destroy",
+    OperationMode.Normal,
+    None,
+    (),
+    (),
+    (),
+    None,
+    ())
+
+__all__ = ["SessionControl", "SessionControlPrx", "_Glacier2_SessionControlPrx_t"]

Glacier2/SessionControl_forward.py

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

Glacier2/SessionManager.py

@@ -0,0 +1,189 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Glacier2.CannotCreateSessionException import _Glacier2_CannotCreateSessionException_t
+
+from Glacier2.SessionControl_forward import _Glacier2_SessionControlPrx_t
+
+from Glacier2.SessionManager_forward import _Glacier2_SessionManagerPrx_t
+
+from Glacier2.Session_forward import _Glacier2_SessionPrx_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 abc import ABC
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING
+from typing import overload
+
+if TYPE_CHECKING:
+    from Glacier2.Session import SessionPrx
+    from Glacier2.SessionControl import SessionControlPrx
+    from Ice.Current import Current
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class SessionManagerPrx(ObjectPrx):
+    """
+    Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
+    own SessionManager implementation; this router will then return the sessions created by this session manager to
+    its clients.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Glacier2::SessionManager``.
+    """
+
+    def create(self, userId: str, control: SessionControlPrx | None, context: dict[str, str] | None = None) -> SessionPrx | None:
+        """
+        Creates a new session object.
+        
+        Parameters
+        ----------
+        userId : str
+            The user ID for the session.
+        control : SessionControlPrx | None
+            A proxy to the session control object. This proxy is null when ``Glacier2.Server.Endpoints``
+            is not configured.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        SessionPrx | None
+            A proxy to the newly created session. This proxy is never null.
+        
+        Raises
+        ------
+        CannotCreateSessionException
+            Thrown when the session cannot be created.
+        """
+        return SessionManager._op_create.invoke(self, ((userId, control), context))
+
+    def createAsync(self, userId: str, control: SessionControlPrx | None, context: dict[str, str] | None = None) -> Awaitable[SessionPrx | None]:
+        """
+        Creates a new session object.
+        
+        Parameters
+        ----------
+        userId : str
+            The user ID for the session.
+        control : SessionControlPrx | None
+            A proxy to the session control object. This proxy is null when ``Glacier2.Server.Endpoints``
+            is not configured.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[SessionPrx | None]
+            A proxy to the newly created session. This proxy is never null.
+        """
+        return SessionManager._op_create.invokeAsync(self, ((userId, control), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> SessionManagerPrx | None:
+        return checkedCast(SessionManagerPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[SessionManagerPrx | None ]:
+        return checkedCastAsync(SessionManagerPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> SessionManagerPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> SessionManagerPrx | None:
+        return uncheckedCast(SessionManagerPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::SessionManager"
+
+IcePy.defineProxy("::Glacier2::SessionManager", SessionManagerPrx)
+
+class SessionManager(Object, ABC):
+    """
+    Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
+    own SessionManager implementation; this router will then return the sessions created by this session manager to
+    its clients.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Glacier2::SessionManager``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Glacier2::SessionManager", "::Ice::Object", )
+    _op_create: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::SessionManager"
+
+    @abstractmethod
+    def create(self, userId: str, control: SessionControlPrx | None, current: Current) -> SessionPrx | None | Awaitable[SessionPrx | None]:
+        """
+        Creates a new session object.
+        
+        Parameters
+        ----------
+        userId : str
+            The user ID for the session.
+        control : SessionControlPrx | None
+            A proxy to the session control object. This proxy is null when ``Glacier2.Server.Endpoints``
+            is not configured.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        SessionPrx | None | Awaitable[SessionPrx | None]
+            A proxy to the newly created session. This proxy is never null.
+        
+        Raises
+        ------
+        CannotCreateSessionException
+            Thrown when the session cannot be created.
+        """
+        pass
+
+SessionManager._op_create = IcePy.Operation(
+    "create",
+    "create",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0), ((), _Glacier2_SessionControlPrx_t, False, 0)),
+    (),
+    ((), _Glacier2_SessionPrx_t, False, 0),
+    (_Glacier2_CannotCreateSessionException_t,))
+
+__all__ = ["SessionManager", "SessionManagerPrx", "_Glacier2_SessionManagerPrx_t"]

Glacier2/SessionManager_forward.py

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

Glacier2/SessionNotExistException.py

@@ -0,0 +1,39 @@
+# 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 SessionNotExistException(UserException):
+    """
+    The exception that is thrown when a client tries to destroy a session with a router, but no session exists for
+    this client.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::Glacier2::SessionNotExistException``.
+    
+    See Also
+    --------
+        :meth:`Glacier2.RouterPrx.destroySessionAsync`
+    """
+
+    _ice_id = "::Glacier2::SessionNotExistException"
+
+_Glacier2_SessionNotExistException_t = IcePy.defineException(
+    "::Glacier2::SessionNotExistException",
+    SessionNotExistException,
+    (),
+    None,
+    ())
+
+setattr(SessionNotExistException, '_ice_type', _Glacier2_SessionNotExistException_t)
+
+__all__ = ["SessionNotExistException", "_Glacier2_SessionNotExistException_t"]

Glacier2/Session_forward.py

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