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

IceMX/RemoteMetrics.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.RemoteMetrics_forward import _IceMX_RemoteMetrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class RemoteMetrics(ChildInvocationMetrics):
+    """
+    Provides information on invocations that are specifically sent over Ice connections. Remote metrics are embedded
+    within :class:`IceMX.InvocationMetrics`.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::RemoteMetrics``.
+    """
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::RemoteMetrics"
+
+_IceMX_RemoteMetrics_t = IcePy.defineValue(
+    "::IceMX::RemoteMetrics",
+    RemoteMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_ChildInvocationMetrics_t,
+    ())
+
+setattr(RemoteMetrics, '_ice_type', _IceMX_RemoteMetrics_t)
+
+__all__ = ["RemoteMetrics", "_IceMX_RemoteMetrics_t"]

IceMX/RemoteMetrics_forward.py

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

IceMX/SessionMetrics.py

@@ -0,0 +1,73 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceMX.Metrics import Metrics
+
+from IceMX.Metrics_forward import _IceMX_Metrics_t
+
+from IceMX.SessionMetrics_forward import _IceMX_SessionMetrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class SessionMetrics(Metrics):
+    """
+    Provides information about Glacier2 sessions.
+    
+    Attributes
+    ----------
+    forwardedClient : int
+        The number of client requests forwarded.
+    forwardedServer : int
+        The number of server requests forwarded.
+    routingTableSize : int
+        The size of the routing table.
+    queuedClient : int
+        The number of client requests queued.
+    queuedServer : int
+        The number of server requests queued.
+    overriddenClient : int
+        The number of client requests overridden.
+    overriddenServer : int
+        The number of server requests overridden.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::SessionMetrics``.
+    """
+    forwardedClient: int = 0
+    forwardedServer: int = 0
+    routingTableSize: int = 0
+    queuedClient: int = 0
+    queuedServer: int = 0
+    overriddenClient: int = 0
+    overriddenServer: int = 0
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::SessionMetrics"
+
+_IceMX_SessionMetrics_t = IcePy.defineValue(
+    "::IceMX::SessionMetrics",
+    SessionMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_Metrics_t,
+    (
+        ("forwardedClient", (), IcePy._t_int, False, 0),
+        ("forwardedServer", (), IcePy._t_int, False, 0),
+        ("routingTableSize", (), IcePy._t_int, False, 0),
+        ("queuedClient", (), IcePy._t_int, False, 0),
+        ("queuedServer", (), IcePy._t_int, False, 0),
+        ("overriddenClient", (), IcePy._t_int, False, 0),
+        ("overriddenServer", (), IcePy._t_int, False, 0)
+    ))
+
+setattr(SessionMetrics, '_ice_type', _IceMX_SessionMetrics_t)
+
+__all__ = ["SessionMetrics", "_IceMX_SessionMetrics_t"]

IceMX/SessionMetrics_forward.py

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

IceMX/StringIntDict.py

@@ -0,0 +1,10 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+_IceMX_StringIntDict_t = IcePy.defineDictionary("::IceMX::StringIntDict", (), IcePy._t_string, IcePy._t_int)
+
+__all__ = ["_IceMX_StringIntDict_t"]

IceMX/SubscriberMetrics.py

@@ -0,0 +1,57 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceMX.Metrics import Metrics
+
+from IceMX.Metrics_forward import _IceMX_Metrics_t
+
+from IceMX.SubscriberMetrics_forward import _IceMX_SubscriberMetrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class SubscriberMetrics(Metrics):
+    """
+    Provides information about IceStorm subscribers.
+    
+    Attributes
+    ----------
+    queued : int
+        The number of queued events.
+    outstanding : int
+        The number of outstanding events.
+    delivered : int
+        The number of forwarded events.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::SubscriberMetrics``.
+    """
+    queued: int = 0
+    outstanding: int = 0
+    delivered: int = 0
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::SubscriberMetrics"
+
+_IceMX_SubscriberMetrics_t = IcePy.defineValue(
+    "::IceMX::SubscriberMetrics",
+    SubscriberMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_Metrics_t,
+    (
+        ("queued", (), IcePy._t_int, False, 0),
+        ("outstanding", (), IcePy._t_int, False, 0),
+        ("delivered", (), IcePy._t_long, False, 0)
+    ))
+
+setattr(SubscriberMetrics, '_ice_type', _IceMX_SubscriberMetrics_t)
+
+__all__ = ["SubscriberMetrics", "_IceMX_SubscriberMetrics_t"]

