zeroc-ice 3.8.0__cp312-cp312-macosx_10_13_universal2.whl

IceGrid/LoadSample.py

@@ -0,0 +1,45 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from enum import Enum
+
+class LoadSample(Enum):
+    """
+    Determines which load sampling interval to use.
+    
+    Enumerators:
+    
+    - LoadSample1:
+        Sample every minute.
+    
+    - LoadSample5:
+        Sample every five minutes.
+    
+    - LoadSample15:
+        Sample every fifteen minutes.
+    
+    Notes
+    -----
+        The Slice compiler generated this enum class from Slice enumeration ``::IceGrid::LoadSample``.
+    """
+    
+    LoadSample1 = 0
+    LoadSample5 = 1
+    LoadSample15 = 2
+
+_IceGrid_LoadSample_t = IcePy.defineEnum(
+    "::IceGrid::LoadSample",
+    LoadSample,
+    (),
+    {
+        0: LoadSample.LoadSample1,
+        1: LoadSample.LoadSample5,
+        2: LoadSample.LoadSample15,
+    }
+)
+
+__all__ = ["LoadSample", "_IceGrid_LoadSample_t"]

IceGrid/Locator.py

@@ -0,0 +1,232 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.AdapterNotFoundException import _Ice_AdapterNotFoundException_t
+
+from Ice.Identity import _Ice_Identity_t
+
+from Ice.Locator import Locator as _m_Ice_Locator_Locator
+from Ice.Locator import LocatorPrx as _m_Ice_Locator_LocatorPrx
+
+from Ice.LocatorRegistry_forward import _Ice_LocatorRegistryPrx_t
+
+from Ice.ObjectNotFoundException import _Ice_ObjectNotFoundException_t
+
+from Ice.ObjectPrx import checkedCast
+from Ice.ObjectPrx import checkedCastAsync
+from Ice.ObjectPrx import uncheckedCast
+
+from Ice.ObjectPrx_forward import _Ice_ObjectPrx_t
+
+from Ice.OperationMode import OperationMode
+
+from IceGrid.Locator_forward import _IceGrid_LocatorPrx_t
+
+from IceGrid.Query_forward import _IceGrid_QueryPrx_t
+
+from IceGrid.Registry_forward import _IceGrid_RegistryPrx_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 Ice.Identity import Identity
+    from Ice.LocatorRegistry import LocatorRegistryPrx
+    from Ice.ObjectPrx import ObjectPrx
+    from IceGrid.Query import QueryPrx
+    from IceGrid.Registry import RegistryPrx
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class LocatorPrx(_m_Ice_Locator_LocatorPrx):
+    """
+    Provides access to the :class:`IceGrid.QueryPrx` and :class:`IceGrid.RegistryPrx` objects implemented by the IceGrid registry.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::IceGrid::Locator``.
+    """
+
+    def getLocalRegistry(self, context: dict[str, str] | None = None) -> RegistryPrx | None:
+        """
+        Gets a proxy to the registry object hosted by this IceGrid registry.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        RegistryPrx | None
+            A proxy to the registry object. This proxy is never null.
+        """
+        return Locator._op_getLocalRegistry.invoke(self, ((), context))
+
+    def getLocalRegistryAsync(self, context: dict[str, str] | None = None) -> Awaitable[RegistryPrx | None]:
+        """
+        Gets a proxy to the registry object hosted by this IceGrid registry.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[RegistryPrx | None]
+            A proxy to the registry object. This proxy is never null.
+        """
+        return Locator._op_getLocalRegistry.invokeAsync(self, ((), context))
+
+    def getLocalQuery(self, context: dict[str, str] | None = None) -> QueryPrx | None:
+        """
+        Gets a proxy to the query object hosted by this IceGrid registry.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        QueryPrx | None
+            A proxy to the query object. This proxy is never null.
+        """
+        return Locator._op_getLocalQuery.invoke(self, ((), context))
+
+    def getLocalQueryAsync(self, context: dict[str, str] | None = None) -> Awaitable[QueryPrx | None]:
+        """
+        Gets a proxy to the query object hosted by this IceGrid registry.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[QueryPrx | None]
+            A proxy to the query object. This proxy is never null.
+        """
+        return Locator._op_getLocalQuery.invokeAsync(self, ((), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> LocatorPrx | None:
+        return checkedCast(LocatorPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[LocatorPrx | None ]:
+        return checkedCastAsync(LocatorPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> LocatorPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> LocatorPrx | None:
+        return uncheckedCast(LocatorPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::Locator"
+
+IcePy.defineProxy("::IceGrid::Locator", LocatorPrx)
+
+class Locator(_m_Ice_Locator_Locator, ABC):
+    """
+    Provides access to the :class:`IceGrid.QueryPrx` and :class:`IceGrid.RegistryPrx` objects implemented by the IceGrid registry.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::IceGrid::Locator``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Locator", "::Ice::Object", "::IceGrid::Locator", )
+    _op_getLocalRegistry: IcePy.Operation
+    _op_getLocalQuery: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::Locator"
+
+    @abstractmethod
+    def getLocalRegistry(self, current: Current) -> RegistryPrx | None | Awaitable[RegistryPrx | None]:
+        """
+        Gets a proxy to the registry object hosted by this IceGrid registry.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        RegistryPrx | None | Awaitable[RegistryPrx | None]
+            A proxy to the registry object. This proxy is never null.
+        """
+        pass
+
+    @abstractmethod
+    def getLocalQuery(self, current: Current) -> QueryPrx | None | Awaitable[QueryPrx | None]:
+        """
+        Gets a proxy to the query object hosted by this IceGrid registry.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        QueryPrx | None | Awaitable[QueryPrx | None]
+            A proxy to the query object. This proxy is never null.
+        """
+        pass
+
+Locator._op_getLocalRegistry = IcePy.Operation(
+    "getLocalRegistry",
+    "getLocalRegistry",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), _IceGrid_RegistryPrx_t, False, 0),
+    ())
+
+Locator._op_getLocalQuery = IcePy.Operation(
+    "getLocalQuery",
+    "getLocalQuery",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (),
+    (),
+    ((), _IceGrid_QueryPrx_t, False, 0),
+    ())
+
+__all__ = ["Locator", "LocatorPrx", "_IceGrid_LocatorPrx_t"]

IceGrid/Locator_forward.py

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

IceGrid/NodeDescriptor.py

@@ -0,0 +1,71 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+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.PropertySetDescriptor import PropertySetDescriptor
+    from IceGrid.ServerDescriptor import ServerDescriptor
+    from IceGrid.ServerInstanceDescriptor import ServerInstanceDescriptor
+
+
+@dataclass
+class NodeDescriptor:
+    """
+    Describes an IceGrid node.
+    
+    Attributes
+    ----------
+    variables : dict[str, str]
+        The variables defined for the node.
+    serverInstances : list[ServerInstanceDescriptor]
+        The server instances (template instances).
+    servers : list[ServerDescriptor | None]
+        Servers that are not template instances.
+    loadFactor : str
+        Load factor of the node.
+    description : str
+        The description of this node.
+    propertySets : dict[str, PropertySetDescriptor]
+        Property set descriptors.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::NodeDescriptor``.
+    """
+    variables: dict[str, str] = field(default_factory=dict)
+    serverInstances: list[ServerInstanceDescriptor] = field(default_factory=list)
+    servers: list[ServerDescriptor | None] = field(default_factory=list)
+    loadFactor: str = ""
+    description: str = ""
+    propertySets: dict[str, PropertySetDescriptor] = field(default_factory=dict)
+
+_IceGrid_NodeDescriptor_t = IcePy.defineStruct(
+    "::IceGrid::NodeDescriptor",
+    NodeDescriptor,
+    (),
+    (
+        ("variables", (), _IceGrid_StringStringDict_t),
+        ("serverInstances", (), _IceGrid_ServerInstanceDescriptorSeq_t),
+        ("servers", (), _IceGrid_ServerDescriptorSeq_t),
+        ("loadFactor", (), IcePy._t_string),
+        ("description", (), IcePy._t_string),
+        ("propertySets", (), _IceGrid_PropertySetDescriptorDict_t)
+    ))
+
+__all__ = ["NodeDescriptor", "_IceGrid_NodeDescriptor_t"]

IceGrid/NodeDescriptorDict.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.NodeDescriptor import _IceGrid_NodeDescriptor_t
+
+_IceGrid_NodeDescriptorDict_t = IcePy.defineDictionary("::IceGrid::NodeDescriptorDict", (), IcePy._t_string, _IceGrid_NodeDescriptor_t)
+
+__all__ = ["_IceGrid_NodeDescriptorDict_t"]

IceGrid/NodeDynamicInfo.py

@@ -0,0 +1,57 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.AdapterDynamicInfoSeq import _IceGrid_AdapterDynamicInfoSeq_t
+
+from IceGrid.NodeInfo import NodeInfo
+from IceGrid.NodeInfo import _IceGrid_NodeInfo_t
+
+from IceGrid.ServerDynamicInfoSeq import _IceGrid_ServerDynamicInfoSeq_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from IceGrid.AdapterDynamicInfo import AdapterDynamicInfo
+    from IceGrid.ServerDynamicInfo import ServerDynamicInfo
+
+
+@dataclass
+class NodeDynamicInfo:
+    """
+    Dynamic information about the state of a node.
+    
+    Attributes
+    ----------
+    info : NodeInfo
+        Some static information about the node.
+    servers : list[ServerDynamicInfo]
+        The dynamic information of the servers deployed on this node.
+    adapters : list[AdapterDynamicInfo]
+        The dynamic information of the adapters deployed on this node.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::NodeDynamicInfo``.
+    """
+    info: NodeInfo = field(default_factory=NodeInfo)
+    servers: list[ServerDynamicInfo] = field(default_factory=list)
+    adapters: list[AdapterDynamicInfo] = field(default_factory=list)
+
+_IceGrid_NodeDynamicInfo_t = IcePy.defineStruct(
+    "::IceGrid::NodeDynamicInfo",
+    NodeDynamicInfo,
+    (),
+    (
+        ("info", (), _IceGrid_NodeInfo_t),
+        ("servers", (), _IceGrid_ServerDynamicInfoSeq_t),
+        ("adapters", (), _IceGrid_AdapterDynamicInfoSeq_t)
+    ))
+
+__all__ = ["NodeDynamicInfo", "_IceGrid_NodeDynamicInfo_t"]

IceGrid/NodeDynamicInfoSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.NodeDynamicInfo import _IceGrid_NodeDynamicInfo_t
+
+_IceGrid_NodeDynamicInfoSeq_t = IcePy.defineSequence("::IceGrid::NodeDynamicInfoSeq", (), _IceGrid_NodeDynamicInfo_t)
+
+__all__ = ["_IceGrid_NodeDynamicInfoSeq_t"]

IceGrid/NodeInfo.py

@@ -0,0 +1,64 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from dataclasses import dataclass
+
+
+@dataclass(order=True, unsafe_hash=True)
+class NodeInfo:
+    """
+    Information about an IceGrid node.
+    
+    Attributes
+    ----------
+    name : str
+        The name of the node.
+    os : str
+        The operating system name.
+    hostname : str
+        The network name of the host running this node.
+    release : str
+        The operation system release level.
+    version : str
+        The operation system version.
+    machine : str
+        The machine hardware type.
+    nProcessors : int
+        The number of processor threads on the node.
+        For example, nProcessors is 8 on a computer with a single quad-core processor and two threads per core.
+    dataDir : str
+        The path to the node data directory.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::NodeInfo``.
+    """
+    name: str = ""
+    os: str = ""
+    hostname: str = ""
+    release: str = ""
+    version: str = ""
+    machine: str = ""
+    nProcessors: int = 0
+    dataDir: str = ""
+
+_IceGrid_NodeInfo_t = IcePy.defineStruct(
+    "::IceGrid::NodeInfo",
+    NodeInfo,
+    (),
+    (
+        ("name", (), IcePy._t_string),
+        ("os", (), IcePy._t_string),
+        ("hostname", (), IcePy._t_string),
+        ("release", (), IcePy._t_string),
+        ("version", (), IcePy._t_string),
+        ("machine", (), IcePy._t_string),
+        ("nProcessors", (), IcePy._t_int),
+        ("dataDir", (), IcePy._t_string)
+    ))
+
+__all__ = ["NodeInfo", "_IceGrid_NodeInfo_t"]

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