zeroc-ice 3.7.11__cp314-cp314-macosx_10_15_universal2.whl → 3.8.0.post1__cp314-cp314-macosx_10_15_universal2.whl

IceGrid/UserAccountMapper.py

@@ -0,0 +1,178 @@
+# 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.UserAccountMapper_forward import _IceGrid_UserAccountMapperPrx_t
+
+from IceGrid.UserAccountNotFoundException import _IceGrid_UserAccountNotFoundException_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 UserAccountMapperPrx(ObjectPrx):
+    """
+    Maps user strings in server descriptors to actual user account names. You can configure the user account mapper
+    of an IceGrid node with the property ``IceGrid.Node.UserAccountMapper``.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::IceGrid::UserAccountMapper``.
+    """
+
+    def getUserAccount(self, user: str, context: dict[str, str] | None = None) -> str:
+        """
+        Gets the name of the user account for the given user. This is used by IceGrid nodes to figure out the user
+        account to use to run servers.
+        
+        Parameters
+        ----------
+        user : str
+            The value of the server descriptor's ``user`` attribute. When this attribute is not defined, and
+            the server's activation mode is ``session``, the default value for ``user`` is the session identifier.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        str
+            The user account name.
+        
+        Raises
+        ------
+        UserAccountNotFoundException
+            Thrown when no user account is found for the given user.
+        """
+        return UserAccountMapper._op_getUserAccount.invoke(self, ((user, ), context))
+
+    def getUserAccountAsync(self, user: str, context: dict[str, str] | None = None) -> Awaitable[str]:
+        """
+        Gets the name of the user account for the given user. This is used by IceGrid nodes to figure out the user
+        account to use to run servers.
+        
+        Parameters
+        ----------
+        user : str
+            The value of the server descriptor's ``user`` attribute. When this attribute is not defined, and
+            the server's activation mode is ``session``, the default value for ``user`` is the session identifier.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[str]
+            The user account name.
+        """
+        return UserAccountMapper._op_getUserAccount.invokeAsync(self, ((user, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> UserAccountMapperPrx | None:
+        return checkedCast(UserAccountMapperPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[UserAccountMapperPrx | None ]:
+        return checkedCastAsync(UserAccountMapperPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> UserAccountMapperPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> UserAccountMapperPrx | None:
+        return uncheckedCast(UserAccountMapperPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::UserAccountMapper"
+
+IcePy.defineProxy("::IceGrid::UserAccountMapper", UserAccountMapperPrx)
+
+class UserAccountMapper(Object, ABC):
+    """
+    Maps user strings in server descriptors to actual user account names. You can configure the user account mapper
+    of an IceGrid node with the property ``IceGrid.Node.UserAccountMapper``.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::IceGrid::UserAccountMapper``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::IceGrid::UserAccountMapper", )
+    _op_getUserAccount: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::UserAccountMapper"
+
+    @abstractmethod
+    def getUserAccount(self, user: str, current: Current) -> str | Awaitable[str]:
+        """
+        Gets the name of the user account for the given user. This is used by IceGrid nodes to figure out the user
+        account to use to run servers.
+        
+        Parameters
+        ----------
+        user : str
+            The value of the server descriptor's ``user`` attribute. When this attribute is not defined, and
+            the server's activation mode is ``session``, the default value for ``user`` is the session identifier.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        str | Awaitable[str]
+            The user account name.
+        
+        Raises
+        ------
+        UserAccountNotFoundException
+            Thrown when no user account is found for the given user.
+        """
+        pass
+
+UserAccountMapper._op_getUserAccount = IcePy.Operation(
+    "getUserAccount",
+    "getUserAccount",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0),),
+    (),
+    ((), IcePy._t_string, False, 0),
+    (_IceGrid_UserAccountNotFoundException_t,))
+
+__all__ = ["UserAccountMapper", "UserAccountMapperPrx", "_IceGrid_UserAccountMapperPrx_t"]

IceGrid/UserAccountMapper_forward.py

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

IceGrid/UserAccountNotFoundException.py

@@ -0,0 +1,34 @@
+# 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 UserAccountNotFoundException(UserException):
+    """
+    The exception that is thrown when a user account for a given session identifier can't be found.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::UserAccountNotFoundException``.
+    """
+
+    _ice_id = "::IceGrid::UserAccountNotFoundException"
+
+_IceGrid_UserAccountNotFoundException_t = IcePy.defineException(
+    "::IceGrid::UserAccountNotFoundException",
+    UserAccountNotFoundException,
+    (),
+    None,
+    ())
+
+setattr(UserAccountNotFoundException, '_ice_type', _IceGrid_UserAccountNotFoundException_t)
+
+__all__ = ["UserAccountNotFoundException", "_IceGrid_UserAccountNotFoundException_t"]

IceGrid/__init__.py

@@ -1,17 +1,375 @@
-# Generated by slice2py - DO NOT EDIT!
-#
 
-import Ice
-Ice.updateModule("IceGrid")
+# Copyright (c) ZeroC, Inc.
 
-# Modules:
-import IceGrid.Admin_ice
-import IceGrid.Descriptor_ice
-import IceGrid.Exception_ice
-import IceGrid.FileParser_ice
-import IceGrid.PluginFacade_ice
-import IceGrid.Registry_ice
-import IceGrid.Session_ice
-import IceGrid.UserAccountMapper_ice
+# slice2py version 3.8.0
 
-# Submodules:
+from .AccessDeniedException import AccessDeniedException
+from .AccessDeniedException import _IceGrid_AccessDeniedException_t
+from .AdapterDescriptor import AdapterDescriptor
+from .AdapterDescriptor import _IceGrid_AdapterDescriptor_t
+from .AdapterDescriptorSeq import _IceGrid_AdapterDescriptorSeq_t
+from .AdapterDynamicInfo import AdapterDynamicInfo
+from .AdapterDynamicInfo import _IceGrid_AdapterDynamicInfo_t
+from .AdapterDynamicInfoSeq import _IceGrid_AdapterDynamicInfoSeq_t
+from .AdapterInfo import AdapterInfo
+from .AdapterInfo import _IceGrid_AdapterInfo_t
+from .AdapterInfoSeq import _IceGrid_AdapterInfoSeq_t
+from .AdapterNotExistException import AdapterNotExistException
+from .AdapterNotExistException import _IceGrid_AdapterNotExistException_t
+from .AdapterObserver import AdapterObserver
+from .AdapterObserver import AdapterObserverPrx
+from .AdapterObserver_forward import _IceGrid_AdapterObserverPrx_t
+from .AdaptiveLoadBalancingPolicy import AdaptiveLoadBalancingPolicy
+from .AdaptiveLoadBalancingPolicy_forward import _IceGrid_AdaptiveLoadBalancingPolicy_t
+from .Admin import Admin
+from .Admin import AdminPrx
+from .AdminSession import AdminSession
+from .AdminSession import AdminSessionPrx
+from .AdminSession_forward import _IceGrid_AdminSessionPrx_t
+from .Admin_forward import _IceGrid_AdminPrx_t
+from .AllocationException import AllocationException
+from .AllocationException import _IceGrid_AllocationException_t
+from .AllocationTimeoutException import AllocationTimeoutException
+from .AllocationTimeoutException import _IceGrid_AllocationTimeoutException_t
+from .ApplicationDescriptor import ApplicationDescriptor
+from .ApplicationDescriptor import _IceGrid_ApplicationDescriptor_t
+from .ApplicationDescriptorSeq import _IceGrid_ApplicationDescriptorSeq_t
+from .ApplicationInfo import ApplicationInfo
+from .ApplicationInfo import _IceGrid_ApplicationInfo_t
+from .ApplicationInfoSeq import _IceGrid_ApplicationInfoSeq_t
+from .ApplicationNotExistException import ApplicationNotExistException
+from .ApplicationNotExistException import _IceGrid_ApplicationNotExistException_t
+from .ApplicationObserver import ApplicationObserver
+from .ApplicationObserver import ApplicationObserverPrx
+from .ApplicationObserver_forward import _IceGrid_ApplicationObserverPrx_t
+from .ApplicationUpdateDescriptor import ApplicationUpdateDescriptor
+from .ApplicationUpdateDescriptor import _IceGrid_ApplicationUpdateDescriptor_t
+from .ApplicationUpdateInfo import ApplicationUpdateInfo
+from .ApplicationUpdateInfo import _IceGrid_ApplicationUpdateInfo_t
+from .BadSignalException import BadSignalException
+from .BadSignalException import _IceGrid_BadSignalException_t
+from .BoxedDistributionDescriptor import BoxedDistributionDescriptor
+from .BoxedDistributionDescriptor_forward import _IceGrid_BoxedDistributionDescriptor_t
+from .BoxedString import BoxedString
+from .BoxedString_forward import _IceGrid_BoxedString_t
+from .CommunicatorDescriptor import CommunicatorDescriptor
+from .CommunicatorDescriptor_forward import _IceGrid_CommunicatorDescriptor_t
+from .DbEnvDescriptor import DbEnvDescriptor
+from .DbEnvDescriptor import _IceGrid_DbEnvDescriptor_t
+from .DbEnvDescriptorSeq import _IceGrid_DbEnvDescriptorSeq_t
+from .DeploymentException import DeploymentException
+from .DeploymentException import _IceGrid_DeploymentException_t
+from .DistributionDescriptor import DistributionDescriptor
+from .DistributionDescriptor import _IceGrid_DistributionDescriptor_t
+from .FileIterator import FileIterator
+from .FileIterator import FileIteratorPrx
+from .FileIterator_forward import _IceGrid_FileIteratorPrx_t
+from .FileNotAvailableException import FileNotAvailableException
+from .FileNotAvailableException import _IceGrid_FileNotAvailableException_t
+from .FileParser import FileParser
+from .FileParser import FileParserPrx
+from .FileParser_forward import _IceGrid_FileParserPrx_t
+from .IceBoxDescriptor import IceBoxDescriptor
+from .IceBoxDescriptor_forward import _IceGrid_IceBoxDescriptor_t
+from .LoadBalancingPolicy import LoadBalancingPolicy
+from .LoadBalancingPolicy_forward import _IceGrid_LoadBalancingPolicy_t
+from .LoadInfo import LoadInfo
+from .LoadInfo import _IceGrid_LoadInfo_t
+from .LoadSample import LoadSample
+from .LoadSample import _IceGrid_LoadSample_t
+from .Locator import Locator
+from .Locator import LocatorPrx
+from .Locator_forward import _IceGrid_LocatorPrx_t
+from .NodeDescriptor import NodeDescriptor
+from .NodeDescriptor import _IceGrid_NodeDescriptor_t
+from .NodeDescriptorDict import _IceGrid_NodeDescriptorDict_t
+from .NodeDynamicInfo import NodeDynamicInfo
+from .NodeDynamicInfo import _IceGrid_NodeDynamicInfo_t
+from .NodeDynamicInfoSeq import _IceGrid_NodeDynamicInfoSeq_t
+from .NodeInfo import NodeInfo
+from .NodeInfo import _IceGrid_NodeInfo_t
+from .NodeNotExistException import NodeNotExistException
+from .NodeNotExistException import _IceGrid_NodeNotExistException_t
+from .NodeObserver import NodeObserver
+from .NodeObserver import NodeObserverPrx
+from .NodeObserver_forward import _IceGrid_NodeObserverPrx_t
+from .NodeUnreachableException import NodeUnreachableException
+from .NodeUnreachableException import _IceGrid_NodeUnreachableException_t
+from .NodeUpdateDescriptor import NodeUpdateDescriptor
+from .NodeUpdateDescriptor import _IceGrid_NodeUpdateDescriptor_t
+from .NodeUpdateDescriptorSeq import _IceGrid_NodeUpdateDescriptorSeq_t
+from .ObjectDescriptor import ObjectDescriptor
+from .ObjectDescriptor import _IceGrid_ObjectDescriptor_t
+from .ObjectDescriptorSeq import _IceGrid_ObjectDescriptorSeq_t
+from .ObjectExistsException import ObjectExistsException
+from .ObjectExistsException import _IceGrid_ObjectExistsException_t
+from .ObjectInfo import ObjectInfo
+from .ObjectInfo import _IceGrid_ObjectInfo_t
+from .ObjectInfoSeq import _IceGrid_ObjectInfoSeq_t
+from .ObjectNotRegisteredException import ObjectNotRegisteredException
+from .ObjectNotRegisteredException import _IceGrid_ObjectNotRegisteredException_t
+from .ObjectObserver import ObjectObserver
+from .ObjectObserver import ObjectObserverPrx
+from .ObjectObserver_forward import _IceGrid_ObjectObserverPrx_t
+from .ObserverAlreadyRegisteredException import ObserverAlreadyRegisteredException
+from .ObserverAlreadyRegisteredException import _IceGrid_ObserverAlreadyRegisteredException_t
+from .OrderedLoadBalancingPolicy import OrderedLoadBalancingPolicy
+from .OrderedLoadBalancingPolicy_forward import _IceGrid_OrderedLoadBalancingPolicy_t
+from .ParseException import ParseException
+from .ParseException import _IceGrid_ParseException_t
+from .PermissionDeniedException import PermissionDeniedException
+from .PermissionDeniedException import _IceGrid_PermissionDeniedException_t
+from .PropertyDescriptor import PropertyDescriptor
+from .PropertyDescriptor import _IceGrid_PropertyDescriptor_t
+from .PropertyDescriptorSeq import _IceGrid_PropertyDescriptorSeq_t
+from .PropertySetDescriptor import PropertySetDescriptor
+from .PropertySetDescriptor import _IceGrid_PropertySetDescriptor_t
+from .PropertySetDescriptorDict import _IceGrid_PropertySetDescriptorDict_t
+from .Query import Query
+from .Query import QueryPrx
+from .Query_forward import _IceGrid_QueryPrx_t
+from .RandomLoadBalancingPolicy import RandomLoadBalancingPolicy
+from .RandomLoadBalancingPolicy_forward import _IceGrid_RandomLoadBalancingPolicy_t
+from .Registry import Registry
+from .Registry import RegistryPrx
+from .RegistryInfo import RegistryInfo
+from .RegistryInfo import _IceGrid_RegistryInfo_t
+from .RegistryInfoSeq import _IceGrid_RegistryInfoSeq_t
+from .RegistryNotExistException import RegistryNotExistException
+from .RegistryNotExistException import _IceGrid_RegistryNotExistException_t
+from .RegistryObserver import RegistryObserver
+from .RegistryObserver import RegistryObserverPrx
+from .RegistryObserver_forward import _IceGrid_RegistryObserverPrx_t
+from .RegistryUnreachableException import RegistryUnreachableException
+from .RegistryUnreachableException import _IceGrid_RegistryUnreachableException_t
+from .Registry_forward import _IceGrid_RegistryPrx_t
+from .ReplicaGroupDescriptor import ReplicaGroupDescriptor
+from .ReplicaGroupDescriptor import _IceGrid_ReplicaGroupDescriptor_t
+from .ReplicaGroupDescriptorSeq import _IceGrid_ReplicaGroupDescriptorSeq_t
+from .RoundRobinLoadBalancingPolicy import RoundRobinLoadBalancingPolicy
+from .RoundRobinLoadBalancingPolicy_forward import _IceGrid_RoundRobinLoadBalancingPolicy_t
+from .ServerDescriptor import ServerDescriptor
+from .ServerDescriptorSeq import _IceGrid_ServerDescriptorSeq_t
+from .ServerDescriptor_forward import _IceGrid_ServerDescriptor_t
+from .ServerDynamicInfo import ServerDynamicInfo
+from .ServerDynamicInfo import _IceGrid_ServerDynamicInfo_t
+from .ServerDynamicInfoSeq import _IceGrid_ServerDynamicInfoSeq_t
+from .ServerInfo import ServerInfo
+from .ServerInfo import _IceGrid_ServerInfo_t
+from .ServerInstanceDescriptor import ServerInstanceDescriptor
+from .ServerInstanceDescriptor import _IceGrid_ServerInstanceDescriptor_t
+from .ServerInstanceDescriptorSeq import _IceGrid_ServerInstanceDescriptorSeq_t
+from .ServerNotExistException import ServerNotExistException
+from .ServerNotExistException import _IceGrid_ServerNotExistException_t
+from .ServerStartException import ServerStartException
+from .ServerStartException import _IceGrid_ServerStartException_t
+from .ServerState import ServerState
+from .ServerState import _IceGrid_ServerState_t
+from .ServerStopException import ServerStopException
+from .ServerStopException import _IceGrid_ServerStopException_t
+from .ServiceDescriptor import ServiceDescriptor
+from .ServiceDescriptorSeq import _IceGrid_ServiceDescriptorSeq_t
+from .ServiceDescriptor_forward import _IceGrid_ServiceDescriptor_t
+from .ServiceInstanceDescriptor import ServiceInstanceDescriptor
+from .ServiceInstanceDescriptor import _IceGrid_ServiceInstanceDescriptor_t
+from .ServiceInstanceDescriptorSeq import _IceGrid_ServiceInstanceDescriptorSeq_t
+from .Session import Session
+from .Session import SessionPrx
+from .Session_forward import _IceGrid_SessionPrx_t
+from .StringObjectProxyDict import _IceGrid_StringObjectProxyDict_t
+from .StringStringDict import _IceGrid_StringStringDict_t
+from .TemplateDescriptor import TemplateDescriptor
+from .TemplateDescriptor import _IceGrid_TemplateDescriptor_t
+from .TemplateDescriptorDict import _IceGrid_TemplateDescriptorDict_t
+from .UserAccountMapper import UserAccountMapper
+from .UserAccountMapper import UserAccountMapperPrx
+from .UserAccountMapper_forward import _IceGrid_UserAccountMapperPrx_t
+from .UserAccountNotFoundException import UserAccountNotFoundException
+from .UserAccountNotFoundException import _IceGrid_UserAccountNotFoundException_t
+
+
+__all__ = [
+    "AccessDeniedException",
+    "_IceGrid_AccessDeniedException_t",
+    "AdapterDescriptor",
+    "_IceGrid_AdapterDescriptor_t",
+    "_IceGrid_AdapterDescriptorSeq_t",
+    "AdapterDynamicInfo",
+    "_IceGrid_AdapterDynamicInfo_t",
+    "_IceGrid_AdapterDynamicInfoSeq_t",
+    "AdapterInfo",
+    "_IceGrid_AdapterInfo_t",
+    "_IceGrid_AdapterInfoSeq_t",
+    "AdapterNotExistException",
+    "_IceGrid_AdapterNotExistException_t",
+    "AdapterObserver",
+    "AdapterObserverPrx",
+    "_IceGrid_AdapterObserverPrx_t",
+    "AdaptiveLoadBalancingPolicy",
+    "_IceGrid_AdaptiveLoadBalancingPolicy_t",
+    "Admin",
+    "AdminPrx",
+    "AdminSession",
+    "AdminSessionPrx",
+    "_IceGrid_AdminSessionPrx_t",
+    "_IceGrid_AdminPrx_t",
+    "AllocationException",
+    "_IceGrid_AllocationException_t",
+    "AllocationTimeoutException",
+    "_IceGrid_AllocationTimeoutException_t",
+    "ApplicationDescriptor",
+    "_IceGrid_ApplicationDescriptor_t",
+    "_IceGrid_ApplicationDescriptorSeq_t",
+    "ApplicationInfo",
+    "_IceGrid_ApplicationInfo_t",
+    "_IceGrid_ApplicationInfoSeq_t",
+    "ApplicationNotExistException",
+    "_IceGrid_ApplicationNotExistException_t",
+    "ApplicationObserver",
+    "ApplicationObserverPrx",
+    "_IceGrid_ApplicationObserverPrx_t",
+    "ApplicationUpdateDescriptor",
+    "_IceGrid_ApplicationUpdateDescriptor_t",
+    "ApplicationUpdateInfo",
+    "_IceGrid_ApplicationUpdateInfo_t",
+    "BadSignalException",
+    "_IceGrid_BadSignalException_t",
+    "BoxedDistributionDescriptor",
+    "_IceGrid_BoxedDistributionDescriptor_t",
+    "BoxedString",
+    "_IceGrid_BoxedString_t",
+    "CommunicatorDescriptor",
+    "_IceGrid_CommunicatorDescriptor_t",
+    "DbEnvDescriptor",
+    "_IceGrid_DbEnvDescriptor_t",
+    "_IceGrid_DbEnvDescriptorSeq_t",
+    "DeploymentException",
+    "_IceGrid_DeploymentException_t",
+    "DistributionDescriptor",
+    "_IceGrid_DistributionDescriptor_t",
+    "FileIterator",
+    "FileIteratorPrx",
+    "_IceGrid_FileIteratorPrx_t",
+    "FileNotAvailableException",
+    "_IceGrid_FileNotAvailableException_t",
+    "FileParser",
+    "FileParserPrx",
+    "_IceGrid_FileParserPrx_t",
+    "IceBoxDescriptor",
+    "_IceGrid_IceBoxDescriptor_t",
+    "LoadBalancingPolicy",
+    "_IceGrid_LoadBalancingPolicy_t",
+    "LoadInfo",
+    "_IceGrid_LoadInfo_t",
+    "LoadSample",
+    "_IceGrid_LoadSample_t",
+    "Locator",
+    "LocatorPrx",
+    "_IceGrid_LocatorPrx_t",
+    "NodeDescriptor",
+    "_IceGrid_NodeDescriptor_t",
+    "_IceGrid_NodeDescriptorDict_t",
+    "NodeDynamicInfo",
+    "_IceGrid_NodeDynamicInfo_t",
+    "_IceGrid_NodeDynamicInfoSeq_t",
+    "NodeInfo",
+    "_IceGrid_NodeInfo_t",
+    "NodeNotExistException",
+    "_IceGrid_NodeNotExistException_t",
+    "NodeObserver",
+    "NodeObserverPrx",
+    "_IceGrid_NodeObserverPrx_t",
+    "NodeUnreachableException",
+    "_IceGrid_NodeUnreachableException_t",
+    "NodeUpdateDescriptor",
+    "_IceGrid_NodeUpdateDescriptor_t",
+    "_IceGrid_NodeUpdateDescriptorSeq_t",
+    "ObjectDescriptor",
+    "_IceGrid_ObjectDescriptor_t",
+    "_IceGrid_ObjectDescriptorSeq_t",
+    "ObjectExistsException",
+    "_IceGrid_ObjectExistsException_t",
+    "ObjectInfo",
+    "_IceGrid_ObjectInfo_t",
+    "_IceGrid_ObjectInfoSeq_t",
+    "ObjectNotRegisteredException",
+    "_IceGrid_ObjectNotRegisteredException_t",
+    "ObjectObserver",
+    "ObjectObserverPrx",
+    "_IceGrid_ObjectObserverPrx_t",
+    "ObserverAlreadyRegisteredException",
+    "_IceGrid_ObserverAlreadyRegisteredException_t",
+    "OrderedLoadBalancingPolicy",
+    "_IceGrid_OrderedLoadBalancingPolicy_t",
+    "ParseException",
+    "_IceGrid_ParseException_t",
+    "PermissionDeniedException",
+    "_IceGrid_PermissionDeniedException_t",
+    "PropertyDescriptor",
+    "_IceGrid_PropertyDescriptor_t",
+    "_IceGrid_PropertyDescriptorSeq_t",
+    "PropertySetDescriptor",
+    "_IceGrid_PropertySetDescriptor_t",
+    "_IceGrid_PropertySetDescriptorDict_t",
+    "Query",
+    "QueryPrx",
+    "_IceGrid_QueryPrx_t",
+    "RandomLoadBalancingPolicy",
+    "_IceGrid_RandomLoadBalancingPolicy_t",
+    "Registry",
+    "RegistryPrx",
+    "RegistryInfo",
+    "_IceGrid_RegistryInfo_t",
+    "_IceGrid_RegistryInfoSeq_t",
+    "RegistryNotExistException",
+    "_IceGrid_RegistryNotExistException_t",
+    "RegistryObserver",
+    "RegistryObserverPrx",
+    "_IceGrid_RegistryObserverPrx_t",
+    "RegistryUnreachableException",
+    "_IceGrid_RegistryUnreachableException_t",
+    "_IceGrid_RegistryPrx_t",
+    "ReplicaGroupDescriptor",
+    "_IceGrid_ReplicaGroupDescriptor_t",
+    "_IceGrid_ReplicaGroupDescriptorSeq_t",
+    "RoundRobinLoadBalancingPolicy",
+    "_IceGrid_RoundRobinLoadBalancingPolicy_t",
+    "ServerDescriptor",
+    "_IceGrid_ServerDescriptorSeq_t",
+    "_IceGrid_ServerDescriptor_t",
+    "ServerDynamicInfo",
+    "_IceGrid_ServerDynamicInfo_t",
+    "_IceGrid_ServerDynamicInfoSeq_t",
+    "ServerInfo",
+    "_IceGrid_ServerInfo_t",
+    "ServerInstanceDescriptor",
+    "_IceGrid_ServerInstanceDescriptor_t",
+    "_IceGrid_ServerInstanceDescriptorSeq_t",
+    "ServerNotExistException",
+    "_IceGrid_ServerNotExistException_t",
+    "ServerStartException",
+    "_IceGrid_ServerStartException_t",
+    "ServerState",
+    "_IceGrid_ServerState_t",
+    "ServerStopException",
+    "_IceGrid_ServerStopException_t",
+    "ServiceDescriptor",
+    "_IceGrid_ServiceDescriptorSeq_t",
+    "_IceGrid_ServiceDescriptor_t",
+    "ServiceInstanceDescriptor",
+    "_IceGrid_ServiceInstanceDescriptor_t",
+    "_IceGrid_ServiceInstanceDescriptorSeq_t",
+    "Session",
+    "SessionPrx",
+    "_IceGrid_SessionPrx_t",
+    "_IceGrid_StringObjectProxyDict_t",
+    "_IceGrid_StringStringDict_t",
+    "TemplateDescriptor",
+    "_IceGrid_TemplateDescriptor_t",
+    "_IceGrid_TemplateDescriptorDict_t",
+    "UserAccountMapper",
+    "UserAccountMapperPrx",
+    "_IceGrid_UserAccountMapperPrx_t",
+    "UserAccountNotFoundException",
+    "_IceGrid_UserAccountNotFoundException_t"
+]

IceMX/ChildInvocationMetrics.py

@@ -0,0 +1,56 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceMX.ChildInvocationMetrics_forward import _IceMX_ChildInvocationMetrics_t
+
+from IceMX.Metrics import Metrics
+
+from IceMX.Metrics_forward import _IceMX_Metrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class ChildInvocationMetrics(Metrics):
+    """
+    Provides information on child invocations. A child invocation is either remote (sent over an Ice connection) or
+    collocated. An invocation can have multiple child invocations if it is retried. Child invocation metrics are
+    embedded within :class:`IceMX.InvocationMetrics`.
+    
+    Attributes
+    ----------
+    size : int
+        The size of the invocation. This corresponds to the size of the marshaled input parameters.
+    replySize : int
+        The size of the invocation reply. This corresponds to the size of the marshaled output and return
+        parameters.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::ChildInvocationMetrics``.
+    """
+    size: int = 0
+    replySize: int = 0
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::ChildInvocationMetrics"
+
+_IceMX_ChildInvocationMetrics_t = IcePy.defineValue(
+    "::IceMX::ChildInvocationMetrics",
+    ChildInvocationMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_Metrics_t,
+    (
+        ("size", (), IcePy._t_long, False, 0),
+        ("replySize", (), IcePy._t_long, False, 0)
+    ))
+
+setattr(ChildInvocationMetrics, '_ice_type', _IceMX_ChildInvocationMetrics_t)
+
+__all__ = ["ChildInvocationMetrics", "_IceMX_ChildInvocationMetrics_t"]

IceMX/ChildInvocationMetrics_forward.py

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