zeroc-ice 3.8.0__cp312-cp312-macosx_10_13_universal2.whl

IceBox/__init__.py

@@ -0,0 +1,33 @@
+
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from .AlreadyStartedException import AlreadyStartedException
+from .AlreadyStartedException import _IceBox_AlreadyStartedException_t
+from .AlreadyStoppedException import AlreadyStoppedException
+from .AlreadyStoppedException import _IceBox_AlreadyStoppedException_t
+from .NoSuchServiceException import NoSuchServiceException
+from .NoSuchServiceException import _IceBox_NoSuchServiceException_t
+from .ServiceManager import ServiceManager
+from .ServiceManager import ServiceManagerPrx
+from .ServiceManager_forward import _IceBox_ServiceManagerPrx_t
+from .ServiceObserver import ServiceObserver
+from .ServiceObserver import ServiceObserverPrx
+from .ServiceObserver_forward import _IceBox_ServiceObserverPrx_t
+
+
+__all__ = [
+    "AlreadyStartedException",
+    "_IceBox_AlreadyStartedException_t",
+    "AlreadyStoppedException",
+    "_IceBox_AlreadyStoppedException_t",
+    "NoSuchServiceException",
+    "_IceBox_NoSuchServiceException_t",
+    "ServiceManager",
+    "ServiceManagerPrx",
+    "_IceBox_ServiceManagerPrx_t",
+    "ServiceObserver",
+    "ServiceObserverPrx",
+    "_IceBox_ServiceObserverPrx_t"
+]

IceGrid/AccessDeniedException.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 AccessDeniedException(UserException):
+    """
+    The exception that is thrown when the registry update lock cannot be acquired.
+    
+    Attributes
+    ----------
+    lockUserId : str
+        The id of the user holding the lock (if any).
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::AccessDeniedException``.
+    """
+    lockUserId: str = ""
+
+    _ice_id = "::IceGrid::AccessDeniedException"
+
+_IceGrid_AccessDeniedException_t = IcePy.defineException(
+    "::IceGrid::AccessDeniedException",
+    AccessDeniedException,
+    (),
+    None,
+    (("lockUserId", (), IcePy._t_string, False, 0),))
+
+setattr(AccessDeniedException, '_ice_type', _IceGrid_AccessDeniedException_t)
+
+__all__ = ["AccessDeniedException", "_IceGrid_AccessDeniedException_t"]

IceGrid/AdapterDescriptor.py

@@ -0,0 +1,77 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ObjectDescriptorSeq import _IceGrid_ObjectDescriptorSeq_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from IceGrid.ObjectDescriptor import ObjectDescriptor
+
+
+@dataclass
+class AdapterDescriptor:
+    """
+    Describes an indirect object adapter.
+    
+    Attributes
+    ----------
+    name : str
+        The object adapter name.
+    description : str
+        A description of this object adapter.
+    id : str
+        The adapter ID.
+    replicaGroupId : str
+        The replica group ID. It's empty when the adapter is not part of a replica group.
+    priority : str
+        The adapter priority. Only relevant when the adapter is in a replica group.
+    registerProcess : bool
+        When ``true``, the object adapter registers a process object.
+    serverLifetime : bool
+        When ``true``, the lifetime of this object adapter is the same of the server lifetime. This information is
+        used by the IceGrid node to figure out the server state: the server is active when all its "server lifetime"
+        adapters are active.
+    objects : list[ObjectDescriptor]
+        The descriptors of well-known objects.
+    allocatables : list[ObjectDescriptor]
+        The descriptors of allocatable objects.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::AdapterDescriptor``.
+    """
+    name: str = ""
+    description: str = ""
+    id: str = ""
+    replicaGroupId: str = ""
+    priority: str = ""
+    registerProcess: bool = False
+    serverLifetime: bool = False
+    objects: list[ObjectDescriptor] = field(default_factory=list)
+    allocatables: list[ObjectDescriptor] = field(default_factory=list)
+
+_IceGrid_AdapterDescriptor_t = IcePy.defineStruct(
+    "::IceGrid::AdapterDescriptor",
+    AdapterDescriptor,
+    (),
+    (
+        ("name", (), IcePy._t_string),
+        ("description", (), IcePy._t_string),
+        ("id", (), IcePy._t_string),
+        ("replicaGroupId", (), IcePy._t_string),
+        ("priority", (), IcePy._t_string),
+        ("registerProcess", (), IcePy._t_bool),
+        ("serverLifetime", (), IcePy._t_bool),
+        ("objects", (), _IceGrid_ObjectDescriptorSeq_t),
+        ("allocatables", (), _IceGrid_ObjectDescriptorSeq_t)
+    ))
+
+__all__ = ["AdapterDescriptor", "_IceGrid_AdapterDescriptor_t"]

IceGrid/AdapterDescriptorSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.AdapterDescriptor import _IceGrid_AdapterDescriptor_t
+
+_IceGrid_AdapterDescriptorSeq_t = IcePy.defineSequence("::IceGrid::AdapterDescriptorSeq", (), _IceGrid_AdapterDescriptor_t)
+
+__all__ = ["_IceGrid_AdapterDescriptorSeq_t"]

