wallaroo.records.convert_keras_model

  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 = convert_keras_model_from_dict(json.loads(json_string))
  8
  9from typing import Any, Callable, List, Optional, Type, TypeVar, cast
 10
 11T = TypeVar("T")
 12
 13
 14def from_bool(x: Any) -> bool:
 15    assert isinstance(x, bool)
 16    return x
 17
 18
 19def from_none(x: Any) -> Any:
 20    assert x is None
 21    return x
 22
 23
 24def from_union(fs, x):
 25    for f in fs:
 26        try:
 27            return f(x)
 28        except:
 29            pass
 30    assert False
 31
 32
 33def from_int(x: Any) -> int:
 34    assert isinstance(x, int) and not isinstance(x, bool)
 35    return x
 36
 37
 38def to_class(c: Type[T], x: Any) -> dict:
 39    assert isinstance(x, c)
 40    return cast(Any, x).to_dict()
 41
 42
 43def from_str(x: Any) -> str:
 44    assert isinstance(x, str)
 45    return x
 46
 47
 48def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
 49    assert isinstance(x, list)
 50    return [f(y) for y in x]
 51
 52
 53class ConvertKerasMutation:
 54    ok: Optional[bool]
 55    model: int
 56
 57    def __init__(self, ok: Optional[bool], model: int) -> None:
 58        self.ok = ok
 59        self.model = model
 60
 61    @staticmethod
 62    def from_dict(obj: Any) -> "ConvertKerasMutation":
 63        assert isinstance(obj, dict)
 64        ok = from_union([from_bool, from_none], obj.get("ok"))
 65        model = from_int(obj.get("model"))
 66        return ConvertKerasMutation(ok, model)
 67
 68    def to_dict(self) -> dict:
 69        result: dict = {}
 70        result["ok"] = from_union([from_bool, from_none], self.ok)
 71        result["model"] = from_int(self.model)
 72        return result
 73
 74
 75class Data:
 76    convert_keras: Optional[ConvertKerasMutation]
 77
 78    def __init__(self, convert_keras: Optional[ConvertKerasMutation]) -> None:
 79        self.convert_keras = convert_keras
 80
 81    @staticmethod
 82    def from_dict(obj: Any) -> "Data":
 83        assert isinstance(obj, dict)
 84        convert_keras = from_union(
 85            [ConvertKerasMutation.from_dict, from_none], obj.get("convertKeras")
 86        )
 87        return Data(convert_keras)
 88
 89    def to_dict(self) -> dict:
 90        result: dict = {}
 91        result["convertKeras"] = from_union(
 92            [lambda x: to_class(ConvertKerasMutation, x), from_none], self.convert_keras
 93        )
 94        return result
 95
 96
 97class Error:
 98    message: str
 99
