wallaroo.records.v1_metric_response

  1# To use this code, make sure you
  2#
  3#     import json
  4#
  5# and then, to convert JSON from a string, do
  6#
  7#     result = wallaroo_telemetry_metric_query_v1_from_dict(json.loads(json_string))
  8
  9from enum import Enum
 10from typing import Any, Callable, List, Optional, Type, TypeVar, cast
 11
 12T = TypeVar("T")
 13EnumT = TypeVar("EnumT", bound=Enum)
 14
 15
 16def from_str(x: Any) -> str:
 17    assert isinstance(x, str)
 18    return x
 19
 20
 21def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
 22    assert isinstance(x, list)
 23    return [f(y) for y in x]
 24
 25
 26def from_int(x: Any) -> int:
 27    assert isinstance(x, int) and not isinstance(x, bool)
 28    return x
 29
 30
 31def from_none(x: Any) -> Any:
 32    assert x is None
 33    return x
 34
 35
 36def from_union(fs, x):
 37    for f in fs:
 38        try:
 39            return f(x)
 40        except:
 41            pass
 42    assert False
 43
 44
 45def to_class(c: Type[T], x: Any) -> dict:
 46    assert isinstance(x, c)
 47    return cast(Any, x).to_dict()
 48
 49
 50def to_enum(c: Type[EnumT], x: Any) -> EnumT:
 51    assert isinstance(x, c)
 52    return x.value
 53
 54
 55class MetricQuery:
 56    """The alias for this query. Used for grouping metric results together"""
 57
 58    alias: str
 59    """The prometheus query to run"""
 60    query: str
 61
 62    def __init__(self, alias: str, query: str) -> None:
 63        self.alias = alias
 64        self.query = query
 65
 66    @staticmethod
 67    def from_dict(obj: Any) -> "MetricQuery":
 68        assert isinstance(obj, dict)
 69        alias = from_str(obj.get("alias"))
 70        query = from_str(obj.get("query"))
 71        return MetricQuery(alias, query)
 72
 73    def to_dict(self) -> dict:
 74        result: dict = {}
 75        result["alias"] = from_str(self.alias)
 76        result["query"] = from_str(self.query)
 77        return result
 78
 79
 80class QueryType(Enum):
 81    DAILY = "daily"
 82    INTERVAL = "interval"
 83
 84
 85class WallarooTelemetryMetricQueryV1:
 86    metrics: List[MetricQuery]
 87    query_type: QueryType
 88    """Post metrics on this minute, 0 is every minute."""
 89    run_on_minute: Optional[int]
 90
 91    def __init__(
 92        self,
 93        metrics: List[MetricQuery],
 94        query_type: QueryType,
 95        run_on_minute: Optional[int],
 96    ) -> None:
 97        self.metrics = metrics
 98        self.query_type = query_type
 99        self.run_on_minute = run_on_minute
100
101    @staticmethod
102    def from_dict(obj: Any) -> "WallarooTelemetryMetricQueryV1":
103        assert isinstance(obj, dict)
104        metrics = from_list(MetricQuery.from_dict, obj.get("metrics"))
105        query_type = QueryType(obj.get("query-type"))
106        run_on_minute = from_union([from_int, from_none], obj.get("runOnMinute"))
107        return WallarooTelemetryMetricQueryV1(metrics, query_type, run_on_minute)
108
109    def to_dict(self) -> dict:
110        result: dict = {}
111        result["metrics"] = from_list(lambda x: to_class(MetricQuery, x), self.metrics)
112        result["query-type"] = to_enum(QueryType, self.query_type)
113        result["runOnMinute"] = from_union([from_int, from_none], self.run_on_minute)
114        return result
115
116
117def wallaroo_telemetry_metric_query_v1_from_dict(
118    s: Any,
119) -> WallarooTelemetryMetricQueryV1:
120    return WallarooTelemetryMetricQueryV1.from_dict(s)
121
122
123def wallaroo_telemetry_metric_query_v1_to_dict(
124    x: WallarooTelemetryMetricQueryV1,
125) -> Any:
126    return to_class(WallarooTelemetryMetricQueryV1, x)
def from_str(x: Any) -> str:
17def from_str(x: Any) -> str:
18    assert isinstance(x, str)
19    return x
def from_list(f: Callable[[Any], ~T], x: Any) -> List[~T]:
22def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
23    assert isinstance(x, list)
24    return [f(y) for y in x]
def from_int(x: Any) -> int:
27def from_int(x: Any) -> int:
28    assert isinstance(x, int) and not isinstance(x, bool)
29    return x
def from_none(x: Any) -> Any:
32def from_none(x: Any) -> Any:
33    assert x is None
34    return x
def from_union(fs, x):
37def from_union(fs, x):
38    for f in fs:
39        try:
40            return f(x)
41        except:
42            pass
43    assert False
def to_class(c: Type[~T], x: Any) -> dict:
46def to_class(c: Type[T], x: Any) -> dict:
47    assert isinstance(x, c)
48    return cast(Any, x).to_dict()
def to_enum(c: Type[~EnumT], x: Any) -> ~EnumT:
51def to_enum(c: Type[EnumT], x: Any) -> EnumT:
52    assert isinstance(x, c)
53    return x.value
class MetricQuery:
56class MetricQuery:
57    """The alias for this query. Used for grouping metric results together"""
58
59    alias: str
60    """The prometheus query to run"""
61    query: str
62
63    def __init__(self, alias: str, query: str) -> None:
64        self.alias = alias
65        self.query = query
66
67    @staticmethod
68    def from_dict(obj: Any) -> "MetricQuery":
69        assert isinstance(obj, dict)
70        alias = from_str(obj.get("alias"))
71        query = from_str(obj.get("query"))
72        return MetricQuery(alias, query)
73
74    def to_dict(self) -> dict:
75        result: dict = {}
76        result["alias"] = from_str(self.alias)
77        result["query"] = from_str(self.query)
78        return result

