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.
- chickenstats_api/__init__.py +104 -0
- chickenstats_api/api/__init__.py +13 -0
- chickenstats_api/api/chicken_nhl_api.py +3895 -0
- chickenstats_api/api/game_stats_api.py +1072 -0
- chickenstats_api/api/lines_api.py +878 -0
- chickenstats_api/api/login_api.py +1444 -0
- chickenstats_api/api/play_by_play_api.py +1303 -0
- chickenstats_api/api/season_stats_api.py +480 -0
- chickenstats_api/api/stats_api.py +1514 -0
- chickenstats_api/api/team_stats_api.py +312 -0
- chickenstats_api/api/users_api.py +2471 -0
- chickenstats_api/api_client.py +802 -0
- chickenstats_api/api_response.py +21 -0
- chickenstats_api/configuration.py +582 -0
- chickenstats_api/exceptions.py +217 -0
- chickenstats_api/models/__init__.py +37 -0
- chickenstats_api/models/http_validation_error.py +96 -0
- chickenstats_api/models/lines_create.py +380 -0
- chickenstats_api/models/lines_public.py +378 -0
- chickenstats_api/models/message.py +88 -0
- chickenstats_api/models/new_password.py +91 -0
- chickenstats_api/models/pbp_public.py +1138 -0
- chickenstats_api/models/stats_create.py +488 -0
- chickenstats_api/models/stats_game.py +486 -0
- chickenstats_api/models/stats_season.py +496 -0
- chickenstats_api/models/team_stats_create.py +254 -0
- chickenstats_api/models/team_stats_public.py +252 -0
- chickenstats_api/models/token.py +90 -0
- chickenstats_api/models/update_password.py +91 -0
- chickenstats_api/models/user_create.py +102 -0
- chickenstats_api/models/user_public.py +102 -0
- chickenstats_api/models/user_update.py +112 -0
- chickenstats_api/models/user_update_me.py +101 -0
- chickenstats_api/models/users_public.py +98 -0
- chickenstats_api/models/validation_error.py +100 -0
- chickenstats_api/models/validation_error_loc_inner.py +139 -0
- chickenstats_api/py.typed +0 -0
- chickenstats_api/rest.py +259 -0
- chickenstats_api-0.0.1.dist-info/METADATA +199 -0
- chickenstats_api-0.0.1.dist-info/RECORD +42 -0
- chickenstats_api-0.0.1.dist-info/WHEEL +5 -0
- 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
|
+
|