100    def __init__(self, message: str) -> None:
101        self.message = message
102
103    @staticmethod
104    def from_dict(obj: Any) -> "Error":
105        assert isinstance(obj, dict)
106        message = from_str(obj.get("message"))
107        return Error(message)
108
109    def to_dict(self) -> dict:
110        result: dict = {}
111        result["message"] = from_str(self.message)
112        return result
113
114
115class ConvertKerasModel:
116    data: Optional[Data]
117    errors: Optional[List[Error]]
118
119    def __init__(self, data: Optional[Data], errors: Optional[List[Error]]) -> None:
120        self.data = data
121        self.errors = errors
122
123    @staticmethod
124    def from_dict(obj: Any) -> "ConvertKerasModel":
125        assert isinstance(obj, dict)
126        data = from_union([Data.from_dict, from_none], obj.get("data"))
127        errors = from_union(
128            [lambda x: from_list(Error.from_dict, x), from_none], obj.get("errors")
129        )
130        return ConvertKerasModel(data, errors)
131
132    def to_dict(self) -> dict:
133        result: dict = {}
134        result["data"] = from_union([lambda x: to_class(Data, x), from_none], self.data)
135        result["errors"] = from_union(
136            [lambda x: from_list(lambda x: to_class(Error, x), x), from_none],
137            self.errors,
138        )
139        return result
140
141
142def convert_keras_model_from_dict(s: Any) -> ConvertKerasModel:
143    return ConvertKerasModel.from_dict(s)
144
145
146def convert_keras_model_to_dict(x: ConvertKerasModel) -> Any:
147    return to_class(ConvertKerasModel, x)
def from_bool(x: Any) -> bool:
15def from_bool(x: Any) -> bool:
16    assert isinstance(x, bool)
17    return x
def from_none(x: Any) -> Any:
20def from_none(x: Any) -> Any:
21    assert x is None
22    return x
def from_union(fs, x):
25def from_union(fs, x):
26    for f in fs:
27        try:
28            return f(x)
29        except:
30            pass
31    assert False
def from_int(x: Any) -> int:
34def from_int(x: Any) -> int:
35    assert isinstance(x, int) and not isinstance(x, bool)
36    return x
def to_class(c: Type[~T], x: Any) -> dict:
39def to_class(c: Type[T], x: Any) -> dict:
40    assert isinstance(x, c)
41    return cast(Any, x).to_dict()
def from_str(x: Any) -> str:
44def from_str(x: Any) -> str:
45    assert isinstance(x, str)
46    return x
def from_list(f: Callable[[Any], ~T], x: Any) -> List[~T]:
49def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
50    assert isinstance(x, list)
51    return [f(y) for y in x]
class ConvertKerasMutation:
54class ConvertKerasMutation:
55    ok: Optional[bool]
56    model: int
57
58    def __init__(self, ok: Optional[bool], model: int) -> None:
59        self.ok = ok
60        self.model = model
61
62    @staticmethod
63    def from_dict(obj: Any) -> "ConvertKerasMutation":
64        assert isinstance(obj, dict)
65        ok = from_union([from_bool, from_none], obj.get("ok"))
66        model = from_int(obj.get("model"))
67        return ConvertKerasMutation(ok, model)
68
69    def to_dict(self) -> dict:
70        result: dict = {}
71        result["ok"] = from_union([from_bool, from_none], self.ok)
72        result["model"] = from_int(self.model)
73        return result
ConvertKerasMutation(ok: Optional[bool], model: int)
58    def __init__(self, ok: Optional[bool], model: int) -> None:
59        self.ok = ok
60        self.model = model
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.convert_keras_model.ConvertKerasMutation:
62    @staticmethod
63    def from_dict(obj: Any) -> "ConvertKerasMutation":
64        assert isinstance(obj, dict)
65        ok = from_union([from_bool, from_none], obj.get("ok"))
66        model = from_int(obj.get("model"))
67        return ConvertKerasMutation(ok, model)
def to_dict(self) -> dict:
69    def to_dict(self) -> dict:
70        result: dict = {}
71        result["ok"] = from_union([from_bool, from_none], self.ok)
72        result["model"] = from_int(self.model)
73        return result
class Data:
76class Data:
77    convert_keras: Optional[ConvertKerasMutation]
78
79    def __init__(self, convert_keras: Optional[ConvertKerasMutation]) -> None:
80        self.convert_keras = convert_keras
81
82    @staticmethod
83    def from_dict(obj: Any) -> "Data":
84        assert isinstance(obj, dict)
85        convert_keras = from_union(
86            [ConvertKerasMutation.from_dict, from_none], obj.get("convertKeras")
87        )
88        return Data(convert_keras)
89
90    def to_dict(self) -> dict:
91        result: dict = {}
92        result["convertKeras"] = from_union(
93            [lambda x: to_class(ConvertKerasMutation, x), from_none], self.convert_keras
94        )
95        return result
Data( convert_keras: Optional[wallaroo.records.convert_keras_model.ConvertKerasMutation])
79    def __init__(self, convert_keras: Optional[ConvertKerasMutation]) -> None:
80        self.convert_keras = convert_keras
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.convert_keras_model.Data:
82    @staticmethod
83    def from_dict(obj: Any) -> "Data":
84        assert isinstance(obj, dict)
85        convert_keras = from_union(
86            [ConvertKerasMutation.from_dict, from_none], obj.get("convertKeras")
87        )
88        return Data(convert_keras)
def to_dict(self) -> dict:
90    def to_dict(self) -> dict:
91        result: dict = {}
92        result["convertKeras"] = from_union(
93            [lambda x: to_class(ConvertKerasMutation, x), from_none], self.convert_keras
94        )
95        return result
class Error:
 98class Error:
 99    message: str
