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

IceGrid/AdminSession_forward.py

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

IceGrid/Admin_forward.py

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

IceGrid/AllocationException.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 AllocationException(UserException):
+    """
+    The exception that is thrown when the allocation of an object failed.
+    
+    Attributes
+    ----------
+    reason : str
+        The reason why the object couldn't be allocated.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::AllocationException``.
+    """
+    reason: str = ""
+
+    _ice_id = "::IceGrid::AllocationException"
+
+_IceGrid_AllocationException_t = IcePy.defineException(
+    "::IceGrid::AllocationException",
+    AllocationException,
+    (),
+    None,
+    (("reason", (), IcePy._t_string, False, 0),))
+
+setattr(AllocationException, '_ice_type', _IceGrid_AllocationException_t)
+
+__all__ = ["AllocationException", "_IceGrid_AllocationException_t"]

IceGrid/AllocationTimeoutException.py

@@ -0,0 +1,35 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.AllocationException import AllocationException
+from IceGrid.AllocationException import _IceGrid_AllocationException_t
+
+from dataclasses import dataclass
+
+
+@dataclass
+class AllocationTimeoutException(AllocationException):
+    """
+    The exception that is thrown when the request to allocate an object times out.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::AllocationTimeoutException``.
+    """
+
+    _ice_id = "::IceGrid::AllocationTimeoutException"
+
+_IceGrid_AllocationTimeoutException_t = IcePy.defineException(
+    "::IceGrid::AllocationTimeoutException",
+    AllocationTimeoutException,
+    (),
+    _IceGrid_AllocationException_t,
+    ())
+
+setattr(AllocationTimeoutException, '_ice_type', _IceGrid_AllocationTimeoutException_t)
+
+__all__ = ["AllocationTimeoutException", "_IceGrid_AllocationTimeoutException_t"]

IceGrid/ApplicationDescriptor.py

@@ -0,0 +1,89 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.DistributionDescriptor import DistributionDescriptor
+from IceGrid.DistributionDescriptor import _IceGrid_DistributionDescriptor_t
+
+from IceGrid.NodeDescriptorDict import _IceGrid_NodeDescriptorDict_t
+
+from IceGrid.PropertySetDescriptorDict import _IceGrid_PropertySetDescriptorDict_t
+
+from IceGrid.ReplicaGroupDescriptorSeq import _IceGrid_ReplicaGroupDescriptorSeq_t
+
+from IceGrid.StringStringDict import _IceGrid_StringStringDict_t
+
+from IceGrid.TemplateDescriptorDict import _IceGrid_TemplateDescriptorDict_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from IceGrid.NodeDescriptor import NodeDescriptor
+    from IceGrid.PropertySetDescriptor import PropertySetDescriptor
+    from IceGrid.ReplicaGroupDescriptor import ReplicaGroupDescriptor
+    from IceGrid.TemplateDescriptor import TemplateDescriptor
+
+
+@dataclass
+class ApplicationDescriptor:
+    """
+    Describes an application.
+    
+    Attributes
+    ----------
+    name : str
+        The application name.
+    variables : dict[str, str]
+        The variables defined in the application descriptor.
+    replicaGroups : list[ReplicaGroupDescriptor]
+        The replica groups.
+    serverTemplates : dict[str, TemplateDescriptor]
+        The server templates.
+    serviceTemplates : dict[str, TemplateDescriptor]
+        The service templates.
+    nodes : dict[str, NodeDescriptor]
+        The node descriptors.
+    distrib : DistributionDescriptor
+        The application distribution.
+    description : str
+        The description of this application.
+    propertySets : dict[str, PropertySetDescriptor]
+        Property set descriptors.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::ApplicationDescriptor``.
+    """
+    name: str = ""
+    variables: dict[str, str] = field(default_factory=dict)
+    replicaGroups: list[ReplicaGroupDescriptor] = field(default_factory=list)
+    serverTemplates: dict[str, TemplateDescriptor] = field(default_factory=dict)
+    serviceTemplates: dict[str, TemplateDescriptor] = field(default_factory=dict)
+    nodes: dict[str, NodeDescriptor] = field(default_factory=dict)
+    distrib: DistributionDescriptor = field(default_factory=DistributionDescriptor)
+    description: str = ""
+    propertySets: dict[str, PropertySetDescriptor] = field(default_factory=dict)
+
+_IceGrid_ApplicationDescriptor_t = IcePy.defineStruct(
+    "::IceGrid::ApplicationDescriptor",
+    ApplicationDescriptor,
+    (),
+    (
+        ("name", (), IcePy._t_string),
+        ("variables", (), _IceGrid_StringStringDict_t),
+        ("replicaGroups", (), _IceGrid_ReplicaGroupDescriptorSeq_t),
+        ("serverTemplates", (), _IceGrid_TemplateDescriptorDict_t),
+        ("serviceTemplates", (), _IceGrid_TemplateDescriptorDict_t),
+        ("nodes", (), _IceGrid_NodeDescriptorDict_t),
+        ("distrib", (), _IceGrid_DistributionDescriptor_t),
+        ("description", (), IcePy._t_string),
+        ("propertySets", (), _IceGrid_PropertySetDescriptorDict_t)
+    ))
+
+__all__ = ["ApplicationDescriptor", "_IceGrid_ApplicationDescriptor_t"]

