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

IceGrid/NodeObserver.py

@@ -0,0 +1,424 @@
+# 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.AdapterDynamicInfo import _IceGrid_AdapterDynamicInfo_t
+
+from IceGrid.NodeDynamicInfo import _IceGrid_NodeDynamicInfo_t
+
+from IceGrid.NodeDynamicInfoSeq import _IceGrid_NodeDynamicInfoSeq_t
+
+from IceGrid.NodeObserver_forward import _IceGrid_NodeObserverPrx_t
+
+from IceGrid.ServerDynamicInfo import _IceGrid_ServerDynamicInfo_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.AdapterDynamicInfo import AdapterDynamicInfo
+    from IceGrid.NodeDynamicInfo import NodeDynamicInfo
+    from IceGrid.ServerDynamicInfo import ServerDynamicInfo
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class NodeObserverPrx(ObjectPrx):
+    """
+    Monitors changes to the state of the nodes.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::IceGrid::NodeObserver``.
+    """
+
+    def nodeInit(self, nodes: Sequence[NodeDynamicInfo], context: dict[str, str] | None = None) -> None:
+        """
+        Provides the initial state of the nodes to the observer.
+        
+        Parameters
+        ----------
+        nodes : Sequence[NodeDynamicInfo]
+            The current state of the nodes.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return NodeObserver._op_nodeInit.invoke(self, ((nodes, ), context))
+
+    def nodeInitAsync(self, nodes: Sequence[NodeDynamicInfo], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Provides the initial state of the nodes to the observer.
+        
+        Parameters
+        ----------
+        nodes : Sequence[NodeDynamicInfo]
+            The current state of the nodes.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return NodeObserver._op_nodeInit.invokeAsync(self, ((nodes, ), context))
+
+    def nodeUp(self, node: NodeDynamicInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that a node came up.
+        
+        Parameters
+        ----------
+        node : NodeDynamicInfo
+            The node state.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return NodeObserver._op_nodeUp.invoke(self, ((node, ), context))
+
+    def nodeUpAsync(self, node: NodeDynamicInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that a node came up.
+        
+        Parameters
+        ----------
+        node : NodeDynamicInfo
+            The node state.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return NodeObserver._op_nodeUp.invokeAsync(self, ((node, ), context))
+
+    def nodeDown(self, name: str, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that a node went down.
+        
+        Parameters
+        ----------
+        name : str
+            The node name.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return NodeObserver._op_nodeDown.invoke(self, ((name, ), context))
+
+    def nodeDownAsync(self, name: str, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that a node went down.
+        
+        Parameters
+        ----------
+        name : str
+            The node name.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return NodeObserver._op_nodeDown.invokeAsync(self, ((name, ), context))
+
+    def updateServer(self, node: str, updatedInfo: ServerDynamicInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that the state of a server changed.
+        
+        Parameters
+        ----------
+        node : str
+            The node hosting the server.
+        updatedInfo : ServerDynamicInfo
+            The new server state.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return NodeObserver._op_updateServer.invoke(self, ((node, updatedInfo), context))
+
+    def updateServerAsync(self, node: str, updatedInfo: ServerDynamicInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that the state of a server changed.
+        
+        Parameters
+        ----------
+        node : str
+            The node hosting the server.
+        updatedInfo : ServerDynamicInfo
+            The new server state.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return NodeObserver._op_updateServer.invokeAsync(self, ((node, updatedInfo), context))
+
+    def updateAdapter(self, node: str, updatedInfo: AdapterDynamicInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that the state of an object adapter changed.
+        
+        Parameters
+        ----------
+        node : str
+            The node hosting the adapter.
+        updatedInfo : AdapterDynamicInfo
+            The new adapter state.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return NodeObserver._op_updateAdapter.invoke(self, ((node, updatedInfo), context))
+
+    def updateAdapterAsync(self, node: str, updatedInfo: AdapterDynamicInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that the state of an object adapter changed.
+        
+        Parameters
+        ----------
+        node : str
+            The node hosting the adapter.
+        updatedInfo : AdapterDynamicInfo
+            The new adapter state.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return NodeObserver._op_updateAdapter.invokeAsync(self, ((node, updatedInfo), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> NodeObserverPrx | None:
+        return checkedCast(NodeObserverPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[NodeObserverPrx | None ]:
+        return checkedCastAsync(NodeObserverPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> NodeObserverPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> NodeObserverPrx | None:
+        return uncheckedCast(NodeObserverPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::NodeObserver"
+
+IcePy.defineProxy("::IceGrid::NodeObserver", NodeObserverPrx)
+
+class NodeObserver(Object, ABC):
+    """
+    Monitors changes to the state of the nodes.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::IceGrid::NodeObserver``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::IceGrid::NodeObserver", )
+    _op_nodeInit: IcePy.Operation
+    _op_nodeUp: IcePy.Operation
+    _op_nodeDown: IcePy.Operation
+    _op_updateServer: IcePy.Operation
+    _op_updateAdapter: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::NodeObserver"
+
+    @abstractmethod
+    def nodeInit(self, nodes: list[NodeDynamicInfo], current: Current) -> None | Awaitable[None]:
+        """
+        Provides the initial state of the nodes to the observer.
+        
+        Parameters
+        ----------
+        nodes : list[NodeDynamicInfo]
+            The current state of the nodes.
+        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 nodeUp(self, node: NodeDynamicInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that a node came up.
+        
+        Parameters
+        ----------
+        node : NodeDynamicInfo
+            The node state.
+        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 nodeDown(self, name: str, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that a node went down.
+        
+        Parameters
+        ----------
+        name : str
+            The node name.
+        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 updateServer(self, node: str, updatedInfo: ServerDynamicInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that the state of a server changed.
+        
+        Parameters
+        ----------
+        node : str
+            The node hosting the server.
+        updatedInfo : ServerDynamicInfo
+            The new server state.
+        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 updateAdapter(self, node: str, updatedInfo: AdapterDynamicInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that the state of an object adapter changed.
+        
+        Parameters
+        ----------
+        node : str
+            The node hosting the adapter.
+        updatedInfo : AdapterDynamicInfo
+            The new adapter state.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+NodeObserver._op_nodeInit = IcePy.Operation(
+    "nodeInit",
+    "nodeInit",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_NodeDynamicInfoSeq_t, False, 0),),
+    (),
+    None,
+    ())
+
+NodeObserver._op_nodeUp = IcePy.Operation(
+    "nodeUp",
+    "nodeUp",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_NodeDynamicInfo_t, False, 0),),
+    (),
+    None,
+    ())
+
+NodeObserver._op_nodeDown = IcePy.Operation(
+    "nodeDown",
+    "nodeDown",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0),),
+    (),
+    None,
+    ())
+
+NodeObserver._op_updateServer = IcePy.Operation(
+    "updateServer",
+    "updateServer",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0), ((), _IceGrid_ServerDynamicInfo_t, False, 0)),
+    (),
+    None,
+    ())
+
+NodeObserver._op_updateAdapter = IcePy.Operation(
+    "updateAdapter",
+    "updateAdapter",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0), ((), _IceGrid_AdapterDynamicInfo_t, False, 0)),
+    (),
+    None,
+    ())
+
+__all__ = ["NodeObserver", "NodeObserverPrx", "_IceGrid_NodeObserverPrx_t"]

IceGrid/NodeObserver_forward.py

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

IceGrid/NodeUnreachableException.py

@@ -0,0 +1,46 @@
+# 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 NodeUnreachableException(UserException):
+    """
+    The exception that is thrown when IceGrid cannot reach a node.
+    
+    Attributes
+    ----------
+    name : str
+        The name of the node that is not reachable.
+    reason : str
+        The reason why the node couldn't be reached.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::NodeUnreachableException``.
+    """
+    name: str = ""
+    reason: str = ""
+
+    _ice_id = "::IceGrid::NodeUnreachableException"
+
+_IceGrid_NodeUnreachableException_t = IcePy.defineException(
+    "::IceGrid::NodeUnreachableException",
+    NodeUnreachableException,
+    (),
+    None,
+    (
+        ("name", (), IcePy._t_string, False, 0),
+        ("reason", (), IcePy._t_string, False, 0)
+    ))
+
+setattr(NodeUnreachableException, '_ice_type', _IceGrid_NodeUnreachableException_t)
+
+__all__ = ["NodeUnreachableException", "_IceGrid_NodeUnreachableException_t"]

IceGrid/NodeUpdateDescriptor.py

@@ -0,0 +1,92 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.StringSeq import _Ice_StringSeq_t
+
+from IceGrid.BoxedString_forward import _IceGrid_BoxedString_t
+
+from IceGrid.PropertySetDescriptorDict import _IceGrid_PropertySetDescriptorDict_t
+
+from IceGrid.ServerDescriptorSeq import _IceGrid_ServerDescriptorSeq_t
+
+from IceGrid.ServerInstanceDescriptorSeq import _IceGrid_ServerInstanceDescriptorSeq_t
+
+from IceGrid.StringStringDict import _IceGrid_StringStringDict_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from IceGrid.BoxedString import BoxedString
+    from IceGrid.PropertySetDescriptor import PropertySetDescriptor
+    from IceGrid.ServerDescriptor import ServerDescriptor
+    from IceGrid.ServerInstanceDescriptor import ServerInstanceDescriptor
+
+
+@dataclass
+class NodeUpdateDescriptor:
+    """
+    Describes the updates to apply to a node in a deployed application.
+    
+    Attributes
+    ----------
+    name : str
+        The name of the node to update.
+    description : BoxedString | None
+        The updated description (or null if the description wasn't updated.)
+    variables : dict[str, str]
+        The variables to update.
+    removeVariables : list[str]
+        The variables to remove.
+    propertySets : dict[str, PropertySetDescriptor]
+        The property sets to update.
+    removePropertySets : list[str]
+        The property sets to remove.
+    serverInstances : list[ServerInstanceDescriptor]
+        The server instances to update.
+    servers : list[ServerDescriptor | None]
+        The servers which are not template instances to update.
+    removeServers : list[str]
+        The IDs of the servers to remove.
+    loadFactor : BoxedString | None
+        The updated load factor of the node (or null if the load factor was not updated).
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::NodeUpdateDescriptor``.
+    """
+    name: str = ""
+    description: BoxedString | None = None
+    variables: dict[str, str] = field(default_factory=dict)
+    removeVariables: list[str] = field(default_factory=list)
+    propertySets: dict[str, PropertySetDescriptor] = field(default_factory=dict)
+    removePropertySets: list[str] = field(default_factory=list)
+    serverInstances: list[ServerInstanceDescriptor] = field(default_factory=list)
+    servers: list[ServerDescriptor | None] = field(default_factory=list)
+    removeServers: list[str] = field(default_factory=list)
+    loadFactor: BoxedString | None = None
+
+_IceGrid_NodeUpdateDescriptor_t = IcePy.defineStruct(
+    "::IceGrid::NodeUpdateDescriptor",
+    NodeUpdateDescriptor,
+    (),
+    (
+        ("name", (), IcePy._t_string),
+        ("description", (), _IceGrid_BoxedString_t),
+        ("variables", (), _IceGrid_StringStringDict_t),
+        ("removeVariables", (), _Ice_StringSeq_t),
+        ("propertySets", (), _IceGrid_PropertySetDescriptorDict_t),
+        ("removePropertySets", (), _Ice_StringSeq_t),
+        ("serverInstances", (), _IceGrid_ServerInstanceDescriptorSeq_t),
+        ("servers", (), _IceGrid_ServerDescriptorSeq_t),
+        ("removeServers", (), _Ice_StringSeq_t),
+        ("loadFactor", (), _IceGrid_BoxedString_t)
+    ))
+
+__all__ = ["NodeUpdateDescriptor", "_IceGrid_NodeUpdateDescriptor_t"]

IceGrid/NodeUpdateDescriptorSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.NodeUpdateDescriptor import _IceGrid_NodeUpdateDescriptor_t
+
+_IceGrid_NodeUpdateDescriptorSeq_t = IcePy.defineSequence("::IceGrid::NodeUpdateDescriptorSeq", (), _IceGrid_NodeUpdateDescriptor_t)
+
+__all__ = ["_IceGrid_NodeUpdateDescriptorSeq_t"]

IceGrid/ObjectDescriptor.py

@@ -0,0 +1,48 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Identity import Identity
+from Ice.Identity import _Ice_Identity_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+
+@dataclass(order=True, unsafe_hash=True)
+class ObjectDescriptor:
+    """
+    Describes a well-known Ice object.
+    
+    Attributes
+    ----------
+    id : Identity
+        The identity of the object.
+    type : str
+        The object type.
+    proxyOptions : str
+        The proxy options to use when creating a proxy for this well-known object. If empty, the proxy is created
+        with the proxy options specified on the object adapter or replica group.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::ObjectDescriptor``.
+    """
+    id: Identity = field(default_factory=Identity)
+    type: str = ""
+    proxyOptions: str = ""
+
+_IceGrid_ObjectDescriptor_t = IcePy.defineStruct(
+    "::IceGrid::ObjectDescriptor",
+    ObjectDescriptor,
+    (),
+    (
+        ("id", (), _Ice_Identity_t),
+        ("type", (), IcePy._t_string),
+        ("proxyOptions", (), IcePy._t_string)
+    ))
+
+__all__ = ["ObjectDescriptor", "_IceGrid_ObjectDescriptor_t"]

IceGrid/ObjectDescriptorSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ObjectDescriptor import _IceGrid_ObjectDescriptor_t
+
+_IceGrid_ObjectDescriptorSeq_t = IcePy.defineSequence("::IceGrid::ObjectDescriptorSeq", (), _IceGrid_ObjectDescriptor_t)
+
+__all__ = ["_IceGrid_ObjectDescriptorSeq_t"]

IceGrid/ObjectExistsException.py

@@ -0,0 +1,44 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Identity import Identity
+from Ice.Identity import _Ice_Identity_t
+
+from Ice.UserException import UserException
+
+from dataclasses import dataclass
+from dataclasses import field
+
+
+@dataclass
+class ObjectExistsException(UserException):
+    """
+    The exception that is thrown when a well-known object is already registered.
+    
+    Attributes
+    ----------
+    id : Identity
+        The identity of the object.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::ObjectExistsException``.
+    """
+    id: Identity = field(default_factory=Identity)
+
+    _ice_id = "::IceGrid::ObjectExistsException"
+
+_IceGrid_ObjectExistsException_t = IcePy.defineException(
+    "::IceGrid::ObjectExistsException",
+    ObjectExistsException,
+    (),
+    None,
+    (("id", (), _Ice_Identity_t, False, 0),))
+
+setattr(ObjectExistsException, '_ice_type', _IceGrid_ObjectExistsException_t)
+
+__all__ = ["ObjectExistsException", "_IceGrid_ObjectExistsException_t"]