zeroc-ice 3.8.0__cp312-cp312-macosx_10_13_universal2.whl

Glacier2/StringSet.py

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

Glacier2/StringSet_forward.py

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

Glacier2/__init__.py

@@ -0,0 +1,79 @@
+
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from .CannotCreateSessionException import CannotCreateSessionException
+from .CannotCreateSessionException import _Glacier2_CannotCreateSessionException_t
+from .IdentitySet import IdentitySet
+from .IdentitySet import IdentitySetPrx
+from .IdentitySet_forward import _Glacier2_IdentitySetPrx_t
+from .PermissionDeniedException import PermissionDeniedException
+from .PermissionDeniedException import _Glacier2_PermissionDeniedException_t
+from .PermissionsVerifier import PermissionsVerifier
+from .PermissionsVerifier import PermissionsVerifierPrx
+from .PermissionsVerifier_forward import _Glacier2_PermissionsVerifierPrx_t
+from .Router import Router
+from .Router import RouterPrx
+from .Router_forward import _Glacier2_RouterPrx_t
+from .SSLInfo import SSLInfo
+from .SSLInfo import _Glacier2_SSLInfo_t
+from .SSLPermissionsVerifier import SSLPermissionsVerifier
+from .SSLPermissionsVerifier import SSLPermissionsVerifierPrx
+from .SSLPermissionsVerifier_forward import _Glacier2_SSLPermissionsVerifierPrx_t
+from .SSLSessionManager import SSLSessionManager
+from .SSLSessionManager import SSLSessionManagerPrx
+from .SSLSessionManager_forward import _Glacier2_SSLSessionManagerPrx_t
+from .Session import Session
+from .Session import SessionPrx
+from .SessionControl import SessionControl
+from .SessionControl import SessionControlPrx
+from .SessionControl_forward import _Glacier2_SessionControlPrx_t
+from .SessionManager import SessionManager
+from .SessionManager import SessionManagerPrx
+from .SessionManager_forward import _Glacier2_SessionManagerPrx_t
+from .SessionNotExistException import SessionNotExistException
+from .SessionNotExistException import _Glacier2_SessionNotExistException_t
+from .Session_forward import _Glacier2_SessionPrx_t
+from .StringSet import StringSet
+from .StringSet import StringSetPrx
+from .StringSet_forward import _Glacier2_StringSetPrx_t
+
+
+__all__ = [
+    "CannotCreateSessionException",
+    "_Glacier2_CannotCreateSessionException_t",
+    "IdentitySet",
+    "IdentitySetPrx",
+    "_Glacier2_IdentitySetPrx_t",
+    "PermissionDeniedException",
+    "_Glacier2_PermissionDeniedException_t",
+    "PermissionsVerifier",
+    "PermissionsVerifierPrx",
+    "_Glacier2_PermissionsVerifierPrx_t",
+    "Router",
+    "RouterPrx",
+    "_Glacier2_RouterPrx_t",
+    "SSLInfo",
+    "_Glacier2_SSLInfo_t",
+    "SSLPermissionsVerifier",
+    "SSLPermissionsVerifierPrx",
+    "_Glacier2_SSLPermissionsVerifierPrx_t",
+    "SSLSessionManager",
+    "SSLSessionManagerPrx",
+    "_Glacier2_SSLSessionManagerPrx_t",
+    "Session",
+    "SessionPrx",
+    "SessionControl",
+    "SessionControlPrx",
+    "_Glacier2_SessionControlPrx_t",
+    "SessionManager",
+    "SessionManagerPrx",
+    "_Glacier2_SessionManagerPrx_t",
+    "SessionNotExistException",
+    "_Glacier2_SessionNotExistException_t",
+    "_Glacier2_SessionPrx_t",
+    "StringSet",
+    "StringSetPrx",
+    "_Glacier2_StringSetPrx_t"
+]

Ice/AdapterAlreadyActiveException.py

