zeroc-ice 3.8.0__cp312-cp312-macosx_10_13_universal2.whl

IceMX/CollocatedMetrics.py

@@ -0,0 +1,42 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceMX.ChildInvocationMetrics import ChildInvocationMetrics
+
+from IceMX.ChildInvocationMetrics_forward import _IceMX_ChildInvocationMetrics_t
+
+from IceMX.CollocatedMetrics_forward import _IceMX_CollocatedMetrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class CollocatedMetrics(ChildInvocationMetrics):
+    """
+    Provides information on invocations that are collocated. Collocated metrics are embedded within
+    :class:`IceMX.InvocationMetrics`.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::CollocatedMetrics``.
+    """
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::CollocatedMetrics"
+
+_IceMX_CollocatedMetrics_t = IcePy.defineValue(
+    "::IceMX::CollocatedMetrics",
+    CollocatedMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_ChildInvocationMetrics_t,
+    ())
+
+setattr(CollocatedMetrics, '_ice_type', _IceMX_CollocatedMetrics_t)
+
+__all__ = ["CollocatedMetrics", "_IceMX_CollocatedMetrics_t"]

IceMX/CollocatedMetrics_forward.py

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

IceMX/ConnectionMetrics.py

@@ -0,0 +1,53 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceMX.ConnectionMetrics_forward import _IceMX_ConnectionMetrics_t
+
+from IceMX.Metrics import Metrics
+
+from IceMX.Metrics_forward import _IceMX_Metrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class ConnectionMetrics(Metrics):
+    """
+    Provides information on the data sent and received over Ice connections.
+    
+    Attributes
+    ----------
+    receivedBytes : int
+        The number of bytes received by the connection.
+    sentBytes : int
+        The number of bytes sent by the connection.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::ConnectionMetrics``.
+    """
+    receivedBytes: int = 0
+    sentBytes: int = 0
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::ConnectionMetrics"
+
+_IceMX_ConnectionMetrics_t = IcePy.defineValue(
+    "::IceMX::ConnectionMetrics",
+    ConnectionMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_Metrics_t,
+    (
+        ("receivedBytes", (), IcePy._t_long, False, 0),
+        ("sentBytes", (), IcePy._t_long, False, 0)
+    ))
+
+setattr(ConnectionMetrics, '_ice_type', _IceMX_ConnectionMetrics_t)
+
+__all__ = ["ConnectionMetrics", "_IceMX_ConnectionMetrics_t"]

IceMX/ConnectionMetrics_forward.py

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

IceMX/DispatchMetrics.py

@@ -0,0 +1,57 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceMX.DispatchMetrics_forward import _IceMX_DispatchMetrics_t
+
+from IceMX.Metrics import Metrics
+
+from IceMX.Metrics_forward import _IceMX_Metrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class DispatchMetrics(Metrics):
+    """
+    Provides information on servant dispatches.
+    
+    Attributes
+    ----------
+    userException : int
+        The number of dispatches that failed with a user exception.
+    size : int
+        The size of the incoming requests. This corresponds to the size of the marshaled input parameters.
+    replySize : int
+        The size of the replies. This corresponds to the size of the marshaled output and return parameters.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::DispatchMetrics``.
+    """
+    userException: int = 0
+    size: int = 0
+    replySize: int = 0
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::DispatchMetrics"
+
+_IceMX_DispatchMetrics_t = IcePy.defineValue(
+    "::IceMX::DispatchMetrics",
+    DispatchMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_Metrics_t,
+    (
+        ("userException", (), IcePy._t_int, False, 0),
+        ("size", (), IcePy._t_long, False, 0),
+        ("replySize", (), IcePy._t_long, False, 0)
+    ))
+
+setattr(DispatchMetrics, '_ice_type', _IceMX_DispatchMetrics_t)
+
+__all__ = ["DispatchMetrics", "_IceMX_DispatchMetrics_t"]

IceMX/DispatchMetrics_forward.py

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

IceMX/InvocationMetrics.py

@@ -0,0 +1,66 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceMX.InvocationMetrics_forward import _IceMX_InvocationMetrics_t
+
+from IceMX.Metrics import Metrics
+
+from IceMX.MetricsMap import _IceMX_MetricsMap_t
+
+from IceMX.Metrics_forward import _IceMX_Metrics_t
+
+from dataclasses import dataclass
+from dataclasses import field
+
+from typing import TYPE_CHECKING
+
+@dataclass(eq=False)
+class InvocationMetrics(Metrics):
+    """
+    Provide measurements for proxy invocations. Proxy invocations can either be sent over the wire or be collocated.
+    
+    Attributes
+    ----------
+    retry : int
+        The number of retries for the invocations.
+    userException : int
+        The number of invocations that failed with a user exception.
+    remotes : list[Metrics | None]
+        The remote invocation metrics map.
+    collocated : list[Metrics | None]
+        The collocated invocation metrics map.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::InvocationMetrics``.
+    """
+    retry: int = 0
+    userException: int = 0
+    remotes: list[Metrics | None] = field(default_factory=list)
+    collocated: list[Metrics | None] = field(default_factory=list)
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::InvocationMetrics"
+
+_IceMX_InvocationMetrics_t = IcePy.defineValue(
+    "::IceMX::InvocationMetrics",
+    InvocationMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_Metrics_t,
+    (
+        ("retry", (), IcePy._t_int, False, 0),
+        ("userException", (), IcePy._t_int, False, 0),
+        ("remotes", (), _IceMX_MetricsMap_t, False, 0),
+        ("collocated", (), _IceMX_MetricsMap_t, False, 0)
+    ))
+
+setattr(InvocationMetrics, '_ice_type', _IceMX_InvocationMetrics_t)
+
+__all__ = ["InvocationMetrics", "_IceMX_InvocationMetrics_t"]

IceMX/InvocationMetrics_forward.py

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

IceMX/Metrics.py

@@ -0,0 +1,66 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from Ice.Value import Value
+
+from IceMX.Metrics_forward import _IceMX_Metrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class Metrics(Value):
+    """
+    The base class for metrics. A metrics object represents a collection of measurements associated to a given a
+    system.
+    
+    Attributes
+    ----------
+    id : str
+        The metrics identifier.
+    total : int
+        The total number of objects observed by this metrics. This includes the number of currently observed objects
+        and the number of objects observed in the past.
+    current : int
+        The number of objects currently observed by this metrics.
+    totalLifetime : int
+        The sum of the lifetime of each observed objects. This does not include the lifetime of objects which are
+        currently observed, only the objects observed in the past.
+    failures : int
+        The number of failures observed.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::Metrics``.
+    """
+    id: str = ""
+    total: int = 0
+    current: int = 0
+    totalLifetime: int = 0
+    failures: int = 0
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::Metrics"
+
+_IceMX_Metrics_t = IcePy.defineValue(
+    "::IceMX::Metrics",
+    Metrics,
+    -1,
+    (),
+    False,
+    None,
+    (
+        ("id", (), IcePy._t_string, False, 0),
+        ("total", (), IcePy._t_long, False, 0),
+        ("current", (), IcePy._t_int, False, 0),
+        ("totalLifetime", (), IcePy._t_long, False, 0),
+        ("failures", (), IcePy._t_int, False, 0)
+    ))
+
+setattr(Metrics, '_ice_type', _IceMX_Metrics_t)
+
+__all__ = ["Metrics", "_IceMX_Metrics_t"]