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

Glacier2/SSLInfo.py

@@ -0,0 +1,62 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.StringSeq import _Ice_StringSeq_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+
+@dataclass
+class SSLInfo:
+    """
+    Represents information gathered from an incoming SSL connection and used for authentication and authorization.
+    
+    Attributes
+    ----------
+    remoteHost : str
+        The remote host.
+    remotePort : int
+        The remote port.
+    localHost : str
+        The router's host.
+    localPort : int
+        The router's port.
+    cipher : str
+        The negotiated cipher suite.
+    certs : list[str]
+        The certificate chain.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::Glacier2::SSLInfo``.
+    
+    See Also
+    --------
+        :class:`Glacier2.SSLPermissionsVerifierPrx`
+    """
+    remoteHost: str = ""
+    remotePort: int = 0
+    localHost: str = ""
+    localPort: int = 0
+    cipher: str = ""
+    certs: list[str] = field(default_factory=list)
+
+_Glacier2_SSLInfo_t = IcePy.defineStruct(
+    "::Glacier2::SSLInfo",
+    SSLInfo,
+    (),
+    (
+        ("remoteHost", (), IcePy._t_string),
+        ("remotePort", (), IcePy._t_int),
+        ("localHost", (), IcePy._t_string),
+        ("localPort", (), IcePy._t_int),
+        ("cipher", (), IcePy._t_string),
+        ("certs", (), _Ice_StringSeq_t)
+    ))
+
+__all__ = ["SSLInfo", "_Glacier2_SSLInfo_t"]

Glacier2/SSLPermissionsVerifier.py

