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

IceGrid/RegistryObserver.py

@@ -0,0 +1,282 @@
+# 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.RegistryInfo import _IceGrid_RegistryInfo_t
+
+from IceGrid.RegistryInfoSeq import _IceGrid_RegistryInfoSeq_t
+
+from IceGrid.RegistryObserver_forward import _IceGrid_RegistryObserverPrx_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.RegistryInfo import RegistryInfo
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class RegistryObserverPrx(ObjectPrx):
+    """
+    Monitors changes to the state of the registries.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::IceGrid::RegistryObserver``.
+    """
+
+    def registryInit(self, registries: Sequence[RegistryInfo], context: dict[str, str] | None = None) -> None:
+        """
+        Provides the initial state of the registries to the observer.
+        
+        Parameters
+        ----------
+        registries : Sequence[RegistryInfo]
+            The current state of the registries.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return RegistryObserver._op_registryInit.invoke(self, ((registries, ), context))
+
+    def registryInitAsync(self, registries: Sequence[RegistryInfo], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Provides the initial state of the registries to the observer.
+        
+        Parameters
+        ----------
+        registries : Sequence[RegistryInfo]
+            The current state of the registries.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return RegistryObserver._op_registryInit.invokeAsync(self, ((registries, ), context))
+
+    def registryUp(self, registryReplica: RegistryInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that a registry replica came up.
+        
+        Parameters
+        ----------
+        registryReplica : RegistryInfo
+            The registry state.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return RegistryObserver._op_registryUp.invoke(self, ((registryReplica, ), context))
+
+    def registryUpAsync(self, registryReplica: RegistryInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that a registry replica came up.
+        
+        Parameters
+        ----------
+        registryReplica : RegistryInfo
+            The registry state.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return RegistryObserver._op_registryUp.invokeAsync(self, ((registryReplica, ), context))
+
+    def registryDown(self, name: str, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that a registry replica went down.
+        
+        Parameters
+        ----------
+        name : str
+            The registry name.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return RegistryObserver._op_registryDown.invoke(self, ((name, ), context))
+
+    def registryDownAsync(self, name: str, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that a registry replica went down.
+        
+        Parameters
+        ----------
+        name : str
+            The registry name.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return RegistryObserver._op_registryDown.invokeAsync(self, ((name, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> RegistryObserverPrx | None:
+        return checkedCast(RegistryObserverPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[RegistryObserverPrx | None ]:
+        return checkedCastAsync(RegistryObserverPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> RegistryObserverPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> RegistryObserverPrx | None:
+        return uncheckedCast(RegistryObserverPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::RegistryObserver"
+
+IcePy.defineProxy("::IceGrid::RegistryObserver", RegistryObserverPrx)
+
+class RegistryObserver(Object, ABC):
+    """
+    Monitors changes to the state of the registries.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::IceGrid::RegistryObserver``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::IceGrid::RegistryObserver", )
+    _op_registryInit: IcePy.Operation
+    _op_registryUp: IcePy.Operation
+    _op_registryDown: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::RegistryObserver"
+
+    @abstractmethod
+    def registryInit(self, registries: list[RegistryInfo], current: Current) -> None | Awaitable[None]:
+        """
+        Provides the initial state of the registries to the observer.
+        
+        Parameters
+        ----------
+        registries : list[RegistryInfo]
+            The current state of the registries.
+        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 registryUp(self, registryReplica: RegistryInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that a registry replica came up.
+        
+        Parameters
+        ----------
+        registryReplica : RegistryInfo
+            The registry 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 registryDown(self, name: str, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that a registry replica went down.
+        
+        Parameters
+        ----------
+        name : str
+            The registry 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
+
+RegistryObserver._op_registryInit = IcePy.Operation(
+    "registryInit",
+    "registryInit",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_RegistryInfoSeq_t, False, 0),),
+    (),
+    None,
+    ())
+
+RegistryObserver._op_registryUp = IcePy.Operation(
+    "registryUp",
+    "registryUp",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_RegistryInfo_t, False, 0),),
+    (),
+    None,
+    ())
+
+RegistryObserver._op_registryDown = IcePy.Operation(
+    "registryDown",
+    "registryDown",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0),),
+    (),
+    None,
+    ())
+
+__all__ = ["RegistryObserver", "RegistryObserverPrx", "_IceGrid_RegistryObserverPrx_t"]

IceGrid/RegistryObserver_forward.py

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

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

IceGrid/Registry_forward.py

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

IceGrid/ReplicaGroupDescriptor.py

@@ -0,0 +1,66 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.LoadBalancingPolicy_forward import _IceGrid_LoadBalancingPolicy_t
+
+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.LoadBalancingPolicy import LoadBalancingPolicy
+    from IceGrid.ObjectDescriptor import ObjectDescriptor
+
+
+@dataclass
+class ReplicaGroupDescriptor:
+    """
+    Describes a replica group.
+    
+    Attributes
+    ----------
+    id : str
+        The replica group ID.
+    loadBalancing : LoadBalancingPolicy | None
+        The load balancing policy.
+    proxyOptions : str
+        Default options for proxies created for the replica group.
+    objects : list[ObjectDescriptor]
+        The descriptors for the well-known objects.
+    description : str
+        The description of this replica group.
+    filter : str
+        The filter to use for this replica group.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::ReplicaGroupDescriptor``.
+    """
+    id: str = ""
+    loadBalancing: LoadBalancingPolicy | None = None
+    proxyOptions: str = ""
+    objects: list[ObjectDescriptor] = field(default_factory=list)
+    description: str = ""
+    filter: str = ""
+
+_IceGrid_ReplicaGroupDescriptor_t = IcePy.defineStruct(
+    "::IceGrid::ReplicaGroupDescriptor",
+    ReplicaGroupDescriptor,
+    (),
+    (
+        ("id", (), IcePy._t_string),
+        ("loadBalancing", (), _IceGrid_LoadBalancingPolicy_t),
+        ("proxyOptions", (), IcePy._t_string),
+        ("objects", (), _IceGrid_ObjectDescriptorSeq_t),
+        ("description", (), IcePy._t_string),
+        ("filter", (), IcePy._t_string)
+    ))
+
+__all__ = ["ReplicaGroupDescriptor", "_IceGrid_ReplicaGroupDescriptor_t"]

IceGrid/ReplicaGroupDescriptorSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ReplicaGroupDescriptor import _IceGrid_ReplicaGroupDescriptor_t
+
+_IceGrid_ReplicaGroupDescriptorSeq_t = IcePy.defineSequence("::IceGrid::ReplicaGroupDescriptorSeq", (), _IceGrid_ReplicaGroupDescriptor_t)
+
+__all__ = ["_IceGrid_ReplicaGroupDescriptorSeq_t"]

IceGrid/RoundRobinLoadBalancingPolicy.py

@@ -0,0 +1,41 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.LoadBalancingPolicy import LoadBalancingPolicy
+
+from IceGrid.LoadBalancingPolicy_forward import _IceGrid_LoadBalancingPolicy_t
+
+from IceGrid.RoundRobinLoadBalancingPolicy_forward import _IceGrid_RoundRobinLoadBalancingPolicy_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class RoundRobinLoadBalancingPolicy(LoadBalancingPolicy):
+    """
+    The load balancing policy that returns endpoints using round-robin.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceGrid::RoundRobinLoadBalancingPolicy``.
+    """
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::RoundRobinLoadBalancingPolicy"
+
+_IceGrid_RoundRobinLoadBalancingPolicy_t = IcePy.defineValue(
+    "::IceGrid::RoundRobinLoadBalancingPolicy",
+    RoundRobinLoadBalancingPolicy,
+    -1,
+    (),
+    False,
+    _IceGrid_LoadBalancingPolicy_t,
+    ())
+
+setattr(RoundRobinLoadBalancingPolicy, '_ice_type', _IceGrid_RoundRobinLoadBalancingPolicy_t)
+
+__all__ = ["RoundRobinLoadBalancingPolicy", "_IceGrid_RoundRobinLoadBalancingPolicy_t"]

IceGrid/RoundRobinLoadBalancingPolicy_forward.py

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

IceGrid/ServerDescriptor.py

@@ -0,0 +1,107 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.StringSeq import _Ice_StringSeq_t
+
+from IceGrid.CommunicatorDescriptor import CommunicatorDescriptor
+
+from IceGrid.CommunicatorDescriptor_forward import _IceGrid_CommunicatorDescriptor_t
+
+from IceGrid.DistributionDescriptor import DistributionDescriptor
+from IceGrid.DistributionDescriptor import _IceGrid_DistributionDescriptor_t
+
+from IceGrid.ServerDescriptor_forward import _IceGrid_ServerDescriptor_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+@dataclass(eq=False)
+class ServerDescriptor(CommunicatorDescriptor):
+    """
+    Describes an Ice server.
+    
+    Attributes
+    ----------
+    id : str
+        The server ID.
+    exe : str
+        The path of the server executable.
+    iceVersion : str
+        The Ice version used by this server. This is only required if backward compatibility with servers using old
+        Ice versions is needed (otherwise the registry assumes the server is using the same Ice version as the
+        registry itself). For example ``"3.7.5"``.
+    pwd : str
+        The path to the server working directory.
+    options : list[str]
+        The command line options to pass to the server executable.
+    envs : list[str]
+        The server environment variables.
+    activation : str
+        The server activation mode. Possible values are ``"on-demand"`` and ``"manual"``.
+    activationTimeout : str
+        The activation timeout. It's an integer (in string format) that represents the number of seconds to wait for
+        activation.
+    deactivationTimeout : str
+        The deactivation timeout. It's an integer (in string format) that represents the number of seconds to wait
+        for deactivation.
+    applicationDistrib : bool
+        Specifies if the server depends on the application distribution.
+    distrib : DistributionDescriptor
+        The distribution descriptor.
+    allocatable : bool
+        Specifies if the server is allocatable.
+    user : str
+        The user account used to run the server.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceGrid::ServerDescriptor``.
+    """
+    id: str = ""
+    exe: str = ""
+    iceVersion: str = ""
+    pwd: str = ""
+    options: list[str] = field(default_factory=list)
+    envs: list[str] = field(default_factory=list)
+    activation: str = ""
+    activationTimeout: str = ""
+    deactivationTimeout: str = ""
+    applicationDistrib: bool = False
+    distrib: DistributionDescriptor = field(default_factory=DistributionDescriptor)
+    allocatable: bool = False
+    user: str = ""
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::ServerDescriptor"
+
+_IceGrid_ServerDescriptor_t = IcePy.defineValue(
+    "::IceGrid::ServerDescriptor",
+    ServerDescriptor,
+    -1,
+    (),
+    False,
+    _IceGrid_CommunicatorDescriptor_t,
+    (
+        ("id", (), IcePy._t_string, False, 0),
+        ("exe", (), IcePy._t_string, False, 0),
+        ("iceVersion", (), IcePy._t_string, False, 0),
+        ("pwd", (), IcePy._t_string, False, 0),
+        ("options", (), _Ice_StringSeq_t, False, 0),
+        ("envs", (), _Ice_StringSeq_t, False, 0),
+        ("activation", (), IcePy._t_string, False, 0),
+        ("activationTimeout", (), IcePy._t_string, False, 0),
+        ("deactivationTimeout", (), IcePy._t_string, False, 0),
+        ("applicationDistrib", (), IcePy._t_bool, False, 0),
+        ("distrib", (), _IceGrid_DistributionDescriptor_t, False, 0),
+        ("allocatable", (), IcePy._t_bool, False, 0),
+        ("user", (), IcePy._t_string, False, 0)
+    ))
+
+setattr(ServerDescriptor, '_ice_type', _IceGrid_ServerDescriptor_t)
+
+__all__ = ["ServerDescriptor", "_IceGrid_ServerDescriptor_t"]

IceGrid/ServerDescriptorSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ServerDescriptor_forward import _IceGrid_ServerDescriptor_t
+
+_IceGrid_ServerDescriptorSeq_t = IcePy.defineSequence("::IceGrid::ServerDescriptorSeq", (), _IceGrid_ServerDescriptor_t)
+
+__all__ = ["_IceGrid_ServerDescriptorSeq_t"]

IceGrid/ServerDescriptor_forward.py

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

IceGrid/ServerDynamicInfo.py

@@ -0,0 +1,50 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ServerState import ServerState
+from IceGrid.ServerState import _IceGrid_ServerState_t
+
+from dataclasses import dataclass
+
+
+@dataclass(order=True, unsafe_hash=True)
+class ServerDynamicInfo:
+    """
+    Dynamic information about the state of a server.
+    
+    Attributes
+    ----------
+    id : str
+        The ID of the server.
+    state : ServerState
+        The state of the server.
+    pid : int
+        The process ID of the server.
+    enabled : bool
+        Indicates whether the server is enabled.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::ServerDynamicInfo``.
+    """
+    id: str = ""
+    state: ServerState = ServerState.Inactive
+    pid: int = 0
+    enabled: bool = False
+
+_IceGrid_ServerDynamicInfo_t = IcePy.defineStruct(
+    "::IceGrid::ServerDynamicInfo",
+    ServerDynamicInfo,
+    (),
+    (
+        ("id", (), IcePy._t_string),
+        ("state", (), _IceGrid_ServerState_t),
+        ("pid", (), IcePy._t_int),
+        ("enabled", (), IcePy._t_bool)
+    ))
+
+__all__ = ["ServerDynamicInfo", "_IceGrid_ServerDynamicInfo_t"]

IceGrid/ServerDynamicInfoSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ServerDynamicInfo import _IceGrid_ServerDynamicInfo_t
+
+_IceGrid_ServerDynamicInfoSeq_t = IcePy.defineSequence("::IceGrid::ServerDynamicInfoSeq", (), _IceGrid_ServerDynamicInfo_t)
+
+__all__ = ["_IceGrid_ServerDynamicInfoSeq_t"]