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

IceBox/ServiceObserver.py

@@ -0,0 +1,229 @@
+# 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 Ice.StringSeq import _Ice_StringSeq_t
+
+from IceBox.ServiceObserver_forward import _IceBox_ServiceObserverPrx_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 ServiceObserverPrx(ObjectPrx):
+    """
+    Observes the status of services in an IceBox server.
+    
+    Notes
+    -----
+        This interface is implemented by admin tools that monitor the IceBox server.
+        
+        The Slice compiler generated this proxy class from Slice interface ``::IceBox::ServiceObserver``.
+    
+    See Also
+    --------
+        :meth:`IceBox.ServiceManagerPrx.addObserverAsync`
+    """
+
+    def servicesStarted(self, services: Sequence[str], context: dict[str, str] | None = None) -> None:
+        """
+        Receives the names of the services that were started.
+        
+        Parameters
+        ----------
+        services : Sequence[str]
+            The names of the services that were started.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServiceObserver._op_servicesStarted.invoke(self, ((services, ), context))
+
+    def servicesStartedAsync(self, services: Sequence[str], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Receives the names of the services that were started.
+        
+        Parameters
+        ----------
+        services : Sequence[str]
+            The names of the services that were started.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServiceObserver._op_servicesStarted.invokeAsync(self, ((services, ), context))
+
+    def servicesStopped(self, services: Sequence[str], context: dict[str, str] | None = None) -> None:
+        """
+        Receives the names of the services that were stopped.
+        
+        Parameters
+        ----------
+        services : Sequence[str]
+            The names of the services that were stopped.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ServiceObserver._op_servicesStopped.invoke(self, ((services, ), context))
+
+    def servicesStoppedAsync(self, services: Sequence[str], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Receives the names of the services that were stopped.
+        
+        Parameters
+        ----------
+        services : Sequence[str]
+            The names of the services that were stopped.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ServiceObserver._op_servicesStopped.invokeAsync(self, ((services, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> ServiceObserverPrx | None:
+        return checkedCast(ServiceObserverPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[ServiceObserverPrx | None ]:
+        return checkedCastAsync(ServiceObserverPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> ServiceObserverPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> ServiceObserverPrx | None:
+        return uncheckedCast(ServiceObserverPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceBox::ServiceObserver"
+
+IcePy.defineProxy("::IceBox::ServiceObserver", ServiceObserverPrx)
+
+class ServiceObserver(Object, ABC):
+    """
+    Observes the status of services in an IceBox server.
+    
+    Notes
+    -----
+        This interface is implemented by admin tools that monitor the IceBox server.
+        
+        The Slice compiler generated this skeleton class from Slice interface ``::IceBox::ServiceObserver``.
+    
+    See Also
+    --------
+        :meth:`IceBox.ServiceManagerPrx.addObserverAsync`
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::IceBox::ServiceObserver", )
+    _op_servicesStarted: IcePy.Operation
+    _op_servicesStopped: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceBox::ServiceObserver"
+
+    @abstractmethod
+    def servicesStarted(self, services: list[str], current: Current) -> None | Awaitable[None]:
+        """
+        Receives the names of the services that were started.
+        
+        Parameters
+        ----------
+        services : list[str]
+            The names of the services that were started.
+        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 servicesStopped(self, services: list[str], current: Current) -> None | Awaitable[None]:
+        """
+        Receives the names of the services that were stopped.
+        
+        Parameters
+        ----------
+        services : list[str]
+            The names of the services that were stopped.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+ServiceObserver._op_servicesStarted = IcePy.Operation(
+    "servicesStarted",
+    "servicesStarted",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _Ice_StringSeq_t, False, 0),),
+    (),
+    None,
+    ())
+
+ServiceObserver._op_servicesStopped = IcePy.Operation(
+    "servicesStopped",
+    "servicesStopped",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _Ice_StringSeq_t, False, 0),),
+    (),
+    None,
+    ())
+
+__all__ = ["ServiceObserver", "ServiceObserverPrx", "_IceBox_ServiceObserverPrx_t"]

IceBox/ServiceObserver_forward.py

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

IceBox/__init__.py

@@ -1,10 +1,33 @@
-# Generated by slice2py - DO NOT EDIT!
-#
-
-import Ice
-Ice.updateModule("IceBox")
-
-# Modules:
-import IceBox.IceBox_ice
-
-# Submodules:
+
+# 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"]