IceGrid/AdapterDynamicInfo.py

@@ -0,0 +1,46 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.ObjectPrx_forward import _Ice_ObjectPrx_t
+
+from dataclasses import dataclass
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from Ice.ObjectPrx import ObjectPrx
+
+
+@dataclass
+class AdapterDynamicInfo:
+    """
+    Dynamic information about the state of an adapter.
+    
+    Attributes
+    ----------
+    id : str
+        The id of the adapter.
+    proxy : ObjectPrx | None
+        The direct proxy containing the adapter endpoints. This proxy is never null.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::AdapterDynamicInfo``.
+    """
+    id: str = ""
+    proxy: ObjectPrx | None = None
+
+_IceGrid_AdapterDynamicInfo_t = IcePy.defineStruct(
+    "::IceGrid::AdapterDynamicInfo",
+    AdapterDynamicInfo,
+    (),
+    (
+        ("id", (), IcePy._t_string),
+        ("proxy", (), _Ice_ObjectPrx_t)
+    ))
+
+__all__ = ["AdapterDynamicInfo", "_IceGrid_AdapterDynamicInfo_t"]

IceGrid/AdapterDynamicInfoSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.AdapterDynamicInfo import _IceGrid_AdapterDynamicInfo_t
+
+_IceGrid_AdapterDynamicInfoSeq_t = IcePy.defineSequence("::IceGrid::AdapterDynamicInfoSeq", (), _IceGrid_AdapterDynamicInfo_t)
+
+__all__ = ["_IceGrid_AdapterDynamicInfoSeq_t"]

IceGrid/AdapterInfo.py

@@ -0,0 +1,50 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.ObjectPrx_forward import _Ice_ObjectPrx_t
+
+from dataclasses import dataclass
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from Ice.ObjectPrx import ObjectPrx
+
+
+@dataclass
+class AdapterInfo:
+    """
+    Information about an adapter registered with the IceGrid registry.
+    
+    Attributes
+    ----------
+    id : str
+        The ID of the adapter.
+    proxy : ObjectPrx | None
+        A dummy direct proxy that contains the adapter endpoints.
+    replicaGroupId : str
+        The replica group ID of the object adapter, or empty if the adapter doesn't belong to a replica group.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::AdapterInfo``.
+    """
+    id: str = ""
+    proxy: ObjectPrx | None = None
+    replicaGroupId: str = ""
+
+_IceGrid_AdapterInfo_t = IcePy.defineStruct(
+    "::IceGrid::AdapterInfo",
+    AdapterInfo,
+    (),
+    (
+        ("id", (), IcePy._t_string),
+        ("proxy", (), _Ice_ObjectPrx_t),
+        ("replicaGroupId", (), IcePy._t_string)
+    ))
+
+__all__ = ["AdapterInfo", "_IceGrid_AdapterInfo_t"]

IceGrid/AdapterInfoSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.AdapterInfo import _IceGrid_AdapterInfo_t
+
+_IceGrid_AdapterInfoSeq_t = IcePy.defineSequence("::IceGrid::AdapterInfoSeq", (), _IceGrid_AdapterInfo_t)
+
+__all__ = ["_IceGrid_AdapterInfoSeq_t"]

IceGrid/AdapterNotExistException.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 AdapterNotExistException(UserException):
+    """
+    The exception that is thrown when IceGrid does not know an object adapter with the provided adapter ID.
+    
+    Attributes
+    ----------
+    id : str
+        The adapter ID.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::AdapterNotExistException``.
+    """
+    id: str = ""
+
+    _ice_id = "::IceGrid::AdapterNotExistException"
+
+_IceGrid_AdapterNotExistException_t = IcePy.defineException(
+    "::IceGrid::AdapterNotExistException",
+    AdapterNotExistException,
+    (),
+    None,
+    (("id", (), IcePy._t_string, False, 0),))
+
+setattr(AdapterNotExistException, '_ice_type', _IceGrid_AdapterNotExistException_t)
+
+__all__ = ["AdapterNotExistException", "_IceGrid_AdapterNotExistException_t"]

IceGrid/AdapterObserver.py