The alias for this query. Used for grouping metric results together

MetricQuery(alias: str, query: str)
63    def __init__(self, alias: str, query: str) -> None:
64        self.alias = alias
65        self.query = query
alias: str

The prometheus query to run

@staticmethod
def from_dict(obj: Any) -> wallaroo.records.v1_metric_response.MetricQuery:
67    @staticmethod
68    def from_dict(obj: Any) -> "MetricQuery":
69        assert isinstance(obj, dict)
70        alias = from_str(obj.get("alias"))
71        query = from_str(obj.get("query"))
72        return MetricQuery(alias, query)
def to_dict(self) -> dict:
74    def to_dict(self) -> dict:
75        result: dict = {}
76        result["alias"] = from_str(self.alias)
77        result["query"] = from_str(self.query)
78        return result
class QueryType(enum.Enum):
81class QueryType(Enum):
82    DAILY = "daily"
83    INTERVAL = "interval"

An enumeration.

DAILY = <QueryType.DAILY: 'daily'>
INTERVAL = <QueryType.INTERVAL: 'interval'>
Inherited Members
enum.Enum
name
value
class WallarooTelemetryMetricQueryV1:
 86class WallarooTelemetryMetricQueryV1:
 87    metrics: List[MetricQuery]
 88    query_type: QueryType
 89    """Post metrics on this minute, 0 is every minute."""
 90    run_on_minute: Optional[int]
 91
 92    def __init__(
 93        self,
 94        metrics: List[MetricQuery],
 95        query_type: QueryType,
 96        run_on_minute: Optional[int],
 97    ) -> None:
 98        self.metrics = metrics
 99        self.query_type = query_type
100        self.run_on_minute = run_on_minute
101
102    @staticmethod
103    def from_dict(obj: Any) -> "WallarooTelemetryMetricQueryV1":
104        assert isinstance(obj, dict)
105        metrics = from_list(MetricQuery.from_dict, obj.get("metrics"))
106        query_type = QueryType(obj.get("query-type"))
107        run_on_minute = from_union([from_int, from_none], obj.get("runOnMinute"))
108        return WallarooTelemetryMetricQueryV1(metrics, query_type, run_on_minute)
109
110    def to_dict(self) -> dict:
111        result: dict = {}
112        result["metrics"] = from_list(lambda x: to_class(MetricQuery, x), self.metrics)
113        result["query-type"] = to_enum(QueryType, self.query_type)
114        result["runOnMinute"] = from_union([from_int, from_none], self.run_on_minute)
115        return result
WallarooTelemetryMetricQueryV1( metrics: List[wallaroo.records.v1_metric_response.MetricQuery], query_type: wallaroo.records.v1_metric_response.QueryType, run_on_minute: Optional[int])
 92    def __init__(
 93        self,
 94        metrics: List[MetricQuery],
 95        query_type: QueryType,
 96        run_on_minute: Optional[int],
 97    ) -> None:
 98        self.metrics = metrics
 99        self.query_type = query_type
100        self.run_on_minute = run_on_minute

Post metrics on this minute, 0 is every minute.

@staticmethod
def from_dict( obj: Any) -> wallaroo.records.v1_metric_response.WallarooTelemetryMetricQueryV1:
102    @staticmethod
103    def from_dict(obj: Any) -> "WallarooTelemetryMetricQueryV1":
104        assert isinstance(obj, dict)
105        metrics = from_list(MetricQuery.from_dict, obj.get("metrics"))
106        query_type = QueryType(obj.get("query-type"))
107        run_on_minute = from_union([from_int, from_none], obj.get("runOnMinute"))
108        return WallarooTelemetryMetricQueryV1(metrics, query_type, run_on_minute)
def to_dict(self) -> dict:
110    def to_dict(self) -> dict:
111        result: dict = {}
112        result["metrics"] = from_list(lambda x: to_class(MetricQuery, x), self.metrics)
113        result["query-type"] = to_enum(QueryType, self.query_type)
114        result["runOnMinute"] = from_union([from_int, from_none], self.run_on_minute)
115        return result
def wallaroo_telemetry_metric_query_v1_from_dict( s: Any) -> wallaroo.records.v1_metric_response.WallarooTelemetryMetricQueryV1:
118def wallaroo_telemetry_metric_query_v1_from_dict(
119    s: Any,
120) -> WallarooTelemetryMetricQueryV1:
121    return WallarooTelemetryMetricQueryV1.from_dict(s)
def wallaroo_telemetry_metric_query_v1_to_dict( x: wallaroo.records.v1_metric_response.WallarooTelemetryMetricQueryV1) -> Any:
124def wallaroo_telemetry_metric_query_v1_to_dict(
125    x: WallarooTelemetryMetricQueryV1,
126) -> Any:
127    return to_class(WallarooTelemetryMetricQueryV1, x)