@@ -0,0 +1,186 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Glacier2.PermissionDeniedException import _Glacier2_PermissionDeniedException_t
+
+from Glacier2.SSLInfo import _Glacier2_SSLInfo_t
+
+from Glacier2.SSLPermissionsVerifier_forward import _Glacier2_SSLPermissionsVerifierPrx_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.SSLInfo import SSLInfo
+    from Ice.Current import Current
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class SSLPermissionsVerifierPrx(ObjectPrx):
+    """
+    Represents an object that checks user permissions. The Glacier2 router and other services use an
+    :class:`Glacier2.SSLPermissionsVerifierPrx` proxy when the user is authenticated through an SSL certificate.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Glacier2::SSLPermissionsVerifier``.
+    """
+
+    def authorize(self, info: SSLInfo, context: dict[str, str] | None = None) -> tuple[bool, str]:
+        """
+        Checks if a user is authorized to establish a session.
+        
+        Parameters
+        ----------
+        info : SSLInfo
+            The SSL information.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        tuple[bool, str]
+        
+            A tuple containing:
+                - bool ``true`` if access is granted, ``false`` otherwise.
+                - str The reason why access was denied.
+        
+        Raises
+        ------
+        PermissionDeniedException
+            Thrown when the user's access is denied. This exception can be thrown
+            instead of returning ``false`` with a reason set in the reason out parameter.
+        """
+        return SSLPermissionsVerifier._op_authorize.invoke(self, ((info, ), context))
+
+    def authorizeAsync(self, info: SSLInfo, context: dict[str, str] | None = None) -> Awaitable[tuple[bool, str]]:
+        """
+        Checks if a user is authorized to establish a session.
+        
+        Parameters
+        ----------
+        info : SSLInfo
+            The SSL information.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[tuple[bool, str]]
+        
+            A tuple containing:
+                - bool ``true`` if access is granted, ``false`` otherwise.
+                - str The reason why access was denied.
+        """
+        return SSLPermissionsVerifier._op_authorize.invokeAsync(self, ((info, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> SSLPermissionsVerifierPrx | None:
+        return checkedCast(SSLPermissionsVerifierPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[SSLPermissionsVerifierPrx | None ]:
+        return checkedCastAsync(SSLPermissionsVerifierPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> SSLPermissionsVerifierPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> SSLPermissionsVerifierPrx | None:
+        return uncheckedCast(SSLPermissionsVerifierPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::SSLPermissionsVerifier"
+
+IcePy.defineProxy("::Glacier2::SSLPermissionsVerifier", SSLPermissionsVerifierPrx)
+
+class SSLPermissionsVerifier(Object, ABC):
+    """
+    Represents an object that checks user permissions. The Glacier2 router and other services use an
+    :class:`Glacier2.SSLPermissionsVerifierPrx` proxy when the user is authenticated through an SSL certificate.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Glacier2::SSLPermissionsVerifier``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Glacier2::SSLPermissionsVerifier", "::Ice::Object", )
+    _op_authorize: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::SSLPermissionsVerifier"
+
+    @abstractmethod
+    def authorize(self, info: SSLInfo, current: Current) -> tuple[bool, str] | Awaitable[tuple[bool, str]]:
+        """
+        Checks if a user is authorized to establish a session.
+        
+        Parameters
+        ----------
+        info : SSLInfo
+            The SSL information.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        tuple[bool, str] | Awaitable[tuple[bool, str]]
+        
+            A tuple containing:
+                - bool ``true`` if access is granted, ``false`` otherwise.
+                - str The reason why access was denied.
+        
+        Raises
+        ------
+        PermissionDeniedException
+            Thrown when the user's access is denied. This exception can be thrown
+            instead of returning ``false`` with a reason set in the reason out parameter.
+        """
+        pass
+
+SSLPermissionsVerifier._op_authorize = IcePy.Operation(
+    "authorize",
+    "authorize",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _Glacier2_SSLInfo_t, False, 0),),
+    (((), IcePy._t_string, False, 0),),
+    ((), IcePy._t_bool, False, 0),
+    (_Glacier2_PermissionDeniedException_t,))
+
+__all__ = ["SSLPermissionsVerifier", "SSLPermissionsVerifierPrx", "_Glacier2_SSLPermissionsVerifierPrx_t"]

Glacier2/SSLPermissionsVerifier_forward.py

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

Glacier2/SSLSessionManager.py

@@ -0,0 +1,192 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Glacier2.CannotCreateSessionException import _Glacier2_CannotCreateSessionException_t
+
+from Glacier2.SSLInfo import _Glacier2_SSLInfo_t
+
+from Glacier2.SSLSessionManager_forward import _Glacier2_SSLSessionManagerPrx_t
+
+from Glacier2.SessionControl_forward import _Glacier2_SessionControlPrx_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.SSLInfo import SSLInfo
+    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 SSLSessionManagerPrx(ObjectPrx):
+    """
+    Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
+    own SSLSessionManager 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::SSLSessionManager``.
+    """
+
+    def create(self, info: SSLInfo, control: SessionControlPrx | None, context: dict[str, str] | None = None) -> SessionPrx | None:
+        """
+        Creates a new session object.
+        
+        Parameters
+        ----------
+        info : SSLInfo
+            The SSL info.
+        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 SSLSessionManager._op_create.invoke(self, ((info, control), context))
+
+    def createAsync(self, info: SSLInfo, control: SessionControlPrx | None, context: dict[str, str] | None = None) -> Awaitable[SessionPrx | None]:
+        """
+        Creates a new session object.
+        
+        Parameters
+        ----------
+        info : SSLInfo
+            The SSL info.
+        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 SSLSessionManager._op_create.invokeAsync(self, ((info, control), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> SSLSessionManagerPrx | None:
+        return checkedCast(SSLSessionManagerPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[SSLSessionManagerPrx | None ]:
+        return checkedCastAsync(SSLSessionManagerPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> SSLSessionManagerPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> SSLSessionManagerPrx | None:
+        return uncheckedCast(SSLSessionManagerPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::SSLSessionManager"
+
+IcePy.defineProxy("::Glacier2::SSLSessionManager", SSLSessionManagerPrx)
+
+class SSLSessionManager(Object, ABC):
+    """
+    Represents an application-provided factory for session objects. You can configure a Glacier2 router with your
+    own SSLSessionManager 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::SSLSessionManager``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Glacier2::SSLSessionManager", "::Ice::Object", )
+    _op_create: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::SSLSessionManager"
+
+    @abstractmethod
+    def create(self, info: SSLInfo, control: SessionControlPrx | None, current: Current) -> SessionPrx | None | Awaitable[SessionPrx | None]:
+        """
+        Creates a new session object.
+        
+        Parameters
+        ----------
+        info : SSLInfo
+            The SSL info.
+        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
+
+SSLSessionManager._op_create = IcePy.Operation(
+    "create",
+    "create",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _Glacier2_SSLInfo_t, False, 0), ((), _Glacier2_SessionControlPrx_t, False, 0)),
+    (),
+    ((), _Glacier2_SessionPrx_t, False, 0),
+    (_Glacier2_CannotCreateSessionException_t,))
+
+__all__ = ["SSLSessionManager", "SSLSessionManagerPrx", "_Glacier2_SSLSessionManagerPrx_t"]

Glacier2/SSLSessionManager_forward.py

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

Glacier2/Session.py

@@ -0,0 +1,161 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+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 Ice.Current import Current
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class SessionPrx(ObjectPrx):
+    """
+    Represents a session between a client application and the Glacier2 router. With Glacier2, the lifetime of a
+    session is tied to the Ice connection between the client and the router: the session is destroyed when the
+    connection is closed.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Glacier2::Session``.
+    
+    See Also
+    --------
+        :class:`Glacier2.RouterPrx`
+        :class:`Glacier2.SessionManagerPrx`
+    """
+
+    def destroy(self, context: dict[str, str] | None = None) -> None:
+        """
+        Destroys this session.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return Session._op_destroy.invoke(self, ((), context))
+
+    def destroyAsync(self, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Destroys this 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 Session._op_destroy.invokeAsync(self, ((), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> SessionPrx | None:
+        return checkedCast(SessionPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[SessionPrx | None ]:
+        return checkedCastAsync(SessionPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> SessionPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> SessionPrx | None:
+        return uncheckedCast(SessionPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::Session"
+
+IcePy.defineProxy("::Glacier2::Session", SessionPrx)
+
+class Session(Object, ABC):
+    """
+    Represents a session between a client application and the Glacier2 router. With Glacier2, the lifetime of a
+    session is tied to the Ice connection between the client and the router: the session is destroyed when the
+    connection is closed.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Glacier2::Session``.
+    
+    See Also
+    --------
+        :class:`Glacier2.RouterPrx`
+        :class:`Glacier2.SessionManagerPrx`
+    """
+
+    _ice_ids: Sequence[str] = ("::Glacier2::Session", "::Ice::Object", )
+    _op_destroy: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::Session"
+
+    @abstractmethod
+    def destroy(self, current: Current) -> None | Awaitable[None]:
+        """
+        Destroys this 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
+
+Session._op_destroy = IcePy.Operation(
+    "destroy",
+    "destroy",
+    OperationMode.Normal,
+    None,
+    (),
+    (),
+    (),
+    None,
+    ())
+
+__all__ = ["Session", "SessionPrx", "_Glacier2_SessionPrx_t"]