zeroc-ice 3.7.11__cp313-cp313-win_amd64.whl → 3.8.0.post1__cp313-cp313-win_amd64.whl

IceGrid/ObjectInfo.py

@@ -0,0 +1,46 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.ObjectPrx_forward import _Ice_ObjectPrx_t
+
+from dataclasses import dataclass
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from Ice.ObjectPrx import ObjectPrx
+
+
+@dataclass
+class ObjectInfo:
+    """
+    Information about an Ice well-known object.
+    
+    Attributes
+    ----------
+    proxy : ObjectPrx | None
+        The proxy of the object.
+    type : str
+        The type of the object.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::ObjectInfo``.
+    """
+    proxy: ObjectPrx | None = None
+    type: str = ""
+
+_IceGrid_ObjectInfo_t = IcePy.defineStruct(
+    "::IceGrid::ObjectInfo",
+    ObjectInfo,
+    (),
+    (
+        ("proxy", (), _Ice_ObjectPrx_t),
+        ("type", (), IcePy._t_string)
+    ))
+
+__all__ = ["ObjectInfo", "_IceGrid_ObjectInfo_t"]

IceGrid/ObjectInfoSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.ObjectInfo import _IceGrid_ObjectInfo_t
+
+_IceGrid_ObjectInfoSeq_t = IcePy.defineSequence("::IceGrid::ObjectInfoSeq", (), _IceGrid_ObjectInfo_t)
+
+__all__ = ["_IceGrid_ObjectInfoSeq_t"]

IceGrid/ObjectNotRegisteredException.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 ObjectNotRegisteredException(UserException):
+    """
+    The exception that is thrown when a well-known object is not registered.
+    
+    Attributes
+    ----------
+    id : Identity
+        The identity of the object.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::ObjectNotRegisteredException``.
+    """
+    id: Identity = field(default_factory=Identity)
+
+    _ice_id = "::IceGrid::ObjectNotRegisteredException"
+
+_IceGrid_ObjectNotRegisteredException_t = IcePy.defineException(
+    "::IceGrid::ObjectNotRegisteredException",
+    ObjectNotRegisteredException,
+    (),
+    None,
+    (("id", (), _Ice_Identity_t, False, 0),))
+
+setattr(ObjectNotRegisteredException, '_ice_type', _IceGrid_ObjectNotRegisteredException_t)
+
+__all__ = ["ObjectNotRegisteredException", "_IceGrid_ObjectNotRegisteredException_t"]

IceGrid/ObjectObserver.py