IceGrid/ApplicationDescriptorSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ApplicationDescriptor import _IceGrid_ApplicationDescriptor_t
+
+_IceGrid_ApplicationDescriptorSeq_t = IcePy.defineSequence("::IceGrid::ApplicationDescriptorSeq", (), _IceGrid_ApplicationDescriptor_t)
+
+__all__ = ["_IceGrid_ApplicationDescriptorSeq_t"]

IceGrid/ApplicationInfo.py

@@ -0,0 +1,63 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ApplicationDescriptor import ApplicationDescriptor
+from IceGrid.ApplicationDescriptor import _IceGrid_ApplicationDescriptor_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+
+@dataclass
+class ApplicationInfo:
+    """
+    Information about an IceGrid application.
+    
+    Attributes
+    ----------
+    uuid : str
+        Unique application identifier.
+    createTime : int
+        The creation time.
+    createUser : str
+        The user who created the application.
+    updateTime : int
+        The last update time.
+    updateUser : str
+        The user who updated the application.
+    revision : int
+        The application revision number.
+    descriptor : ApplicationDescriptor
+        The application descriptor.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::ApplicationInfo``.
+    """
+    uuid: str = ""
+    createTime: int = 0
+    createUser: str = ""
+    updateTime: int = 0
+    updateUser: str = ""
+    revision: int = 0
+    descriptor: ApplicationDescriptor = field(default_factory=ApplicationDescriptor)
+
+_IceGrid_ApplicationInfo_t = IcePy.defineStruct(
+    "::IceGrid::ApplicationInfo",
+    ApplicationInfo,
+    (),
+    (
+        ("uuid", (), IcePy._t_string),
+        ("createTime", (), IcePy._t_long),
+        ("createUser", (), IcePy._t_string),
+        ("updateTime", (), IcePy._t_long),
+        ("updateUser", (), IcePy._t_string),
+        ("revision", (), IcePy._t_int),
+        ("descriptor", (), _IceGrid_ApplicationDescriptor_t)
+    ))
+
+__all__ = ["ApplicationInfo", "_IceGrid_ApplicationInfo_t"]

IceGrid/ApplicationInfoSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ApplicationInfo import _IceGrid_ApplicationInfo_t
+
+_IceGrid_ApplicationInfoSeq_t = IcePy.defineSequence("::IceGrid::ApplicationInfoSeq", (), _IceGrid_ApplicationInfo_t)
+
+__all__ = ["_IceGrid_ApplicationInfoSeq_t"]

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

IceGrid/ApplicationObserver.py

