zeroc-ice 3.7.11__cp313-cp313-win_amd64.whl → 3.8.0.post1__cp313-cp313-win_amd64.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

@@ -1,226 +1,79 @@
-#
-# Copyright (c) ZeroC, Inc. All rights reserved.
-#
 
-"""
-Glacier2 module
-"""
-
-import threading, traceback, copy
-
-#
-# Import the Python extension.
-#
-import Ice
-Ice.updateModule("Glacier2")
-
-import Glacier2.Router_ice
-import Glacier2.Session_ice
-import Glacier2.PermissionsVerifier_ice
-import Glacier2.SSLInfo_ice
-import Glacier2.Metrics_ice
-
-class SessionNotExistException(Exception):
-    def __init__(self):
-        pass
-
-class RestartSessionException(Exception):
-    def __init__(self):
-        pass
-
-class Application(Ice.Application):
-
-    def __init__(self, signalPolicy=0): # HandleSignals=0
-        '''The constructor accepts an optional argument indicating
-whether to handle signals. The value should be either
-Application.HandleSignals (the default) or
-Application.NoSignalHandling.
-'''
-
-        if type(self) == Application:
-            raise RuntimeError("Glacier2.Application is an abstract class")
-
-        Ice.Application.__init__(self, signalPolicy)
-
-        Application._adapter = None
-        Application._router = None
-        Application._session = None
-        Application._category = None
-
-    def run(self, args):
-        raise RuntimeError('run should not be called on Glacier2.Application - call runWithSession instead')
-
-    def createSession(self, args):
-        raise RuntimeError('createSession() not implemented')
-
-    def runWithSession(self, args):
-        raise RuntimeError('runWithSession() not implemented')
-
-    def sessionDestroyed(self):
-        pass
-
-    def restart(self):
-        raise RestartSessionException()
-    restart = classmethod(restart)
-
-    def router(self):
-        return Application._router
-    router = classmethod(router)
-
-    def session(self):
-        return Application._session
-    session = classmethod(session)
-
-    def categoryForClient(self):
-        if Application._router == None:
-            raise SessionNotExistException()
-        return Application._category
-    categoryForClient = classmethod(categoryForClient)
-
-    def createCallbackIdentity(self, name):
-        return Ice.Identity(name, self.categoryForClient())
-    createCallbackIdentity = classmethod(createCallbackIdentity)
-
-    def addWithUUID(self, servant):
-        return self.objectAdapter().add(servant, self.createCallbackIdentity(Ice.generateUUID()))
-    addWithUUID = classmethod(addWithUUID)
-
-    def objectAdapter(self):
-        if Application._router == None:
-            raise SessionNotExistException()
-        if Application._adapter == None:
-            Application._adapter = self.communicator().createObjectAdapterWithRouter("", Application._router)
-            Application._adapter.activate()
-        return Application._adapter
-    objectAdapter = classmethod(objectAdapter)
-
-    def doMainInternal(self, args, initData):
-        # Reset internal state variables from Ice.Application. The
-        # remainder are reset at the end of this method.
-        Ice.Application._callbackInProgress = False
-        Ice.Application._destroyed = False
-        Ice.Application._interrupted = False
-
-        restart = False
-        status = 0
-        sessionCreated = False
-        try:
-            Ice.Application._communicator = Ice.initialize(args, initData)
-
-            Application._router = RouterPrx.uncheckedCast(Ice.Application.communicator().getDefaultRouter())
-            if Application._router == None:
-                Ice.getProcessLogger().error("no glacier2 router configured")
-                status = 1
-            else:
-                #
-                # The default is to destroy when a signal is received.
-                #
-                if Ice.Application._signalPolicy == Ice.Application.HandleSignals:
-                    Ice.Application.destroyOnInterrupt()
-
-                # If createSession throws, we're done.
-                try:
-                    Application._session = self.createSession()
-                    sessionCreated = True
-                except Ice.LocalException:
-                    Ice.getProcessLogger().error(traceback.format_exc())
-                    status = 1
-
-                if sessionCreated:
-                    acmTimeout = 0
-                    try:
-                        acmTimeout = Application._router.getACMTimeout()
-                    except(Ice.OperationNotExistException):
-                        pass
-                    if acmTimeout <= 0:
-                        acmTimeout = Application._router.getSessionTimeout()
-                    if acmTimeout > 0:
-                        connection = Application._router.ice_getCachedConnection()
-                        assert(connection)
-                        connection.setACM(acmTimeout, Ice.Unset, Ice.ACMHeartbeat.HeartbeatAlways)
-                        connection.setCloseCallback(lambda conn: self.sessionDestroyed())
-                    Application._category = Application._router.getCategoryForClient()
-                    status = self.runWithSession(args)
-
-        # We want to restart on those exceptions which indicate a
-        # break down in communications, but not those exceptions that
-        # indicate a programming logic error (ie: marshal, protocol
-        # failure, etc).
-        except(RestartSessionException):
-            restart = True
-        except(Ice.ConnectionRefusedException, Ice.ConnectionLostException, Ice.UnknownLocalException, \
-               Ice.RequestFailedException, Ice.TimeoutException):
-            Ice.getProcessLogger().error(traceback.format_exc())
-            restart = True
-        except:
-            Ice.getProcessLogger().error(traceback.format_exc())
-            status = 1
-
-        #
-        # Don't want any new interrupt and at this point (post-run),
-        # it would not make sense to release a held signal to run
-        # shutdown or destroy.
-        #
-        if Ice.Application._signalPolicy == Ice.Application.HandleSignals:
-            Ice.Application.ignoreInterrupt()
-
-        Ice.Application._condVar.acquire()
-        while Ice.Application._callbackInProgress:
-            Ice.Application._condVar.wait()
-        if Ice.Application._destroyed:
-            Ice.Application._communicator = None
-        else:
-            Ice.Application._destroyed = True
-            #
-            # And _communicator != None, meaning will be destroyed
-            # next, _destroyed = True also ensures that any
-            # remaining callback won't do anything
-            #
-        Ice.Application._condVar.release()
-
-        if sessionCreated and Application._router:
-            try:
-                Application._router.destroySession()
-            except (Ice.ConnectionLostException, SessionNotExistException):
-                pass
-            except:
-                Ice.getProcessLogger().error("unexpected exception when destroying the session " + \
-                                             traceback.format_exc())
-            Application._router = None
-
-        if Ice.Application._communicator:
-            try:
-                Ice.Application._communicator.destroy()
-            except:
-                getProcessLogger().error(traceback.format_exc())
-                status = 1
-
-            Ice.Application._communicator = None
-
-        # Reset internal state. We cannot reset the Application state
-        # here, since _destroyed must remain true until we re-run
-        # this method.
-        Application._adapter = None
-        Application._router = None
-        Application._session = None
-        sessionCreated = False
-        Application._category = None
-
-        return (restart, status)
-
-    def doMain(self, args, initData):
-        # Set the default properties for all Glacier2 applications.
-        initData.properties.setProperty("Ice.RetryIntervals", "-1")
-
-        restart = True
-        ret = 0
-        while restart:
-            # A copy of the initialization data and the string seq
-            # needs to be passed to doMainInternal, as these can be
-            # changed by the application.
-            id = copy.copy(initData)
-            if id.properties:
-                id.properties = id.properties.clone()
-            argsCopy = args[:]
-            (restart, ret) = self.doMainInternal(argsCopy, initData)
-        return ret
+# 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"]