@@ -0,0 +1,347 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Identity import _Ice_Identity_t
+
+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.ObjectInfo import _IceGrid_ObjectInfo_t
+
+from IceGrid.ObjectInfoSeq import _IceGrid_ObjectInfoSeq_t
+
+from IceGrid.ObjectObserver_forward import _IceGrid_ObjectObserverPrx_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 IceGrid.ObjectInfo import ObjectInfo
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class ObjectObserverPrx(ObjectPrx):
+    """
+    Monitors well-known objects that are added, updated or removed using :class:`IceGrid.AdminPrx`.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::IceGrid::ObjectObserver``.
+    """
+
+    def objectInit(self, objects: Sequence[ObjectInfo], context: dict[str, str] | None = None) -> None:
+        """
+        Provides the initial list of well-known objects to the observer.
+        
+        Parameters
+        ----------
+        objects : Sequence[ObjectInfo]
+            The well-known objects registered using :class:`IceGrid.AdminPrx`.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ObjectObserver._op_objectInit.invoke(self, ((objects, ), context))
+
+    def objectInitAsync(self, objects: Sequence[ObjectInfo], context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Provides the initial list of well-known objects to the observer.
+        
+        Parameters
+        ----------
+        objects : Sequence[ObjectInfo]
+            The well-known objects registered using :class:`IceGrid.AdminPrx`.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ObjectObserver._op_objectInit.invokeAsync(self, ((objects, ), context))
+
+    def objectAdded(self, info: ObjectInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that a well-known object was added.
+        
+        Parameters
+        ----------
+        info : ObjectInfo
+            The details of the new object.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ObjectObserver._op_objectAdded.invoke(self, ((info, ), context))
+
+    def objectAddedAsync(self, info: ObjectInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that a well-known object was added.
+        
+        Parameters
+        ----------
+        info : ObjectInfo
+            The details of the new object.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ObjectObserver._op_objectAdded.invokeAsync(self, ((info, ), context))
+
+    def objectUpdated(self, info: ObjectInfo, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that a well-known object was updated.
+        
+        Parameters
+        ----------
+        info : ObjectInfo
+            The details of the updated object.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ObjectObserver._op_objectUpdated.invoke(self, ((info, ), context))
+
+    def objectUpdatedAsync(self, info: ObjectInfo, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that a well-known object was updated.
+        
+        Parameters
+        ----------
+        info : ObjectInfo
+            The details of the updated object.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ObjectObserver._op_objectUpdated.invokeAsync(self, ((info, ), context))
+
+    def objectRemoved(self, id: Identity, context: dict[str, str] | None = None) -> None:
+        """
+        Notifies the observer that a well-known object was removed.
+        
+        Parameters
+        ----------
+        id : Identity
+            The identity of the removed object.
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return ObjectObserver._op_objectRemoved.invoke(self, ((id, ), context))
+
+    def objectRemovedAsync(self, id: Identity, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Notifies the observer that a well-known object was removed.
+        
+        Parameters
+        ----------
+        id : Identity
+            The identity of the removed object.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return ObjectObserver._op_objectRemoved.invokeAsync(self, ((id, ), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> ObjectObserverPrx | None:
+        return checkedCast(ObjectObserverPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[ObjectObserverPrx | None ]:
+        return checkedCastAsync(ObjectObserverPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> ObjectObserverPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> ObjectObserverPrx | None:
+        return uncheckedCast(ObjectObserverPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::ObjectObserver"
+
+IcePy.defineProxy("::IceGrid::ObjectObserver", ObjectObserverPrx)
+
+class ObjectObserver(Object, ABC):
+    """
+    Monitors well-known objects that are added, updated or removed using :class:`IceGrid.AdminPrx`.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::IceGrid::ObjectObserver``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::IceGrid::ObjectObserver", )
+    _op_objectInit: IcePy.Operation
+    _op_objectAdded: IcePy.Operation
+    _op_objectUpdated: IcePy.Operation
+    _op_objectRemoved: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::ObjectObserver"
+
+    @abstractmethod
+    def objectInit(self, objects: list[ObjectInfo], current: Current) -> None | Awaitable[None]:
+        """
+        Provides the initial list of well-known objects to the observer.
+        
+        Parameters
+        ----------
+        objects : list[ObjectInfo]
+            The well-known objects registered using :class:`IceGrid.AdminPrx`.
+        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 objectAdded(self, info: ObjectInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that a well-known object was added.
+        
+        Parameters
+        ----------
+        info : ObjectInfo
+            The details of the new object.
+        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 objectUpdated(self, info: ObjectInfo, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that a well-known object was updated.
+        
+        Parameters
+        ----------
+        info : ObjectInfo
+            The details of the updated object.
+        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 objectRemoved(self, id: Identity, current: Current) -> None | Awaitable[None]:
+        """
+        Notifies the observer that a well-known object was removed.
+        
+        Parameters
+        ----------
+        id : Identity
+            The identity of the removed object.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+ObjectObserver._op_objectInit = IcePy.Operation(
+    "objectInit",
+    "objectInit",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_ObjectInfoSeq_t, False, 0),),
+    (),
+    None,
+    ())
+
+ObjectObserver._op_objectAdded = IcePy.Operation(
+    "objectAdded",
+    "objectAdded",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_ObjectInfo_t, False, 0),),
+    (),
+    None,
+    ())
+
+ObjectObserver._op_objectUpdated = IcePy.Operation(
+    "objectUpdated",
+    "objectUpdated",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _IceGrid_ObjectInfo_t, False, 0),),
+    (),
+    None,
+    ())
+
+ObjectObserver._op_objectRemoved = IcePy.Operation(
+    "objectRemoved",
+    "objectRemoved",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), _Ice_Identity_t, False, 0),),
+    (),
+    None,
+    ())
+
+__all__ = ["ObjectObserver", "ObjectObserverPrx", "_IceGrid_ObjectObserverPrx_t"]

IceGrid/ObjectObserver_forward.py

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

IceGrid/ObserverAlreadyRegisteredException.py

@@ -0,0 +1,49 @@
+# 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 ObserverAlreadyRegisteredException(UserException):
+    """
+    The exception that is thrown when an observer is already registered with the registry.
+    
+    Attributes
+    ----------
+    id : Identity
+        The identity of the observer.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::ObserverAlreadyRegisteredException``.
+    
+    See Also
+    --------
+        :meth:`IceGrid.AdminSessionPrx.setObserversAsync`
+        :meth:`IceGrid.AdminSessionPrx.setObserversByIdentityAsync`
+    """
+    id: Identity = field(default_factory=Identity)
+
+    _ice_id = "::IceGrid::ObserverAlreadyRegisteredException"
+
+_IceGrid_ObserverAlreadyRegisteredException_t = IcePy.defineException(
+    "::IceGrid::ObserverAlreadyRegisteredException",
+    ObserverAlreadyRegisteredException,
+    (),
+    None,
+    (("id", (), _Ice_Identity_t, False, 0),))
+
+setattr(ObserverAlreadyRegisteredException, '_ice_type', _IceGrid_ObserverAlreadyRegisteredException_t)
+
+__all__ = ["ObserverAlreadyRegisteredException", "_IceGrid_ObserverAlreadyRegisteredException_t"]

IceGrid/OrderedLoadBalancingPolicy.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.OrderedLoadBalancingPolicy_forward import _IceGrid_OrderedLoadBalancingPolicy_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class OrderedLoadBalancingPolicy(LoadBalancingPolicy):
+    """
+    The load balancing policy that returns endpoints in order.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceGrid::OrderedLoadBalancingPolicy``.
+    """
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::OrderedLoadBalancingPolicy"
+
+_IceGrid_OrderedLoadBalancingPolicy_t = IcePy.defineValue(
+    "::IceGrid::OrderedLoadBalancingPolicy",
+    OrderedLoadBalancingPolicy,
+    -1,
+    (),
+    False,
+    _IceGrid_LoadBalancingPolicy_t,
+    ())
+
+setattr(OrderedLoadBalancingPolicy, '_ice_type', _IceGrid_OrderedLoadBalancingPolicy_t)
+
+__all__ = ["OrderedLoadBalancingPolicy", "_IceGrid_OrderedLoadBalancingPolicy_t"]

IceGrid/OrderedLoadBalancingPolicy_forward.py

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

IceGrid/ParseException.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 ParseException(UserException):
+    """
+    The exception that is thrown when an error occurs during the parsing of an IceGrid XML file.
+    
+    Attributes
+    ----------
+    reason : str
+        The reason for the failure.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::ParseException``.
+    """
+    reason: str = ""
+
+    _ice_id = "::IceGrid::ParseException"
+
+_IceGrid_ParseException_t = IcePy.defineException(
+    "::IceGrid::ParseException",
+    ParseException,
+    (),
+    None,
+    (("reason", (), IcePy._t_string, False, 0),))
+
+setattr(ParseException, '_ice_type', _IceGrid_ParseException_t)
+
+__all__ = ["ParseException", "_IceGrid_ParseException_t"]

IceGrid/PermissionDeniedException.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 PermissionDeniedException(UserException):
+    """
+    The exception that is thrown when a client is not allowed to create a session.
+    
+    Attributes
+    ----------
+    reason : str
+        The reason why permission was denied.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::PermissionDeniedException``.
+    """
+    reason: str = ""
+
+    _ice_id = "::IceGrid::PermissionDeniedException"
+
+_IceGrid_PermissionDeniedException_t = IcePy.defineException(
+    "::IceGrid::PermissionDeniedException",
+    PermissionDeniedException,
+    (),
+    None,
+    (("reason", (), IcePy._t_string, False, 0),))
+
+setattr(PermissionDeniedException, '_ice_type', _IceGrid_PermissionDeniedException_t)
+
+__all__ = ["PermissionDeniedException", "_IceGrid_PermissionDeniedException_t"]

IceGrid/PropertyDescriptor.py

@@ -0,0 +1,39 @@
+# 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 PropertyDescriptor:
+    """
+    Describes an Ice property.
+    
+    Attributes
+    ----------
+    name : str
+        The name of the property.
+    value : str
+        The value of the property.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::PropertyDescriptor``.
+    """
+    name: str = ""
+    value: str = ""
+
+_IceGrid_PropertyDescriptor_t = IcePy.defineStruct(
+    "::IceGrid::PropertyDescriptor",
+    PropertyDescriptor,
+    (),
+    (
+        ("name", (), IcePy._t_string),
+        ("value", (), IcePy._t_string)
+    ))
+
+__all__ = ["PropertyDescriptor", "_IceGrid_PropertyDescriptor_t"]

IceGrid/PropertyDescriptorSeq.py

@@ -0,0 +1,12 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.PropertyDescriptor import _IceGrid_PropertyDescriptor_t
+
+_IceGrid_PropertyDescriptorSeq_t = IcePy.defineSequence("::IceGrid::PropertyDescriptorSeq", (), _IceGrid_PropertyDescriptor_t)
+
+__all__ = ["_IceGrid_PropertyDescriptorSeq_t"]