@@ -0,0 +1,374 @@
+# 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.ApplicationInfo import _IceGrid_ApplicationInfo_t
+
+from IceGrid.ApplicationInfoSeq import _IceGrid_ApplicationInfoSeq_t
+
+from IceGrid.ApplicationObserver_forward import _IceGrid_ApplicationObserverPrx_t
+
+from IceGrid.ApplicationUpdateInfo import _IceGrid_ApplicationUpdateInfo_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.ApplicationInfo import ApplicationInfo
+    from IceGrid.ApplicationUpdateInfo import ApplicationUpdateInfo
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class ApplicationObserverPrx(ObjectPrx):
+    """
+    Monitors applications.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::IceGrid::ApplicationObserver``.
+    """
+
+    def applicationInit(self, serial: int, applications: Sequence[ApplicationInfo], context: dict[str, str] | None = None) -> None:
+        """
+        Provides the initial application infos to the observer.
+        
+        Parameters
+        ----------
+        serial : int
+            The current serial number of the registry database. This serial number allows observers to
+            make sure that their internal state is synchronized with the registry.
+        applications : Sequence[ApplicationInfo]
+            The applications currently registered with the registry.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ApplicationObserver._op_applicationInit.invoke(self, ((serial, applications), context))
+
+    def applicationInitAsync(self, serial: int, applications: Sequence[ApplicationInfo], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Provides the initial application infos to the observer.
+        
+        Parameters
+        ----------
+        serial : int
+            The current serial number of the registry database. This serial number allows observers to
+            make sure that their internal state is synchronized with the registry.
+        applications : Sequence[ApplicationInfo]
+            The applications currently 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 ApplicationObserver._op_applicationInit.invokeAsync(self, ((serial, applications), context))
+
+    def applicationAdded(self, serial: int, desc: ApplicationInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that an application was added.
+        
+        Parameters
+        ----------
+        serial : int
+            The new serial number of the registry database.
+        desc : ApplicationInfo
+            The descriptor of the new application.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ApplicationObserver._op_applicationAdded.invoke(self, ((serial, desc), context))
+
+    def applicationAddedAsync(self, serial: int, desc: ApplicationInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that an application was added.
+        
+        Parameters
+        ----------
+        serial : int
+            The new serial number of the registry database.
+        desc : ApplicationInfo
+            The descriptor of the new application.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ApplicationObserver._op_applicationAdded.invokeAsync(self, ((serial, desc), context))
+
+    def applicationRemoved(self, serial: int, name: str, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that an application was removed.
+        
+        Parameters
+        ----------
+        serial : int
+            The new serial number of the registry database.
+        name : str
+            The name of the application that was removed.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ApplicationObserver._op_applicationRemoved.invoke(self, ((serial, name), context))
+
+    def applicationRemovedAsync(self, serial: int, name: str, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that an application was removed.
+        
+        Parameters
+        ----------
+        serial : int
+            The new serial number of the registry database.
+        name : str
+            The name of the application that was removed.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ApplicationObserver._op_applicationRemoved.invokeAsync(self, ((serial, name), context))
+
+    def applicationUpdated(self, serial: int, desc: ApplicationUpdateInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that an application was updated.
+        
+        Parameters
+        ----------
+        serial : int
+            The new serial number of the registry database.
+        desc : ApplicationUpdateInfo
+            The descriptor of the update.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ApplicationObserver._op_applicationUpdated.invoke(self, ((serial, desc), context))
+
+    def applicationUpdatedAsync(self, serial: int, desc: ApplicationUpdateInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that an application was updated.
+        
+        Parameters
+        ----------
+        serial : int
+            The new serial number of the registry database.
+        desc : ApplicationUpdateInfo
+            The descriptor of the update.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ApplicationObserver._op_applicationUpdated.invokeAsync(self, ((serial, desc), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> ApplicationObserverPrx | None:
+        return checkedCast(ApplicationObserverPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[ApplicationObserverPrx | None ]:
+        return checkedCastAsync(ApplicationObserverPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> ApplicationObserverPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> ApplicationObserverPrx | None:
+        return uncheckedCast(ApplicationObserverPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::ApplicationObserver"
+
+IcePy.defineProxy("::IceGrid::ApplicationObserver", ApplicationObserverPrx)
+
+class ApplicationObserver(Object, ABC):
+    """
+    Monitors applications.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::IceGrid::ApplicationObserver``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::IceGrid::ApplicationObserver", )
+    _op_applicationInit: IcePy.Operation
+    _op_applicationAdded: IcePy.Operation
+    _op_applicationRemoved: IcePy.Operation
+    _op_applicationUpdated: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::ApplicationObserver"
+
+    @abstractmethod
+    def applicationInit(self, serial: int, applications: list[ApplicationInfo], current: Current) -> None | Awaitable[None]:
+        """
+        Provides the initial application infos to the observer.
+        
+        Parameters
+        ----------
+        serial : int
+            The current serial number of the registry database. This serial number allows observers to
+            make sure that their internal state is synchronized with the registry.
+        applications : list[ApplicationInfo]
+            The applications currently 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 applicationAdded(self, serial: int, desc: ApplicationInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that an application was added.
+        
+        Parameters
+        ----------
+        serial : int
+            The new serial number of the registry database.
+        desc : ApplicationInfo
+            The descriptor of the new application.
+        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 applicationRemoved(self, serial: int, name: str, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that an application was removed.
+        
+        Parameters
+        ----------
+        serial : int
+            The new serial number of the registry database.
+        name : str
+            The name of the application that was removed.
+        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 applicationUpdated(self, serial: int, desc: ApplicationUpdateInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that an application was updated.
+        
+        Parameters
+        ----------
+        serial : int
+            The new serial number of the registry database.
+        desc : ApplicationUpdateInfo
+            The descriptor of the update.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+ApplicationObserver._op_applicationInit = IcePy.Operation(
+    "applicationInit",
+    "applicationInit",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0), ((), _IceGrid_ApplicationInfoSeq_t, False, 0)),
+    (),
+    None,
+    ())
+
+ApplicationObserver._op_applicationAdded = IcePy.Operation(
+    "applicationAdded",
+    "applicationAdded",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0), ((), _IceGrid_ApplicationInfo_t, False, 0)),
+    (),
+    None,
+    ())
+
+ApplicationObserver._op_applicationRemoved = IcePy.Operation(
+    "applicationRemoved",
+    "applicationRemoved",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0), ((), IcePy._t_string, False, 0)),
+    (),
+    None,
+    ())
+
+ApplicationObserver._op_applicationUpdated = IcePy.Operation(
+    "applicationUpdated",
+    "applicationUpdated",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0), ((), _IceGrid_ApplicationUpdateInfo_t, False, 0)),
+    (),
+    None,
+    ())
+
+__all__ = ["ApplicationObserver", "ApplicationObserverPrx", "_IceGrid_ApplicationObserverPrx_t"]