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

IceGrid/FileIterator.py

@@ -0,0 +1,246 @@
+# 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 Ice.StringSeq import _Ice_StringSeq_t
+
+from IceGrid.FileIterator_forward import _IceGrid_FileIteratorPrx_t
+
+from IceGrid.FileNotAvailableException import _IceGrid_FileNotAvailableException_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 FileIteratorPrx(ObjectPrx):
+    """
+    Iterates over an IceGrid log file.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::IceGrid::FileIterator``.
+    """
+
+    def read(self, size: int, context: dict[str, str] | None = None) -> tuple[bool, list[str]]:
+        """
+        Read lines from the log file.
+        
+        Parameters
+        ----------
+        size : int
+            Specifies the maximum number of bytes to be received. The server will ensure that the returned
+            message doesn't exceed the given size.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        tuple[bool, list[str]]
+        
+            A tuple containing:
+                - bool ``true`` if EOF is encountered.
+                - list[str] The lines read from the file. If there was nothing to read from the file since the last call to
+                  read, an empty sequence is returned. The last line of the sequence is always incomplete (and therefore no
+                  newline character should be added when writing the last line to the to the output device).
+        
+        Raises
+        ------
+        FileNotAvailableException
+            Thrown when the implementation failed to read from the file.
+        """
+        return FileIterator._op_read.invoke(self, ((size, ), context))
+
+    def readAsync(self, size: int, context: dict[str, str] | None = None) -> Awaitable[tuple[bool, list[str]]]:
+        """
+        Read lines from the log file.
+        
+        Parameters
+        ----------
+        size : int
+            Specifies the maximum number of bytes to be received. The server will ensure that the returned
+            message doesn't exceed the given size.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[tuple[bool, list[str]]]
+        
+            A tuple containing:
+                - bool ``true`` if EOF is encountered.
+                - list[str] The lines read from the file. If there was nothing to read from the file since the last call to
+                  read, an empty sequence is returned. The last line of the sequence is always incomplete (and therefore no
+                  newline character should be added when writing the last line to the to the output device).
+        """
+        return FileIterator._op_read.invokeAsync(self, ((size, ), context))
+
+    def destroy(self, context: dict[str, str] | None = None) -> None:
+        """
+        Destroys the iterator.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        """
+        return FileIterator._op_destroy.invoke(self, ((), context))
+
+    def destroyAsync(self, context: dict[str, str] | None = None) -> Awaitable[None]:
+        """
+        Destroys the iterator.
+        
+        Parameters
+        ----------
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[None]
+            An awaitable that is completed when the invocation completes.
+        """
+        return FileIterator._op_destroy.invokeAsync(self, ((), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> FileIteratorPrx | None:
+        return checkedCast(FileIteratorPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[FileIteratorPrx | None ]:
+        return checkedCastAsync(FileIteratorPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> FileIteratorPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> FileIteratorPrx | None:
+        return uncheckedCast(FileIteratorPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::FileIterator"
+
+IcePy.defineProxy("::IceGrid::FileIterator", FileIteratorPrx)
+
+class FileIterator(Object, ABC):
+    """
+    Iterates over an IceGrid log file.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::IceGrid::FileIterator``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::IceGrid::FileIterator", )
+    _op_read: IcePy.Operation
+    _op_destroy: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::FileIterator"
+
+    @abstractmethod
+    def read(self, size: int, current: Current) -> tuple[bool, Sequence[str]] | Awaitable[tuple[bool, Sequence[str]]]:
+        """
+        Read lines from the log file.
+        
+        Parameters
+        ----------
+        size : int
+            Specifies the maximum number of bytes to be received. The server will ensure that the returned
+            message doesn't exceed the given size.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        tuple[bool, Sequence[str]] | Awaitable[tuple[bool, Sequence[str]]]
+        
+            A tuple containing:
+                - bool ``true`` if EOF is encountered.
+                - Sequence[str] The lines read from the file. If there was nothing to read from the file since the last call to
+                  read, an empty sequence is returned. The last line of the sequence is always incomplete (and therefore no
+                  newline character should be added when writing the last line to the to the output device).
+        
+        Raises
+        ------
+        FileNotAvailableException
+            Thrown when the implementation failed to read from the file.
+        """
+        pass
+
+    @abstractmethod
+    def destroy(self, current: Current) -> None | Awaitable[None]:
+        """
+        Destroys the iterator.
+        
+        Parameters
+        ----------
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        None | Awaitable[None]
+            None or an awaitable that completes when the dispatch completes.
+        """
+        pass
+
+FileIterator._op_read = IcePy.Operation(
+    "read",
+    "read",
+    OperationMode.Normal,
+    None,
+    (),
+    (((), IcePy._t_int, False, 0),),
+    (((), _Ice_StringSeq_t, False, 0),),
+    ((), IcePy._t_bool, False, 0),
+    (_IceGrid_FileNotAvailableException_t,))
+
+FileIterator._op_destroy = IcePy.Operation(
+    "destroy",
+    "destroy",
+    OperationMode.Normal,
+    None,
+    (),
+    (),
+    (),
+    None,
+    ())
+
+__all__ = ["FileIterator", "FileIteratorPrx", "_IceGrid_FileIteratorPrx_t"]

IceGrid/FileIterator_forward.py

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

IceGrid/FileNotAvailableException.py

@@ -0,0 +1,49 @@
+# 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 FileNotAvailableException(UserException):
+    """
+    The exception that is thrown when a log file is not available.
+    
+    Attributes
+    ----------
+    reason : str
+        The reason for the failure.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceGrid::FileNotAvailableException``.
+    
+    See Also
+    --------
+        :meth:`IceGrid.AdminSessionPrx.openServerStdOutAsync`
+        :meth:`IceGrid.AdminSessionPrx.openServerStdErrAsync`
+        :meth:`IceGrid.AdminSessionPrx.openNodeStdOutAsync`
+        :meth:`IceGrid.AdminSessionPrx.openNodeStdErrAsync`
+        :meth:`IceGrid.AdminSessionPrx.openRegistryStdOutAsync`
+        :meth:`IceGrid.AdminSessionPrx.openRegistryStdErrAsync`
+    """
+    reason: str = ""
+
+    _ice_id = "::IceGrid::FileNotAvailableException"
+
+_IceGrid_FileNotAvailableException_t = IcePy.defineException(
+    "::IceGrid::FileNotAvailableException",
+    FileNotAvailableException,
+    (),
+    None,
+    (("reason", (), IcePy._t_string, False, 0),))
+
+setattr(FileNotAvailableException, '_ice_type', _IceGrid_FileNotAvailableException_t)
+
+__all__ = ["FileNotAvailableException", "_IceGrid_FileNotAvailableException_t"]

IceGrid/FileParser.py

@@ -0,0 +1,182 @@
+# 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.Admin_forward import _IceGrid_AdminPrx_t
+
+from IceGrid.ApplicationDescriptor import _IceGrid_ApplicationDescriptor_t
+
+from IceGrid.FileParser_forward import _IceGrid_FileParserPrx_t
+
+from IceGrid.ParseException import _IceGrid_ParseException_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.Admin import AdminPrx
+    from IceGrid.ApplicationDescriptor import ApplicationDescriptor
+    from collections.abc import Awaitable
+    from collections.abc import Sequence
+
+
+class FileParserPrx(ObjectPrx):
+    """
+    ``icegridadmin`` provides a ``FileParser`` object to transform XML files into :class:`IceGrid.ApplicationDescriptor` objects.
+    
+    Notes
+    -----
+        The Slice compiler generated this proxy class from Slice interface ``::IceGrid::FileParser``.
+    """
+
+    def parse(self, xmlFile: str, adminProxy: AdminPrx | None, context: dict[str, str] | None = None) -> ApplicationDescriptor:
+        """
+        Parses a file.
+        
+        Parameters
+        ----------
+        xmlFile : str
+            The full path to the file.
+        adminProxy : AdminPrx | None
+            An :class:`IceGrid.AdminPrx` proxy, used only to retrieve default templates when needed. May be null.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        ApplicationDescriptor
+            The application descriptor.
+        
+        Raises
+        ------
+        ParseException
+            Thrown when an error occurs during parsing.
+        """
+        return FileParser._op_parse.invoke(self, ((xmlFile, adminProxy), context))
+
+    def parseAsync(self, xmlFile: str, adminProxy: AdminPrx | None, context: dict[str, str] | None = None) -> Awaitable[ApplicationDescriptor]:
+        """
+        Parses a file.
+        
+        Parameters
+        ----------
+        xmlFile : str
+            The full path to the file.
+        adminProxy : AdminPrx | None
+            An :class:`IceGrid.AdminPrx` proxy, used only to retrieve default templates when needed. May be null.
+        context : dict[str, str]
+            The request context for the invocation.
+        
+        Returns
+        -------
+        Awaitable[ApplicationDescriptor]
+            The application descriptor.
+        """
+        return FileParser._op_parse.invokeAsync(self, ((xmlFile, adminProxy), context))
+
+    @staticmethod
+    def checkedCast(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> FileParserPrx | None:
+        return checkedCast(FileParserPrx, proxy, facet, context)
+
+    @staticmethod
+    def checkedCastAsync(
+        proxy: ObjectPrx | None,
+        facet: str | None = None,
+        context: dict[str, str] | None = None
+    ) -> Awaitable[FileParserPrx | None ]:
+        return checkedCastAsync(FileParserPrx, proxy, facet, context)
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx, facet: str | None = None) -> FileParserPrx:
+        ...
+
+    @overload
+    @staticmethod
+    def uncheckedCast(proxy: None, facet: str | None = None) -> None:
+        ...
+
+    @staticmethod
+    def uncheckedCast(proxy: ObjectPrx | None, facet: str | None = None) -> FileParserPrx | None:
+        return uncheckedCast(FileParserPrx, proxy, facet)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::FileParser"
+
+IcePy.defineProxy("::IceGrid::FileParser", FileParserPrx)
+
+class FileParser(Object, ABC):
+    """
+    ``icegridadmin`` provides a ``FileParser`` object to transform XML files into :class:`IceGrid.ApplicationDescriptor` objects.
+    
+    Notes
+    -----
+        The Slice compiler generated this skeleton class from Slice interface ``::IceGrid::FileParser``.
+    """
+
+    _ice_ids: Sequence[str] = ("::Ice::Object", "::IceGrid::FileParser", )
+    _op_parse: IcePy.Operation
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::FileParser"
+
+    @abstractmethod
+    def parse(self, xmlFile: str, adminProxy: AdminPrx | None, current: Current) -> ApplicationDescriptor | Awaitable[ApplicationDescriptor]:
+        """
+        Parses a file.
+        
+        Parameters
+        ----------
+        xmlFile : str
+            The full path to the file.
+        adminProxy : AdminPrx | None
+            An :class:`IceGrid.AdminPrx` proxy, used only to retrieve default templates when needed. May be null.
+        current : Ice.Current
+            The Current object for the dispatch.
+        
+        Returns
+        -------
+        ApplicationDescriptor | Awaitable[ApplicationDescriptor]
+            The application descriptor.
+        
+        Raises
+        ------
+        ParseException
+            Thrown when an error occurs during parsing.
+        """
+        pass
+
+FileParser._op_parse = IcePy.Operation(
+    "parse",
+    "parse",
+    OperationMode.Idempotent,
+    None,
+    (),
+    (((), IcePy._t_string, False, 0), ((), _IceGrid_AdminPrx_t, False, 0)),
+    (),
+    ((), _IceGrid_ApplicationDescriptor_t, False, 0),
+    (_IceGrid_ParseException_t,))
+
+__all__ = ["FileParser", "FileParserPrx", "_IceGrid_FileParserPrx_t"]

IceGrid/FileParser_forward.py

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

IceGrid/IceBoxDescriptor.py

@@ -0,0 +1,55 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceGrid.IceBoxDescriptor_forward import _IceGrid_IceBoxDescriptor_t
+
+from IceGrid.ServerDescriptor import ServerDescriptor
+
+from IceGrid.ServerDescriptor_forward import _IceGrid_ServerDescriptor_t
+
+from IceGrid.ServiceInstanceDescriptorSeq import _IceGrid_ServiceInstanceDescriptorSeq_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from IceGrid.ServiceInstanceDescriptor import ServiceInstanceDescriptor
+
+@dataclass(eq=False)
+class IceBoxDescriptor(ServerDescriptor):
+    """
+    Describes an IceBox server.
+    
+    Attributes
+    ----------
+    services : list[ServiceInstanceDescriptor]
+        The service instances.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceGrid::IceBoxDescriptor``.
+    """
+    services: list[ServiceInstanceDescriptor] = field(default_factory=list)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::IceBoxDescriptor"
+
+_IceGrid_IceBoxDescriptor_t = IcePy.defineValue(
+    "::IceGrid::IceBoxDescriptor",
+    IceBoxDescriptor,
+    -1,
+    (),
+    False,
+    _IceGrid_ServerDescriptor_t,
+    (("services", (), _IceGrid_ServiceInstanceDescriptorSeq_t, False, 0),))
+
+setattr(IceBoxDescriptor, '_ice_type', _IceGrid_IceBoxDescriptor_t)
+
+__all__ = ["IceBoxDescriptor", "_IceGrid_IceBoxDescriptor_t"]

IceGrid/IceBoxDescriptor_forward.py

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

IceGrid/LoadBalancingPolicy.py

@@ -0,0 +1,45 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Value import Value
+
+from IceGrid.LoadBalancingPolicy_forward import _IceGrid_LoadBalancingPolicy_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class LoadBalancingPolicy(Value):
+    """
+    The base class for load balancing policies.
+    
+    Attributes
+    ----------
+    nReplicas : str
+        The number of replicas that will be used to gather the endpoints of a replica group.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceGrid::LoadBalancingPolicy``.
+    """
+    nReplicas: str = ""
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceGrid::LoadBalancingPolicy"
+
+_IceGrid_LoadBalancingPolicy_t = IcePy.defineValue(
+    "::IceGrid::LoadBalancingPolicy",
+    LoadBalancingPolicy,
+    -1,
+    (),
+    False,
+    None,
+    (("nReplicas", (), IcePy._t_string, False, 0),))
+
+setattr(LoadBalancingPolicy, '_ice_type', _IceGrid_LoadBalancingPolicy_t)
+
+__all__ = ["LoadBalancingPolicy", "_IceGrid_LoadBalancingPolicy_t"]

IceGrid/LoadBalancingPolicy_forward.py

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

IceGrid/LoadInfo.py

@@ -0,0 +1,43 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from dataclasses import dataclass
+
+
+@dataclass
+class LoadInfo:
+    """
+    Information about the load of a node.
+    
+    Attributes
+    ----------
+    avg1 : float
+        The load average over the past minute.
+    avg5 : float
+        The load average over the past 5 minutes.
+    avg15 : float
+        The load average over the past 15 minutes.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice struct ``::IceGrid::LoadInfo``.
+    """
+    avg1: float = 0.0
+    avg5: float = 0.0
+    avg15: float = 0.0
+
+_IceGrid_LoadInfo_t = IcePy.defineStruct(
+    "::IceGrid::LoadInfo",
+    LoadInfo,
+    (),
+    (
+        ("avg1", (), IcePy._t_float),
+        ("avg5", (), IcePy._t_float),
+        ("avg15", (), IcePy._t_float)
+    ))
+
+__all__ = ["LoadInfo", "_IceGrid_LoadInfo_t"]