wallaroo.records.telemetry_body

  1# This code parses date/times, so please
  2#
  3#     pip install python-dateutil
  4#
  5# To use this code, make sure you
  6#
  7#     import json
  8#
  9# and then, to convert JSON from a string, do
 10#
 11#     result = wallaroo_api_telemetry_data_v1_from_dict(json.loads(json_string))
 12
 13from datetime import datetime
 14from typing import Any, Callable, List, Type, TypeVar, cast
 15from uuid import UUID
 16
 17import dateutil.parser
 18
 19T = TypeVar("T")
 20
 21
 22def from_int(x: Any) -> int:
 23    assert isinstance(x, int) and not isinstance(x, bool)
 24    return x
 25
 26
 27def to_class(c: Type[T], x: Any) -> dict:
 28    assert isinstance(x, c)
 29    return cast(Any, x).to_dict()
 30
 31
 32def from_str(x: Any) -> str:
 33    assert isinstance(x, str)
 34    return x
 35
 36
 37def from_bool(x: Any) -> bool:
 38    assert isinstance(x, bool)
 39    return x
 40
 41
 42def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
 43    assert isinstance(x, list)
 44    return [f(y) for y in x]
 45
 46
 47def from_datetime(x: Any) -> datetime:
 48    return dateutil.parser.parse(x)
 49
 50
 51class ModelConfigElement:
 52    id: int
 53
 54    def __init__(self, id: int) -> None:
 55        self.id = id
 56
 57    @staticmethod
 58    def from_dict(obj: Any) -> "ModelConfigElement":
 59        assert isinstance(obj, dict)
 60        id = from_int(obj.get("id"))
 61        return ModelConfigElement(id)
 62
 63    def to_dict(self) -> dict:
 64        result: dict = {}
 65        result["id"] = from_int(self.id)
 66        return result
 67
 68
 69class DeploymentModelConfig:
 70    model_config: ModelConfigElement
 71
 72    def __init__(self, model_config: ModelConfigElement) -> None:
 73        self.model_config = model_config
 74
 75    @staticmethod
 76    def from_dict(obj: Any) -> "DeploymentModelConfig":
 77        assert isinstance(obj, dict)
 78        model_config = ModelConfigElement.from_dict(obj.get("model_config"))
 79        return DeploymentModelConfig(model_config)
 80
 81    def to_dict(self) -> dict:
 82        result: dict = {}
 83        result["model_config"] = to_class(ModelConfigElement, self.model_config)
 84        return result
 85
 86
 87class Deployment:
 88    deploy_id: str
 89    deployed: bool
 90    deployment_model_configs: List[DeploymentModelConfig]
 91    id: int
 92
 93    def __init__(
 94        self,
 95        deploy_id: str,
 96        deployed: bool,
 97        deployment_model_configs: List[DeploymentModelConfig],
 98        id: int,
 99    ) -> None:
