chickenstats-api 0.0.1__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (42) hide show
  1. chickenstats_api/__init__.py +104 -0
  2. chickenstats_api/api/__init__.py +13 -0
  3. chickenstats_api/api/chicken_nhl_api.py +3895 -0
  4. chickenstats_api/api/game_stats_api.py +1072 -0
  5. chickenstats_api/api/lines_api.py +878 -0
  6. chickenstats_api/api/login_api.py +1444 -0
  7. chickenstats_api/api/play_by_play_api.py +1303 -0
  8. chickenstats_api/api/season_stats_api.py +480 -0
  9. chickenstats_api/api/stats_api.py +1514 -0
  10. chickenstats_api/api/team_stats_api.py +312 -0
  11. chickenstats_api/api/users_api.py +2471 -0
  12. chickenstats_api/api_client.py +802 -0
  13. chickenstats_api/api_response.py +21 -0
  14. chickenstats_api/configuration.py +582 -0
  15. chickenstats_api/exceptions.py +217 -0
  16. chickenstats_api/models/__init__.py +37 -0
  17. chickenstats_api/models/http_validation_error.py +96 -0
  18. chickenstats_api/models/lines_create.py +380 -0
  19. chickenstats_api/models/lines_public.py +378 -0
  20. chickenstats_api/models/message.py +88 -0
  21. chickenstats_api/models/new_password.py +91 -0
  22. chickenstats_api/models/pbp_public.py +1138 -0
  23. chickenstats_api/models/stats_create.py +488 -0
  24. chickenstats_api/models/stats_game.py +486 -0
  25. chickenstats_api/models/stats_season.py +496 -0
  26. chickenstats_api/models/team_stats_create.py +254 -0
  27. chickenstats_api/models/team_stats_public.py +252 -0
  28. chickenstats_api/models/token.py +90 -0
  29. chickenstats_api/models/update_password.py +91 -0
  30. chickenstats_api/models/user_create.py +102 -0
  31. chickenstats_api/models/user_public.py +102 -0
  32. chickenstats_api/models/user_update.py +112 -0
  33. chickenstats_api/models/user_update_me.py +101 -0
  34. chickenstats_api/models/users_public.py +98 -0
  35. chickenstats_api/models/validation_error.py +100 -0
  36. chickenstats_api/models/validation_error_loc_inner.py +139 -0
  37. chickenstats_api/py.typed +0 -0
  38. chickenstats_api/rest.py +259 -0
  39. chickenstats_api-0.0.1.dist-info/METADATA +199 -0
  40. chickenstats_api-0.0.1.dist-info/RECORD +42 -0
  41. chickenstats_api-0.0.1.dist-info/WHEEL +5 -0
  42. chickenstats_api-0.0.1.dist-info/top_level.txt +1 -0