IceMX/SubscriberMetrics_forward.py

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

IceMX/ThreadMetrics.py

@@ -0,0 +1,59 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceMX.Metrics import Metrics
+
+from IceMX.Metrics_forward import _IceMX_Metrics_t
+
+from IceMX.ThreadMetrics_forward import _IceMX_ThreadMetrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class ThreadMetrics(Metrics):
+    """
+    Provides information on the number of threads currently in use and their activity.
+    
+    Attributes
+    ----------
+    inUseForIO : int
+        The number of threads which are currently performing socket reads or writes.
+    inUseForUser : int
+        The number of threads which are currently calling user code (servant dispatch, AMI callbacks, etc).
+    inUseForOther : int
+        The number of threads which are currently performing other activities such as DNS lookups, garbage
+        collection, etc. These are all the other threads created by the Ice runtime that are not counted in
+        :class:`IceMX.ThreadMetrics.inUseForUser` or :class:`IceMX.ThreadMetrics.inUseForIO`.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::ThreadMetrics``.
+    """
+    inUseForIO: int = 0
+    inUseForUser: int = 0
+    inUseForOther: int = 0
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::ThreadMetrics"
+
+_IceMX_ThreadMetrics_t = IcePy.defineValue(
+    "::IceMX::ThreadMetrics",
+    ThreadMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_Metrics_t,
+    (
+        ("inUseForIO", (), IcePy._t_int, False, 0),
+        ("inUseForUser", (), IcePy._t_int, False, 0),
+        ("inUseForOther", (), IcePy._t_int, False, 0)
+    ))
+
+setattr(ThreadMetrics, '_ice_type', _IceMX_ThreadMetrics_t)
+
+__all__ = ["ThreadMetrics", "_IceMX_ThreadMetrics_t"]

IceMX/ThreadMetrics_forward.py

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

IceMX/TopicMetrics.py

@@ -0,0 +1,53 @@
+# Copyright (c) ZeroC, Inc.
+
+# slice2py version 3.8.0
+
+from __future__ import annotations
+import IcePy
+
+from IceMX.Metrics import Metrics
+
+from IceMX.Metrics_forward import _IceMX_Metrics_t
+
+from IceMX.TopicMetrics_forward import _IceMX_TopicMetrics_t
+
+from dataclasses import dataclass
+
+@dataclass(eq=False)
+class TopicMetrics(Metrics):
+    """
+    Provides information about one or more IceStorm topics.
+    
+    Attributes
+    ----------
+    published : int
+        The number of events published on the topic(s) by publishers.
+    forwarded : int
+        The number of events forwarded on the topic(s) by IceStorm topic links.
+    
+    Notes
+    -----
+        The Slice compiler generated this dataclass from Slice class ``::IceMX::TopicMetrics``.
+    """
+    published: int = 0
+    forwarded: int = 0
+
+    @staticmethod
+    def ice_staticId() -> str:
+        return "::IceMX::TopicMetrics"
+
+_IceMX_TopicMetrics_t = IcePy.defineValue(
+    "::IceMX::TopicMetrics",
+    TopicMetrics,
+    -1,
+    (),
+    False,
+    _IceMX_Metrics_t,
+    (
+        ("published", (), IcePy._t_long, False, 0),
+        ("forwarded", (), IcePy._t_long, False, 0)
+    ))
+
+setattr(TopicMetrics, '_ice_type', _IceMX_TopicMetrics_t)
+
+__all__ = ["TopicMetrics", "_IceMX_TopicMetrics_t"]

IceMX/TopicMetrics_forward.py

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

IceMX/UnknownMetricsView.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 UnknownMetricsView(UserException):
+    """
+    The exception that is thrown when a metrics view cannot be found.
+    
+    Notes
+    -----
+        The Slice compiler generated this exception dataclass from Slice exception ``::IceMX::UnknownMetricsView``.
+    """
+
+    _ice_id = "::IceMX::UnknownMetricsView"
+
+_IceMX_UnknownMetricsView_t = IcePy.defineException(
+    "::IceMX::UnknownMetricsView",
+    UnknownMetricsView,
+    (),
+    None,
+    ())
+
+setattr(UnknownMetricsView, '_ice_type', _IceMX_UnknownMetricsView_t)
+
+__all__ = ["UnknownMetricsView", "_IceMX_UnknownMetricsView_t"]

