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

Glacier2/CannotCreateSessionException.py

@@ -0,0 +1,40 @@
+# 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 CannotCreateSessionException(UserException):
+    """
+    The exception that is thrown when an attempt to create a new session fails.
+    
+    Attributes
+    ----------
+    reason : str
+        The reason why the session creation failed.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::Glacier2::CannotCreateSessionException``.
+    """
+    reason: str = ""
+
+    _ice_id = "::Glacier2::CannotCreateSessionException"
+
+_Glacier2_CannotCreateSessionException_t = IcePy.defineException(
+    "::Glacier2::CannotCreateSessionException",
+    CannotCreateSessionException,
+    (),
+    None,
+    (("reason", (), IcePy._t_string, False, 0),))
+
+setattr(CannotCreateSessionException, '_ice_type', _Glacier2_CannotCreateSessionException_t)
+
+__all__ = ["CannotCreateSessionException", "_Glacier2_CannotCreateSessionException_t"]

Glacier2/IdentitySet.py

@@ -0,0 +1,293 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Glacier2.IdentitySet_forward import _Glacier2_IdentitySetPrx_t
+
+from Ice.IdentitySeq import _Ice_IdentitySeq_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 Ice.Identity import Identity
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class IdentitySetPrx(ObjectPrx):
+    """
+    Manages a set of object identity constraints on a :class:`Glacier2.SessionPrx`.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Glacier2::IdentitySet``.
+    
+    See Also
+    --------
+        :class:`Glacier2.SessionControlPrx`
+    """
+
+    def add(self, additions: Sequence[Identity], context: dict[str, str] | None = None) -> None:
+        """
+        Adds a sequence of Ice identities to this set of constraints. Order is not preserved and duplicates are
+        implicitly removed.
+        
+        Parameters
+        ----------
+        additions : Sequence[Identity]
+            The sequence of Ice identities to add.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return IdentitySet._op_add.invoke(self, ((additions, ), context))
+
+    def addAsync(self, additions: Sequence[Identity], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Adds a sequence of Ice identities to this set of constraints. Order is not preserved and duplicates are
+        implicitly removed.
+        
+        Parameters
+        ----------
+        additions : Sequence[Identity]
+            The sequence of Ice identities to add.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return IdentitySet._op_add.invokeAsync(self, ((additions, ), context))
+
+    def remove(self, deletions: Sequence[Identity], context: dict[str, str] | None = None) -> None:
+        """
+        Removes a sequence of identities from this set of constraints. No errors are returned if an entry is not
+        found.
+        
+        Parameters
+        ----------
+        deletions : Sequence[Identity]
+            The sequence of Ice identities to remove.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return IdentitySet._op_remove.invoke(self, ((deletions, ), context))
+
+    def removeAsync(self, deletions: Sequence[Identity], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Removes a sequence of identities from this set of constraints. No errors are returned if an entry is not
+        found.
+        
+        Parameters
+        ----------
+        deletions : Sequence[Identity]
+            The sequence of Ice identities to remove.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return IdentitySet._op_remove.invokeAsync(self, ((deletions, ), context))
+
+    def get(self, context: dict[str, str] | None = None) -> list[Identity]:
+        """
+        Gets a sequence of identities describing the constraints in this set.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        list[Identity]
+            The sequence of Ice identities for this set.
+        """
+        return IdentitySet._op_get.invoke(self, ((), context))
+
+    def getAsync(self, context: dict[str, str] | None = None) -> Awaitable[list[Identity]]:
+        """
+        Gets a sequence of identities describing the constraints in this set.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[list[Identity]]
+            The sequence of Ice identities for this set.
+        """
+        return IdentitySet._op_get.invokeAsync(self, ((), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> IdentitySetPrx | None:
+        return checkedCast(IdentitySetPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[IdentitySetPrx | None ]:
+        return checkedCastAsync(IdentitySetPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> IdentitySetPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> IdentitySetPrx | None:
+        return uncheckedCast(IdentitySetPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::IdentitySet"
+
+IcePy.defineProxy("::Glacier2::IdentitySet", IdentitySetPrx)
+
+class IdentitySet(Object, ABC):
+    """
+    Manages a set of object identity constraints on a :class:`Glacier2.SessionPrx`.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Glacier2::IdentitySet``.
+    
+    See Also
+    --------
+        :class:`Glacier2.SessionControlPrx`
+    """
+
+    _ice_ids: Sequence[str] = ("::Glacier2::IdentitySet", "::Ice::Object", )
+    _op_add: IcePy.Operation
+    _op_remove: IcePy.Operation
+    _op_get: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::IdentitySet"
+
+    @abstractmethod
+    def add(self, additions: list[Identity], current: Current) -> None | Awaitable[None]:
+        """
+        Adds a sequence of Ice identities to this set of constraints. Order is not preserved and duplicates are
+        implicitly removed.
+        
+        Parameters
+        ----------
+        additions : list[Identity]
+            The sequence of Ice identities to add.
+        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 remove(self, deletions: list[Identity], current: Current) -> None | Awaitable[None]:
+        """
+        Removes a sequence of identities from this set of constraints. No errors are returned if an entry is not
+        found.
+        
+        Parameters
+        ----------
+        deletions : list[Identity]
+            The sequence of Ice identities to 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
+
+    @abstractmethod
+    def get(self, current: Current) -> Sequence[Identity] | Awaitable[Sequence[Identity]]:
+        """
+        Gets a sequence of identities describing the constraints in this set.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        Sequence[Identity] | Awaitable[Sequence[Identity]]
+            The sequence of Ice identities for this set.
+        """
+        pass
+
+IdentitySet._op_add = IcePy.Operation(
+    "add",
+    "add",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _Ice_IdentitySeq_t, False, 0),),
+    (),
+    None,
+    ())
+
+IdentitySet._op_remove = IcePy.Operation(
+    "remove",
+    "remove",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), _Ice_IdentitySeq_t, False, 0),),
+    (),
+    None,
+    ())
+
+IdentitySet._op_get = IcePy.Operation(
+    "get",
+    "get",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), _Ice_IdentitySeq_t, False, 0),
+    ())
+
+__all__ = ["IdentitySet", "IdentitySetPrx", "_Glacier2_IdentitySetPrx_t"]