@@ -0,0 +1,338 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+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 IceGrid.AdapterInfo import _IceGrid_AdapterInfo_t
+
+from IceGrid.AdapterInfoSeq import _IceGrid_AdapterInfoSeq_t
+
+from IceGrid.AdapterObserver_forward import _IceGrid_AdapterObserverPrx_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 IceGrid.AdapterInfo import AdapterInfo
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class AdapterObserverPrx(ObjectPrx):
+    """
+    Monitors dynamically-registered object adapters.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::IceGrid::AdapterObserver``.
+    """
+
+    def adapterInit(self, adpts: Sequence[AdapterInfo], context: dict[str, str] | None = None) -> None:
+        """
+        Provides the initial list of dynamically registered adapters to the observer.
+        
+        Parameters
+        ----------
+        adpts : Sequence[AdapterInfo]
+            The adapters that were dynamically registered with the registry.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return AdapterObserver._op_adapterInit.invoke(self, ((adpts, ), context))
+
+    def adapterInitAsync(self, adpts: Sequence[AdapterInfo], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Provides the initial list of dynamically registered adapters to the observer.
+        
+        Parameters
+        ----------
+        adpts : Sequence[AdapterInfo]
+            The adapters that were dynamically registered with the registry.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return AdapterObserver._op_adapterInit.invokeAsync(self, ((adpts, ), context))
+
+    def adapterAdded(self, info: AdapterInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that a dynamically-registered adapter was added.
+        
+        Parameters
+        ----------
+        info : AdapterInfo
+            The details of the new adapter.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return AdapterObserver._op_adapterAdded.invoke(self, ((info, ), context))
+
+    def adapterAddedAsync(self, info: AdapterInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that a dynamically-registered adapter was added.
+        
+        Parameters
+        ----------
+        info : AdapterInfo
+            The details of the new adapter.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return AdapterObserver._op_adapterAdded.invokeAsync(self, ((info, ), context))
+
+    def adapterUpdated(self, info: AdapterInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Parameters
+        ----------
+        info : AdapterInfo
+            The details of the updated adapter.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return AdapterObserver._op_adapterUpdated.invoke(self, ((info, ), context))
+
+    def adapterUpdatedAsync(self, info: AdapterInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Parameters
+        ----------
+        info : AdapterInfo
+            The details of the updated adapter.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return AdapterObserver._op_adapterUpdated.invokeAsync(self, ((info, ), context))
+
+    def adapterRemoved(self, id: str, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that a dynamically-registered adapter was removed.
+        
+        Parameters
+        ----------
+        id : str
+            The ID of the removed adapter.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return AdapterObserver._op_adapterRemoved.invoke(self, ((id, ), context))
+
+    def adapterRemovedAsync(self, id: str, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that a dynamically-registered adapter was removed.
+        
+        Parameters
+        ----------
+        id : str
+            The ID of the removed adapter.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return AdapterObserver._op_adapterRemoved.invokeAsync(self, ((id, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> AdapterObserverPrx | None:
+        return checkedCast(AdapterObserverPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[AdapterObserverPrx | None ]:
+        return checkedCastAsync(AdapterObserverPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> AdapterObserverPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> AdapterObserverPrx | None:
+        return uncheckedCast(AdapterObserverPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::AdapterObserver"
+
+IcePy.defineProxy("::IceGrid::AdapterObserver", AdapterObserverPrx)
+
+class AdapterObserver(Object, ABC):
+    """
+    Monitors dynamically-registered object adapters.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::IceGrid::AdapterObserver``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::IceGrid::AdapterObserver", )
+    _op_adapterInit: IcePy.Operation
+    _op_adapterAdded: IcePy.Operation
+    _op_adapterUpdated: IcePy.Operation
+    _op_adapterRemoved: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::AdapterObserver"
+
+    @abstractmethod
+    def adapterInit(self, adpts: list[AdapterInfo], current: Current) -> None | Awaitable[None]:
+        """
+        Provides the initial list of dynamically registered adapters to the observer.
+        
+        Parameters
+        ----------
+        adpts : list[AdapterInfo]
+            The adapters that were dynamically registered with the registry.
+        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 adapterAdded(self, info: AdapterInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that a dynamically-registered adapter was added.
+        
+        Parameters
+        ----------
+        info : AdapterInfo
+            The details of the new adapter.
+        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 adapterUpdated(self, info: AdapterInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Parameters
+        ----------
+        info : AdapterInfo
+            The details of the updated adapter.
+        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 adapterRemoved(self, id: str, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that a dynamically-registered adapter was removed.
+        
+        Parameters
+        ----------
+        id : str
+            The ID of the removed adapter.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+AdapterObserver._op_adapterInit = IcePy.Operation(
+    "adapterInit",
+    "adapterInit",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_AdapterInfoSeq_t, False, 0),),
+    (),
+    None,
+    ())
+
+AdapterObserver._op_adapterAdded = IcePy.Operation(
+    "adapterAdded",
+    "adapterAdded",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_AdapterInfo_t, False, 0),),
+    (),
+    None,
+    ())
+
+AdapterObserver._op_adapterUpdated = IcePy.Operation(
+    "adapterUpdated",
+    "adapterUpdated",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_AdapterInfo_t, False, 0),),
+    (),
+    None,
+    ())
+
+AdapterObserver._op_adapterRemoved = IcePy.Operation(
+    "adapterRemoved",
+    "adapterRemoved",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0),),
+    (),
+    None,
+    ())
+
+__all__ = ["AdapterObserver", "AdapterObserverPrx", "_IceGrid_AdapterObserverPrx_t"]

IceGrid/AdapterObserver_forward.py

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