IceMX/__init__.py

@@ -1,12 +1,75 @@
-# Generated by slice2py - DO NOT EDIT!
-#
 
-import Ice
-Ice.updateModule("IceMX")
+# Copyright (c) ZeroC, Inc.
 
-# Modules:
-import Glacier2.Metrics_ice
-import Ice.Metrics_ice
-import IceStorm.Metrics_ice
+# slice2py version 3.8.0
 
-# Submodules:
+from .ChildInvocationMetrics import ChildInvocationMetrics
+from .ChildInvocationMetrics_forward import _IceMX_ChildInvocationMetrics_t
+from .CollocatedMetrics import CollocatedMetrics
+from .CollocatedMetrics_forward import _IceMX_CollocatedMetrics_t
+from .ConnectionMetrics import ConnectionMetrics
+from .ConnectionMetrics_forward import _IceMX_ConnectionMetrics_t
+from .DispatchMetrics import DispatchMetrics
+from .DispatchMetrics_forward import _IceMX_DispatchMetrics_t
+from .InvocationMetrics import InvocationMetrics
+from .InvocationMetrics_forward import _IceMX_InvocationMetrics_t
+from .Metrics import Metrics
+from .MetricsAdmin import MetricsAdmin
+from .MetricsAdmin import MetricsAdminPrx
+from .MetricsAdmin_forward import _IceMX_MetricsAdminPrx_t
+from .MetricsFailures import MetricsFailures
+from .MetricsFailures import _IceMX_MetricsFailures_t
+from .MetricsFailuresSeq import _IceMX_MetricsFailuresSeq_t
+from .MetricsMap import _IceMX_MetricsMap_t
+from .MetricsView import _IceMX_MetricsView_t
+from .Metrics_forward import _IceMX_Metrics_t
+from .RemoteMetrics import RemoteMetrics
+from .RemoteMetrics_forward import _IceMX_RemoteMetrics_t
+from .SessionMetrics import SessionMetrics
+from .SessionMetrics_forward import _IceMX_SessionMetrics_t
+from .StringIntDict import _IceMX_StringIntDict_t
+from .SubscriberMetrics import SubscriberMetrics
+from .SubscriberMetrics_forward import _IceMX_SubscriberMetrics_t
+from .ThreadMetrics import ThreadMetrics
+from .ThreadMetrics_forward import _IceMX_ThreadMetrics_t
+from .TopicMetrics import TopicMetrics
+from .TopicMetrics_forward import _IceMX_TopicMetrics_t
+from .UnknownMetricsView import UnknownMetricsView
+from .UnknownMetricsView import _IceMX_UnknownMetricsView_t
+
+
+__all__ = [
+    "ChildInvocationMetrics",
+    "_IceMX_ChildInvocationMetrics_t",
+    "CollocatedMetrics",
+    "_IceMX_CollocatedMetrics_t",
+    "ConnectionMetrics",
+    "_IceMX_ConnectionMetrics_t",
+    "DispatchMetrics",
+    "_IceMX_DispatchMetrics_t",
+    "InvocationMetrics",
+    "_IceMX_InvocationMetrics_t",
+    "Metrics",
+    "MetricsAdmin",
+    "MetricsAdminPrx",
+    "_IceMX_MetricsAdminPrx_t",
+    "MetricsFailures",
+    "_IceMX_MetricsFailures_t",
+    "_IceMX_MetricsFailuresSeq_t",
+    "_IceMX_MetricsMap_t",
+    "_IceMX_MetricsView_t",
+    "_IceMX_Metrics_t",
+    "RemoteMetrics",
+    "_IceMX_RemoteMetrics_t",
+    "SessionMetrics",
+    "_IceMX_SessionMetrics_t",
+    "_IceMX_StringIntDict_t",
+    "SubscriberMetrics",
+    "_IceMX_SubscriberMetrics_t",
+    "ThreadMetrics",
+    "_IceMX_ThreadMetrics_t",
+    "TopicMetrics",
+    "_IceMX_TopicMetrics_t",
+    "UnknownMetricsView",
+    "_IceMX_UnknownMetricsView_t"
+]