Glacier2/IdentitySet_forward.py

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

Glacier2/PermissionDeniedException.py

@@ -0,0 +1,40 @@
+# 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 PermissionDeniedException(UserException):
+    """
+    The exception that is thrown when a client is not allowed to create a session.
+    
+    Attributes
+    ----------
+    reason : str
+        The reason why permission was denied.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::Glacier2::PermissionDeniedException``.
+    """
+    reason: str = ""
+
+    _ice_id = "::Glacier2::PermissionDeniedException"
+
+_Glacier2_PermissionDeniedException_t = IcePy.defineException(
+    "::Glacier2::PermissionDeniedException",
+    PermissionDeniedException,
+    (),
+    None,
+    (("reason", (), IcePy._t_string, False, 0),))
+
+setattr(PermissionDeniedException, '_ice_type', _Glacier2_PermissionDeniedException_t)
+
+__all__ = ["PermissionDeniedException", "_Glacier2_PermissionDeniedException_t"]

Glacier2/PermissionsVerifier.py

@@ -0,0 +1,189 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Glacier2.PermissionDeniedException import _Glacier2_PermissionDeniedException_t
+
+from Glacier2.PermissionsVerifier_forward import _Glacier2_PermissionsVerifierPrx_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 PermissionsVerifierPrx(ObjectPrx):
+    """
+    Represents an object that checks user permissions. The Glacier2 router and other services use a
+    :class:`Glacier2.PermissionsVerifierPrx` proxy when the user is authenticated using a user ID and password.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::Glacier2::PermissionsVerifier``.
+    """
+
+    def checkPermissions(self, userId: str, password: str, context: dict[str, str] | None = None) -> tuple[bool, str]:
+        """
+        Checks if a user is authorized to establish a session.
+        
+        Parameters
+        ----------
+        userId : str
+            The user ID.
+        password : str
+            The user's password.
+        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 PermissionsVerifier._op_checkPermissions.invoke(self, ((userId, password), context))
+
+    def checkPermissionsAsync(self, userId: str, password: str, context: dict[str, str] | None = None) -> Awaitable[tuple[bool, str]]:
+        """
+        Checks if a user is authorized to establish a session.
+        
+        Parameters
+        ----------
+        userId : str
+            The user ID.
+        password : str
+            The user's password.
+        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 PermissionsVerifier._op_checkPermissions.invokeAsync(self, ((userId, password), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> PermissionsVerifierPrx | None:
+        return checkedCast(PermissionsVerifierPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[PermissionsVerifierPrx | None ]:
+        return checkedCastAsync(PermissionsVerifierPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> PermissionsVerifierPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> PermissionsVerifierPrx | None:
+        return uncheckedCast(PermissionsVerifierPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::PermissionsVerifier"
+
+IcePy.defineProxy("::Glacier2::PermissionsVerifier", PermissionsVerifierPrx)
+
+class PermissionsVerifier(Object, ABC):
+    """
+    Represents an object that checks user permissions. The Glacier2 router and other services use a
+    :class:`Glacier2.PermissionsVerifierPrx` proxy when the user is authenticated using a user ID and password.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::Glacier2::PermissionsVerifier``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Glacier2::PermissionsVerifier", "::Ice::Object", )
+    _op_checkPermissions: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::Glacier2::PermissionsVerifier"
+
+    @abstractmethod
+    def checkPermissions(self, userId: str, password: str, current: Current) -> tuple[bool, str] | Awaitable[tuple[bool, str]]:
+        """
+        Checks if a user is authorized to establish a session.
+        
+        Parameters
+        ----------
+        userId : str
+            The user ID.
+        password : str
+            The user's password.
+        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
+
+PermissionsVerifier._op_checkPermissions = IcePy.Operation(
+    "checkPermissions",
+    "checkPermissions",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0), ((), IcePy._t_string, False, 0)),
+    (((), IcePy._t_string, False, 0),),
+    ((), IcePy._t_bool, False, 0),
+    (_Glacier2_PermissionDeniedException_t,))
+
+__all__ = ["PermissionsVerifier", "PermissionsVerifierPrx", "_Glacier2_PermissionsVerifierPrx_t"]

Glacier2/PermissionsVerifier_forward.py

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