@@ -0,0 +1,35 @@
+# 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 AdapterAlreadyActiveException(UserException):
+    """
+    The exception that is thrown when a server application tries to register endpoints for an object adapter that is
+    already active.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::Ice::AdapterAlreadyActiveException``.
+    """
+
+    _ice_id = "::Ice::AdapterAlreadyActiveException"
+
+_Ice_AdapterAlreadyActiveException_t = IcePy.defineException(
+    "::Ice::AdapterAlreadyActiveException",
+    AdapterAlreadyActiveException,
+    (),
+    None,
+    ())
+
+setattr(AdapterAlreadyActiveException, '_ice_type', _Ice_AdapterAlreadyActiveException_t)
+
+__all__ = ["AdapterAlreadyActiveException", "_Ice_AdapterAlreadyActiveException_t"]

Ice/AdapterNotFoundException.py

@@ -0,0 +1,35 @@
+# 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 AdapterNotFoundException(UserException):
+    """
+    The exception that is thrown by a :class:`Ice.LocatorPrx` implementation when it cannot find an object adapter with the
+    provided adapter ID.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::Ice::AdapterNotFoundException``.
+    """
+
+    _ice_id = "::Ice::AdapterNotFoundException"
+
+_Ice_AdapterNotFoundException_t = IcePy.defineException(
+    "::Ice::AdapterNotFoundException",
+    AdapterNotFoundException,
+    (),
+    None,
+    ())
+
+setattr(AdapterNotFoundException, '_ice_type', _Ice_AdapterNotFoundException_t)
+
+__all__ = ["AdapterNotFoundException", "_Ice_AdapterNotFoundException_t"]

Ice/BTEndpointType.py

@@ -0,0 +1,11 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+BTEndpointType = 6
+
+__all__ = ["BTEndpointType"]

Ice/BTSEndpointType.py

@@ -0,0 +1,11 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+
+BTSEndpointType = 7
+
+__all__ = ["BTSEndpointType"]

Ice/Blobject.py

@@ -0,0 +1,42 @@
+# Copyright (c) ZeroC, Inc.
+
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable
+
+from .Current import Current
+from .Object import Object
+
+
+class Blobject(Object, ABC):
+    """
+    Special-purpose servant base class that allows a subclass to handle synchronous Ice invocations as "blobs" of
+    bytes.
+
+    This class serves as a base for creating servants that can process encoded Ice operation arguments and return
+    results or exceptions in an encoded form. Subclasses must implement the `ice_invoke` method to handle the
+    invocation logic.
+    """
+
+    @abstractmethod
+    def ice_invoke(self, bytes: bytes, current: Current) -> tuple[bool, bytes] | Awaitable[tuple[bool, bytes]]:
+        """
+        Dispatches a synchronous Ice invocation.
+
+        The operation's arguments are encoded in the `bytes` parameter. The return value must be a tuple of two
+        values: the first is a boolean indicating whether the operation succeeded (True) or raised a user exception
+        (False), and the second is the encoded form of the operation's results or the user exception.
+
+        Parameters
+        ----------
+        bytes : bytes
+            The encoded operation arguments.
+        current : Ice.Current
+            The current invocation context.
+
+        Returns
+        -------
+        tuple of (bool, bytes) or awaitable of tuple of (bool, bytes)
+            - bool True if the operation succeeded, False if it raised a user exception.
+            - bytes The encoded form of the operation's results or the user exception.
+        """
+        pass

Ice/BoolSeq.py

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

Ice/Builtin.py

@@ -0,0 +1,11 @@
+# Copyright (c) ZeroC, Inc.
+
+BuiltinBool = 0
+BuiltinByte = 1
+BuiltinShort = 2
+BuiltinInt = 3
+BuiltinLong = 4
+BuiltinFloat = 5
+BuiltinDouble = 6
+
+__all__ = ["BuiltinBool", "BuiltinByte", "BuiltinDouble", "BuiltinFloat", "BuiltinInt", "BuiltinLong", "BuiltinShort"]

Ice/ByteSeq.py

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