100        self.deploy_id = deploy_id
101        self.deployed = deployed
102        self.deployment_model_configs = deployment_model_configs
103        self.id = id
104
105    @staticmethod
106    def from_dict(obj: Any) -> "Deployment":
107        assert isinstance(obj, dict)
108        deploy_id = from_str(obj.get("deploy_id"))
109        deployed = from_bool(obj.get("deployed"))
110        deployment_model_configs = from_list(
111            DeploymentModelConfig.from_dict, obj.get("deployment_model_configs")
112        )
113        id = from_int(obj.get("id"))
114        return Deployment(deploy_id, deployed, deployment_model_configs, id)
115
116    def to_dict(self) -> dict:
117        result: dict = {}
118        result["deploy_id"] = from_str(self.deploy_id)
119        result["deployed"] = from_bool(self.deployed)
120        result["deployment_model_configs"] = from_list(
121            lambda x: to_class(DeploymentModelConfig, x), self.deployment_model_configs
122        )
123        result["id"] = from_int(self.id)
124        return result
125
126
127class WelcomeModel:
128    file_name: str
129    id: int
130    model_id: str
131    model_version: UUID
132    updated_at: datetime
133
134    def __init__(
135        self,
136        file_name: str,
137        id: int,
138        model_id: str,
139        model_version: UUID,
140        updated_at: datetime,
141    ) -> None:
142        self.file_name = file_name
143        self.id = id
144        self.model_id = model_id
145        self.model_version = model_version
146        self.updated_at = updated_at
147
148    @staticmethod
149    def from_dict(obj: Any) -> "WelcomeModel":
150        assert isinstance(obj, dict)
151        file_name = from_str(obj.get("file_name"))
152        id = from_int(obj.get("id"))
153        model_id = from_str(obj.get("model_id"))
154        model_version = UUID(obj.get("model_version"))
155        updated_at = from_datetime(obj.get("updated_at"))
156        return WelcomeModel(file_name, id, model_id, model_version, updated_at)
157
158    def to_dict(self) -> dict:
159        result: dict = {}
160        result["file_name"] = from_str(self.file_name)
161        result["id"] = from_int(self.id)
162        result["model_id"] = from_str(self.model_id)
163        result["model_version"] = str(self.model_version)
164        result["updated_at"] = self.updated_at.isoformat()
165        return result
166
167
168class WelcomePipeline:
169    id: int
170    pipeline_tags: List[Any]
171
172    def __init__(self, id: int, pipeline_tags: List[Any]) -> None:
173        self.id = id
174        self.pipeline_tags = pipeline_tags
175
176    @staticmethod
177    def from_dict(obj: Any) -> "WelcomePipeline":
178        assert isinstance(obj, dict)
179        id = from_int(obj.get("id"))
180        pipeline_tags = from_list(lambda x: x, obj.get("pipeline_tags"))
181        return WelcomePipeline(id, pipeline_tags)
182
183    def to_dict(self) -> dict:
184        result: dict = {}
185        result["id"] = from_int(self.id)
186        result["pipeline_tags"] = from_list(lambda x: x, self.pipeline_tags)
187        return result
188
189
190class WorkspaceModel:
191    models: List[ModelConfigElement]
192
193    def __init__(self, models: List[ModelConfigElement]) -> None:
194        self.models = models
195
196    @staticmethod
197    def from_dict(obj: Any) -> "WorkspaceModel":
198        assert isinstance(obj, dict)
199        models = from_list(ModelConfigElement.from_dict, obj.get("models"))
200        return WorkspaceModel(models)
201
202    def to_dict(self) -> dict:
203        result: dict = {}
204        result["models"] = from_list(
205            lambda x: to_class(ModelConfigElement, x), self.models
206        )
207        return result
208
209
210class Workspace:
211    archived: bool
212    created_at: datetime
213    created_by: UUID
214    id: int
215    models: List[WorkspaceModel]
216    name: str
217    pipelines: List[ModelConfigElement]
218
219    def __init__(
220        self,
221        archived: bool,
222        created_at: datetime,
223        created_by: UUID,
224        id: int,
225        models: List[WorkspaceModel],
226        name: str,
227        pipelines: List[ModelConfigElement],
228    ) -> None:
229        self.archived = archived
230        self.created_at = created_at
231        self.created_by = created_by
232        self.id = id
233        self.models = models
234        self.name = name
235        self.pipelines = pipelines
236
237    @staticmethod
238    def from_dict(obj: Any) -> "Workspace":
239        assert isinstance(obj, dict)
240        archived = from_bool(obj.get("archived"))
241        created_at = from_datetime(obj.get("created_at"))
242        created_by = UUID(obj.get("created_by"))
243        id = from_int(obj.get("id"))
244        models = from_list(WorkspaceModel.from_dict, obj.get("models"))
245        name = from_str(obj.get("name"))
246        pipelines = from_list(ModelConfigElement.from_dict, obj.get("pipelines"))
247        return Workspace(archived, created_at, created_by, id, models, name, pipelines)
248
249    def to_dict(self) -> dict:
250        result: dict = {}
251        result["archived"] = from_bool(self.archived)
252        result["created_at"] = self.created_at.isoformat()
253        result["created_by"] = str(self.created_by)
254        result["id"] = from_int(self.id)
255        result["models"] = from_list(lambda x: to_class(WorkspaceModel, x), self.models)
256        result["name"] = from_str(self.name)
257        result["pipelines"] = from_list(
258            lambda x: to_class(ModelConfigElement, x), self.pipelines
259        )
260        return result
261
262
263class WallarooAPITelemetryDataV1:
264    api_key: str
265    deployments: List[Deployment]
266    models: List[WelcomeModel]
267    pipelines: List[WelcomePipeline]
268    users: int
269    workspaces: List[Workspace]
270
271    def __init__(
272        self,
273        api_key: str,
274        deployments: List[Deployment],
275        models: List[WelcomeModel],
276        pipelines: List[WelcomePipeline],
277        users: int,
278        workspaces: List[Workspace],
279    ) -> None:
280        self.api_key = api_key
281        self.deployments = deployments
282        self.models = models
283        self.pipelines = pipelines
284        self.users = users
285        self.workspaces = workspaces
286
287    @staticmethod
288    def from_dict(obj: Any) -> "WallarooAPITelemetryDataV1":
289        assert isinstance(obj, dict)
290        api_key = from_str(obj.get("api_key"))
291        deployments = from_list(Deployment.from_dict, obj.get("deployments"))
292        models = from_list(WelcomeModel.from_dict, obj.get("models"))
293        pipelines = from_list(WelcomePipeline.from_dict, obj.get("pipelines"))
294        users = from_int(obj.get("users"))
295        workspaces = from_list(Workspace.from_dict, obj.get("workspaces"))
296        return WallarooAPITelemetryDataV1(
297            api_key, deployments, models, pipelines, users, workspaces
298        )
299
300    def to_dict(self) -> dict:
301        result: dict = {}
302        result["api_key"] = from_str(self.api_key)
303        result["deployments"] = from_list(
304            lambda x: to_class(Deployment, x), self.deployments
305        )
306        result["models"] = from_list(lambda x: to_class(WelcomeModel, x), self.models)
307        result["pipelines"] = from_list(
308            lambda x: to_class(WelcomePipeline, x), self.pipelines
309        )
310        result["users"] = from_int(self.users)
311        result["workspaces"] = from_list(
312            lambda x: to_class(Workspace, x), self.workspaces
313        )
314        return result
315
316
317def wallaroo_api_telemetry_data_v1_from_dict(s: Any) -> WallarooAPITelemetryDataV1:
318    return WallarooAPITelemetryDataV1.from_dict(s)
319
320
321def wallaroo_api_telemetry_data_v1_to_dict(x: WallarooAPITelemetryDataV1) -> Any:
322    return to_class(WallarooAPITelemetryDataV1, x)
def from_int(x: Any) -> int:
23def from_int(x: Any) -> int:
24    assert isinstance(x, int) and not isinstance(x, bool)
25    return x
def to_class(c: Type[~T], x: Any) -> dict:
28def to_class(c: Type[T], x: Any) -> dict:
29    assert isinstance(x, c)
30    return cast(Any, x).to_dict()
def from_str(x: Any) -> str:
33def from_str(x: Any) -> str:
34    assert isinstance(x, str)
35    return x
def from_bool(x: Any) -> bool:
38def from_bool(x: Any) -> bool:
39    assert isinstance(x, bool)
40    return x
def from_list(f: Callable[[Any], ~T], x: Any) -> List[~T]:
43def from_list(f: Callable[[Any], T], x: Any) -> List[T]:
44    assert isinstance(x, list)
45    return [f(y) for y in x]
def from_datetime(x: Any) -> datetime.datetime:
48def from_datetime(x: Any) -> datetime:
49    return dateutil.parser.parse(x)
class ModelConfigElement:
52class ModelConfigElement:
53    id: int
54
55    def __init__(self, id: int) -> None:
56        self.id = id
57
58    @staticmethod
59    def from_dict(obj: Any) -> "ModelConfigElement":
60        assert isinstance(obj, dict)
61        id = from_int(obj.get("id"))
62        return ModelConfigElement(id)
63
64    def to_dict(self) -> dict:
65        result: dict = {}
66        result["id"] = from_int(self.id)
67        return result
ModelConfigElement(id: int)
55    def __init__(self, id: int) -> None:
56        self.id = id
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.telemetry_body.ModelConfigElement:
58    @staticmethod
59    def from_dict(obj: Any) -> "ModelConfigElement":
60        assert isinstance(obj, dict)
61        id = from_int(obj.get("id"))
62        return ModelConfigElement(id)
def to_dict(self) -> dict:
64    def to_dict(self) -> dict:
65        result: dict = {}
66        result["id"] = from_int(self.id)
67        return result
class DeploymentModelConfig:
70class DeploymentModelConfig:
71    model_config: ModelConfigElement
72
73    def __init__(self, model_config: ModelConfigElement) -> None:
74        self.model_config = model_config
75
76    @staticmethod
77    def from_dict(obj: Any) -> "DeploymentModelConfig":
78        assert isinstance(obj, dict)
79        model_config = ModelConfigElement.from_dict(obj.get("model_config"))
80        return DeploymentModelConfig(model_config)
81
82    def to_dict(self) -> dict:
83        result: dict = {}
84        result["model_config"] = to_class(ModelConfigElement, self.model_config)
85        return result
DeploymentModelConfig(model_config: wallaroo.records.telemetry_body.ModelConfigElement)
73    def __init__(self, model_config: ModelConfigElement) -> None:
74        self.model_config = model_config
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.telemetry_body.DeploymentModelConfig:
76    @staticmethod
77    def from_dict(obj: Any) -> "DeploymentModelConfig":
78        assert isinstance(obj, dict)
79        model_config = ModelConfigElement.from_dict(obj.get("model_config"))
80        return DeploymentModelConfig(model_config)
def to_dict(self) -> dict:
82    def to_dict(self) -> dict:
83        result: dict = {}
84        result["model_config"] = to_class(ModelConfigElement, self.model_config)
85        return result
class Deployment:
 88class Deployment:
 89    deploy_id: str
 90    deployed: bool
 91    deployment_model_configs: List[DeploymentModelConfig]
 92    id: int
 93
 94    def __init__(
 95        self,
 96        deploy_id: str,
 97        deployed: bool,
 98        deployment_model_configs: List[DeploymentModelConfig],
 99        id: int,
100    ) -> None:
101        self.deploy_id = deploy_id
102        self.deployed = deployed
103        self.deployment_model_configs = deployment_model_configs
104        self.id = id
105
106    @staticmethod
107    def from_dict(obj: Any) -> "Deployment":
108        assert isinstance(obj, dict)
109        deploy_id = from_str(obj.get("deploy_id"))
110        deployed = from_bool(obj.get("deployed"))
111        deployment_model_configs = from_list(
112            DeploymentModelConfig.from_dict, obj.get("deployment_model_configs")
113        )
114        id = from_int(obj.get("id"))
115        return Deployment(deploy_id, deployed, deployment_model_configs, id)
116
117    def to_dict(self) -> dict:
118        result: dict = {}
119        result["deploy_id"] = from_str(self.deploy_id)
120        result["deployed"] = from_bool(self.deployed)
121        result["deployment_model_configs"] = from_list(
122            lambda x: to_class(DeploymentModelConfig, x), self.deployment_model_configs
123        )
124        result["id"] = from_int(self.id)
125        return result
Deployment( deploy_id: str, deployed: bool, deployment_model_configs: List[wallaroo.records.telemetry_body.DeploymentModelConfig], id: int)
 94    def __init__(
 95        self,
 96        deploy_id: str,
 97        deployed: bool,
 98        deployment_model_configs: List[DeploymentModelConfig],
 99        id: int,
100    ) -> None:
101        self.deploy_id = deploy_id
102        self.deployed = deployed
103        self.deployment_model_configs = deployment_model_configs
104        self.id = id
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.telemetry_body.Deployment:
106    @staticmethod
107    def from_dict(obj: Any) -> "Deployment":
108        assert isinstance(obj, dict)
109        deploy_id = from_str(obj.get("deploy_id"))
110        deployed = from_bool(obj.get("deployed"))
111        deployment_model_configs = from_list(
112            DeploymentModelConfig.from_dict, obj.get("deployment_model_configs")
113        )
114        id = from_int(obj.get("id"))
115        return Deployment(deploy_id, deployed, deployment_model_configs, id)
def to_dict(self) -> dict:
117    def to_dict(self) -> dict:
118        result: dict = {}
119        result["deploy_id"] = from_str(self.deploy_id)
120        result["deployed"] = from_bool(self.deployed)
121        result["deployment_model_configs"] = from_list(
122            lambda x: to_class(DeploymentModelConfig, x), self.deployment_model_configs
123        )
124        result["id"] = from_int(self.id)
125        return result
class WelcomeModel:
128class WelcomeModel:
129    file_name: str
130    id: int
131    model_id: str
132    model_version: UUID
133    updated_at: datetime
134
135    def __init__(
136        self,
137        file_name: str,
138        id: int,
139        model_id: str,
140        model_version: UUID,
141        updated_at: datetime,
142    ) -> None:
143        self.file_name = file_name
144        self.id = id
145        self.model_id = model_id
146        self.model_version = model_version
147        self.updated_at = updated_at
148
149    @staticmethod
150    def from_dict(obj: Any) -> "WelcomeModel":
151        assert isinstance(obj, dict)
152        file_name = from_str(obj.get("file_name"))
153        id = from_int(obj.get("id"))
154        model_id = from_str(obj.get("model_id"))
155        model_version = UUID(obj.get("model_version"))
156        updated_at = from_datetime(obj.get("updated_at"))
157        return WelcomeModel(file_name, id, model_id, model_version, updated_at)
158
159    def to_dict(self) -> dict:
160        result: dict = {}
161        result["file_name"] = from_str(self.file_name)
162        result["id"] = from_int(self.id)
163        result["model_id"] = from_str(self.model_id)
164        result["model_version"] = str(self.model_version)
165        result["updated_at"] = self.updated_at.isoformat()
166        return result
WelcomeModel( file_name: str, id: int, model_id: str, model_version: uuid.UUID, updated_at: datetime.datetime)
135    def __init__(
136        self,
137        file_name: str,
138        id: int,
139        model_id: str,
140        model_version: UUID,
141        updated_at: datetime,
142    ) -> None:
143        self.file_name = file_name
144        self.id = id
145        self.model_id = model_id
146        self.model_version = model_version
147        self.updated_at = updated_at
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.telemetry_body.WelcomeModel:
149    @staticmethod
150    def from_dict(obj: Any) -> "WelcomeModel":
151        assert isinstance(obj, dict)
152        file_name = from_str(obj.get("file_name"))
153        id = from_int(obj.get("id"))
154        model_id = from_str(obj.get("model_id"))
155        model_version = UUID(obj.get("model_version"))
156        updated_at = from_datetime(obj.get("updated_at"))
157        return WelcomeModel(file_name, id, model_id, model_version, updated_at)
def to_dict(self) -> dict:
159    def to_dict(self) -> dict:
160        result: dict = {}
161        result["file_name"] = from_str(self.file_name)
162        result["id"] = from_int(self.id)
163        result["model_id"] = from_str(self.model_id)
164        result["model_version"] = str(self.model_version)
165        result["updated_at"] = self.updated_at.isoformat()
166        return result
class WelcomePipeline:
169class WelcomePipeline:
170    id: int
171    pipeline_tags: List[Any]
172
173    def __init__(self, id: int, pipeline_tags: List[Any]) -> None:
174        self.id = id
175        self.pipeline_tags = pipeline_tags
176
177    @staticmethod
178    def from_dict(obj: Any) -> "WelcomePipeline":
179        assert isinstance(obj, dict)
180        id = from_int(obj.get("id"))
181        pipeline_tags = from_list(lambda x: x, obj.get("pipeline_tags"))
182        return WelcomePipeline(id, pipeline_tags)
183
184    def to_dict(self) -> dict:
185        result: dict = {}
186        result["id"] = from_int(self.id)
187        result["pipeline_tags"] = from_list(lambda x: x, self.pipeline_tags)
188        return result
WelcomePipeline(id: int, pipeline_tags: List[Any])
173    def __init__(self, id: int, pipeline_tags: List[Any]) -> None:
174        self.id = id
175        self.pipeline_tags = pipeline_tags
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.telemetry_body.WelcomePipeline:
177    @staticmethod
178    def from_dict(obj: Any) -> "WelcomePipeline":
179        assert isinstance(obj, dict)
180        id = from_int(obj.get("id"))
181        pipeline_tags = from_list(lambda x: x, obj.get("pipeline_tags"))
182        return WelcomePipeline(id, pipeline_tags)
def to_dict(self) -> dict:
184    def to_dict(self) -> dict:
185        result: dict = {}
186        result["id"] = from_int(self.id)
187        result["pipeline_tags"] = from_list(lambda x: x, self.pipeline_tags)
188        return result
class WorkspaceModel:
191class WorkspaceModel:
192    models: List[ModelConfigElement]
193
194    def __init__(self, models: List[ModelConfigElement]) -> None:
195        self.models = models
196
197    @staticmethod
198    def from_dict(obj: Any) -> "WorkspaceModel":
199        assert isinstance(obj, dict)
200        models = from_list(ModelConfigElement.from_dict, obj.get("models"))
201        return WorkspaceModel(models)
202
203    def to_dict(self) -> dict:
204        result: dict = {}
205        result["models"] = from_list(
206            lambda x: to_class(ModelConfigElement, x), self.models
207        )
208        return result
WorkspaceModel(models: List[wallaroo.records.telemetry_body.ModelConfigElement])
194    def __init__(self, models: List[ModelConfigElement]) -> None:
195        self.models = models
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.telemetry_body.WorkspaceModel:
197    @staticmethod
198    def from_dict(obj: Any) -> "WorkspaceModel":
199        assert isinstance(obj, dict)
200        models = from_list(ModelConfigElement.from_dict, obj.get("models"))
201        return WorkspaceModel(models)
def to_dict(self) -> dict:
203    def to_dict(self) -> dict:
204        result: dict = {}
205        result["models"] = from_list(
206            lambda x: to_class(ModelConfigElement, x), self.models
207        )
208        return result
class Workspace:
211class Workspace:
212    archived: bool
213    created_at: datetime
214    created_by: UUID
215    id: int
216    models: List[WorkspaceModel]
217    name: str
218    pipelines: List[ModelConfigElement]
219
220    def __init__(
221        self,
222        archived: bool,
223        created_at: datetime,
224        created_by: UUID,
225        id: int,
226        models: List[WorkspaceModel],
227        name: str,
228        pipelines: List[ModelConfigElement],
229    ) -> None:
230        self.archived = archived
231        self.created_at = created_at
232        self.created_by = created_by
233        self.id = id
234        self.models = models
235        self.name = name
236        self.pipelines = pipelines
237
238    @staticmethod
239    def from_dict(obj: Any) -> "Workspace":
240        assert isinstance(obj, dict)
241        archived = from_bool(obj.get("archived"))
242        created_at = from_datetime(obj.get("created_at"))
243        created_by = UUID(obj.get("created_by"))
244        id = from_int(obj.get("id"))
245        models = from_list(WorkspaceModel.from_dict, obj.get("models"))
246        name = from_str(obj.get("name"))
247        pipelines = from_list(ModelConfigElement.from_dict, obj.get("pipelines"))
248        return Workspace(archived, created_at, created_by, id, models, name, pipelines)
249
250    def to_dict(self) -> dict:
251        result: dict = {}
252        result["archived"] = from_bool(self.archived)
253        result["created_at"] = self.created_at.isoformat()
254        result["created_by"] = str(self.created_by)
255        result["id"] = from_int(self.id)
256        result["models"] = from_list(lambda x: to_class(WorkspaceModel, x), self.models)
257        result["name"] = from_str(self.name)
258        result["pipelines"] = from_list(
259            lambda x: to_class(ModelConfigElement, x), self.pipelines
260        )
261        return result
Workspace( archived: bool, created_at: datetime.datetime, created_by: uuid.UUID, id: int, models: List[wallaroo.records.telemetry_body.WorkspaceModel], name: str, pipelines: List[wallaroo.records.telemetry_body.ModelConfigElement])
220    def __init__(
221        self,
222        archived: bool,
223        created_at: datetime,
224        created_by: UUID,
225        id: int,
226        models: List[WorkspaceModel],
227        name: str,
228        pipelines: List[ModelConfigElement],
229    ) -> None:
230        self.archived = archived
231        self.created_at = created_at
232        self.created_by = created_by
233        self.id = id
234        self.models = models
235        self.name = name
236        self.pipelines = pipelines
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.telemetry_body.Workspace:
238    @staticmethod
239    def from_dict(obj: Any) -> "Workspace":
240        assert isinstance(obj, dict)
241        archived = from_bool(obj.get("archived"))
242        created_at = from_datetime(obj.get("created_at"))
243        created_by = UUID(obj.get("created_by"))
244        id = from_int(obj.get("id"))
245        models = from_list(WorkspaceModel.from_dict, obj.get("models"))
246        name = from_str(obj.get("name"))
247        pipelines = from_list(ModelConfigElement.from_dict, obj.get("pipelines"))
248        return Workspace(archived, created_at, created_by, id, models, name, pipelines)
def to_dict(self) -> dict:
250    def to_dict(self) -> dict:
251        result: dict = {}
252        result["archived"] = from_bool(self.archived)
253        result["created_at"] = self.created_at.isoformat()
254        result["created_by"] = str(self.created_by)
255        result["id"] = from_int(self.id)
256        result["models"] = from_list(lambda x: to_class(WorkspaceModel, x), self.models)
257        result["name"] = from_str(self.name)
258        result["pipelines"] = from_list(
259            lambda x: to_class(ModelConfigElement, x), self.pipelines
260        )
261        return result
class WallarooAPITelemetryDataV1:
264class WallarooAPITelemetryDataV1:
265    api_key: str
266    deployments: List[Deployment]
267    models: List[WelcomeModel]
268    pipelines: List[WelcomePipeline]
269    users: int
270    workspaces: List[Workspace]
271
272    def __init__(
273        self,
274        api_key: str,
275        deployments: List[Deployment],
276        models: List[WelcomeModel],
277        pipelines: List[WelcomePipeline],
278        users: int,
279        workspaces: List[Workspace],
280    ) -> None:
281        self.api_key = api_key
282        self.deployments = deployments
283        self.models = models
284        self.pipelines = pipelines
285        self.users = users
286        self.workspaces = workspaces
287
288    @staticmethod
289    def from_dict(obj: Any) -> "WallarooAPITelemetryDataV1":
290        assert isinstance(obj, dict)
291        api_key = from_str(obj.get("api_key"))
292        deployments = from_list(Deployment.from_dict, obj.get("deployments"))
293        models = from_list(WelcomeModel.from_dict, obj.get("models"))
294        pipelines = from_list(WelcomePipeline.from_dict, obj.get("pipelines"))
295        users = from_int(obj.get("users"))
296        workspaces = from_list(Workspace.from_dict, obj.get("workspaces"))
297        return WallarooAPITelemetryDataV1(
298            api_key, deployments, models, pipelines, users, workspaces
299        )
300
301    def to_dict(self) -> dict:
302        result: dict = {}
303        result["api_key"] = from_str(self.api_key)
304        result["deployments"] = from_list(
305            lambda x: to_class(Deployment, x), self.deployments
306        )
307        result["models"] = from_list(lambda x: to_class(WelcomeModel, x), self.models)
308        result["pipelines"] = from_list(
309            lambda x: to_class(WelcomePipeline, x), self.pipelines
310        )
311        result["users"] = from_int(self.users)
312        result["workspaces"] = from_list(
313            lambda x: to_class(Workspace, x), self.workspaces
314        )
315        return result
WallarooAPITelemetryDataV1( api_key: str, deployments: List[wallaroo.records.telemetry_body.Deployment], models: List[wallaroo.records.telemetry_body.WelcomeModel], pipelines: List[wallaroo.records.telemetry_body.WelcomePipeline], users: int, workspaces: List[wallaroo.records.telemetry_body.Workspace])
272    def __init__(
273        self,
274        api_key: str,
275        deployments: List[Deployment],
276        models: List[WelcomeModel],
277        pipelines: List[WelcomePipeline],
278        users: int,
279        workspaces: List[Workspace],
280    ) -> None:
281        self.api_key = api_key
282        self.deployments = deployments
283        self.models = models
284        self.pipelines = pipelines
285        self.users = users
286        self.workspaces = workspaces
@staticmethod
def from_dict(obj: Any) -> wallaroo.records.telemetry_body.WallarooAPITelemetryDataV1:
288    @staticmethod
289    def from_dict(obj: Any) -> "WallarooAPITelemetryDataV1":
290        assert isinstance(obj, dict)
291        api_key = from_str(obj.get("api_key"))
292        deployments = from_list(Deployment.from_dict, obj.get("deployments"))
293        models = from_list(WelcomeModel.from_dict, obj.get("models"))
294        pipelines = from_list(WelcomePipeline.from_dict, obj.get("pipelines"))
295        users = from_int(obj.get("users"))
296        workspaces = from_list(Workspace.from_dict, obj.get("workspaces"))
297        return WallarooAPITelemetryDataV1(
298            api_key, deployments, models, pipelines, users, workspaces
299        )
def to_dict(self) -> dict:
301    def to_dict(self) -> dict:
302        result: dict = {}
303        result["api_key"] = from_str(self.api_key)
304        result["deployments"] = from_list(
305            lambda x: to_class(Deployment, x), self.deployments
306        )
307        result["models"] = from_list(lambda x: to_class(WelcomeModel, x), self.models)
308        result["pipelines"] = from_list(
309            lambda x: to_class(WelcomePipeline, x), self.pipelines
310        )
311        result["users"] = from_int(self.users)
312        result["workspaces"] = from_list(
313            lambda x: to_class(Workspace, x), self.workspaces
314        )
315        return result
def wallaroo_api_telemetry_data_v1_from_dict(s: Any) -> wallaroo.records.telemetry_body.WallarooAPITelemetryDataV1:
318def wallaroo_api_telemetry_data_v1_from_dict(s: Any) -> WallarooAPITelemetryDataV1:
319    return WallarooAPITelemetryDataV1.from_dict(s)
def wallaroo_api_telemetry_data_v1_to_dict(x: wallaroo.records.telemetry_body.WallarooAPITelemetryDataV1) -> Any:
322def wallaroo_api_telemetry_data_v1_to_dict(x: WallarooAPITelemetryDataV1) -> Any:
323    return to_class(WallarooAPITelemetryDataV1, x)