100
101    def __init__(self, message: str) -> None:
102        self.message = message
103
104    @staticmethod
105    def from_dict(obj: Any) -> "Error":
106        assert isinstance(obj, dict)
107        message = from_str(obj.get("message"))
108        return Error(message)
109
110    def to_dict(self) -> dict:
111        result: dict = {}
112        result["message"] = from_str(self.message)
113        return result
Error(message: str)
101    def __init__(self, message: str) -> None:
102        self.message = message
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.convert_keras_model.Error:
104    @staticmethod
105    def from_dict(obj: Any) -> "Error":
106        assert isinstance(obj, dict)
107        message = from_str(obj.get("message"))
108        return Error(message)
def to_dict(self) -> dict:
110    def to_dict(self) -> dict:
111        result: dict = {}
112        result["message"] = from_str(self.message)
113        return result
class ConvertKerasModel:
116class ConvertKerasModel:
117    data: Optional[Data]
118    errors: Optional[List[Error]]
119
120    def __init__(self, data: Optional[Data], errors: Optional[List[Error]]) -> None:
121        self.data = data
122        self.errors = errors
123
124    @staticmethod
125    def from_dict(obj: Any) -> "ConvertKerasModel":
126        assert isinstance(obj, dict)
127        data = from_union([Data.from_dict, from_none], obj.get("data"))
128        errors = from_union(
129            [lambda x: from_list(Error.from_dict, x), from_none], obj.get("errors")
130        )
131        return ConvertKerasModel(data, errors)
132
133    def to_dict(self) -> dict:
134        result: dict = {}
135        result["data"] = from_union([lambda x: to_class(Data, x), from_none], self.data)
136        result["errors"] = from_union(
137            [lambda x: from_list(lambda x: to_class(Error, x), x), from_none],
138            self.errors,
139        )
140        return result
ConvertKerasModel( data: Optional[wallaroo.records.convert_keras_model.Data], errors: Optional[List[wallaroo.records.convert_keras_model.Error]])
120    def __init__(self, data: Optional[Data], errors: Optional[List[Error]]) -> None:
121        self.data = data
122        self.errors = errors
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.convert_keras_model.ConvertKerasModel:
124    @staticmethod
125    def from_dict(obj: Any) -> "ConvertKerasModel":
126        assert isinstance(obj, dict)
127        data = from_union([Data.from_dict, from_none], obj.get("data"))
128        errors = from_union(
129            [lambda x: from_list(Error.from_dict, x), from_none], obj.get("errors")
130        )
131        return ConvertKerasModel(data, errors)
def to_dict(self) -> dict:
133    def to_dict(self) -> dict:
134        result: dict = {}
135        result["data"] = from_union([lambda x: to_class(Data, x), from_none], self.data)
136        result["errors"] = from_union(
137            [lambda x: from_list(lambda x: to_class(Error, x), x), from_none],
138            self.errors,
139        )
140        return result
def convert_keras_model_from_dict(s: Any) -> wallaroo.records.convert_keras_model.ConvertKerasModel:
143def convert_keras_model_from_dict(s: Any) -> ConvertKerasModel:
144    return ConvertKerasModel.from_dict(s)
def convert_keras_model_to_dict(x: wallaroo.records.convert_keras_model.ConvertKerasModel) -> Any:
147def convert_keras_model_to_dict(x: ConvertKerasModel) -> Any:
148    return to_class(ConvertKerasModel, x)