@@ -0,0 +1,3895 @@
1
+ # coding: utf-8
2
+
3
+ """
4
+ chickenstats API
5
+
6
+ API for downloading NHL data
7
+
8
+ The version of the OpenAPI document: 0.1.0
9
+ Contact: chicken@chickenandstats.com
10
+ Generated by OpenAPI Generator (https://openapi-generator.tech)
11
+
12
+ Do not edit the class manually.
13
+ """ # noqa: E501
14
+
15
+ import warnings
16
+ from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
17
+ from typing import Any, Dict, List, Optional, Tuple, Union
18
+ from typing_extensions import Annotated
19
+
20
+ from pydantic import StrictBool, StrictInt, StrictStr, field_validator
21
+ from typing import List, Optional
22
+ from chickenstats_api.models.lines_create import LinesCreate
23
+ from chickenstats_api.models.lines_public import LinesPublic
24
+ from chickenstats_api.models.pbp_public import PbpPublic
25
+ from chickenstats_api.models.stats_create import StatsCreate
26
+ from chickenstats_api.models.stats_game import StatsGame
27
+ from chickenstats_api.models.stats_season import StatsSeason
28
+ from chickenstats_api.models.team_stats_create import TeamStatsCreate
29
+ from chickenstats_api.models.team_stats_public import TeamStatsPublic
30
+
31
+ from chickenstats_api.api_client import ApiClient, RequestSerialized
32
+ from chickenstats_api.api_response import ApiResponse
33
+ from chickenstats_api.rest import RESTResponseType
34
+
35
+
36
+ class ChickenNhlApi:
37
+ """NOTE: This class is auto generated by OpenAPI Generator
38
+ Ref: https://openapi-generator.tech
39
+
40
+ Do not edit the class manually.
41
+ """
42
+
43
+ def __init__(self, api_client=None) -> None:
44
+ if api_client is None:
45
+ api_client = ApiClient.get_default()
46
+ self.api_client = api_client
47
+
48
+
49
+ @validate_call
50
+ def chicken_nhl_create_lines(
51
+ self,
52
+ lines_create: LinesCreate,
53
+ _request_timeout: Union[
54
+ None,
55
+ Annotated[StrictFloat, Field(gt=0)],
56
+ Tuple[
57
+ Annotated[StrictFloat, Field(gt=0)],
58
+ Annotated[StrictFloat, Field(gt=0)]
59
+ ]
60
+ ] = None,
61
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
62
+ _content_type: Optional[StrictStr] = None,
63
+ _headers: Optional[Dict[StrictStr, Any]] = None,
64
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
65
+ ) -> LinesPublic:
66
+ """Create Lines
67
+
68
+
69
+ :param lines_create: (required)
70
+ :type lines_create: LinesCreate
71
+ :param _request_timeout: timeout setting for this request. If one
72
+ number provided, it will be total request
73
+ timeout. It can also be a pair (tuple) of
74
+ (connection, read) timeouts.
75
+ :type _request_timeout: int, tuple(int, int), optional
76
+ :param _request_auth: set to override the auth_settings for an a single
77
+ request; this effectively ignores the
78
+ authentication in the spec for a single request.
79
+ :type _request_auth: dict, optional
80
+ :param _content_type: force content-type for the request.
81
+ :type _content_type: str, Optional
82
+ :param _headers: set to override the headers for a single
83
+ request; this effectively ignores the headers
84
+ in the spec for a single request.
85
+ :type _headers: dict, optional
86
+ :param _host_index: set to override the host_index for a single
87
+ request; this effectively ignores the host_index
88
+ in the spec for a single request.
89
+ :type _host_index: int, optional
90
+ :return: Returns the result object.
91
+ """ # noqa: E501
92
+
93
+ _param = self._chicken_nhl_create_lines_serialize(
94
+ lines_create=lines_create,
95
+ _request_auth=_request_auth,
96
+ _content_type=_content_type,
97
+ _headers=_headers,
98
+ _host_index=_host_index
99
+ )
100
+
101
+ _response_types_map: Dict[str, Optional[str]] = {
102
+ '200': "LinesPublic",
103
+ '422': "HTTPValidationError",
104
+ }
105
+ response_data = self.api_client.call_api(
106
+ *_param,
107
+ _request_timeout=_request_timeout
108
+ )
109
+ response_data.read()
110
+ return self.api_client.response_deserialize(
111
+ response_data=response_data,
112
+ response_types_map=_response_types_map,
113
+ ).data
114
+
115
+
116
+ @validate_call
117
+ def chicken_nhl_create_lines_with_http_info(
118
+ self,
119
+ lines_create: LinesCreate,
120
+ _request_timeout: Union[
121
+ None,
122
+ Annotated[StrictFloat, Field(gt=0)],
123
+ Tuple[
124
+ Annotated[StrictFloat, Field(gt=0)],
125
+ Annotated[StrictFloat, Field(gt=0)]
126
+ ]
127
+ ] = None,
128
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
129
+ _content_type: Optional[StrictStr] = None,
130
+ _headers: Optional[Dict[StrictStr, Any]] = None,
131
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
132
+ ) -> ApiResponse[LinesPublic]:
133
+ """Create Lines
134
+
135
+
136
+ :param lines_create: (required)
137
+ :type lines_create: LinesCreate
138
+ :param _request_timeout: timeout setting for this request. If one
139
+ number provided, it will be total request
140
+ timeout. It can also be a pair (tuple) of
141
+ (connection, read) timeouts.
142
+ :type _request_timeout: int, tuple(int, int), optional
143
+ :param _request_auth: set to override the auth_settings for an a single
144
+ request; this effectively ignores the
145
+ authentication in the spec for a single request.
146
+ :type _request_auth: dict, optional
147
+ :param _content_type: force content-type for the request.
148
+ :type _content_type: str, Optional
149
+ :param _headers: set to override the headers for a single
150
+ request; this effectively ignores the headers
151
+ in the spec for a single request.
152
+ :type _headers: dict, optional
153
+ :param _host_index: set to override the host_index for a single
154
+ request; this effectively ignores the host_index
155
+ in the spec for a single request.
156
+ :type _host_index: int, optional
157
+ :return: Returns the result object.
158
+ """ # noqa: E501
159
+
160
+ _param = self._chicken_nhl_create_lines_serialize(
161
+ lines_create=lines_create,
162
+ _request_auth=_request_auth,
163
+ _content_type=_content_type,
164
+ _headers=_headers,
165
+ _host_index=_host_index
166
+ )
167
+
168
+ _response_types_map: Dict[str, Optional[str]] = {
169
+ '200': "LinesPublic",
170
+ '422': "HTTPValidationError",
171
+ }
172
+ response_data = self.api_client.call_api(
173
+ *_param,
174
+ _request_timeout=_request_timeout
175
+ )
176
+ response_data.read()
177
+ return self.api_client.response_deserialize(
178
+ response_data=response_data,
179
+ response_types_map=_response_types_map,
180
+ )
181
+
182
+
183
+ @validate_call
184
+ def chicken_nhl_create_lines_without_preload_content(
185
+ self,
186
+ lines_create: LinesCreate,
187
+ _request_timeout: Union[
188
+ None,
189
+ Annotated[StrictFloat, Field(gt=0)],
190
+ Tuple[
191
+ Annotated[StrictFloat, Field(gt=0)],
192
+ Annotated[StrictFloat, Field(gt=0)]
193
+ ]
194
+ ] = None,
195
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
196
+ _content_type: Optional[StrictStr] = None,
197
+ _headers: Optional[Dict[StrictStr, Any]] = None,
198
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
199
+ ) -> RESTResponseType:
200
+ """Create Lines
201
+
202
+
203
+ :param lines_create: (required)
204
+ :type lines_create: LinesCreate
205
+ :param _request_timeout: timeout setting for this request. If one
206
+ number provided, it will be total request
207
+ timeout. It can also be a pair (tuple) of
208
+ (connection, read) timeouts.
209
+ :type _request_timeout: int, tuple(int, int), optional
210
+ :param _request_auth: set to override the auth_settings for an a single
211
+ request; this effectively ignores the
212
+ authentication in the spec for a single request.
213
+ :type _request_auth: dict, optional
214
+ :param _content_type: force content-type for the request.
215
+ :type _content_type: str, Optional
216
+ :param _headers: set to override the headers for a single
217
+ request; this effectively ignores the headers
218
+ in the spec for a single request.
219
+ :type _headers: dict, optional
220
+ :param _host_index: set to override the host_index for a single
221
+ request; this effectively ignores the host_index
222
+ in the spec for a single request.
223
+ :type _host_index: int, optional
224
+ :return: Returns the result object.
225
+ """ # noqa: E501
226
+
227
+ _param = self._chicken_nhl_create_lines_serialize(
228
+ lines_create=lines_create,
229
+ _request_auth=_request_auth,
230
+ _content_type=_content_type,
231
+ _headers=_headers,
232
+ _host_index=_host_index
233
+ )
234
+
235
+ _response_types_map: Dict[str, Optional[str]] = {
236
+ '200': "LinesPublic",
237
+ '422': "HTTPValidationError",
238
+ }
239
+ response_data = self.api_client.call_api(
240
+ *_param,
241
+ _request_timeout=_request_timeout
242
+ )
243
+ return response_data.response
244
+
245
+
246
+ def _chicken_nhl_create_lines_serialize(
247
+ self,
248
+ lines_create,
249
+ _request_auth,
250
+ _content_type,
251
+ _headers,
252
+ _host_index,
253
+ ) -> RequestSerialized:
254
+
255
+ _host = None
256
+
257
+ _collection_formats: Dict[str, str] = {
258
+ }
259
+
260
+ _path_params: Dict[str, str] = {}
261
+ _query_params: List[Tuple[str, str]] = []
262
+ _header_params: Dict[str, Optional[str]] = _headers or {}
263
+ _form_params: List[Tuple[str, str]] = []
264
+ _files: Dict[
265
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
266
+ ] = {}
267
+ _body_params: Optional[bytes] = None
268
+
269
+ # process the path parameters
270
+ # process the query parameters
271
+ # process the header parameters
272
+ # process the form parameters
273
+ # process the body parameter
274
+ if lines_create is not None:
275
+ _body_params = lines_create
276
+
277
+
278
+ # set the HTTP header `Accept`
279
+ if 'Accept' not in _header_params:
280
+ _header_params['Accept'] = self.api_client.select_header_accept(
281
+ [
282
+ 'application/json'
283
+ ]
284
+ )
285
+
286
+ # set the HTTP header `Content-Type`
287
+ if _content_type:
288
+ _header_params['Content-Type'] = _content_type
289
+ else:
290
+ _default_content_type = (
291
+ self.api_client.select_header_content_type(
292
+ [
293
+ 'application/json'
294
+ ]
295
+ )
296
+ )
297
+ if _default_content_type is not None:
298
+ _header_params['Content-Type'] = _default_content_type
299
+
300
+ # authentication setting
301
+ _auth_settings: List[str] = [
302
+ 'OAuth2PasswordBearer'
303
+ ]
304
+
305
+ return self.api_client.param_serialize(
306
+ method='POST',
307
+ resource_path='/api/v1/chicken_nhl/lines',
308
+ path_params=_path_params,
309
+ query_params=_query_params,
310
+ header_params=_header_params,
311
+ body=_body_params,
312
+ post_params=_form_params,
313
+ files=_files,
314
+ auth_settings=_auth_settings,
315
+ collection_formats=_collection_formats,
316
+ _host=_host,
317
+ _request_auth=_request_auth
318
+ )
319
+
320
+
321
+
322
+
323
+ @validate_call
324
+ def chicken_nhl_create_pbp(
325
+ self,
326
+ pbp_public: PbpPublic,
327
+ _request_timeout: Union[
328
+ None,
329
+ Annotated[StrictFloat, Field(gt=0)],
330
+ Tuple[
331
+ Annotated[StrictFloat, Field(gt=0)],
332
+ Annotated[StrictFloat, Field(gt=0)]
333
+ ]
334
+ ] = None,
335
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
336
+ _content_type: Optional[StrictStr] = None,
337
+ _headers: Optional[Dict[StrictStr, Any]] = None,
338
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
339
+ ) -> PbpPublic:
340
+ """Create Pbp
341
+
342
+
343
+ :param pbp_public: (required)
344
+ :type pbp_public: PbpPublic
345
+ :param _request_timeout: timeout setting for this request. If one
346
+ number provided, it will be total request
347
+ timeout. It can also be a pair (tuple) of
348
+ (connection, read) timeouts.
349
+ :type _request_timeout: int, tuple(int, int), optional
350
+ :param _request_auth: set to override the auth_settings for an a single
351
+ request; this effectively ignores the
352
+ authentication in the spec for a single request.
353
+ :type _request_auth: dict, optional
354
+ :param _content_type: force content-type for the request.
355
+ :type _content_type: str, Optional
356
+ :param _headers: set to override the headers for a single
357
+ request; this effectively ignores the headers
358
+ in the spec for a single request.
359
+ :type _headers: dict, optional
360
+ :param _host_index: set to override the host_index for a single
361
+ request; this effectively ignores the host_index
362
+ in the spec for a single request.
363
+ :type _host_index: int, optional
364
+ :return: Returns the result object.
365
+ """ # noqa: E501
366
+
367
+ _param = self._chicken_nhl_create_pbp_serialize(
368
+ pbp_public=pbp_public,
369
+ _request_auth=_request_auth,
370
+ _content_type=_content_type,
371
+ _headers=_headers,
372
+ _host_index=_host_index
373
+ )
374
+
375
+ _response_types_map: Dict[str, Optional[str]] = {
376
+ '200': "PbpPublic",
377
+ '422': "HTTPValidationError",
378
+ }
379
+ response_data = self.api_client.call_api(
380
+ *_param,
381
+ _request_timeout=_request_timeout
382
+ )
383
+ response_data.read()
384
+ return self.api_client.response_deserialize(
385
+ response_data=response_data,
386
+ response_types_map=_response_types_map,
387
+ ).data
388
+
389
+
390
+ @validate_call
391
+ def chicken_nhl_create_pbp_with_http_info(
392
+ self,
393
+ pbp_public: PbpPublic,
394
+ _request_timeout: Union[
395
+ None,
396
+ Annotated[StrictFloat, Field(gt=0)],
397
+ Tuple[
398
+ Annotated[StrictFloat, Field(gt=0)],
399
+ Annotated[StrictFloat, Field(gt=0)]
400
+ ]
401
+ ] = None,
402
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
403
+ _content_type: Optional[StrictStr] = None,
404
+ _headers: Optional[Dict[StrictStr, Any]] = None,
405
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
406
+ ) -> ApiResponse[PbpPublic]:
407
+ """Create Pbp
408
+
409
+
410
+ :param pbp_public: (required)
411
+ :type pbp_public: PbpPublic
412
+ :param _request_timeout: timeout setting for this request. If one
413
+ number provided, it will be total request
414
+ timeout. It can also be a pair (tuple) of
415
+ (connection, read) timeouts.
416
+ :type _request_timeout: int, tuple(int, int), optional
417
+ :param _request_auth: set to override the auth_settings for an a single
418
+ request; this effectively ignores the
419
+ authentication in the spec for a single request.
420
+ :type _request_auth: dict, optional
421
+ :param _content_type: force content-type for the request.
422
+ :type _content_type: str, Optional
423
+ :param _headers: set to override the headers for a single
424
+ request; this effectively ignores the headers
425
+ in the spec for a single request.
426
+ :type _headers: dict, optional
427
+ :param _host_index: set to override the host_index for a single
428
+ request; this effectively ignores the host_index
429
+ in the spec for a single request.
430
+ :type _host_index: int, optional
431
+ :return: Returns the result object.
432
+ """ # noqa: E501
433
+
434
+ _param = self._chicken_nhl_create_pbp_serialize(
435
+ pbp_public=pbp_public,
436
+ _request_auth=_request_auth,
437
+ _content_type=_content_type,
438
+ _headers=_headers,
439
+ _host_index=_host_index
440
+ )
441
+
442
+ _response_types_map: Dict[str, Optional[str]] = {
443
+ '200': "PbpPublic",
444
+ '422': "HTTPValidationError",
445
+ }
446
+ response_data = self.api_client.call_api(
447
+ *_param,
448
+ _request_timeout=_request_timeout
449
+ )
450
+ response_data.read()
451
+ return self.api_client.response_deserialize(
452
+ response_data=response_data,
453
+ response_types_map=_response_types_map,
454
+ )
455
+
456
+
457
+ @validate_call
458
+ def chicken_nhl_create_pbp_without_preload_content(
459
+ self,
460
+ pbp_public: PbpPublic,
461
+ _request_timeout: Union[
462
+ None,
463
+ Annotated[StrictFloat, Field(gt=0)],
464
+ Tuple[
465
+ Annotated[StrictFloat, Field(gt=0)],
466
+ Annotated[StrictFloat, Field(gt=0)]
467
+ ]
468
+ ] = None,
469
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
470
+ _content_type: Optional[StrictStr] = None,
471
+ _headers: Optional[Dict[StrictStr, Any]] = None,
472
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
473
+ ) -> RESTResponseType:
474
+ """Create Pbp
475
+
476
+
477
+ :param pbp_public: (required)
478
+ :type pbp_public: PbpPublic
479
+ :param _request_timeout: timeout setting for this request. If one
480
+ number provided, it will be total request
481
+ timeout. It can also be a pair (tuple) of
482
+ (connection, read) timeouts.
483
+ :type _request_timeout: int, tuple(int, int), optional
484
+ :param _request_auth: set to override the auth_settings for an a single
485
+ request; this effectively ignores the
486
+ authentication in the spec for a single request.
487
+ :type _request_auth: dict, optional
488
+ :param _content_type: force content-type for the request.
489
+ :type _content_type: str, Optional
490
+ :param _headers: set to override the headers for a single
491
+ request; this effectively ignores the headers
492
+ in the spec for a single request.
493
+ :type _headers: dict, optional
494
+ :param _host_index: set to override the host_index for a single
495
+ request; this effectively ignores the host_index
496
+ in the spec for a single request.
497
+ :type _host_index: int, optional
498
+ :return: Returns the result object.
499
+ """ # noqa: E501
500
+
501
+ _param = self._chicken_nhl_create_pbp_serialize(
502
+ pbp_public=pbp_public,
503
+ _request_auth=_request_auth,
504
+ _content_type=_content_type,
505
+ _headers=_headers,
506
+ _host_index=_host_index
507
+ )
508
+
509
+ _response_types_map: Dict[str, Optional[str]] = {
510
+ '200': "PbpPublic",
511
+ '422': "HTTPValidationError",
512
+ }
513
+ response_data = self.api_client.call_api(
514
+ *_param,
515
+ _request_timeout=_request_timeout
516
+ )
517
+ return response_data.response
518
+
519
+
520
+ def _chicken_nhl_create_pbp_serialize(
521
+ self,
522
+ pbp_public,
523
+ _request_auth,
524
+ _content_type,
525
+ _headers,
526
+ _host_index,
527
+ ) -> RequestSerialized:
528
+
529
+ _host = None
530
+
531
+ _collection_formats: Dict[str, str] = {
532
+ }
533
+
534
+ _path_params: Dict[str, str] = {}
535
+ _query_params: List[Tuple[str, str]] = []
536
+ _header_params: Dict[str, Optional[str]] = _headers or {}
537
+ _form_params: List[Tuple[str, str]] = []
538
+ _files: Dict[
539
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
540
+ ] = {}
541
+ _body_params: Optional[bytes] = None
542
+
543
+ # process the path parameters
544
+ # process the query parameters
545
+ # process the header parameters
546
+ # process the form parameters
547
+ # process the body parameter
548
+ if pbp_public is not None:
549
+ _body_params = pbp_public
550
+
551
+
552
+ # set the HTTP header `Accept`
553
+ if 'Accept' not in _header_params:
554
+ _header_params['Accept'] = self.api_client.select_header_accept(
555
+ [
556
+ 'application/json'
557
+ ]
558
+ )
559
+
560
+ # set the HTTP header `Content-Type`
561
+ if _content_type:
562
+ _header_params['Content-Type'] = _content_type
563
+ else:
564
+ _default_content_type = (
565
+ self.api_client.select_header_content_type(
566
+ [
567
+ 'application/json'
568
+ ]
569
+ )
570
+ )
571
+ if _default_content_type is not None:
572
+ _header_params['Content-Type'] = _default_content_type
573
+
574
+ # authentication setting
575
+ _auth_settings: List[str] = [
576
+ 'OAuth2PasswordBearer'
577
+ ]
578
+
579
+ return self.api_client.param_serialize(
580
+ method='POST',
581
+ resource_path='/api/v1/chicken_nhl/play_by_play',
582
+ path_params=_path_params,
583
+ query_params=_query_params,
584
+ header_params=_header_params,
585
+ body=_body_params,
586
+ post_params=_form_params,
587
+ files=_files,
588
+ auth_settings=_auth_settings,
589
+ collection_formats=_collection_formats,
590
+ _host=_host,
591
+ _request_auth=_request_auth
592
+ )
593
+
594
+
595
+
596
+
597
+ @validate_call
598
+ def chicken_nhl_create_stats(
599
+ self,
600
+ stats_create: StatsCreate,
601
+ _request_timeout: Union[
602
+ None,
603
+ Annotated[StrictFloat, Field(gt=0)],
604
+ Tuple[
605
+ Annotated[StrictFloat, Field(gt=0)],
606
+ Annotated[StrictFloat, Field(gt=0)]
607
+ ]
608
+ ] = None,
609
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
610
+ _content_type: Optional[StrictStr] = None,
611
+ _headers: Optional[Dict[StrictStr, Any]] = None,
612
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
613
+ ) -> StatsGame:
614
+ """Create Stats
615
+
616
+
617
+ :param stats_create: (required)
618
+ :type stats_create: StatsCreate
619
+ :param _request_timeout: timeout setting for this request. If one
620
+ number provided, it will be total request
621
+ timeout. It can also be a pair (tuple) of
622
+ (connection, read) timeouts.
623
+ :type _request_timeout: int, tuple(int, int), optional
624
+ :param _request_auth: set to override the auth_settings for an a single
625
+ request; this effectively ignores the
626
+ authentication in the spec for a single request.
627
+ :type _request_auth: dict, optional
628
+ :param _content_type: force content-type for the request.
629
+ :type _content_type: str, Optional
630
+ :param _headers: set to override the headers for a single
631
+ request; this effectively ignores the headers
632
+ in the spec for a single request.
633
+ :type _headers: dict, optional
634
+ :param _host_index: set to override the host_index for a single
635
+ request; this effectively ignores the host_index
636
+ in the spec for a single request.
637
+ :type _host_index: int, optional
638
+ :return: Returns the result object.
639
+ """ # noqa: E501
640
+
641
+ _param = self._chicken_nhl_create_stats_serialize(
642
+ stats_create=stats_create,
643
+ _request_auth=_request_auth,
644
+ _content_type=_content_type,
645
+ _headers=_headers,
646
+ _host_index=_host_index
647
+ )
648
+
649
+ _response_types_map: Dict[str, Optional[str]] = {
650
+ '200': "StatsGame",
651
+ '422': "HTTPValidationError",
652
+ }
653
+ response_data = self.api_client.call_api(
654
+ *_param,
655
+ _request_timeout=_request_timeout
656
+ )
657
+ response_data.read()
658
+ return self.api_client.response_deserialize(
659
+ response_data=response_data,
660
+ response_types_map=_response_types_map,
661
+ ).data
662
+
663
+
664
+ @validate_call
665
+ def chicken_nhl_create_stats_with_http_info(
666
+ self,
667
+ stats_create: StatsCreate,
668
+ _request_timeout: Union[
669
+ None,
670
+ Annotated[StrictFloat, Field(gt=0)],
671
+ Tuple[
672
+ Annotated[StrictFloat, Field(gt=0)],
673
+ Annotated[StrictFloat, Field(gt=0)]
674
+ ]
675
+ ] = None,
676
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
677
+ _content_type: Optional[StrictStr] = None,
678
+ _headers: Optional[Dict[StrictStr, Any]] = None,
679
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
680
+ ) -> ApiResponse[StatsGame]:
681
+ """Create Stats
682
+
683
+
684
+ :param stats_create: (required)
685
+ :type stats_create: StatsCreate
686
+ :param _request_timeout: timeout setting for this request. If one
687
+ number provided, it will be total request
688
+ timeout. It can also be a pair (tuple) of
689
+ (connection, read) timeouts.
690
+ :type _request_timeout: int, tuple(int, int), optional
691
+ :param _request_auth: set to override the auth_settings for an a single
692
+ request; this effectively ignores the
693
+ authentication in the spec for a single request.
694
+ :type _request_auth: dict, optional
695
+ :param _content_type: force content-type for the request.
696
+ :type _content_type: str, Optional
697
+ :param _headers: set to override the headers for a single
698
+ request; this effectively ignores the headers
699
+ in the spec for a single request.
700
+ :type _headers: dict, optional
701
+ :param _host_index: set to override the host_index for a single
702
+ request; this effectively ignores the host_index
703
+ in the spec for a single request.
704
+ :type _host_index: int, optional
705
+ :return: Returns the result object.
706
+ """ # noqa: E501
707
+
708
+ _param = self._chicken_nhl_create_stats_serialize(
709
+ stats_create=stats_create,
710
+ _request_auth=_request_auth,
711
+ _content_type=_content_type,
712
+ _headers=_headers,
713
+ _host_index=_host_index
714
+ )
715
+
716
+ _response_types_map: Dict[str, Optional[str]] = {
717
+ '200': "StatsGame",
718
+ '422': "HTTPValidationError",
719
+ }
720
+ response_data = self.api_client.call_api(
721
+ *_param,
722
+ _request_timeout=_request_timeout
723
+ )
724
+ response_data.read()
725
+ return self.api_client.response_deserialize(
726
+ response_data=response_data,
727
+ response_types_map=_response_types_map,
728
+ )
729
+
730
+
731
+ @validate_call
732
+ def chicken_nhl_create_stats_without_preload_content(
733
+ self,
734
+ stats_create: StatsCreate,
735
+ _request_timeout: Union[
736
+ None,
737
+ Annotated[StrictFloat, Field(gt=0)],
738
+ Tuple[
739
+ Annotated[StrictFloat, Field(gt=0)],
740
+ Annotated[StrictFloat, Field(gt=0)]
741
+ ]
742
+ ] = None,
743
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
744
+ _content_type: Optional[StrictStr] = None,
745
+ _headers: Optional[Dict[StrictStr, Any]] = None,
746
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
747
+ ) -> RESTResponseType:
748
+ """Create Stats
749
+
750
+
751
+ :param stats_create: (required)
752
+ :type stats_create: StatsCreate
753
+ :param _request_timeout: timeout setting for this request. If one
754
+ number provided, it will be total request
755
+ timeout. It can also be a pair (tuple) of
756
+ (connection, read) timeouts.
757
+ :type _request_timeout: int, tuple(int, int), optional
758
+ :param _request_auth: set to override the auth_settings for an a single
759
+ request; this effectively ignores the
760
+ authentication in the spec for a single request.
761
+ :type _request_auth: dict, optional
762
+ :param _content_type: force content-type for the request.
763
+ :type _content_type: str, Optional
764
+ :param _headers: set to override the headers for a single
765
+ request; this effectively ignores the headers
766
+ in the spec for a single request.
767
+ :type _headers: dict, optional
768
+ :param _host_index: set to override the host_index for a single
769
+ request; this effectively ignores the host_index
770
+ in the spec for a single request.
771
+ :type _host_index: int, optional
772
+ :return: Returns the result object.
773
+ """ # noqa: E501
774
+
775
+ _param = self._chicken_nhl_create_stats_serialize(
776
+ stats_create=stats_create,
777
+ _request_auth=_request_auth,
778
+ _content_type=_content_type,
779
+ _headers=_headers,
780
+ _host_index=_host_index
781
+ )
782
+
783
+ _response_types_map: Dict[str, Optional[str]] = {
784
+ '200': "StatsGame",
785
+ '422': "HTTPValidationError",
786
+ }
787
+ response_data = self.api_client.call_api(
788
+ *_param,
789
+ _request_timeout=_request_timeout
790
+ )
791
+ return response_data.response
792
+
793
+
794
+ def _chicken_nhl_create_stats_serialize(
795
+ self,
796
+ stats_create,
797
+ _request_auth,
798
+ _content_type,
799
+ _headers,
800
+ _host_index,
801
+ ) -> RequestSerialized:
802
+
803
+ _host = None
804
+
805
+ _collection_formats: Dict[str, str] = {
806
+ }
807
+
808
+ _path_params: Dict[str, str] = {}
809
+ _query_params: List[Tuple[str, str]] = []
810
+ _header_params: Dict[str, Optional[str]] = _headers or {}
811
+ _form_params: List[Tuple[str, str]] = []
812
+ _files: Dict[
813
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
814
+ ] = {}
815
+ _body_params: Optional[bytes] = None
816
+
817
+ # process the path parameters
818
+ # process the query parameters
819
+ # process the header parameters
820
+ # process the form parameters
821
+ # process the body parameter
822
+ if stats_create is not None:
823
+ _body_params = stats_create
824
+
825
+
826
+ # set the HTTP header `Accept`
827
+ if 'Accept' not in _header_params:
828
+ _header_params['Accept'] = self.api_client.select_header_accept(
829
+ [
830
+ 'application/json'
831
+ ]
832
+ )
833
+
834
+ # set the HTTP header `Content-Type`
835
+ if _content_type:
836
+ _header_params['Content-Type'] = _content_type
837
+ else:
838
+ _default_content_type = (
839
+ self.api_client.select_header_content_type(
840
+ [
841
+ 'application/json'
842
+ ]
843
+ )
844
+ )
845
+ if _default_content_type is not None:
846
+ _header_params['Content-Type'] = _default_content_type
847
+
848
+ # authentication setting
849
+ _auth_settings: List[str] = [
850
+ 'OAuth2PasswordBearer'
851
+ ]
852
+
853
+ return self.api_client.param_serialize(
854
+ method='POST',
855
+ resource_path='/api/v1/chicken_nhl/stats',
856
+ path_params=_path_params,
857
+ query_params=_query_params,
858
+ header_params=_header_params,
859
+ body=_body_params,
860
+ post_params=_form_params,
861
+ files=_files,
862
+ auth_settings=_auth_settings,
863
+ collection_formats=_collection_formats,
864
+ _host=_host,
865
+ _request_auth=_request_auth
866
+ )
867
+
868
+
869
+
870
+
871
+ @validate_call
872
+ def chicken_nhl_create_team_stats(
873
+ self,
874
+ team_stats_create: TeamStatsCreate,
875
+ _request_timeout: Union[
876
+ None,
877
+ Annotated[StrictFloat, Field(gt=0)],
878
+ Tuple[
879
+ Annotated[StrictFloat, Field(gt=0)],
880
+ Annotated[StrictFloat, Field(gt=0)]
881
+ ]
882
+ ] = None,
883
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
884
+ _content_type: Optional[StrictStr] = None,
885
+ _headers: Optional[Dict[StrictStr, Any]] = None,
886
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
887
+ ) -> TeamStatsPublic:
888
+ """Create Team Stats
889
+
890
+
891
+ :param team_stats_create: (required)
892
+ :type team_stats_create: TeamStatsCreate
893
+ :param _request_timeout: timeout setting for this request. If one
894
+ number provided, it will be total request
895
+ timeout. It can also be a pair (tuple) of
896
+ (connection, read) timeouts.
897
+ :type _request_timeout: int, tuple(int, int), optional
898
+ :param _request_auth: set to override the auth_settings for an a single
899
+ request; this effectively ignores the
900
+ authentication in the spec for a single request.
901
+ :type _request_auth: dict, optional
902
+ :param _content_type: force content-type for the request.
903
+ :type _content_type: str, Optional
904
+ :param _headers: set to override the headers for a single
905
+ request; this effectively ignores the headers
906
+ in the spec for a single request.
907
+ :type _headers: dict, optional
908
+ :param _host_index: set to override the host_index for a single
909
+ request; this effectively ignores the host_index
910
+ in the spec for a single request.
911
+ :type _host_index: int, optional
912
+ :return: Returns the result object.
913
+ """ # noqa: E501
914
+
915
+ _param = self._chicken_nhl_create_team_stats_serialize(
916
+ team_stats_create=team_stats_create,
917
+ _request_auth=_request_auth,
918
+ _content_type=_content_type,
919
+ _headers=_headers,
920
+ _host_index=_host_index
921
+ )
922
+
923
+ _response_types_map: Dict[str, Optional[str]] = {
924
+ '200': "TeamStatsPublic",
925
+ '422': "HTTPValidationError",
926
+ }
927
+ response_data = self.api_client.call_api(
928
+ *_param,
929
+ _request_timeout=_request_timeout
930
+ )
931
+ response_data.read()
932
+ return self.api_client.response_deserialize(
933
+ response_data=response_data,
934
+ response_types_map=_response_types_map,
935
+ ).data
936
+
937
+
938
+ @validate_call
939
+ def chicken_nhl_create_team_stats_with_http_info(
940
+ self,
941
+ team_stats_create: TeamStatsCreate,
942
+ _request_timeout: Union[
943
+ None,
944
+ Annotated[StrictFloat, Field(gt=0)],
945
+ Tuple[
946
+ Annotated[StrictFloat, Field(gt=0)],
947
+ Annotated[StrictFloat, Field(gt=0)]
948
+ ]
949
+ ] = None,
950
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
951
+ _content_type: Optional[StrictStr] = None,
952
+ _headers: Optional[Dict[StrictStr, Any]] = None,
953
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
954
+ ) -> ApiResponse[TeamStatsPublic]:
955
+ """Create Team Stats
956
+
957
+
958
+ :param team_stats_create: (required)
959
+ :type team_stats_create: TeamStatsCreate
960
+ :param _request_timeout: timeout setting for this request. If one
961
+ number provided, it will be total request
962
+ timeout. It can also be a pair (tuple) of
963
+ (connection, read) timeouts.
964
+ :type _request_timeout: int, tuple(int, int), optional
965
+ :param _request_auth: set to override the auth_settings for an a single
966
+ request; this effectively ignores the
967
+ authentication in the spec for a single request.
968
+ :type _request_auth: dict, optional
969
+ :param _content_type: force content-type for the request.
970
+ :type _content_type: str, Optional
971
+ :param _headers: set to override the headers for a single
972
+ request; this effectively ignores the headers
973
+ in the spec for a single request.
974
+ :type _headers: dict, optional
975
+ :param _host_index: set to override the host_index for a single
976
+ request; this effectively ignores the host_index
977
+ in the spec for a single request.
978
+ :type _host_index: int, optional
979
+ :return: Returns the result object.
980
+ """ # noqa: E501
981
+
982
+ _param = self._chicken_nhl_create_team_stats_serialize(
983
+ team_stats_create=team_stats_create,
984
+ _request_auth=_request_auth,
985
+ _content_type=_content_type,
986
+ _headers=_headers,
987
+ _host_index=_host_index
988
+ )
989
+
990
+ _response_types_map: Dict[str, Optional[str]] = {
991
+ '200': "TeamStatsPublic",
992
+ '422': "HTTPValidationError",
993
+ }
994
+ response_data = self.api_client.call_api(
995
+ *_param,
996
+ _request_timeout=_request_timeout
997
+ )
998
+ response_data.read()
999
+ return self.api_client.response_deserialize(
1000
+ response_data=response_data,
1001
+ response_types_map=_response_types_map,
1002
+ )
1003
+
1004
+
1005
+ @validate_call
1006
+ def chicken_nhl_create_team_stats_without_preload_content(
1007
+ self,
1008
+ team_stats_create: TeamStatsCreate,
1009
+ _request_timeout: Union[
1010
+ None,
1011
+ Annotated[StrictFloat, Field(gt=0)],
1012
+ Tuple[
1013
+ Annotated[StrictFloat, Field(gt=0)],
1014
+ Annotated[StrictFloat, Field(gt=0)]
1015
+ ]
1016
+ ] = None,
1017
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
1018
+ _content_type: Optional[StrictStr] = None,
1019
+ _headers: Optional[Dict[StrictStr, Any]] = None,
1020
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1021
+ ) -> RESTResponseType:
1022
+ """Create Team Stats
1023
+
1024
+
1025
+ :param team_stats_create: (required)
1026
+ :type team_stats_create: TeamStatsCreate
1027
+ :param _request_timeout: timeout setting for this request. If one
1028
+ number provided, it will be total request
1029
+ timeout. It can also be a pair (tuple) of
1030
+ (connection, read) timeouts.
1031
+ :type _request_timeout: int, tuple(int, int), optional
1032
+ :param _request_auth: set to override the auth_settings for an a single
1033
+ request; this effectively ignores the
1034
+ authentication in the spec for a single request.
1035
+ :type _request_auth: dict, optional
1036
+ :param _content_type: force content-type for the request.
1037
+ :type _content_type: str, Optional
1038
+ :param _headers: set to override the headers for a single
1039
+ request; this effectively ignores the headers
1040
+ in the spec for a single request.
1041
+ :type _headers: dict, optional
1042
+ :param _host_index: set to override the host_index for a single
1043
+ request; this effectively ignores the host_index
1044
+ in the spec for a single request.
1045
+ :type _host_index: int, optional
1046
+ :return: Returns the result object.
1047
+ """ # noqa: E501
1048
+
1049
+ _param = self._chicken_nhl_create_team_stats_serialize(
1050
+ team_stats_create=team_stats_create,
1051
+ _request_auth=_request_auth,
1052
+ _content_type=_content_type,
1053
+ _headers=_headers,
1054
+ _host_index=_host_index
1055
+ )
1056
+
1057
+ _response_types_map: Dict[str, Optional[str]] = {
1058
+ '200': "TeamStatsPublic",
1059
+ '422': "HTTPValidationError",
1060
+ }
1061
+ response_data = self.api_client.call_api(
1062
+ *_param,
1063
+ _request_timeout=_request_timeout
1064
+ )
1065
+ return response_data.response
1066
+
1067
+
1068
+ def _chicken_nhl_create_team_stats_serialize(
1069
+ self,
1070
+ team_stats_create,
1071
+ _request_auth,
1072
+ _content_type,
1073
+ _headers,
1074
+ _host_index,
1075
+ ) -> RequestSerialized:
1076
+
1077
+ _host = None
1078
+
1079
+ _collection_formats: Dict[str, str] = {
1080
+ }
1081
+
1082
+ _path_params: Dict[str, str] = {}
1083
+ _query_params: List[Tuple[str, str]] = []
1084
+ _header_params: Dict[str, Optional[str]] = _headers or {}
1085
+ _form_params: List[Tuple[str, str]] = []
1086
+ _files: Dict[
1087
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1088
+ ] = {}
1089
+ _body_params: Optional[bytes] = None
1090
+
1091
+ # process the path parameters
1092
+ # process the query parameters
1093
+ # process the header parameters
1094
+ # process the form parameters
1095
+ # process the body parameter
1096
+ if team_stats_create is not None:
1097
+ _body_params = team_stats_create
1098
+
1099
+
1100
+ # set the HTTP header `Accept`
1101
+ if 'Accept' not in _header_params:
1102
+ _header_params['Accept'] = self.api_client.select_header_accept(
1103
+ [
1104
+ 'application/json'
1105
+ ]
1106
+ )
1107
+
1108
+ # set the HTTP header `Content-Type`
1109
+ if _content_type:
1110
+ _header_params['Content-Type'] = _content_type
1111
+ else:
1112
+ _default_content_type = (
1113
+ self.api_client.select_header_content_type(
1114
+ [
1115
+ 'application/json'
1116
+ ]
1117
+ )
1118
+ )
1119
+ if _default_content_type is not None:
1120
+ _header_params['Content-Type'] = _default_content_type
1121
+
1122
+ # authentication setting
1123
+ _auth_settings: List[str] = [
1124
+ 'OAuth2PasswordBearer'
1125
+ ]
1126
+
1127
+ return self.api_client.param_serialize(
1128
+ method='POST',
1129
+ resource_path='/api/v1/chicken_nhl/team_stats',
1130
+ path_params=_path_params,
1131
+ query_params=_query_params,
1132
+ header_params=_header_params,
1133
+ body=_body_params,
1134
+ post_params=_form_params,
1135
+ files=_files,
1136
+ auth_settings=_auth_settings,
1137
+ collection_formats=_collection_formats,
1138
+ _host=_host,
1139
+ _request_auth=_request_auth
1140
+ )
1141
+
1142
+
1143
+
1144
+
1145
+ @validate_call
1146
+ def chicken_nhl_read_game_stats(
1147
+ self,
1148
+ season: Optional[List[StrictInt]] = None,
1149
+ sessions: Optional[List[StrictStr]] = None,
1150
+ game_id: Optional[List[StrictInt]] = None,
1151
+ level: Optional[StrictStr] = None,
1152
+ player: Optional[List[StrictStr]] = None,
1153
+ api_id: Optional[List[StrictInt]] = None,
1154
+ eh_id: Optional[List[StrictStr]] = None,
1155
+ team: Optional[List[StrictStr]] = None,
1156
+ opp_team: Optional[List[StrictStr]] = None,
1157
+ strength_state: Optional[List[StrictStr]] = None,
1158
+ score_state: Optional[StrictBool] = None,
1159
+ teammates: Optional[StrictBool] = None,
1160
+ opposition: Optional[StrictBool] = None,
1161
+ _request_timeout: Union[
1162
+ None,
1163
+ Annotated[StrictFloat, Field(gt=0)],
1164
+ Tuple[
1165
+ Annotated[StrictFloat, Field(gt=0)],
1166
+ Annotated[StrictFloat, Field(gt=0)]
1167
+ ]
1168
+ ] = None,
1169
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
1170
+ _content_type: Optional[StrictStr] = None,
1171
+ _headers: Optional[Dict[StrictStr, Any]] = None,
1172
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1173
+ ) -> List[StatsGame]:
1174
+ """Read Game Stats
1175
+
1176
+
1177
+ :param season:
1178
+ :type season: List[int]
1179
+ :param sessions:
1180
+ :type sessions: List[str]
1181
+ :param game_id:
1182
+ :type game_id: List[int]
1183
+ :param level:
1184
+ :type level: str
1185
+ :param player:
1186
+ :type player: List[str]
1187
+ :param api_id:
1188
+ :type api_id: List[int]
1189
+ :param eh_id:
1190
+ :type eh_id: List[str]
1191
+ :param team:
1192
+ :type team: List[str]
1193
+ :param opp_team:
1194
+ :type opp_team: List[str]
1195
+ :param strength_state:
1196
+ :type strength_state: List[str]
1197
+ :param score_state:
1198
+ :type score_state: bool
1199
+ :param teammates:
1200
+ :type teammates: bool
1201
+ :param opposition:
1202
+ :type opposition: bool
1203
+ :param _request_timeout: timeout setting for this request. If one
1204
+ number provided, it will be total request
1205
+ timeout. It can also be a pair (tuple) of
1206
+ (connection, read) timeouts.
1207
+ :type _request_timeout: int, tuple(int, int), optional
1208
+ :param _request_auth: set to override the auth_settings for an a single
1209
+ request; this effectively ignores the
1210
+ authentication in the spec for a single request.
1211
+ :type _request_auth: dict, optional
1212
+ :param _content_type: force content-type for the request.
1213
+ :type _content_type: str, Optional
1214
+ :param _headers: set to override the headers for a single
1215
+ request; this effectively ignores the headers
1216
+ in the spec for a single request.
1217
+ :type _headers: dict, optional
1218
+ :param _host_index: set to override the host_index for a single
1219
+ request; this effectively ignores the host_index
1220
+ in the spec for a single request.
1221
+ :type _host_index: int, optional
1222
+ :return: Returns the result object.
1223
+ """ # noqa: E501
1224
+
1225
+ _param = self._chicken_nhl_read_game_stats_serialize(
1226
+ season=season,
1227
+ sessions=sessions,
1228
+ game_id=game_id,
1229
+ level=level,
1230
+ player=player,
1231
+ api_id=api_id,
1232
+ eh_id=eh_id,
1233
+ team=team,
1234
+ opp_team=opp_team,
1235
+ strength_state=strength_state,
1236
+ score_state=score_state,
1237
+ teammates=teammates,
1238
+ opposition=opposition,
1239
+ _request_auth=_request_auth,
1240
+ _content_type=_content_type,
1241
+ _headers=_headers,
1242
+ _host_index=_host_index
1243
+ )
1244
+
1245
+ _response_types_map: Dict[str, Optional[str]] = {
1246
+ '200': "List[StatsGame]",
1247
+ '422': "HTTPValidationError",
1248
+ }
1249
+ response_data = self.api_client.call_api(
1250
+ *_param,
1251
+ _request_timeout=_request_timeout
1252
+ )
1253
+ response_data.read()
1254
+ return self.api_client.response_deserialize(
1255
+ response_data=response_data,
1256
+ response_types_map=_response_types_map,
1257
+ ).data
1258
+
1259
+
1260
+ @validate_call
1261
+ def chicken_nhl_read_game_stats_with_http_info(
1262
+ self,
1263
+ season: Optional[List[StrictInt]] = None,
1264
+ sessions: Optional[List[StrictStr]] = None,
1265
+ game_id: Optional[List[StrictInt]] = None,
1266
+ level: Optional[StrictStr] = None,
1267
+ player: Optional[List[StrictStr]] = None,
1268
+ api_id: Optional[List[StrictInt]] = None,
1269
+ eh_id: Optional[List[StrictStr]] = None,
1270
+ team: Optional[List[StrictStr]] = None,
1271
+ opp_team: Optional[List[StrictStr]] = None,
1272
+ strength_state: Optional[List[StrictStr]] = None,
1273
+ score_state: Optional[StrictBool] = None,
1274
+ teammates: Optional[StrictBool] = None,
1275
+ opposition: Optional[StrictBool] = None,
1276
+ _request_timeout: Union[
1277
+ None,
1278
+ Annotated[StrictFloat, Field(gt=0)],
1279
+ Tuple[
1280
+ Annotated[StrictFloat, Field(gt=0)],
1281
+ Annotated[StrictFloat, Field(gt=0)]
1282
+ ]
1283
+ ] = None,
1284
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
1285
+ _content_type: Optional[StrictStr] = None,
1286
+ _headers: Optional[Dict[StrictStr, Any]] = None,
1287
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1288
+ ) -> ApiResponse[List[StatsGame]]:
1289
+ """Read Game Stats
1290
+
1291
+
1292
+ :param season:
1293
+ :type season: List[int]
1294
+ :param sessions:
1295
+ :type sessions: List[str]
1296
+ :param game_id:
1297
+ :type game_id: List[int]
1298
+ :param level:
1299
+ :type level: str
1300
+ :param player:
1301
+ :type player: List[str]
1302
+ :param api_id:
1303
+ :type api_id: List[int]
1304
+ :param eh_id:
1305
+ :type eh_id: List[str]
1306
+ :param team:
1307
+ :type team: List[str]
1308
+ :param opp_team:
1309
+ :type opp_team: List[str]
1310
+ :param strength_state:
1311
+ :type strength_state: List[str]
1312
+ :param score_state:
1313
+ :type score_state: bool
1314
+ :param teammates:
1315
+ :type teammates: bool
1316
+ :param opposition:
1317
+ :type opposition: bool
1318
+ :param _request_timeout: timeout setting for this request. If one
1319
+ number provided, it will be total request
1320
+ timeout. It can also be a pair (tuple) of
1321
+ (connection, read) timeouts.
1322
+ :type _request_timeout: int, tuple(int, int), optional
1323
+ :param _request_auth: set to override the auth_settings for an a single
1324
+ request; this effectively ignores the
1325
+ authentication in the spec for a single request.
1326
+ :type _request_auth: dict, optional
1327
+ :param _content_type: force content-type for the request.
1328
+ :type _content_type: str, Optional
1329
+ :param _headers: set to override the headers for a single
1330
+ request; this effectively ignores the headers
1331
+ in the spec for a single request.
1332
+ :type _headers: dict, optional
1333
+ :param _host_index: set to override the host_index for a single
1334
+ request; this effectively ignores the host_index
1335
+ in the spec for a single request.
1336
+ :type _host_index: int, optional
1337
+ :return: Returns the result object.
1338
+ """ # noqa: E501
1339
+
1340
+ _param = self._chicken_nhl_read_game_stats_serialize(
1341
+ season=season,
1342
+ sessions=sessions,
1343
+ game_id=game_id,
1344
+ level=level,
1345
+ player=player,
1346
+ api_id=api_id,
1347
+ eh_id=eh_id,
1348
+ team=team,
1349
+ opp_team=opp_team,
1350
+ strength_state=strength_state,
1351
+ score_state=score_state,
1352
+ teammates=teammates,
1353
+ opposition=opposition,
1354
+ _request_auth=_request_auth,
1355
+ _content_type=_content_type,
1356
+ _headers=_headers,
1357
+ _host_index=_host_index
1358
+ )
1359
+
1360
+ _response_types_map: Dict[str, Optional[str]] = {
1361
+ '200': "List[StatsGame]",
1362
+ '422': "HTTPValidationError",
1363
+ }
1364
+ response_data = self.api_client.call_api(
1365
+ *_param,
1366
+ _request_timeout=_request_timeout
1367
+ )
1368
+ response_data.read()
1369
+ return self.api_client.response_deserialize(
1370
+ response_data=response_data,
1371
+ response_types_map=_response_types_map,
1372
+ )
1373
+
1374
+
1375
+ @validate_call
1376
+ def chicken_nhl_read_game_stats_without_preload_content(
1377
+ self,
1378
+ season: Optional[List[StrictInt]] = None,
1379
+ sessions: Optional[List[StrictStr]] = None,
1380
+ game_id: Optional[List[StrictInt]] = None,
1381
+ level: Optional[StrictStr] = None,
1382
+ player: Optional[List[StrictStr]] = None,
1383
+ api_id: Optional[List[StrictInt]] = None,
1384
+ eh_id: Optional[List[StrictStr]] = None,
1385
+ team: Optional[List[StrictStr]] = None,
1386
+ opp_team: Optional[List[StrictStr]] = None,
1387
+ strength_state: Optional[List[StrictStr]] = None,
1388
+ score_state: Optional[StrictBool] = None,
1389
+ teammates: Optional[StrictBool] = None,
1390
+ opposition: Optional[StrictBool] = None,
1391
+ _request_timeout: Union[
1392
+ None,
1393
+ Annotated[StrictFloat, Field(gt=0)],
1394
+ Tuple[
1395
+ Annotated[StrictFloat, Field(gt=0)],
1396
+ Annotated[StrictFloat, Field(gt=0)]
1397
+ ]
1398
+ ] = None,
1399
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
1400
+ _content_type: Optional[StrictStr] = None,
1401
+ _headers: Optional[Dict[StrictStr, Any]] = None,
1402
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1403
+ ) -> RESTResponseType:
1404
+ """Read Game Stats
1405
+
1406
+
1407
+ :param season:
1408
+ :type season: List[int]
1409
+ :param sessions:
1410
+ :type sessions: List[str]
1411
+ :param game_id:
1412
+ :type game_id: List[int]
1413
+ :param level:
1414
+ :type level: str
1415
+ :param player:
1416
+ :type player: List[str]
1417
+ :param api_id:
1418
+ :type api_id: List[int]
1419
+ :param eh_id:
1420
+ :type eh_id: List[str]
1421
+ :param team:
1422
+ :type team: List[str]
1423
+ :param opp_team:
1424
+ :type opp_team: List[str]
1425
+ :param strength_state:
1426
+ :type strength_state: List[str]
1427
+ :param score_state:
1428
+ :type score_state: bool
1429
+ :param teammates:
1430
+ :type teammates: bool
1431
+ :param opposition:
1432
+ :type opposition: bool
1433
+ :param _request_timeout: timeout setting for this request. If one
1434
+ number provided, it will be total request
1435
+ timeout. It can also be a pair (tuple) of
1436
+ (connection, read) timeouts.
1437
+ :type _request_timeout: int, tuple(int, int), optional
1438
+ :param _request_auth: set to override the auth_settings for an a single
1439
+ request; this effectively ignores the
1440
+ authentication in the spec for a single request.
1441
+ :type _request_auth: dict, optional
1442
+ :param _content_type: force content-type for the request.
1443
+ :type _content_type: str, Optional
1444
+ :param _headers: set to override the headers for a single
1445
+ request; this effectively ignores the headers
1446
+ in the spec for a single request.
1447
+ :type _headers: dict, optional
1448
+ :param _host_index: set to override the host_index for a single
1449
+ request; this effectively ignores the host_index
1450
+ in the spec for a single request.
1451
+ :type _host_index: int, optional
1452
+ :return: Returns the result object.
1453
+ """ # noqa: E501
1454
+
1455
+ _param = self._chicken_nhl_read_game_stats_serialize(
1456
+ season=season,
1457
+ sessions=sessions,
1458
+ game_id=game_id,
1459
+ level=level,
1460
+ player=player,
1461
+ api_id=api_id,
1462
+ eh_id=eh_id,
1463
+ team=team,
1464
+ opp_team=opp_team,
1465
+ strength_state=strength_state,
1466
+ score_state=score_state,
1467
+ teammates=teammates,
1468
+ opposition=opposition,
1469
+ _request_auth=_request_auth,
1470
+ _content_type=_content_type,
1471
+ _headers=_headers,
1472
+ _host_index=_host_index
1473
+ )
1474
+
1475
+ _response_types_map: Dict[str, Optional[str]] = {
1476
+ '200': "List[StatsGame]",
1477
+ '422': "HTTPValidationError",
1478
+ }
1479
+ response_data = self.api_client.call_api(
1480
+ *_param,
1481
+ _request_timeout=_request_timeout
1482
+ )
1483
+ return response_data.response
1484
+
1485
+
1486
+ def _chicken_nhl_read_game_stats_serialize(
1487
+ self,
1488
+ season,
1489
+ sessions,
1490
+ game_id,
1491
+ level,
1492
+ player,
1493
+ api_id,
1494
+ eh_id,
1495
+ team,
1496
+ opp_team,
1497
+ strength_state,
1498
+ score_state,
1499
+ teammates,
1500
+ opposition,
1501
+ _request_auth,
1502
+ _content_type,
1503
+ _headers,
1504
+ _host_index,
1505
+ ) -> RequestSerialized:
1506
+
1507
+ _host = None
1508
+
1509
+ _collection_formats: Dict[str, str] = {
1510
+ 'season': 'multi',
1511
+ 'sessions': 'multi',
1512
+ 'game_id': 'multi',
1513
+ 'player': 'multi',
1514
+ 'api_id': 'multi',
1515
+ 'eh_id': 'multi',
1516
+ 'team': 'multi',
1517
+ 'opp_team': 'multi',
1518
+ 'strength_state': 'multi',
1519
+ }
1520
+
1521
+ _path_params: Dict[str, str] = {}
1522
+ _query_params: List[Tuple[str, str]] = []
1523
+ _header_params: Dict[str, Optional[str]] = _headers or {}
1524
+ _form_params: List[Tuple[str, str]] = []
1525
+ _files: Dict[
1526
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1527
+ ] = {}
1528
+ _body_params: Optional[bytes] = None
1529
+
1530
+ # process the path parameters
1531
+ # process the query parameters
1532
+ if season is not None:
1533
+
1534
+ _query_params.append(('season', season))
1535
+
1536
+ if sessions is not None:
1537
+
1538
+ _query_params.append(('sessions', sessions))
1539
+
1540
+ if game_id is not None:
1541
+
1542
+ _query_params.append(('game_id', game_id))
1543
+
1544
+ if level is not None:
1545
+
1546
+ _query_params.append(('level', level))
1547
+
1548
+ if player is not None:
1549
+
1550
+ _query_params.append(('player', player))
1551
+
1552
+ if api_id is not None:
1553
+
1554
+ _query_params.append(('api_id', api_id))
1555
+
1556
+ if eh_id is not None:
1557
+
1558
+ _query_params.append(('eh_id', eh_id))
1559
+
1560
+ if team is not None:
1561
+
1562
+ _query_params.append(('team', team))
1563
+
1564
+ if opp_team is not None:
1565
+
1566
+ _query_params.append(('opp_team', opp_team))
1567
+
1568
+ if strength_state is not None:
1569
+
1570
+ _query_params.append(('strength_state', strength_state))
1571
+
1572
+ if score_state is not None:
1573
+
1574
+ _query_params.append(('score_state', score_state))
1575
+
1576
+ if teammates is not None:
1577
+
1578
+ _query_params.append(('teammates', teammates))
1579
+
1580
+ if opposition is not None:
1581
+
1582
+ _query_params.append(('opposition', opposition))
1583
+
1584
+ # process the header parameters
1585
+ # process the form parameters
1586
+ # process the body parameter
1587
+
1588
+
1589
+ # set the HTTP header `Accept`
1590
+ if 'Accept' not in _header_params:
1591
+ _header_params['Accept'] = self.api_client.select_header_accept(
1592
+ [
1593
+ 'application/json'
1594
+ ]
1595
+ )
1596
+
1597
+
1598
+ # authentication setting
1599
+ _auth_settings: List[str] = [
1600
+ 'OAuth2PasswordBearer'
1601
+ ]
1602
+
1603
+ return self.api_client.param_serialize(
1604
+ method='GET',
1605
+ resource_path='/api/v1/chicken_nhl/stats/game',
1606
+ path_params=_path_params,
1607
+ query_params=_query_params,
1608
+ header_params=_header_params,
1609
+ body=_body_params,
1610
+ post_params=_form_params,
1611
+ files=_files,
1612
+ auth_settings=_auth_settings,
1613
+ collection_formats=_collection_formats,
1614
+ _host=_host,
1615
+ _request_auth=_request_auth
1616
+ )
1617
+
1618
+
1619
+
1620
+
1621
+ @validate_call
1622
+ def chicken_nhl_read_lines_game_ids(
1623
+ self,
1624
+ season: Optional[List[StrictInt]] = None,
1625
+ sessions: Optional[List[StrictStr]] = None,
1626
+ _request_timeout: Union[
1627
+ None,
1628
+ Annotated[StrictFloat, Field(gt=0)],
1629
+ Tuple[
1630
+ Annotated[StrictFloat, Field(gt=0)],
1631
+ Annotated[StrictFloat, Field(gt=0)]
1632
+ ]
1633
+ ] = None,
1634
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
1635
+ _content_type: Optional[StrictStr] = None,
1636
+ _headers: Optional[Dict[StrictStr, Any]] = None,
1637
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1638
+ ) -> List[int]:
1639
+ """Read Lines Game Ids
1640
+
1641
+
1642
+ :param season:
1643
+ :type season: List[int]
1644
+ :param sessions:
1645
+ :type sessions: List[str]
1646
+ :param _request_timeout: timeout setting for this request. If one
1647
+ number provided, it will be total request
1648
+ timeout. It can also be a pair (tuple) of
1649
+ (connection, read) timeouts.
1650
+ :type _request_timeout: int, tuple(int, int), optional
1651
+ :param _request_auth: set to override the auth_settings for an a single
1652
+ request; this effectively ignores the
1653
+ authentication in the spec for a single request.
1654
+ :type _request_auth: dict, optional
1655
+ :param _content_type: force content-type for the request.
1656
+ :type _content_type: str, Optional
1657
+ :param _headers: set to override the headers for a single
1658
+ request; this effectively ignores the headers
1659
+ in the spec for a single request.
1660
+ :type _headers: dict, optional
1661
+ :param _host_index: set to override the host_index for a single
1662
+ request; this effectively ignores the host_index
1663
+ in the spec for a single request.
1664
+ :type _host_index: int, optional
1665
+ :return: Returns the result object.
1666
+ """ # noqa: E501
1667
+
1668
+ _param = self._chicken_nhl_read_lines_game_ids_serialize(
1669
+ season=season,
1670
+ sessions=sessions,
1671
+ _request_auth=_request_auth,
1672
+ _content_type=_content_type,
1673
+ _headers=_headers,
1674
+ _host_index=_host_index
1675
+ )
1676
+
1677
+ _response_types_map: Dict[str, Optional[str]] = {
1678
+ '200': "List[int]",
1679
+ '422': "HTTPValidationError",
1680
+ }
1681
+ response_data = self.api_client.call_api(
1682
+ *_param,
1683
+ _request_timeout=_request_timeout
1684
+ )
1685
+ response_data.read()
1686
+ return self.api_client.response_deserialize(
1687
+ response_data=response_data,
1688
+ response_types_map=_response_types_map,
1689
+ ).data
1690
+
1691
+
1692
+ @validate_call
1693
+ def chicken_nhl_read_lines_game_ids_with_http_info(
1694
+ self,
1695
+ season: Optional[List[StrictInt]] = None,
1696
+ sessions: Optional[List[StrictStr]] = None,
1697
+ _request_timeout: Union[
1698
+ None,
1699
+ Annotated[StrictFloat, Field(gt=0)],
1700
+ Tuple[
1701
+ Annotated[StrictFloat, Field(gt=0)],
1702
+ Annotated[StrictFloat, Field(gt=0)]
1703
+ ]
1704
+ ] = None,
1705
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
1706
+ _content_type: Optional[StrictStr] = None,
1707
+ _headers: Optional[Dict[StrictStr, Any]] = None,
1708
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1709
+ ) -> ApiResponse[List[int]]:
1710
+ """Read Lines Game Ids
1711
+
1712
+
1713
+ :param season:
1714
+ :type season: List[int]
1715
+ :param sessions:
1716
+ :type sessions: List[str]
1717
+ :param _request_timeout: timeout setting for this request. If one
1718
+ number provided, it will be total request
1719
+ timeout. It can also be a pair (tuple) of
1720
+ (connection, read) timeouts.
1721
+ :type _request_timeout: int, tuple(int, int), optional
1722
+ :param _request_auth: set to override the auth_settings for an a single
1723
+ request; this effectively ignores the
1724
+ authentication in the spec for a single request.
1725
+ :type _request_auth: dict, optional
1726
+ :param _content_type: force content-type for the request.
1727
+ :type _content_type: str, Optional
1728
+ :param _headers: set to override the headers for a single
1729
+ request; this effectively ignores the headers
1730
+ in the spec for a single request.
1731
+ :type _headers: dict, optional
1732
+ :param _host_index: set to override the host_index for a single
1733
+ request; this effectively ignores the host_index
1734
+ in the spec for a single request.
1735
+ :type _host_index: int, optional
1736
+ :return: Returns the result object.
1737
+ """ # noqa: E501
1738
+
1739
+ _param = self._chicken_nhl_read_lines_game_ids_serialize(
1740
+ season=season,
1741
+ sessions=sessions,
1742
+ _request_auth=_request_auth,
1743
+ _content_type=_content_type,
1744
+ _headers=_headers,
1745
+ _host_index=_host_index
1746
+ )
1747
+
1748
+ _response_types_map: Dict[str, Optional[str]] = {
1749
+ '200': "List[int]",
1750
+ '422': "HTTPValidationError",
1751
+ }
1752
+ response_data = self.api_client.call_api(
1753
+ *_param,
1754
+ _request_timeout=_request_timeout
1755
+ )
1756
+ response_data.read()
1757
+ return self.api_client.response_deserialize(
1758
+ response_data=response_data,
1759
+ response_types_map=_response_types_map,
1760
+ )
1761
+
1762
+
1763
+ @validate_call
1764
+ def chicken_nhl_read_lines_game_ids_without_preload_content(
1765
+ self,
1766
+ season: Optional[List[StrictInt]] = None,
1767
+ sessions: Optional[List[StrictStr]] = None,
1768
+ _request_timeout: Union[
1769
+ None,
1770
+ Annotated[StrictFloat, Field(gt=0)],
1771
+ Tuple[
1772
+ Annotated[StrictFloat, Field(gt=0)],
1773
+ Annotated[StrictFloat, Field(gt=0)]
1774
+ ]
1775
+ ] = None,
1776
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
1777
+ _content_type: Optional[StrictStr] = None,
1778
+ _headers: Optional[Dict[StrictStr, Any]] = None,
1779
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1780
+ ) -> RESTResponseType:
1781
+ """Read Lines Game Ids
1782
+
1783
+
1784
+ :param season:
1785
+ :type season: List[int]
1786
+ :param sessions:
1787
+ :type sessions: List[str]
1788
+ :param _request_timeout: timeout setting for this request. If one
1789
+ number provided, it will be total request
1790
+ timeout. It can also be a pair (tuple) of
1791
+ (connection, read) timeouts.
1792
+ :type _request_timeout: int, tuple(int, int), optional
1793
+ :param _request_auth: set to override the auth_settings for an a single
1794
+ request; this effectively ignores the
1795
+ authentication in the spec for a single request.
1796
+ :type _request_auth: dict, optional
1797
+ :param _content_type: force content-type for the request.
1798
+ :type _content_type: str, Optional
1799
+ :param _headers: set to override the headers for a single
1800
+ request; this effectively ignores the headers
1801
+ in the spec for a single request.
1802
+ :type _headers: dict, optional
1803
+ :param _host_index: set to override the host_index for a single
1804
+ request; this effectively ignores the host_index
1805
+ in the spec for a single request.
1806
+ :type _host_index: int, optional
1807
+ :return: Returns the result object.
1808
+ """ # noqa: E501
1809
+
1810
+ _param = self._chicken_nhl_read_lines_game_ids_serialize(
1811
+ season=season,
1812
+ sessions=sessions,
1813
+ _request_auth=_request_auth,
1814
+ _content_type=_content_type,
1815
+ _headers=_headers,
1816
+ _host_index=_host_index
1817
+ )
1818
+
1819
+ _response_types_map: Dict[str, Optional[str]] = {
1820
+ '200': "List[int]",
1821
+ '422': "HTTPValidationError",
1822
+ }
1823
+ response_data = self.api_client.call_api(
1824
+ *_param,
1825
+ _request_timeout=_request_timeout
1826
+ )
1827
+ return response_data.response
1828
+
1829
+
1830
+ def _chicken_nhl_read_lines_game_ids_serialize(
1831
+ self,
1832
+ season,
1833
+ sessions,
1834
+ _request_auth,
1835
+ _content_type,
1836
+ _headers,
1837
+ _host_index,
1838
+ ) -> RequestSerialized:
1839
+
1840
+ _host = None
1841
+
1842
+ _collection_formats: Dict[str, str] = {
1843
+ 'season': 'multi',
1844
+ 'sessions': 'multi',
1845
+ }
1846
+
1847
+ _path_params: Dict[str, str] = {}
1848
+ _query_params: List[Tuple[str, str]] = []
1849
+ _header_params: Dict[str, Optional[str]] = _headers or {}
1850
+ _form_params: List[Tuple[str, str]] = []
1851
+ _files: Dict[
1852
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1853
+ ] = {}
1854
+ _body_params: Optional[bytes] = None
1855
+
1856
+ # process the path parameters
1857
+ # process the query parameters
1858
+ if season is not None:
1859
+
1860
+ _query_params.append(('season', season))
1861
+
1862
+ if sessions is not None:
1863
+
1864
+ _query_params.append(('sessions', sessions))
1865
+
1866
+ # process the header parameters
1867
+ # process the form parameters
1868
+ # process the body parameter
1869
+
1870
+
1871
+ # set the HTTP header `Accept`
1872
+ if 'Accept' not in _header_params:
1873
+ _header_params['Accept'] = self.api_client.select_header_accept(
1874
+ [
1875
+ 'application/json'
1876
+ ]
1877
+ )
1878
+
1879
+
1880
+ # authentication setting
1881
+ _auth_settings: List[str] = [
1882
+ 'OAuth2PasswordBearer'
1883
+ ]
1884
+
1885
+ return self.api_client.param_serialize(
1886
+ method='GET',
1887
+ resource_path='/api/v1/chicken_nhl/lines/game_ids',
1888
+ path_params=_path_params,
1889
+ query_params=_query_params,
1890
+ header_params=_header_params,
1891
+ body=_body_params,
1892
+ post_params=_form_params,
1893
+ files=_files,
1894
+ auth_settings=_auth_settings,
1895
+ collection_formats=_collection_formats,
1896
+ _host=_host,
1897
+ _request_auth=_request_auth
1898
+ )
1899
+
1900
+
1901
+
1902
+
1903
+ @validate_call
1904
+ def chicken_nhl_read_pbp(
1905
+ self,
1906
+ season: Optional[List[StrictInt]] = None,
1907
+ sessions: Optional[List[StrictStr]] = None,
1908
+ game_id: Optional[List[StrictInt]] = None,
1909
+ event: Optional[List[StrictStr]] = None,
1910
+ player_1: Optional[List[StrictStr]] = None,
1911
+ goalie: Optional[List[StrictStr]] = None,
1912
+ event_team: Optional[List[StrictStr]] = None,
1913
+ opp_team: Optional[List[StrictStr]] = None,
1914
+ strength_state: Optional[List[StrictStr]] = None,
1915
+ _request_timeout: Union[
1916
+ None,
1917
+ Annotated[StrictFloat, Field(gt=0)],
1918
+ Tuple[
1919
+ Annotated[StrictFloat, Field(gt=0)],
1920
+ Annotated[StrictFloat, Field(gt=0)]
1921
+ ]
1922
+ ] = None,
1923
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
1924
+ _content_type: Optional[StrictStr] = None,
1925
+ _headers: Optional[Dict[StrictStr, Any]] = None,
1926
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1927
+ ) -> List[PbpPublic]:
1928
+ """Read Pbp
1929
+
1930
+
1931
+ :param season:
1932
+ :type season: List[int]
1933
+ :param sessions:
1934
+ :type sessions: List[str]
1935
+ :param game_id:
1936
+ :type game_id: List[int]
1937
+ :param event:
1938
+ :type event: List[str]
1939
+ :param player_1:
1940
+ :type player_1: List[str]
1941
+ :param goalie:
1942
+ :type goalie: List[str]
1943
+ :param event_team:
1944
+ :type event_team: List[str]
1945
+ :param opp_team:
1946
+ :type opp_team: List[str]
1947
+ :param strength_state:
1948
+ :type strength_state: List[str]
1949
+ :param _request_timeout: timeout setting for this request. If one
1950
+ number provided, it will be total request
1951
+ timeout. It can also be a pair (tuple) of
1952
+ (connection, read) timeouts.
1953
+ :type _request_timeout: int, tuple(int, int), optional
1954
+ :param _request_auth: set to override the auth_settings for an a single
1955
+ request; this effectively ignores the
1956
+ authentication in the spec for a single request.
1957
+ :type _request_auth: dict, optional
1958
+ :param _content_type: force content-type for the request.
1959
+ :type _content_type: str, Optional
1960
+ :param _headers: set to override the headers for a single
1961
+ request; this effectively ignores the headers
1962
+ in the spec for a single request.
1963
+ :type _headers: dict, optional
1964
+ :param _host_index: set to override the host_index for a single
1965
+ request; this effectively ignores the host_index
1966
+ in the spec for a single request.
1967
+ :type _host_index: int, optional
1968
+ :return: Returns the result object.
1969
+ """ # noqa: E501
1970
+
1971
+ _param = self._chicken_nhl_read_pbp_serialize(
1972
+ season=season,
1973
+ sessions=sessions,
1974
+ game_id=game_id,
1975
+ event=event,
1976
+ player_1=player_1,
1977
+ goalie=goalie,
1978
+ event_team=event_team,
1979
+ opp_team=opp_team,
1980
+ strength_state=strength_state,
1981
+ _request_auth=_request_auth,
1982
+ _content_type=_content_type,
1983
+ _headers=_headers,
1984
+ _host_index=_host_index
1985
+ )
1986
+
1987
+ _response_types_map: Dict[str, Optional[str]] = {
1988
+ '200': "List[PbpPublic]",
1989
+ '422': "HTTPValidationError",
1990
+ }
1991
+ response_data = self.api_client.call_api(
1992
+ *_param,
1993
+ _request_timeout=_request_timeout
1994
+ )
1995
+ response_data.read()
1996
+ return self.api_client.response_deserialize(
1997
+ response_data=response_data,
1998
+ response_types_map=_response_types_map,
1999
+ ).data
2000
+
2001
+
2002
+ @validate_call
2003
+ def chicken_nhl_read_pbp_with_http_info(
2004
+ self,
2005
+ season: Optional[List[StrictInt]] = None,
2006
+ sessions: Optional[List[StrictStr]] = None,
2007
+ game_id: Optional[List[StrictInt]] = None,
2008
+ event: Optional[List[StrictStr]] = None,
2009
+ player_1: Optional[List[StrictStr]] = None,
2010
+ goalie: Optional[List[StrictStr]] = None,
2011
+ event_team: Optional[List[StrictStr]] = None,
2012
+ opp_team: Optional[List[StrictStr]] = None,
2013
+ strength_state: Optional[List[StrictStr]] = None,
2014
+ _request_timeout: Union[
2015
+ None,
2016
+ Annotated[StrictFloat, Field(gt=0)],
2017
+ Tuple[
2018
+ Annotated[StrictFloat, Field(gt=0)],
2019
+ Annotated[StrictFloat, Field(gt=0)]
2020
+ ]
2021
+ ] = None,
2022
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
2023
+ _content_type: Optional[StrictStr] = None,
2024
+ _headers: Optional[Dict[StrictStr, Any]] = None,
2025
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2026
+ ) -> ApiResponse[List[PbpPublic]]:
2027
+ """Read Pbp
2028
+
2029
+
2030
+ :param season:
2031
+ :type season: List[int]
2032
+ :param sessions:
2033
+ :type sessions: List[str]
2034
+ :param game_id:
2035
+ :type game_id: List[int]
2036
+ :param event:
2037
+ :type event: List[str]
2038
+ :param player_1:
2039
+ :type player_1: List[str]
2040
+ :param goalie:
2041
+ :type goalie: List[str]
2042
+ :param event_team:
2043
+ :type event_team: List[str]
2044
+ :param opp_team:
2045
+ :type opp_team: List[str]
2046
+ :param strength_state:
2047
+ :type strength_state: List[str]
2048
+ :param _request_timeout: timeout setting for this request. If one
2049
+ number provided, it will be total request
2050
+ timeout. It can also be a pair (tuple) of
2051
+ (connection, read) timeouts.
2052
+ :type _request_timeout: int, tuple(int, int), optional
2053
+ :param _request_auth: set to override the auth_settings for an a single
2054
+ request; this effectively ignores the
2055
+ authentication in the spec for a single request.
2056
+ :type _request_auth: dict, optional
2057
+ :param _content_type: force content-type for the request.
2058
+ :type _content_type: str, Optional
2059
+ :param _headers: set to override the headers for a single
2060
+ request; this effectively ignores the headers
2061
+ in the spec for a single request.
2062
+ :type _headers: dict, optional
2063
+ :param _host_index: set to override the host_index for a single
2064
+ request; this effectively ignores the host_index
2065
+ in the spec for a single request.
2066
+ :type _host_index: int, optional
2067
+ :return: Returns the result object.
2068
+ """ # noqa: E501
2069
+
2070
+ _param = self._chicken_nhl_read_pbp_serialize(
2071
+ season=season,
2072
+ sessions=sessions,
2073
+ game_id=game_id,
2074
+ event=event,
2075
+ player_1=player_1,
2076
+ goalie=goalie,
2077
+ event_team=event_team,
2078
+ opp_team=opp_team,
2079
+ strength_state=strength_state,
2080
+ _request_auth=_request_auth,
2081
+ _content_type=_content_type,
2082
+ _headers=_headers,
2083
+ _host_index=_host_index
2084
+ )
2085
+
2086
+ _response_types_map: Dict[str, Optional[str]] = {
2087
+ '200': "List[PbpPublic]",
2088
+ '422': "HTTPValidationError",
2089
+ }
2090
+ response_data = self.api_client.call_api(
2091
+ *_param,
2092
+ _request_timeout=_request_timeout
2093
+ )
2094
+ response_data.read()
2095
+ return self.api_client.response_deserialize(
2096
+ response_data=response_data,
2097
+ response_types_map=_response_types_map,
2098
+ )
2099
+
2100
+
2101
+ @validate_call
2102
+ def chicken_nhl_read_pbp_without_preload_content(
2103
+ self,
2104
+ season: Optional[List[StrictInt]] = None,
2105
+ sessions: Optional[List[StrictStr]] = None,
2106
+ game_id: Optional[List[StrictInt]] = None,
2107
+ event: Optional[List[StrictStr]] = None,
2108
+ player_1: Optional[List[StrictStr]] = None,
2109
+ goalie: Optional[List[StrictStr]] = None,
2110
+ event_team: Optional[List[StrictStr]] = None,
2111
+ opp_team: Optional[List[StrictStr]] = None,
2112
+ strength_state: Optional[List[StrictStr]] = None,
2113
+ _request_timeout: Union[
2114
+ None,
2115
+ Annotated[StrictFloat, Field(gt=0)],
2116
+ Tuple[
2117
+ Annotated[StrictFloat, Field(gt=0)],
2118
+ Annotated[StrictFloat, Field(gt=0)]
2119
+ ]
2120
+ ] = None,
2121
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
2122
+ _content_type: Optional[StrictStr] = None,
2123
+ _headers: Optional[Dict[StrictStr, Any]] = None,
2124
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2125
+ ) -> RESTResponseType:
2126
+ """Read Pbp
2127
+
2128
+
2129
+ :param season:
2130
+ :type season: List[int]
2131
+ :param sessions:
2132
+ :type sessions: List[str]
2133
+ :param game_id:
2134
+ :type game_id: List[int]
2135
+ :param event:
2136
+ :type event: List[str]
2137
+ :param player_1:
2138
+ :type player_1: List[str]
2139
+ :param goalie:
2140
+ :type goalie: List[str]
2141
+ :param event_team:
2142
+ :type event_team: List[str]
2143
+ :param opp_team:
2144
+ :type opp_team: List[str]
2145
+ :param strength_state:
2146
+ :type strength_state: List[str]
2147
+ :param _request_timeout: timeout setting for this request. If one
2148
+ number provided, it will be total request
2149
+ timeout. It can also be a pair (tuple) of
2150
+ (connection, read) timeouts.
2151
+ :type _request_timeout: int, tuple(int, int), optional
2152
+ :param _request_auth: set to override the auth_settings for an a single
2153
+ request; this effectively ignores the
2154
+ authentication in the spec for a single request.
2155
+ :type _request_auth: dict, optional
2156
+ :param _content_type: force content-type for the request.
2157
+ :type _content_type: str, Optional
2158
+ :param _headers: set to override the headers for a single
2159
+ request; this effectively ignores the headers
2160
+ in the spec for a single request.
2161
+ :type _headers: dict, optional
2162
+ :param _host_index: set to override the host_index for a single
2163
+ request; this effectively ignores the host_index
2164
+ in the spec for a single request.
2165
+ :type _host_index: int, optional
2166
+ :return: Returns the result object.
2167
+ """ # noqa: E501
2168
+
2169
+ _param = self._chicken_nhl_read_pbp_serialize(
2170
+ season=season,
2171
+ sessions=sessions,
2172
+ game_id=game_id,
2173
+ event=event,
2174
+ player_1=player_1,
2175
+ goalie=goalie,
2176
+ event_team=event_team,
2177
+ opp_team=opp_team,
2178
+ strength_state=strength_state,
2179
+ _request_auth=_request_auth,
2180
+ _content_type=_content_type,
2181
+ _headers=_headers,
2182
+ _host_index=_host_index
2183
+ )
2184
+
2185
+ _response_types_map: Dict[str, Optional[str]] = {
2186
+ '200': "List[PbpPublic]",
2187
+ '422': "HTTPValidationError",
2188
+ }
2189
+ response_data = self.api_client.call_api(
2190
+ *_param,
2191
+ _request_timeout=_request_timeout
2192
+ )
2193
+ return response_data.response
2194
+
2195
+
2196
+ def _chicken_nhl_read_pbp_serialize(
2197
+ self,
2198
+ season,
2199
+ sessions,
2200
+ game_id,
2201
+ event,
2202
+ player_1,
2203
+ goalie,
2204
+ event_team,
2205
+ opp_team,
2206
+ strength_state,
2207
+ _request_auth,
2208
+ _content_type,
2209
+ _headers,
2210
+ _host_index,
2211
+ ) -> RequestSerialized:
2212
+
2213
+ _host = None
2214
+
2215
+ _collection_formats: Dict[str, str] = {
2216
+ 'season': 'multi',
2217
+ 'sessions': 'multi',
2218
+ 'game_id': 'multi',
2219
+ 'event': 'multi',
2220
+ 'player_1': 'multi',
2221
+ 'goalie': 'multi',
2222
+ 'event_team': 'multi',
2223
+ 'opp_team': 'multi',
2224
+ 'strength_state': 'multi',
2225
+ }
2226
+
2227
+ _path_params: Dict[str, str] = {}
2228
+ _query_params: List[Tuple[str, str]] = []
2229
+ _header_params: Dict[str, Optional[str]] = _headers or {}
2230
+ _form_params: List[Tuple[str, str]] = []
2231
+ _files: Dict[
2232
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2233
+ ] = {}
2234
+ _body_params: Optional[bytes] = None
2235
+
2236
+ # process the path parameters
2237
+ # process the query parameters
2238
+ if season is not None:
2239
+
2240
+ _query_params.append(('season', season))
2241
+
2242
+ if sessions is not None:
2243
+
2244
+ _query_params.append(('sessions', sessions))
2245
+
2246
+ if game_id is not None:
2247
+
2248
+ _query_params.append(('game_id', game_id))
2249
+
2250
+ if event is not None:
2251
+
2252
+ _query_params.append(('event', event))
2253
+
2254
+ if player_1 is not None:
2255
+
2256
+ _query_params.append(('player_1', player_1))
2257
+
2258
+ if goalie is not None:
2259
+
2260
+ _query_params.append(('goalie', goalie))
2261
+
2262
+ if event_team is not None:
2263
+
2264
+ _query_params.append(('event_team', event_team))
2265
+
2266
+ if opp_team is not None:
2267
+
2268
+ _query_params.append(('opp_team', opp_team))
2269
+
2270
+ if strength_state is not None:
2271
+
2272
+ _query_params.append(('strength_state', strength_state))
2273
+
2274
+ # process the header parameters
2275
+ # process the form parameters
2276
+ # process the body parameter
2277
+
2278
+
2279
+ # set the HTTP header `Accept`
2280
+ if 'Accept' not in _header_params:
2281
+ _header_params['Accept'] = self.api_client.select_header_accept(
2282
+ [
2283
+ 'application/json'
2284
+ ]
2285
+ )
2286
+
2287
+
2288
+ # authentication setting
2289
+ _auth_settings: List[str] = [
2290
+ 'OAuth2PasswordBearer'
2291
+ ]
2292
+
2293
+ return self.api_client.param_serialize(
2294
+ method='GET',
2295
+ resource_path='/api/v1/chicken_nhl/play_by_play',
2296
+ path_params=_path_params,
2297
+ query_params=_query_params,
2298
+ header_params=_header_params,
2299
+ body=_body_params,
2300
+ post_params=_form_params,
2301
+ files=_files,
2302
+ auth_settings=_auth_settings,
2303
+ collection_formats=_collection_formats,
2304
+ _host=_host,
2305
+ _request_auth=_request_auth
2306
+ )
2307
+
2308
+
2309
+
2310
+
2311
+ @validate_call
2312
+ def chicken_nhl_read_pbp_game_ids(
2313
+ self,
2314
+ season: Optional[List[StrictInt]] = None,
2315
+ sessions: Optional[List[StrictStr]] = None,
2316
+ _request_timeout: Union[
2317
+ None,
2318
+ Annotated[StrictFloat, Field(gt=0)],
2319
+ Tuple[
2320
+ Annotated[StrictFloat, Field(gt=0)],
2321
+ Annotated[StrictFloat, Field(gt=0)]
2322
+ ]
2323
+ ] = None,
2324
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
2325
+ _content_type: Optional[StrictStr] = None,
2326
+ _headers: Optional[Dict[StrictStr, Any]] = None,
2327
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2328
+ ) -> List[int]:
2329
+ """Read Pbp Game Ids
2330
+
2331
+
2332
+ :param season:
2333
+ :type season: List[int]
2334
+ :param sessions:
2335
+ :type sessions: List[str]
2336
+ :param _request_timeout: timeout setting for this request. If one
2337
+ number provided, it will be total request
2338
+ timeout. It can also be a pair (tuple) of
2339
+ (connection, read) timeouts.
2340
+ :type _request_timeout: int, tuple(int, int), optional
2341
+ :param _request_auth: set to override the auth_settings for an a single
2342
+ request; this effectively ignores the
2343
+ authentication in the spec for a single request.
2344
+ :type _request_auth: dict, optional
2345
+ :param _content_type: force content-type for the request.
2346
+ :type _content_type: str, Optional
2347
+ :param _headers: set to override the headers for a single
2348
+ request; this effectively ignores the headers
2349
+ in the spec for a single request.
2350
+ :type _headers: dict, optional
2351
+ :param _host_index: set to override the host_index for a single
2352
+ request; this effectively ignores the host_index
2353
+ in the spec for a single request.
2354
+ :type _host_index: int, optional
2355
+ :return: Returns the result object.
2356
+ """ # noqa: E501
2357
+
2358
+ _param = self._chicken_nhl_read_pbp_game_ids_serialize(
2359
+ season=season,
2360
+ sessions=sessions,
2361
+ _request_auth=_request_auth,
2362
+ _content_type=_content_type,
2363
+ _headers=_headers,
2364
+ _host_index=_host_index
2365
+ )
2366
+
2367
+ _response_types_map: Dict[str, Optional[str]] = {
2368
+ '200': "List[int]",
2369
+ '422': "HTTPValidationError",
2370
+ }
2371
+ response_data = self.api_client.call_api(
2372
+ *_param,
2373
+ _request_timeout=_request_timeout
2374
+ )
2375
+ response_data.read()
2376
+ return self.api_client.response_deserialize(
2377
+ response_data=response_data,
2378
+ response_types_map=_response_types_map,
2379
+ ).data
2380
+
2381
+
2382
+ @validate_call
2383
+ def chicken_nhl_read_pbp_game_ids_with_http_info(
2384
+ self,
2385
+ season: Optional[List[StrictInt]] = None,
2386
+ sessions: Optional[List[StrictStr]] = None,
2387
+ _request_timeout: Union[
2388
+ None,
2389
+ Annotated[StrictFloat, Field(gt=0)],
2390
+ Tuple[
2391
+ Annotated[StrictFloat, Field(gt=0)],
2392
+ Annotated[StrictFloat, Field(gt=0)]
2393
+ ]
2394
+ ] = None,
2395
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
2396
+ _content_type: Optional[StrictStr] = None,
2397
+ _headers: Optional[Dict[StrictStr, Any]] = None,
2398
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2399
+ ) -> ApiResponse[List[int]]:
2400
+ """Read Pbp Game Ids
2401
+
2402
+
2403
+ :param season:
2404
+ :type season: List[int]
2405
+ :param sessions:
2406
+ :type sessions: List[str]
2407
+ :param _request_timeout: timeout setting for this request. If one
2408
+ number provided, it will be total request
2409
+ timeout. It can also be a pair (tuple) of
2410
+ (connection, read) timeouts.
2411
+ :type _request_timeout: int, tuple(int, int), optional
2412
+ :param _request_auth: set to override the auth_settings for an a single
2413
+ request; this effectively ignores the
2414
+ authentication in the spec for a single request.
2415
+ :type _request_auth: dict, optional
2416
+ :param _content_type: force content-type for the request.
2417
+ :type _content_type: str, Optional
2418
+ :param _headers: set to override the headers for a single
2419
+ request; this effectively ignores the headers
2420
+ in the spec for a single request.
2421
+ :type _headers: dict, optional
2422
+ :param _host_index: set to override the host_index for a single
2423
+ request; this effectively ignores the host_index
2424
+ in the spec for a single request.
2425
+ :type _host_index: int, optional
2426
+ :return: Returns the result object.
2427
+ """ # noqa: E501
2428
+
2429
+ _param = self._chicken_nhl_read_pbp_game_ids_serialize(
2430
+ season=season,
2431
+ sessions=sessions,
2432
+ _request_auth=_request_auth,
2433
+ _content_type=_content_type,
2434
+ _headers=_headers,
2435
+ _host_index=_host_index
2436
+ )
2437
+
2438
+ _response_types_map: Dict[str, Optional[str]] = {
2439
+ '200': "List[int]",
2440
+ '422': "HTTPValidationError",
2441
+ }
2442
+ response_data = self.api_client.call_api(
2443
+ *_param,
2444
+ _request_timeout=_request_timeout
2445
+ )
2446
+ response_data.read()
2447
+ return self.api_client.response_deserialize(
2448
+ response_data=response_data,
2449
+ response_types_map=_response_types_map,
2450
+ )
2451
+
2452
+
2453
+ @validate_call
2454
+ def chicken_nhl_read_pbp_game_ids_without_preload_content(
2455
+ self,
2456
+ season: Optional[List[StrictInt]] = None,
2457
+ sessions: Optional[List[StrictStr]] = None,
2458
+ _request_timeout: Union[
2459
+ None,
2460
+ Annotated[StrictFloat, Field(gt=0)],
2461
+ Tuple[
2462
+ Annotated[StrictFloat, Field(gt=0)],
2463
+ Annotated[StrictFloat, Field(gt=0)]
2464
+ ]
2465
+ ] = None,
2466
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
2467
+ _content_type: Optional[StrictStr] = None,
2468
+ _headers: Optional[Dict[StrictStr, Any]] = None,
2469
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2470
+ ) -> RESTResponseType:
2471
+ """Read Pbp Game Ids
2472
+
2473
+
2474
+ :param season:
2475
+ :type season: List[int]
2476
+ :param sessions:
2477
+ :type sessions: List[str]
2478
+ :param _request_timeout: timeout setting for this request. If one
2479
+ number provided, it will be total request
2480
+ timeout. It can also be a pair (tuple) of
2481
+ (connection, read) timeouts.
2482
+ :type _request_timeout: int, tuple(int, int), optional
2483
+ :param _request_auth: set to override the auth_settings for an a single
2484
+ request; this effectively ignores the
2485
+ authentication in the spec for a single request.
2486
+ :type _request_auth: dict, optional
2487
+ :param _content_type: force content-type for the request.
2488
+ :type _content_type: str, Optional
2489
+ :param _headers: set to override the headers for a single
2490
+ request; this effectively ignores the headers
2491
+ in the spec for a single request.
2492
+ :type _headers: dict, optional
2493
+ :param _host_index: set to override the host_index for a single
2494
+ request; this effectively ignores the host_index
2495
+ in the spec for a single request.
2496
+ :type _host_index: int, optional
2497
+ :return: Returns the result object.
2498
+ """ # noqa: E501
2499
+
2500
+ _param = self._chicken_nhl_read_pbp_game_ids_serialize(
2501
+ season=season,
2502
+ sessions=sessions,
2503
+ _request_auth=_request_auth,
2504
+ _content_type=_content_type,
2505
+ _headers=_headers,
2506
+ _host_index=_host_index
2507
+ )
2508
+
2509
+ _response_types_map: Dict[str, Optional[str]] = {
2510
+ '200': "List[int]",
2511
+ '422': "HTTPValidationError",
2512
+ }
2513
+ response_data = self.api_client.call_api(
2514
+ *_param,
2515
+ _request_timeout=_request_timeout
2516
+ )
2517
+ return response_data.response
2518
+
2519
+
2520
+ def _chicken_nhl_read_pbp_game_ids_serialize(
2521
+ self,
2522
+ season,
2523
+ sessions,
2524
+ _request_auth,
2525
+ _content_type,
2526
+ _headers,
2527
+ _host_index,
2528
+ ) -> RequestSerialized:
2529
+
2530
+ _host = None
2531
+
2532
+ _collection_formats: Dict[str, str] = {
2533
+ 'season': 'multi',
2534
+ 'sessions': 'multi',
2535
+ }
2536
+
2537
+ _path_params: Dict[str, str] = {}
2538
+ _query_params: List[Tuple[str, str]] = []
2539
+ _header_params: Dict[str, Optional[str]] = _headers or {}
2540
+ _form_params: List[Tuple[str, str]] = []
2541
+ _files: Dict[
2542
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2543
+ ] = {}
2544
+ _body_params: Optional[bytes] = None
2545
+
2546
+ # process the path parameters
2547
+ # process the query parameters
2548
+ if season is not None:
2549
+
2550
+ _query_params.append(('season', season))
2551
+
2552
+ if sessions is not None:
2553
+
2554
+ _query_params.append(('sessions', sessions))
2555
+
2556
+ # process the header parameters
2557
+ # process the form parameters
2558
+ # process the body parameter
2559
+
2560
+
2561
+ # set the HTTP header `Accept`
2562
+ if 'Accept' not in _header_params:
2563
+ _header_params['Accept'] = self.api_client.select_header_accept(
2564
+ [
2565
+ 'application/json'
2566
+ ]
2567
+ )
2568
+
2569
+
2570
+ # authentication setting
2571
+ _auth_settings: List[str] = [
2572
+ 'OAuth2PasswordBearer'
2573
+ ]
2574
+
2575
+ return self.api_client.param_serialize(
2576
+ method='GET',
2577
+ resource_path='/api/v1/chicken_nhl/play_by_play/game_ids',
2578
+ path_params=_path_params,
2579
+ query_params=_query_params,
2580
+ header_params=_header_params,
2581
+ body=_body_params,
2582
+ post_params=_form_params,
2583
+ files=_files,
2584
+ auth_settings=_auth_settings,
2585
+ collection_formats=_collection_formats,
2586
+ _host=_host,
2587
+ _request_auth=_request_auth
2588
+ )
2589
+
2590
+
2591
+
2592
+
2593
+ @validate_call
2594
+ def chicken_nhl_read_pbp_play_ids(
2595
+ self,
2596
+ season: Optional[List[StrictInt]] = None,
2597
+ sessions: Optional[List[StrictStr]] = None,
2598
+ game_id: Optional[List[StrictInt]] = None,
2599
+ _request_timeout: Union[
2600
+ None,
2601
+ Annotated[StrictFloat, Field(gt=0)],
2602
+ Tuple[
2603
+ Annotated[StrictFloat, Field(gt=0)],
2604
+ Annotated[StrictFloat, Field(gt=0)]
2605
+ ]
2606
+ ] = None,
2607
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
2608
+ _content_type: Optional[StrictStr] = None,
2609
+ _headers: Optional[Dict[StrictStr, Any]] = None,
2610
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2611
+ ) -> List[int]:
2612
+ """Read Pbp Play Ids
2613
+
2614
+
2615
+ :param season:
2616
+ :type season: List[int]
2617
+ :param sessions:
2618
+ :type sessions: List[str]
2619
+ :param game_id:
2620
+ :type game_id: List[int]
2621
+ :param _request_timeout: timeout setting for this request. If one
2622
+ number provided, it will be total request
2623
+ timeout. It can also be a pair (tuple) of
2624
+ (connection, read) timeouts.
2625
+ :type _request_timeout: int, tuple(int, int), optional
2626
+ :param _request_auth: set to override the auth_settings for an a single
2627
+ request; this effectively ignores the
2628
+ authentication in the spec for a single request.
2629
+ :type _request_auth: dict, optional
2630
+ :param _content_type: force content-type for the request.
2631
+ :type _content_type: str, Optional
2632
+ :param _headers: set to override the headers for a single
2633
+ request; this effectively ignores the headers
2634
+ in the spec for a single request.
2635
+ :type _headers: dict, optional
2636
+ :param _host_index: set to override the host_index for a single
2637
+ request; this effectively ignores the host_index
2638
+ in the spec for a single request.
2639
+ :type _host_index: int, optional
2640
+ :return: Returns the result object.
2641
+ """ # noqa: E501
2642
+
2643
+ _param = self._chicken_nhl_read_pbp_play_ids_serialize(
2644
+ season=season,
2645
+ sessions=sessions,
2646
+ game_id=game_id,
2647
+ _request_auth=_request_auth,
2648
+ _content_type=_content_type,
2649
+ _headers=_headers,
2650
+ _host_index=_host_index
2651
+ )
2652
+
2653
+ _response_types_map: Dict[str, Optional[str]] = {
2654
+ '200': "List[int]",
2655
+ '422': "HTTPValidationError",
2656
+ }
2657
+ response_data = self.api_client.call_api(
2658
+ *_param,
2659
+ _request_timeout=_request_timeout
2660
+ )
2661
+ response_data.read()
2662
+ return self.api_client.response_deserialize(
2663
+ response_data=response_data,
2664
+ response_types_map=_response_types_map,
2665
+ ).data
2666
+
2667
+
2668
+ @validate_call
2669
+ def chicken_nhl_read_pbp_play_ids_with_http_info(
2670
+ self,
2671
+ season: Optional[List[StrictInt]] = None,
2672
+ sessions: Optional[List[StrictStr]] = None,
2673
+ game_id: Optional[List[StrictInt]] = None,
2674
+ _request_timeout: Union[
2675
+ None,
2676
+ Annotated[StrictFloat, Field(gt=0)],
2677
+ Tuple[
2678
+ Annotated[StrictFloat, Field(gt=0)],
2679
+ Annotated[StrictFloat, Field(gt=0)]
2680
+ ]
2681
+ ] = None,
2682
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
2683
+ _content_type: Optional[StrictStr] = None,
2684
+ _headers: Optional[Dict[StrictStr, Any]] = None,
2685
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2686
+ ) -> ApiResponse[List[int]]:
2687
+ """Read Pbp Play Ids
2688
+
2689
+
2690
+ :param season:
2691
+ :type season: List[int]
2692
+ :param sessions:
2693
+ :type sessions: List[str]
2694
+ :param game_id:
2695
+ :type game_id: List[int]
2696
+ :param _request_timeout: timeout setting for this request. If one
2697
+ number provided, it will be total request
2698
+ timeout. It can also be a pair (tuple) of
2699
+ (connection, read) timeouts.
2700
+ :type _request_timeout: int, tuple(int, int), optional
2701
+ :param _request_auth: set to override the auth_settings for an a single
2702
+ request; this effectively ignores the
2703
+ authentication in the spec for a single request.
2704
+ :type _request_auth: dict, optional
2705
+ :param _content_type: force content-type for the request.
2706
+ :type _content_type: str, Optional
2707
+ :param _headers: set to override the headers for a single
2708
+ request; this effectively ignores the headers
2709
+ in the spec for a single request.
2710
+ :type _headers: dict, optional
2711
+ :param _host_index: set to override the host_index for a single
2712
+ request; this effectively ignores the host_index
2713
+ in the spec for a single request.
2714
+ :type _host_index: int, optional
2715
+ :return: Returns the result object.
2716
+ """ # noqa: E501
2717
+
2718
+ _param = self._chicken_nhl_read_pbp_play_ids_serialize(
2719
+ season=season,
2720
+ sessions=sessions,
2721
+ game_id=game_id,
2722
+ _request_auth=_request_auth,
2723
+ _content_type=_content_type,
2724
+ _headers=_headers,
2725
+ _host_index=_host_index
2726
+ )
2727
+
2728
+ _response_types_map: Dict[str, Optional[str]] = {
2729
+ '200': "List[int]",
2730
+ '422': "HTTPValidationError",
2731
+ }
2732
+ response_data = self.api_client.call_api(
2733
+ *_param,
2734
+ _request_timeout=_request_timeout
2735
+ )
2736
+ response_data.read()
2737
+ return self.api_client.response_deserialize(
2738
+ response_data=response_data,
2739
+ response_types_map=_response_types_map,
2740
+ )
2741
+
2742
+
2743
+ @validate_call
2744
+ def chicken_nhl_read_pbp_play_ids_without_preload_content(
2745
+ self,
2746
+ season: Optional[List[StrictInt]] = None,
2747
+ sessions: Optional[List[StrictStr]] = None,
2748
+ game_id: Optional[List[StrictInt]] = None,
2749
+ _request_timeout: Union[
2750
+ None,
2751
+ Annotated[StrictFloat, Field(gt=0)],
2752
+ Tuple[
2753
+ Annotated[StrictFloat, Field(gt=0)],
2754
+ Annotated[StrictFloat, Field(gt=0)]
2755
+ ]
2756
+ ] = None,
2757
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
2758
+ _content_type: Optional[StrictStr] = None,
2759
+ _headers: Optional[Dict[StrictStr, Any]] = None,
2760
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2761
+ ) -> RESTResponseType:
2762
+ """Read Pbp Play Ids
2763
+
2764
+
2765
+ :param season:
2766
+ :type season: List[int]
2767
+ :param sessions:
2768
+ :type sessions: List[str]
2769
+ :param game_id:
2770
+ :type game_id: List[int]
2771
+ :param _request_timeout: timeout setting for this request. If one
2772
+ number provided, it will be total request
2773
+ timeout. It can also be a pair (tuple) of
2774
+ (connection, read) timeouts.
2775
+ :type _request_timeout: int, tuple(int, int), optional
2776
+ :param _request_auth: set to override the auth_settings for an a single
2777
+ request; this effectively ignores the
2778
+ authentication in the spec for a single request.
2779
+ :type _request_auth: dict, optional
2780
+ :param _content_type: force content-type for the request.
2781
+ :type _content_type: str, Optional
2782
+ :param _headers: set to override the headers for a single
2783
+ request; this effectively ignores the headers
2784
+ in the spec for a single request.
2785
+ :type _headers: dict, optional
2786
+ :param _host_index: set to override the host_index for a single
2787
+ request; this effectively ignores the host_index
2788
+ in the spec for a single request.
2789
+ :type _host_index: int, optional
2790
+ :return: Returns the result object.
2791
+ """ # noqa: E501
2792
+
2793
+ _param = self._chicken_nhl_read_pbp_play_ids_serialize(
2794
+ season=season,
2795
+ sessions=sessions,
2796
+ game_id=game_id,
2797
+ _request_auth=_request_auth,
2798
+ _content_type=_content_type,
2799
+ _headers=_headers,
2800
+ _host_index=_host_index
2801
+ )
2802
+
2803
+ _response_types_map: Dict[str, Optional[str]] = {
2804
+ '200': "List[int]",
2805
+ '422': "HTTPValidationError",
2806
+ }
2807
+ response_data = self.api_client.call_api(
2808
+ *_param,
2809
+ _request_timeout=_request_timeout
2810
+ )
2811
+ return response_data.response
2812
+
2813
+
2814
+ def _chicken_nhl_read_pbp_play_ids_serialize(
2815
+ self,
2816
+ season,
2817
+ sessions,
2818
+ game_id,
2819
+ _request_auth,
2820
+ _content_type,
2821
+ _headers,
2822
+ _host_index,
2823
+ ) -> RequestSerialized:
2824
+
2825
+ _host = None
2826
+
2827
+ _collection_formats: Dict[str, str] = {
2828
+ 'season': 'multi',
2829
+ 'sessions': 'multi',
2830
+ 'game_id': 'multi',
2831
+ }
2832
+
2833
+ _path_params: Dict[str, str] = {}
2834
+ _query_params: List[Tuple[str, str]] = []
2835
+ _header_params: Dict[str, Optional[str]] = _headers or {}
2836
+ _form_params: List[Tuple[str, str]] = []
2837
+ _files: Dict[
2838
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2839
+ ] = {}
2840
+ _body_params: Optional[bytes] = None
2841
+
2842
+ # process the path parameters
2843
+ # process the query parameters
2844
+ if season is not None:
2845
+
2846
+ _query_params.append(('season', season))
2847
+
2848
+ if sessions is not None:
2849
+
2850
+ _query_params.append(('sessions', sessions))
2851
+
2852
+ if game_id is not None:
2853
+
2854
+ _query_params.append(('game_id', game_id))
2855
+
2856
+ # process the header parameters
2857
+ # process the form parameters
2858
+ # process the body parameter
2859
+
2860
+
2861
+ # set the HTTP header `Accept`
2862
+ if 'Accept' not in _header_params:
2863
+ _header_params['Accept'] = self.api_client.select_header_accept(
2864
+ [
2865
+ 'application/json'
2866
+ ]
2867
+ )
2868
+
2869
+
2870
+ # authentication setting
2871
+ _auth_settings: List[str] = [
2872
+ 'OAuth2PasswordBearer'
2873
+ ]
2874
+
2875
+ return self.api_client.param_serialize(
2876
+ method='GET',
2877
+ resource_path='/api/v1/chicken_nhl/play_by_play/play_ids',
2878
+ path_params=_path_params,
2879
+ query_params=_query_params,
2880
+ header_params=_header_params,
2881
+ body=_body_params,
2882
+ post_params=_form_params,
2883
+ files=_files,
2884
+ auth_settings=_auth_settings,
2885
+ collection_formats=_collection_formats,
2886
+ _host=_host,
2887
+ _request_auth=_request_auth
2888
+ )
2889
+
2890
+
2891
+
2892
+
2893
+ @validate_call
2894
+ def chicken_nhl_read_season_stats(
2895
+ self,
2896
+ season: Optional[List[StrictInt]] = None,
2897
+ sessions: Optional[List[StrictStr]] = None,
2898
+ player: Optional[List[StrictStr]] = None,
2899
+ api_id: Optional[List[StrictInt]] = None,
2900
+ eh_id: Optional[List[StrictStr]] = None,
2901
+ team: Optional[List[StrictStr]] = None,
2902
+ opp_team: Optional[List[StrictStr]] = None,
2903
+ strength_state: Optional[List[StrictStr]] = None,
2904
+ score_state: Optional[StrictBool] = None,
2905
+ teammates: Optional[StrictBool] = None,
2906
+ opposition: Optional[StrictBool] = None,
2907
+ _request_timeout: Union[
2908
+ None,
2909
+ Annotated[StrictFloat, Field(gt=0)],
2910
+ Tuple[
2911
+ Annotated[StrictFloat, Field(gt=0)],
2912
+ Annotated[StrictFloat, Field(gt=0)]
2913
+ ]
2914
+ ] = None,
2915
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
2916
+ _content_type: Optional[StrictStr] = None,
2917
+ _headers: Optional[Dict[StrictStr, Any]] = None,
2918
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2919
+ ) -> List[StatsSeason]:
2920
+ """Read Season Stats
2921
+
2922
+
2923
+ :param season:
2924
+ :type season: List[int]
2925
+ :param sessions:
2926
+ :type sessions: List[str]
2927
+ :param player:
2928
+ :type player: List[str]
2929
+ :param api_id:
2930
+ :type api_id: List[int]
2931
+ :param eh_id:
2932
+ :type eh_id: List[str]
2933
+ :param team:
2934
+ :type team: List[str]
2935
+ :param opp_team:
2936
+ :type opp_team: List[str]
2937
+ :param strength_state:
2938
+ :type strength_state: List[str]
2939
+ :param score_state:
2940
+ :type score_state: bool
2941
+ :param teammates:
2942
+ :type teammates: bool
2943
+ :param opposition:
2944
+ :type opposition: bool
2945
+ :param _request_timeout: timeout setting for this request. If one
2946
+ number provided, it will be total request
2947
+ timeout. It can also be a pair (tuple) of
2948
+ (connection, read) timeouts.
2949
+ :type _request_timeout: int, tuple(int, int), optional
2950
+ :param _request_auth: set to override the auth_settings for an a single
2951
+ request; this effectively ignores the
2952
+ authentication in the spec for a single request.
2953
+ :type _request_auth: dict, optional
2954
+ :param _content_type: force content-type for the request.
2955
+ :type _content_type: str, Optional
2956
+ :param _headers: set to override the headers for a single
2957
+ request; this effectively ignores the headers
2958
+ in the spec for a single request.
2959
+ :type _headers: dict, optional
2960
+ :param _host_index: set to override the host_index for a single
2961
+ request; this effectively ignores the host_index
2962
+ in the spec for a single request.
2963
+ :type _host_index: int, optional
2964
+ :return: Returns the result object.
2965
+ """ # noqa: E501
2966
+
2967
+ _param = self._chicken_nhl_read_season_stats_serialize(
2968
+ season=season,
2969
+ sessions=sessions,
2970
+ player=player,
2971
+ api_id=api_id,
2972
+ eh_id=eh_id,
2973
+ team=team,
2974
+ opp_team=opp_team,
2975
+ strength_state=strength_state,
2976
+ score_state=score_state,
2977
+ teammates=teammates,
2978
+ opposition=opposition,
2979
+ _request_auth=_request_auth,
2980
+ _content_type=_content_type,
2981
+ _headers=_headers,
2982
+ _host_index=_host_index
2983
+ )
2984
+
2985
+ _response_types_map: Dict[str, Optional[str]] = {
2986
+ '200': "List[StatsSeason]",
2987
+ '422': "HTTPValidationError",
2988
+ }
2989
+ response_data = self.api_client.call_api(
2990
+ *_param,
2991
+ _request_timeout=_request_timeout
2992
+ )
2993
+ response_data.read()
2994
+ return self.api_client.response_deserialize(
2995
+ response_data=response_data,
2996
+ response_types_map=_response_types_map,
2997
+ ).data
2998
+
2999
+
3000
+ @validate_call
3001
+ def chicken_nhl_read_season_stats_with_http_info(
3002
+ self,
3003
+ season: Optional[List[StrictInt]] = None,
3004
+ sessions: Optional[List[StrictStr]] = None,
3005
+ player: Optional[List[StrictStr]] = None,
3006
+ api_id: Optional[List[StrictInt]] = None,
3007
+ eh_id: Optional[List[StrictStr]] = None,
3008
+ team: Optional[List[StrictStr]] = None,
3009
+ opp_team: Optional[List[StrictStr]] = None,
3010
+ strength_state: Optional[List[StrictStr]] = None,
3011
+ score_state: Optional[StrictBool] = None,
3012
+ teammates: Optional[StrictBool] = None,
3013
+ opposition: Optional[StrictBool] = None,
3014
+ _request_timeout: Union[
3015
+ None,
3016
+ Annotated[StrictFloat, Field(gt=0)],
3017
+ Tuple[
3018
+ Annotated[StrictFloat, Field(gt=0)],
3019
+ Annotated[StrictFloat, Field(gt=0)]
3020
+ ]
3021
+ ] = None,
3022
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3023
+ _content_type: Optional[StrictStr] = None,
3024
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3025
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3026
+ ) -> ApiResponse[List[StatsSeason]]:
3027
+ """Read Season Stats
3028
+
3029
+
3030
+ :param season:
3031
+ :type season: List[int]
3032
+ :param sessions:
3033
+ :type sessions: List[str]
3034
+ :param player:
3035
+ :type player: List[str]
3036
+ :param api_id:
3037
+ :type api_id: List[int]
3038
+ :param eh_id:
3039
+ :type eh_id: List[str]
3040
+ :param team:
3041
+ :type team: List[str]
3042
+ :param opp_team:
3043
+ :type opp_team: List[str]
3044
+ :param strength_state:
3045
+ :type strength_state: List[str]
3046
+ :param score_state:
3047
+ :type score_state: bool
3048
+ :param teammates:
3049
+ :type teammates: bool
3050
+ :param opposition:
3051
+ :type opposition: bool
3052
+ :param _request_timeout: timeout setting for this request. If one
3053
+ number provided, it will be total request
3054
+ timeout. It can also be a pair (tuple) of
3055
+ (connection, read) timeouts.
3056
+ :type _request_timeout: int, tuple(int, int), optional
3057
+ :param _request_auth: set to override the auth_settings for an a single
3058
+ request; this effectively ignores the
3059
+ authentication in the spec for a single request.
3060
+ :type _request_auth: dict, optional
3061
+ :param _content_type: force content-type for the request.
3062
+ :type _content_type: str, Optional
3063
+ :param _headers: set to override the headers for a single
3064
+ request; this effectively ignores the headers
3065
+ in the spec for a single request.
3066
+ :type _headers: dict, optional
3067
+ :param _host_index: set to override the host_index for a single
3068
+ request; this effectively ignores the host_index
3069
+ in the spec for a single request.
3070
+ :type _host_index: int, optional
3071
+ :return: Returns the result object.
3072
+ """ # noqa: E501
3073
+
3074
+ _param = self._chicken_nhl_read_season_stats_serialize(
3075
+ season=season,
3076
+ sessions=sessions,
3077
+ player=player,
3078
+ api_id=api_id,
3079
+ eh_id=eh_id,
3080
+ team=team,
3081
+ opp_team=opp_team,
3082
+ strength_state=strength_state,
3083
+ score_state=score_state,
3084
+ teammates=teammates,
3085
+ opposition=opposition,
3086
+ _request_auth=_request_auth,
3087
+ _content_type=_content_type,
3088
+ _headers=_headers,
3089
+ _host_index=_host_index
3090
+ )
3091
+
3092
+ _response_types_map: Dict[str, Optional[str]] = {
3093
+ '200': "List[StatsSeason]",
3094
+ '422': "HTTPValidationError",
3095
+ }
3096
+ response_data = self.api_client.call_api(
3097
+ *_param,
3098
+ _request_timeout=_request_timeout
3099
+ )
3100
+ response_data.read()
3101
+ return self.api_client.response_deserialize(
3102
+ response_data=response_data,
3103
+ response_types_map=_response_types_map,
3104
+ )
3105
+
3106
+
3107
+ @validate_call
3108
+ def chicken_nhl_read_season_stats_without_preload_content(
3109
+ self,
3110
+ season: Optional[List[StrictInt]] = None,
3111
+ sessions: Optional[List[StrictStr]] = None,
3112
+ player: Optional[List[StrictStr]] = None,
3113
+ api_id: Optional[List[StrictInt]] = None,
3114
+ eh_id: Optional[List[StrictStr]] = None,
3115
+ team: Optional[List[StrictStr]] = None,
3116
+ opp_team: Optional[List[StrictStr]] = None,
3117
+ strength_state: Optional[List[StrictStr]] = None,
3118
+ score_state: Optional[StrictBool] = None,
3119
+ teammates: Optional[StrictBool] = None,
3120
+ opposition: Optional[StrictBool] = None,
3121
+ _request_timeout: Union[
3122
+ None,
3123
+ Annotated[StrictFloat, Field(gt=0)],
3124
+ Tuple[
3125
+ Annotated[StrictFloat, Field(gt=0)],
3126
+ Annotated[StrictFloat, Field(gt=0)]
3127
+ ]
3128
+ ] = None,
3129
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3130
+ _content_type: Optional[StrictStr] = None,
3131
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3132
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3133
+ ) -> RESTResponseType:
3134
+ """Read Season Stats
3135
+
3136
+
3137
+ :param season:
3138
+ :type season: List[int]
3139
+ :param sessions:
3140
+ :type sessions: List[str]
3141
+ :param player:
3142
+ :type player: List[str]
3143
+ :param api_id:
3144
+ :type api_id: List[int]
3145
+ :param eh_id:
3146
+ :type eh_id: List[str]
3147
+ :param team:
3148
+ :type team: List[str]
3149
+ :param opp_team:
3150
+ :type opp_team: List[str]
3151
+ :param strength_state:
3152
+ :type strength_state: List[str]
3153
+ :param score_state:
3154
+ :type score_state: bool
3155
+ :param teammates:
3156
+ :type teammates: bool
3157
+ :param opposition:
3158
+ :type opposition: bool
3159
+ :param _request_timeout: timeout setting for this request. If one
3160
+ number provided, it will be total request
3161
+ timeout. It can also be a pair (tuple) of
3162
+ (connection, read) timeouts.
3163
+ :type _request_timeout: int, tuple(int, int), optional
3164
+ :param _request_auth: set to override the auth_settings for an a single
3165
+ request; this effectively ignores the
3166
+ authentication in the spec for a single request.
3167
+ :type _request_auth: dict, optional
3168
+ :param _content_type: force content-type for the request.
3169
+ :type _content_type: str, Optional
3170
+ :param _headers: set to override the headers for a single
3171
+ request; this effectively ignores the headers
3172
+ in the spec for a single request.
3173
+ :type _headers: dict, optional
3174
+ :param _host_index: set to override the host_index for a single
3175
+ request; this effectively ignores the host_index
3176
+ in the spec for a single request.
3177
+ :type _host_index: int, optional
3178
+ :return: Returns the result object.
3179
+ """ # noqa: E501
3180
+
3181
+ _param = self._chicken_nhl_read_season_stats_serialize(
3182
+ season=season,
3183
+ sessions=sessions,
3184
+ player=player,
3185
+ api_id=api_id,
3186
+ eh_id=eh_id,
3187
+ team=team,
3188
+ opp_team=opp_team,
3189
+ strength_state=strength_state,
3190
+ score_state=score_state,
3191
+ teammates=teammates,
3192
+ opposition=opposition,
3193
+ _request_auth=_request_auth,
3194
+ _content_type=_content_type,
3195
+ _headers=_headers,
3196
+ _host_index=_host_index
3197
+ )
3198
+
3199
+ _response_types_map: Dict[str, Optional[str]] = {
3200
+ '200': "List[StatsSeason]",
3201
+ '422': "HTTPValidationError",
3202
+ }
3203
+ response_data = self.api_client.call_api(
3204
+ *_param,
3205
+ _request_timeout=_request_timeout
3206
+ )
3207
+ return response_data.response
3208
+
3209
+
3210
+ def _chicken_nhl_read_season_stats_serialize(
3211
+ self,
3212
+ season,
3213
+ sessions,
3214
+ player,
3215
+ api_id,
3216
+ eh_id,
3217
+ team,
3218
+ opp_team,
3219
+ strength_state,
3220
+ score_state,
3221
+ teammates,
3222
+ opposition,
3223
+ _request_auth,
3224
+ _content_type,
3225
+ _headers,
3226
+ _host_index,
3227
+ ) -> RequestSerialized:
3228
+
3229
+ _host = None
3230
+
3231
+ _collection_formats: Dict[str, str] = {
3232
+ 'season': 'multi',
3233
+ 'sessions': 'multi',
3234
+ 'player': 'multi',
3235
+ 'api_id': 'multi',
3236
+ 'eh_id': 'multi',
3237
+ 'team': 'multi',
3238
+ 'opp_team': 'multi',
3239
+ 'strength_state': 'multi',
3240
+ }
3241
+
3242
+ _path_params: Dict[str, str] = {}
3243
+ _query_params: List[Tuple[str, str]] = []
3244
+ _header_params: Dict[str, Optional[str]] = _headers or {}
3245
+ _form_params: List[Tuple[str, str]] = []
3246
+ _files: Dict[
3247
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
3248
+ ] = {}
3249
+ _body_params: Optional[bytes] = None
3250
+
3251
+ # process the path parameters
3252
+ # process the query parameters
3253
+ if season is not None:
3254
+
3255
+ _query_params.append(('season', season))
3256
+
3257
+ if sessions is not None:
3258
+
3259
+ _query_params.append(('sessions', sessions))
3260
+
3261
+ if player is not None:
3262
+
3263
+ _query_params.append(('player', player))
3264
+
3265
+ if api_id is not None:
3266
+
3267
+ _query_params.append(('api_id', api_id))
3268
+
3269
+ if eh_id is not None:
3270
+
3271
+ _query_params.append(('eh_id', eh_id))
3272
+
3273
+ if team is not None:
3274
+
3275
+ _query_params.append(('team', team))
3276
+
3277
+ if opp_team is not None:
3278
+
3279
+ _query_params.append(('opp_team', opp_team))
3280
+
3281
+ if strength_state is not None:
3282
+
3283
+ _query_params.append(('strength_state', strength_state))
3284
+
3285
+ if score_state is not None:
3286
+
3287
+ _query_params.append(('score_state', score_state))
3288
+
3289
+ if teammates is not None:
3290
+
3291
+ _query_params.append(('teammates', teammates))
3292
+
3293
+ if opposition is not None:
3294
+
3295
+ _query_params.append(('opposition', opposition))
3296
+
3297
+ # process the header parameters
3298
+ # process the form parameters
3299
+ # process the body parameter
3300
+
3301
+
3302
+ # set the HTTP header `Accept`
3303
+ if 'Accept' not in _header_params:
3304
+ _header_params['Accept'] = self.api_client.select_header_accept(
3305
+ [
3306
+ 'application/json'
3307
+ ]
3308
+ )
3309
+
3310
+
3311
+ # authentication setting
3312
+ _auth_settings: List[str] = [
3313
+ 'OAuth2PasswordBearer'
3314
+ ]
3315
+
3316
+ return self.api_client.param_serialize(
3317
+ method='GET',
3318
+ resource_path='/api/v1/chicken_nhl/stats/season',
3319
+ path_params=_path_params,
3320
+ query_params=_query_params,
3321
+ header_params=_header_params,
3322
+ body=_body_params,
3323
+ post_params=_form_params,
3324
+ files=_files,
3325
+ auth_settings=_auth_settings,
3326
+ collection_formats=_collection_formats,
3327
+ _host=_host,
3328
+ _request_auth=_request_auth
3329
+ )
3330
+
3331
+
3332
+
3333
+
3334
+ @validate_call
3335
+ def chicken_nhl_read_stats_game_ids(
3336
+ self,
3337
+ season: Optional[List[StrictInt]] = None,
3338
+ sessions: Optional[List[StrictStr]] = None,
3339
+ _request_timeout: Union[
3340
+ None,
3341
+ Annotated[StrictFloat, Field(gt=0)],
3342
+ Tuple[
3343
+ Annotated[StrictFloat, Field(gt=0)],
3344
+ Annotated[StrictFloat, Field(gt=0)]
3345
+ ]
3346
+ ] = None,
3347
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3348
+ _content_type: Optional[StrictStr] = None,
3349
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3350
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3351
+ ) -> List[int]:
3352
+ """Read Stats Game Ids
3353
+
3354
+
3355
+ :param season:
3356
+ :type season: List[int]
3357
+ :param sessions:
3358
+ :type sessions: List[str]
3359
+ :param _request_timeout: timeout setting for this request. If one
3360
+ number provided, it will be total request
3361
+ timeout. It can also be a pair (tuple) of
3362
+ (connection, read) timeouts.
3363
+ :type _request_timeout: int, tuple(int, int), optional
3364
+ :param _request_auth: set to override the auth_settings for an a single
3365
+ request; this effectively ignores the
3366
+ authentication in the spec for a single request.
3367
+ :type _request_auth: dict, optional
3368
+ :param _content_type: force content-type for the request.
3369
+ :type _content_type: str, Optional
3370
+ :param _headers: set to override the headers for a single
3371
+ request; this effectively ignores the headers
3372
+ in the spec for a single request.
3373
+ :type _headers: dict, optional
3374
+ :param _host_index: set to override the host_index for a single
3375
+ request; this effectively ignores the host_index
3376
+ in the spec for a single request.
3377
+ :type _host_index: int, optional
3378
+ :return: Returns the result object.
3379
+ """ # noqa: E501
3380
+
3381
+ _param = self._chicken_nhl_read_stats_game_ids_serialize(
3382
+ season=season,
3383
+ sessions=sessions,
3384
+ _request_auth=_request_auth,
3385
+ _content_type=_content_type,
3386
+ _headers=_headers,
3387
+ _host_index=_host_index
3388
+ )
3389
+
3390
+ _response_types_map: Dict[str, Optional[str]] = {
3391
+ '200': "List[int]",
3392
+ '422': "HTTPValidationError",
3393
+ }
3394
+ response_data = self.api_client.call_api(
3395
+ *_param,
3396
+ _request_timeout=_request_timeout
3397
+ )
3398
+ response_data.read()
3399
+ return self.api_client.response_deserialize(
3400
+ response_data=response_data,
3401
+ response_types_map=_response_types_map,
3402
+ ).data
3403
+
3404
+
3405
+ @validate_call
3406
+ def chicken_nhl_read_stats_game_ids_with_http_info(
3407
+ self,
3408
+ season: Optional[List[StrictInt]] = None,
3409
+ sessions: Optional[List[StrictStr]] = None,
3410
+ _request_timeout: Union[
3411
+ None,
3412
+ Annotated[StrictFloat, Field(gt=0)],
3413
+ Tuple[
3414
+ Annotated[StrictFloat, Field(gt=0)],
3415
+ Annotated[StrictFloat, Field(gt=0)]
3416
+ ]
3417
+ ] = None,
3418
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3419
+ _content_type: Optional[StrictStr] = None,
3420
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3421
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3422
+ ) -> ApiResponse[List[int]]:
3423
+ """Read Stats Game Ids
3424
+
3425
+
3426
+ :param season:
3427
+ :type season: List[int]
3428
+ :param sessions:
3429
+ :type sessions: List[str]
3430
+ :param _request_timeout: timeout setting for this request. If one
3431
+ number provided, it will be total request
3432
+ timeout. It can also be a pair (tuple) of
3433
+ (connection, read) timeouts.
3434
+ :type _request_timeout: int, tuple(int, int), optional
3435
+ :param _request_auth: set to override the auth_settings for an a single
3436
+ request; this effectively ignores the
3437
+ authentication in the spec for a single request.
3438
+ :type _request_auth: dict, optional
3439
+ :param _content_type: force content-type for the request.
3440
+ :type _content_type: str, Optional
3441
+ :param _headers: set to override the headers for a single
3442
+ request; this effectively ignores the headers
3443
+ in the spec for a single request.
3444
+ :type _headers: dict, optional
3445
+ :param _host_index: set to override the host_index for a single
3446
+ request; this effectively ignores the host_index
3447
+ in the spec for a single request.
3448
+ :type _host_index: int, optional
3449
+ :return: Returns the result object.
3450
+ """ # noqa: E501
3451
+
3452
+ _param = self._chicken_nhl_read_stats_game_ids_serialize(
3453
+ season=season,
3454
+ sessions=sessions,
3455
+ _request_auth=_request_auth,
3456
+ _content_type=_content_type,
3457
+ _headers=_headers,
3458
+ _host_index=_host_index
3459
+ )
3460
+
3461
+ _response_types_map: Dict[str, Optional[str]] = {
3462
+ '200': "List[int]",
3463
+ '422': "HTTPValidationError",
3464
+ }
3465
+ response_data = self.api_client.call_api(
3466
+ *_param,
3467
+ _request_timeout=_request_timeout
3468
+ )
3469
+ response_data.read()
3470
+ return self.api_client.response_deserialize(
3471
+ response_data=response_data,
3472
+ response_types_map=_response_types_map,
3473
+ )
3474
+
3475
+
3476
+ @validate_call
3477
+ def chicken_nhl_read_stats_game_ids_without_preload_content(
3478
+ self,
3479
+ season: Optional[List[StrictInt]] = None,
3480
+ sessions: Optional[List[StrictStr]] = None,
3481
+ _request_timeout: Union[
3482
+ None,
3483
+ Annotated[StrictFloat, Field(gt=0)],
3484
+ Tuple[
3485
+ Annotated[StrictFloat, Field(gt=0)],
3486
+ Annotated[StrictFloat, Field(gt=0)]
3487
+ ]
3488
+ ] = None,
3489
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3490
+ _content_type: Optional[StrictStr] = None,
3491
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3492
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3493
+ ) -> RESTResponseType:
3494
+ """Read Stats Game Ids
3495
+
3496
+
3497
+ :param season:
3498
+ :type season: List[int]
3499
+ :param sessions:
3500
+ :type sessions: List[str]
3501
+ :param _request_timeout: timeout setting for this request. If one
3502
+ number provided, it will be total request
3503
+ timeout. It can also be a pair (tuple) of
3504
+ (connection, read) timeouts.
3505
+ :type _request_timeout: int, tuple(int, int), optional
3506
+ :param _request_auth: set to override the auth_settings for an a single
3507
+ request; this effectively ignores the
3508
+ authentication in the spec for a single request.
3509
+ :type _request_auth: dict, optional
3510
+ :param _content_type: force content-type for the request.
3511
+ :type _content_type: str, Optional
3512
+ :param _headers: set to override the headers for a single
3513
+ request; this effectively ignores the headers
3514
+ in the spec for a single request.
3515
+ :type _headers: dict, optional
3516
+ :param _host_index: set to override the host_index for a single
3517
+ request; this effectively ignores the host_index
3518
+ in the spec for a single request.
3519
+ :type _host_index: int, optional
3520
+ :return: Returns the result object.
3521
+ """ # noqa: E501
3522
+
3523
+ _param = self._chicken_nhl_read_stats_game_ids_serialize(
3524
+ season=season,
3525
+ sessions=sessions,
3526
+ _request_auth=_request_auth,
3527
+ _content_type=_content_type,
3528
+ _headers=_headers,
3529
+ _host_index=_host_index
3530
+ )
3531
+
3532
+ _response_types_map: Dict[str, Optional[str]] = {
3533
+ '200': "List[int]",
3534
+ '422': "HTTPValidationError",
3535
+ }
3536
+ response_data = self.api_client.call_api(
3537
+ *_param,
3538
+ _request_timeout=_request_timeout
3539
+ )
3540
+ return response_data.response
3541
+
3542
+
3543
+ def _chicken_nhl_read_stats_game_ids_serialize(
3544
+ self,
3545
+ season,
3546
+ sessions,
3547
+ _request_auth,
3548
+ _content_type,
3549
+ _headers,
3550
+ _host_index,
3551
+ ) -> RequestSerialized:
3552
+
3553
+ _host = None
3554
+
3555
+ _collection_formats: Dict[str, str] = {
3556
+ 'season': 'multi',
3557
+ 'sessions': 'multi',
3558
+ }
3559
+
3560
+ _path_params: Dict[str, str] = {}
3561
+ _query_params: List[Tuple[str, str]] = []
3562
+ _header_params: Dict[str, Optional[str]] = _headers or {}
3563
+ _form_params: List[Tuple[str, str]] = []
3564
+ _files: Dict[
3565
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
3566
+ ] = {}
3567
+ _body_params: Optional[bytes] = None
3568
+
3569
+ # process the path parameters
3570
+ # process the query parameters
3571
+ if season is not None:
3572
+
3573
+ _query_params.append(('season', season))
3574
+
3575
+ if sessions is not None:
3576
+
3577
+ _query_params.append(('sessions', sessions))
3578
+
3579
+ # process the header parameters
3580
+ # process the form parameters
3581
+ # process the body parameter
3582
+
3583
+
3584
+ # set the HTTP header `Accept`
3585
+ if 'Accept' not in _header_params:
3586
+ _header_params['Accept'] = self.api_client.select_header_accept(
3587
+ [
3588
+ 'application/json'
3589
+ ]
3590
+ )
3591
+
3592
+
3593
+ # authentication setting
3594
+ _auth_settings: List[str] = [
3595
+ 'OAuth2PasswordBearer'
3596
+ ]
3597
+
3598
+ return self.api_client.param_serialize(
3599
+ method='GET',
3600
+ resource_path='/api/v1/chicken_nhl/stats/game_ids',
3601
+ path_params=_path_params,
3602
+ query_params=_query_params,
3603
+ header_params=_header_params,
3604
+ body=_body_params,
3605
+ post_params=_form_params,
3606
+ files=_files,
3607
+ auth_settings=_auth_settings,
3608
+ collection_formats=_collection_formats,
3609
+ _host=_host,
3610
+ _request_auth=_request_auth
3611
+ )
3612
+
3613
+
3614
+
3615
+
3616
+ @validate_call
3617
+ def chicken_nhl_read_team_stats_game_ids(
3618
+ self,
3619
+ season: Optional[List[StrictInt]] = None,
3620
+ sessions: Optional[List[StrictStr]] = None,
3621
+ _request_timeout: Union[
3622
+ None,
3623
+ Annotated[StrictFloat, Field(gt=0)],
3624
+ Tuple[
3625
+ Annotated[StrictFloat, Field(gt=0)],
3626
+ Annotated[StrictFloat, Field(gt=0)]
3627
+ ]
3628
+ ] = None,
3629
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3630
+ _content_type: Optional[StrictStr] = None,
3631
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3632
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3633
+ ) -> List[int]:
3634
+ """Read Team Stats Game Ids
3635
+
3636
+
3637
+ :param season:
3638
+ :type season: List[int]
3639
+ :param sessions:
3640
+ :type sessions: List[str]
3641
+ :param _request_timeout: timeout setting for this request. If one
3642
+ number provided, it will be total request
3643
+ timeout. It can also be a pair (tuple) of
3644
+ (connection, read) timeouts.
3645
+ :type _request_timeout: int, tuple(int, int), optional
3646
+ :param _request_auth: set to override the auth_settings for an a single
3647
+ request; this effectively ignores the
3648
+ authentication in the spec for a single request.
3649
+ :type _request_auth: dict, optional
3650
+ :param _content_type: force content-type for the request.
3651
+ :type _content_type: str, Optional
3652
+ :param _headers: set to override the headers for a single
3653
+ request; this effectively ignores the headers
3654
+ in the spec for a single request.
3655
+ :type _headers: dict, optional
3656
+ :param _host_index: set to override the host_index for a single
3657
+ request; this effectively ignores the host_index
3658
+ in the spec for a single request.
3659
+ :type _host_index: int, optional
3660
+ :return: Returns the result object.
3661
+ """ # noqa: E501
3662
+
3663
+ _param = self._chicken_nhl_read_team_stats_game_ids_serialize(
3664
+ season=season,
3665
+ sessions=sessions,
3666
+ _request_auth=_request_auth,
3667
+ _content_type=_content_type,
3668
+ _headers=_headers,
3669
+ _host_index=_host_index
3670
+ )
3671
+
3672
+ _response_types_map: Dict[str, Optional[str]] = {
3673
+ '200': "List[int]",
3674
+ '422': "HTTPValidationError",
3675
+ }
3676
+ response_data = self.api_client.call_api(
3677
+ *_param,
3678
+ _request_timeout=_request_timeout
3679
+ )
3680
+ response_data.read()
3681
+ return self.api_client.response_deserialize(
3682
+ response_data=response_data,
3683
+ response_types_map=_response_types_map,
3684
+ ).data
3685
+
3686
+
3687
+ @validate_call
3688
+ def chicken_nhl_read_team_stats_game_ids_with_http_info(
3689
+ self,
3690
+ season: Optional[List[StrictInt]] = None,
3691
+ sessions: Optional[List[StrictStr]] = None,
3692
+ _request_timeout: Union[
3693
+ None,
3694
+ Annotated[StrictFloat, Field(gt=0)],
3695
+ Tuple[
3696
+ Annotated[StrictFloat, Field(gt=0)],
3697
+ Annotated[StrictFloat, Field(gt=0)]
3698
+ ]
3699
+ ] = None,
3700
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3701
+ _content_type: Optional[StrictStr] = None,
3702
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3703
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3704
+ ) -> ApiResponse[List[int]]:
3705
+ """Read Team Stats Game Ids
3706
+
3707
+
3708
+ :param season:
3709
+ :type season: List[int]
3710
+ :param sessions:
3711
+ :type sessions: List[str]
3712
+ :param _request_timeout: timeout setting for this request. If one
3713
+ number provided, it will be total request
3714
+ timeout. It can also be a pair (tuple) of
3715
+ (connection, read) timeouts.
3716
+ :type _request_timeout: int, tuple(int, int), optional
3717
+ :param _request_auth: set to override the auth_settings for an a single
3718
+ request; this effectively ignores the
3719
+ authentication in the spec for a single request.
3720
+ :type _request_auth: dict, optional
3721
+ :param _content_type: force content-type for the request.
3722
+ :type _content_type: str, Optional
3723
+ :param _headers: set to override the headers for a single
3724
+ request; this effectively ignores the headers
3725
+ in the spec for a single request.
3726
+ :type _headers: dict, optional
3727
+ :param _host_index: set to override the host_index for a single
3728
+ request; this effectively ignores the host_index
3729
+ in the spec for a single request.
3730
+ :type _host_index: int, optional
3731
+ :return: Returns the result object.
3732
+ """ # noqa: E501
3733
+
3734
+ _param = self._chicken_nhl_read_team_stats_game_ids_serialize(
3735
+ season=season,
3736
+ sessions=sessions,
3737
+ _request_auth=_request_auth,
3738
+ _content_type=_content_type,
3739
+ _headers=_headers,
3740
+ _host_index=_host_index
3741
+ )
3742
+
3743
+ _response_types_map: Dict[str, Optional[str]] = {
3744
+ '200': "List[int]",
3745
+ '422': "HTTPValidationError",
3746
+ }
3747
+ response_data = self.api_client.call_api(
3748
+ *_param,
3749
+ _request_timeout=_request_timeout
3750
+ )
3751
+ response_data.read()
3752
+ return self.api_client.response_deserialize(
3753
+ response_data=response_data,
3754
+ response_types_map=_response_types_map,
3755
+ )
3756
+
3757
+
3758
+ @validate_call
3759
+ def chicken_nhl_read_team_stats_game_ids_without_preload_content(
3760
+ self,
3761
+ season: Optional[List[StrictInt]] = None,
3762
+ sessions: Optional[List[StrictStr]] = None,
3763
+ _request_timeout: Union[
3764
+ None,
3765
+ Annotated[StrictFloat, Field(gt=0)],
3766
+ Tuple[
3767
+ Annotated[StrictFloat, Field(gt=0)],
3768
+ Annotated[StrictFloat, Field(gt=0)]
3769
+ ]
3770
+ ] = None,
3771
+ _request_auth: Optional[Dict[StrictStr, Any]] = None,
3772
+ _content_type: Optional[StrictStr] = None,
3773
+ _headers: Optional[Dict[StrictStr, Any]] = None,
3774
+ _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3775
+ ) -> RESTResponseType:
3776
+ """Read Team Stats Game Ids
3777
+
3778
+
3779
+ :param season:
3780
+ :type season: List[int]
3781
+ :param sessions:
3782
+ :type sessions: List[str]
3783
+ :param _request_timeout: timeout setting for this request. If one
3784
+ number provided, it will be total request
3785
+ timeout. It can also be a pair (tuple) of
3786
+ (connection, read) timeouts.
3787
+ :type _request_timeout: int, tuple(int, int), optional
3788
+ :param _request_auth: set to override the auth_settings for an a single
3789
+ request; this effectively ignores the
3790
+ authentication in the spec for a single request.
3791
+ :type _request_auth: dict, optional
3792
+ :param _content_type: force content-type for the request.
3793
+ :type _content_type: str, Optional
3794
+ :param _headers: set to override the headers for a single
3795
+ request; this effectively ignores the headers
3796
+ in the spec for a single request.
3797
+ :type _headers: dict, optional
3798
+ :param _host_index: set to override the host_index for a single
3799
+ request; this effectively ignores the host_index
3800
+ in the spec for a single request.
3801
+ :type _host_index: int, optional
3802
+ :return: Returns the result object.
3803
+ """ # noqa: E501
3804
+
3805
+ _param = self._chicken_nhl_read_team_stats_game_ids_serialize(
3806
+ season=season,
3807
+ sessions=sessions,
3808
+ _request_auth=_request_auth,
3809
+ _content_type=_content_type,
3810
+ _headers=_headers,
3811
+ _host_index=_host_index
3812
+ )
3813
+
3814
+ _response_types_map: Dict[str, Optional[str]] = {
3815
+ '200': "List[int]",
3816
+ '422': "HTTPValidationError",
3817
+ }
3818
+ response_data = self.api_client.call_api(
3819
+ *_param,
3820
+ _request_timeout=_request_timeout
3821
+ )
3822
+ return response_data.response
3823
+
3824
+
3825
+ def _chicken_nhl_read_team_stats_game_ids_serialize(
3826
+ self,
3827
+ season,
3828
+ sessions,
3829
+ _request_auth,
3830
+ _content_type,
3831
+ _headers,
3832
+ _host_index,
3833
+ ) -> RequestSerialized:
3834
+
3835
+ _host = None
3836
+
3837
+ _collection_formats: Dict[str, str] = {
3838
+ 'season': 'multi',
3839
+ 'sessions': 'multi',
3840
+ }
3841
+
3842
+ _path_params: Dict[str, str] = {}
3843
+ _query_params: List[Tuple[str, str]] = []
3844
+ _header_params: Dict[str, Optional[str]] = _headers or {}
3845
+ _form_params: List[Tuple[str, str]] = []
3846
+ _files: Dict[
3847
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
3848
+ ] = {}
3849
+ _body_params: Optional[bytes] = None
3850
+
3851
+ # process the path parameters
3852
+ # process the query parameters
3853
+ if season is not None:
3854
+
3855
+ _query_params.append(('season', season))
3856
+
3857
+ if sessions is not None:
3858
+
3859
+ _query_params.append(('sessions', sessions))
3860
+
3861
+ # process the header parameters
3862
+ # process the form parameters
3863
+ # process the body parameter
3864
+
3865
+
3866
+ # set the HTTP header `Accept`
3867
+ if 'Accept' not in _header_params:
3868
+ _header_params['Accept'] = self.api_client.select_header_accept(
3869
+ [
3870
+ 'application/json'
3871
+ ]
3872
+ )
3873
+
3874
+
3875
+ # authentication setting
3876
+ _auth_settings: List[str] = [
3877
+ 'OAuth2PasswordBearer'
3878
+ ]
3879
+
3880
+ return self.api_client.param_serialize(
3881
+ method='GET',
3882
+ resource_path='/api/v1/chicken_nhl/team_stats/game_ids',
3883
+ path_params=_path_params,
3884
+ query_params=_query_params,
3885
+ header_params=_header_params,
3886
+ body=_body_params,
3887
+ post_params=_form_params,
3888
+ files=_files,
3889
+ auth_settings=_auth_settings,
3890
+ collection_formats=_collection_formats,
3891
+ _host=_host,
3892
+ _request_auth=_request_auth
3893
+ )
3894
+
3895
+