From a054e8b160079dfe083ff14baa5b0d5249883886 Mon Sep 17 00:00:00 2001 From: activitysmith-bot Date: Sun, 1 Feb 2026 11:42:20 +0000 Subject: [PATCH] chore: regenerate SDK --- activitysmith_openapi/__init__.py | 48 + activitysmith_openapi/api/__init__.py | 6 + .../api/live_activities_api.py | 866 ++++++++++++++++++ .../api/push_notifications_api.py | 312 +++++++ activitysmith_openapi/api_client.py | 781 ++++++++++++++++ activitysmith_openapi/api_response.py | 21 + activitysmith_openapi/configuration.py | 459 ++++++++++ activitysmith_openapi/docs/ContentStateEnd.md | 36 + .../docs/ContentStateStart.md | 36 + .../docs/ContentStateUpdate.md | 35 + .../docs/LiveActivitiesApi.md | 251 +++++ .../docs/LiveActivityEndRequest.md | 30 + .../docs/LiveActivityEndResponse.md | 33 + .../docs/LiveActivityLimitError.md | 32 + .../docs/LiveActivityStartRequest.md | 29 + .../docs/LiveActivityStartResponse.md | 33 + .../docs/LiveActivityUpdateRequest.md | 30 + .../docs/LiveActivityUpdateResponse.md | 33 + .../docs/PushNotificationRequest.md | 31 + .../docs/PushNotificationResponse.md | 32 + .../docs/PushNotificationsApi.md | 89 ++ activitysmith_openapi/docs/RateLimitError.md | 30 + .../docs/SendPushNotification429Response.md | 32 + activitysmith_openapi/exceptions.py | 199 ++++ activitysmith_openapi/models/__init__.py | 30 + .../models/content_state_end.py | 120 +++ .../models/content_state_start.py | 127 +++ .../models/content_state_update.py | 118 +++ .../models/live_activity_end_request.py | 93 ++ .../models/live_activity_end_response.py | 96 ++ .../models/live_activity_limit_error.py | 93 ++ .../models/live_activity_start_request.py | 91 ++ .../models/live_activity_start_response.py | 96 ++ .../models/live_activity_update_request.py | 93 ++ .../models/live_activity_update_response.py | 96 ++ .../models/push_notification_request.py | 91 ++ .../models/push_notification_response.py | 94 ++ .../models/rate_limit_error.py | 89 ++ .../send_push_notification429_response.py | 137 +++ activitysmith_openapi/rest.py | 257 ++++++ activitysmith_openapi/test/__init__.py | 0 .../test/test_content_state_end.py | 59 ++ .../test/test_content_state_start.py | 61 ++ .../test/test_content_state_update.py | 58 ++ .../test/test_live_activities_api.py | 52 ++ .../test/test_live_activity_end_request.py | 68 ++ .../test/test_live_activity_end_response.py | 58 ++ .../test/test_live_activity_limit_error.py | 58 ++ .../test/test_live_activity_start_request.py | 66 ++ .../test/test_live_activity_start_response.py | 58 ++ .../test/test_live_activity_update_request.py | 66 ++ .../test_live_activity_update_response.py | 58 ++ .../test/test_push_notification_request.py | 54 ++ .../test/test_push_notification_response.py | 56 ++ .../test/test_push_notifications_api.py | 38 + .../test/test_rate_limit_error.py | 54 ++ ...test_send_push_notification429_response.py | 58 ++ 57 files changed, 6127 insertions(+) create mode 100644 activitysmith_openapi/__init__.py create mode 100644 activitysmith_openapi/api/__init__.py create mode 100644 activitysmith_openapi/api/live_activities_api.py create mode 100644 activitysmith_openapi/api/push_notifications_api.py create mode 100644 activitysmith_openapi/api_client.py create mode 100644 activitysmith_openapi/api_response.py create mode 100644 activitysmith_openapi/configuration.py create mode 100644 activitysmith_openapi/docs/ContentStateEnd.md create mode 100644 activitysmith_openapi/docs/ContentStateStart.md create mode 100644 activitysmith_openapi/docs/ContentStateUpdate.md create mode 100644 activitysmith_openapi/docs/LiveActivitiesApi.md create mode 100644 activitysmith_openapi/docs/LiveActivityEndRequest.md create mode 100644 activitysmith_openapi/docs/LiveActivityEndResponse.md create mode 100644 activitysmith_openapi/docs/LiveActivityLimitError.md create mode 100644 activitysmith_openapi/docs/LiveActivityStartRequest.md create mode 100644 activitysmith_openapi/docs/LiveActivityStartResponse.md create mode 100644 activitysmith_openapi/docs/LiveActivityUpdateRequest.md create mode 100644 activitysmith_openapi/docs/LiveActivityUpdateResponse.md create mode 100644 activitysmith_openapi/docs/PushNotificationRequest.md create mode 100644 activitysmith_openapi/docs/PushNotificationResponse.md create mode 100644 activitysmith_openapi/docs/PushNotificationsApi.md create mode 100644 activitysmith_openapi/docs/RateLimitError.md create mode 100644 activitysmith_openapi/docs/SendPushNotification429Response.md create mode 100644 activitysmith_openapi/exceptions.py create mode 100644 activitysmith_openapi/models/__init__.py create mode 100644 activitysmith_openapi/models/content_state_end.py create mode 100644 activitysmith_openapi/models/content_state_start.py create mode 100644 activitysmith_openapi/models/content_state_update.py create mode 100644 activitysmith_openapi/models/live_activity_end_request.py create mode 100644 activitysmith_openapi/models/live_activity_end_response.py create mode 100644 activitysmith_openapi/models/live_activity_limit_error.py create mode 100644 activitysmith_openapi/models/live_activity_start_request.py create mode 100644 activitysmith_openapi/models/live_activity_start_response.py create mode 100644 activitysmith_openapi/models/live_activity_update_request.py create mode 100644 activitysmith_openapi/models/live_activity_update_response.py create mode 100644 activitysmith_openapi/models/push_notification_request.py create mode 100644 activitysmith_openapi/models/push_notification_response.py create mode 100644 activitysmith_openapi/models/rate_limit_error.py create mode 100644 activitysmith_openapi/models/send_push_notification429_response.py create mode 100644 activitysmith_openapi/rest.py create mode 100644 activitysmith_openapi/test/__init__.py create mode 100644 activitysmith_openapi/test/test_content_state_end.py create mode 100644 activitysmith_openapi/test/test_content_state_start.py create mode 100644 activitysmith_openapi/test/test_content_state_update.py create mode 100644 activitysmith_openapi/test/test_live_activities_api.py create mode 100644 activitysmith_openapi/test/test_live_activity_end_request.py create mode 100644 activitysmith_openapi/test/test_live_activity_end_response.py create mode 100644 activitysmith_openapi/test/test_live_activity_limit_error.py create mode 100644 activitysmith_openapi/test/test_live_activity_start_request.py create mode 100644 activitysmith_openapi/test/test_live_activity_start_response.py create mode 100644 activitysmith_openapi/test/test_live_activity_update_request.py create mode 100644 activitysmith_openapi/test/test_live_activity_update_response.py create mode 100644 activitysmith_openapi/test/test_push_notification_request.py create mode 100644 activitysmith_openapi/test/test_push_notification_response.py create mode 100644 activitysmith_openapi/test/test_push_notifications_api.py create mode 100644 activitysmith_openapi/test/test_rate_limit_error.py create mode 100644 activitysmith_openapi/test/test_send_push_notification429_response.py diff --git a/activitysmith_openapi/__init__.py b/activitysmith_openapi/__init__.py new file mode 100644 index 0000000..9a26a58 --- /dev/null +++ b/activitysmith_openapi/__init__.py @@ -0,0 +1,48 @@ +# coding: utf-8 + +# flake8: noqa + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +__version__ = "0.1.0" + +# import apis into sdk package +from activitysmith_openapi.api.live_activities_api import LiveActivitiesApi +from activitysmith_openapi.api.push_notifications_api import PushNotificationsApi + +# import ApiClient +from activitysmith_openapi.api_response import ApiResponse +from activitysmith_openapi.api_client import ApiClient +from activitysmith_openapi.configuration import Configuration +from activitysmith_openapi.exceptions import OpenApiException +from activitysmith_openapi.exceptions import ApiTypeError +from activitysmith_openapi.exceptions import ApiValueError +from activitysmith_openapi.exceptions import ApiKeyError +from activitysmith_openapi.exceptions import ApiAttributeError +from activitysmith_openapi.exceptions import ApiException + +# import models into sdk package +from activitysmith_openapi.models.content_state_end import ContentStateEnd +from activitysmith_openapi.models.content_state_start import ContentStateStart +from activitysmith_openapi.models.content_state_update import ContentStateUpdate +from activitysmith_openapi.models.live_activity_end_request import LiveActivityEndRequest +from activitysmith_openapi.models.live_activity_end_response import LiveActivityEndResponse +from activitysmith_openapi.models.live_activity_limit_error import LiveActivityLimitError +from activitysmith_openapi.models.live_activity_start_request import LiveActivityStartRequest +from activitysmith_openapi.models.live_activity_start_response import LiveActivityStartResponse +from activitysmith_openapi.models.live_activity_update_request import LiveActivityUpdateRequest +from activitysmith_openapi.models.live_activity_update_response import LiveActivityUpdateResponse +from activitysmith_openapi.models.push_notification_request import PushNotificationRequest +from activitysmith_openapi.models.push_notification_response import PushNotificationResponse +from activitysmith_openapi.models.rate_limit_error import RateLimitError +from activitysmith_openapi.models.send_push_notification429_response import SendPushNotification429Response diff --git a/activitysmith_openapi/api/__init__.py b/activitysmith_openapi/api/__init__.py new file mode 100644 index 0000000..832ae15 --- /dev/null +++ b/activitysmith_openapi/api/__init__.py @@ -0,0 +1,6 @@ +# flake8: noqa + +# import apis into api package +from activitysmith_openapi.api.live_activities_api import LiveActivitiesApi +from activitysmith_openapi.api.push_notifications_api import PushNotificationsApi + diff --git a/activitysmith_openapi/api/live_activities_api.py b/activitysmith_openapi/api/live_activities_api.py new file mode 100644 index 0000000..ae547d5 --- /dev/null +++ b/activitysmith_openapi/api/live_activities_api.py @@ -0,0 +1,866 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + +import warnings +from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt +from typing import Any, Dict, List, Optional, Tuple, Union +from typing_extensions import Annotated + +from activitysmith_openapi.models.live_activity_end_request import LiveActivityEndRequest +from activitysmith_openapi.models.live_activity_end_response import LiveActivityEndResponse +from activitysmith_openapi.models.live_activity_start_request import LiveActivityStartRequest +from activitysmith_openapi.models.live_activity_start_response import LiveActivityStartResponse +from activitysmith_openapi.models.live_activity_update_request import LiveActivityUpdateRequest +from activitysmith_openapi.models.live_activity_update_response import LiveActivityUpdateResponse + +from activitysmith_openapi.api_client import ApiClient, RequestSerialized +from activitysmith_openapi.api_response import ApiResponse +from activitysmith_openapi.rest import RESTResponseType + + +class LiveActivitiesApi: + """NOTE: This class is auto generated by OpenAPI Generator + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + def __init__(self, api_client=None) -> None: + if api_client is None: + api_client = ApiClient.get_default() + self.api_client = api_client + + + @validate_call + def end_live_activity( + self, + live_activity_end_request: LiveActivityEndRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> LiveActivityEndResponse: + """End a Live Activity + + Ends a Live Activity and archives its lifecycle. + + :param live_activity_end_request: (required) + :type live_activity_end_request: LiveActivityEndRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._end_live_activity_serialize( + live_activity_end_request=live_activity_end_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "LiveActivityEndResponse", + '429': "RateLimitError", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def end_live_activity_with_http_info( + self, + live_activity_end_request: LiveActivityEndRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[LiveActivityEndResponse]: + """End a Live Activity + + Ends a Live Activity and archives its lifecycle. + + :param live_activity_end_request: (required) + :type live_activity_end_request: LiveActivityEndRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._end_live_activity_serialize( + live_activity_end_request=live_activity_end_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "LiveActivityEndResponse", + '429': "RateLimitError", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def end_live_activity_without_preload_content( + self, + live_activity_end_request: LiveActivityEndRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """End a Live Activity + + Ends a Live Activity and archives its lifecycle. + + :param live_activity_end_request: (required) + :type live_activity_end_request: LiveActivityEndRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._end_live_activity_serialize( + live_activity_end_request=live_activity_end_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "LiveActivityEndResponse", + '429': "RateLimitError", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _end_live_activity_serialize( + self, + live_activity_end_request, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[str, Union[str, bytes]] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + if live_activity_end_request is not None: + _body_params = live_activity_end_request + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'application/json' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + 'apiKeyAuth' + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/live-activity/end', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + + @validate_call + def start_live_activity( + self, + live_activity_start_request: LiveActivityStartRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> LiveActivityStartResponse: + """Start a Live Activity + + Starts a Live Activity on all registered devices and returns an activity_id. + + :param live_activity_start_request: (required) + :type live_activity_start_request: LiveActivityStartRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._start_live_activity_serialize( + live_activity_start_request=live_activity_start_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "LiveActivityStartResponse", + '429': "RateLimitError", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def start_live_activity_with_http_info( + self, + live_activity_start_request: LiveActivityStartRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[LiveActivityStartResponse]: + """Start a Live Activity + + Starts a Live Activity on all registered devices and returns an activity_id. + + :param live_activity_start_request: (required) + :type live_activity_start_request: LiveActivityStartRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._start_live_activity_serialize( + live_activity_start_request=live_activity_start_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "LiveActivityStartResponse", + '429': "RateLimitError", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def start_live_activity_without_preload_content( + self, + live_activity_start_request: LiveActivityStartRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Start a Live Activity + + Starts a Live Activity on all registered devices and returns an activity_id. + + :param live_activity_start_request: (required) + :type live_activity_start_request: LiveActivityStartRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._start_live_activity_serialize( + live_activity_start_request=live_activity_start_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "LiveActivityStartResponse", + '429': "RateLimitError", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _start_live_activity_serialize( + self, + live_activity_start_request, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[str, Union[str, bytes]] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + if live_activity_start_request is not None: + _body_params = live_activity_start_request + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'application/json' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + 'apiKeyAuth' + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/live-activity/start', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + + + + @validate_call + def update_live_activity( + self, + live_activity_update_request: LiveActivityUpdateRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> LiveActivityUpdateResponse: + """Update a Live Activity + + Updates an existing Live Activity. If the per-activity token is not registered yet, the update is queued. + + :param live_activity_update_request: (required) + :type live_activity_update_request: LiveActivityUpdateRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._update_live_activity_serialize( + live_activity_update_request=live_activity_update_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "LiveActivityUpdateResponse", + '429': "RateLimitError", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def update_live_activity_with_http_info( + self, + live_activity_update_request: LiveActivityUpdateRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[LiveActivityUpdateResponse]: + """Update a Live Activity + + Updates an existing Live Activity. If the per-activity token is not registered yet, the update is queued. + + :param live_activity_update_request: (required) + :type live_activity_update_request: LiveActivityUpdateRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._update_live_activity_serialize( + live_activity_update_request=live_activity_update_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "LiveActivityUpdateResponse", + '429': "RateLimitError", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def update_live_activity_without_preload_content( + self, + live_activity_update_request: LiveActivityUpdateRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Update a Live Activity + + Updates an existing Live Activity. If the per-activity token is not registered yet, the update is queued. + + :param live_activity_update_request: (required) + :type live_activity_update_request: LiveActivityUpdateRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._update_live_activity_serialize( + live_activity_update_request=live_activity_update_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "LiveActivityUpdateResponse", + '429': "RateLimitError", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _update_live_activity_serialize( + self, + live_activity_update_request, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[str, Union[str, bytes]] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + if live_activity_update_request is not None: + _body_params = live_activity_update_request + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'application/json' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + 'apiKeyAuth' + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/live-activity/update', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + diff --git a/activitysmith_openapi/api/push_notifications_api.py b/activitysmith_openapi/api/push_notifications_api.py new file mode 100644 index 0000000..959fcab --- /dev/null +++ b/activitysmith_openapi/api/push_notifications_api.py @@ -0,0 +1,312 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + +import warnings +from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt +from typing import Any, Dict, List, Optional, Tuple, Union +from typing_extensions import Annotated + +from activitysmith_openapi.models.push_notification_request import PushNotificationRequest +from activitysmith_openapi.models.push_notification_response import PushNotificationResponse + +from activitysmith_openapi.api_client import ApiClient, RequestSerialized +from activitysmith_openapi.api_response import ApiResponse +from activitysmith_openapi.rest import RESTResponseType + + +class PushNotificationsApi: + """NOTE: This class is auto generated by OpenAPI Generator + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + def __init__(self, api_client=None) -> None: + if api_client is None: + api_client = ApiClient.get_default() + self.api_client = api_client + + + @validate_call + def send_push_notification( + self, + push_notification_request: PushNotificationRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> PushNotificationResponse: + """Send a push notification + + Sends a push notification to every paired device in your account. + + :param push_notification_request: (required) + :type push_notification_request: PushNotificationRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._send_push_notification_serialize( + push_notification_request=push_notification_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "PushNotificationResponse", + '429': "SendPushNotification429Response", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + def send_push_notification_with_http_info( + self, + push_notification_request: PushNotificationRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[PushNotificationResponse]: + """Send a push notification + + Sends a push notification to every paired device in your account. + + :param push_notification_request: (required) + :type push_notification_request: PushNotificationRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._send_push_notification_serialize( + push_notification_request=push_notification_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "PushNotificationResponse", + '429': "SendPushNotification429Response", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + def send_push_notification_without_preload_content( + self, + push_notification_request: PushNotificationRequest, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[ + Annotated[StrictFloat, Field(gt=0)], + Annotated[StrictFloat, Field(gt=0)] + ] + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Send a push notification + + Sends a push notification to every paired device in your account. + + :param push_notification_request: (required) + :type push_notification_request: PushNotificationRequest + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._send_push_notification_serialize( + push_notification_request=push_notification_request, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "PushNotificationResponse", + '429': "SendPushNotification429Response", + } + response_data = self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _send_push_notification_serialize( + self, + push_notification_request, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = { + } + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[str, Union[str, bytes]] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + if push_notification_request is not None: + _body_params = push_notification_request + + + # set the HTTP header `Accept` + if 'Accept' not in _header_params: + _header_params['Accept'] = self.api_client.select_header_accept( + [ + 'application/json' + ] + ) + + # set the HTTP header `Content-Type` + if _content_type: + _header_params['Content-Type'] = _content_type + else: + _default_content_type = ( + self.api_client.select_header_content_type( + [ + 'application/json' + ] + ) + ) + if _default_content_type is not None: + _header_params['Content-Type'] = _default_content_type + + # authentication setting + _auth_settings: List[str] = [ + 'apiKeyAuth' + ] + + return self.api_client.param_serialize( + method='POST', + resource_path='/push-notification', + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth + ) + + diff --git a/activitysmith_openapi/api_client.py b/activitysmith_openapi/api_client.py new file mode 100644 index 0000000..0a26fa5 --- /dev/null +++ b/activitysmith_openapi/api_client.py @@ -0,0 +1,781 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import datetime +from dateutil.parser import parse +from enum import Enum +import json +import mimetypes +import os +import re +import tempfile + +from urllib.parse import quote +from typing import Tuple, Optional, List, Dict, Union +from pydantic import SecretStr + +from activitysmith_openapi.configuration import Configuration +from activitysmith_openapi.api_response import ApiResponse, T as ApiResponseT +import activitysmith_openapi.models +from activitysmith_openapi import rest +from activitysmith_openapi.exceptions import ( + ApiValueError, + ApiException, + BadRequestException, + UnauthorizedException, + ForbiddenException, + NotFoundException, + ServiceException +) + +RequestSerialized = Tuple[str, str, Dict[str, str], Optional[str], List[str]] + +class ApiClient: + """Generic API client for OpenAPI client library builds. + + OpenAPI generic API client. This client handles the client- + server communication, and is invariant across implementations. Specifics of + the methods and models for each application are generated from the OpenAPI + templates. + + :param configuration: .Configuration object for this client + :param header_name: a header to pass when making calls to the API. + :param header_value: a header value to pass when making calls to + the API. + :param cookie: a cookie to include in the header when making calls + to the API + """ + + PRIMITIVE_TYPES = (float, bool, bytes, str, int) + NATIVE_TYPES_MAPPING = { + 'int': int, + 'long': int, # TODO remove as only py3 is supported? + 'float': float, + 'str': str, + 'bool': bool, + 'date': datetime.date, + 'datetime': datetime.datetime, + 'object': object, + } + _pool = None + + def __init__( + self, + configuration=None, + header_name=None, + header_value=None, + cookie=None + ) -> None: + # use default configuration if none is provided + if configuration is None: + configuration = Configuration.get_default() + self.configuration = configuration + + self.rest_client = rest.RESTClientObject(configuration) + self.default_headers = {} + if header_name is not None: + self.default_headers[header_name] = header_value + self.cookie = cookie + # Set default User-Agent. + self.user_agent = 'OpenAPI-Generator/0.1.0/python' + self.client_side_validation = configuration.client_side_validation + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + pass + + @property + def user_agent(self): + """User agent for this API client""" + return self.default_headers['User-Agent'] + + @user_agent.setter + def user_agent(self, value): + self.default_headers['User-Agent'] = value + + def set_default_header(self, header_name, header_value): + self.default_headers[header_name] = header_value + + + _default = None + + @classmethod + def get_default(cls): + """Return new instance of ApiClient. + + This method returns newly created, based on default constructor, + object of ApiClient class or returns a copy of default + ApiClient. + + :return: The ApiClient object. + """ + if cls._default is None: + cls._default = ApiClient() + return cls._default + + @classmethod + def set_default(cls, default): + """Set default instance of ApiClient. + + It stores default ApiClient. + + :param default: object of ApiClient. + """ + cls._default = default + + def param_serialize( + self, + method, + resource_path, + path_params=None, + query_params=None, + header_params=None, + body=None, + post_params=None, + files=None, auth_settings=None, + collection_formats=None, + _host=None, + _request_auth=None + ) -> RequestSerialized: + + """Builds the HTTP request params needed by the request. + :param method: Method to call. + :param resource_path: Path to method endpoint. + :param path_params: Path parameters in the url. + :param query_params: Query parameters in the url. + :param header_params: Header parameters to be + placed in the request header. + :param body: Request body. + :param post_params dict: Request post form parameters, + for `application/x-www-form-urlencoded`, `multipart/form-data`. + :param auth_settings list: Auth Settings names for the request. + :param files dict: key -> filename, value -> filepath, + for `multipart/form-data`. + :param collection_formats: dict of collection formats for path, query, + header, and post parameters. + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the authentication + in the spec for a single request. + :return: tuple of form (path, http_method, query_params, header_params, + body, post_params, files) + """ + + config = self.configuration + + # header parameters + header_params = header_params or {} + header_params.update(self.default_headers) + if self.cookie: + header_params['Cookie'] = self.cookie + if header_params: + header_params = self.sanitize_for_serialization(header_params) + header_params = dict( + self.parameters_to_tuples(header_params,collection_formats) + ) + + # path parameters + if path_params: + path_params = self.sanitize_for_serialization(path_params) + path_params = self.parameters_to_tuples( + path_params, + collection_formats + ) + for k, v in path_params: + # specified safe chars, encode everything + resource_path = resource_path.replace( + '{%s}' % k, + quote(str(v), safe=config.safe_chars_for_path_param) + ) + + # post parameters + if post_params or files: + post_params = post_params if post_params else [] + post_params = self.sanitize_for_serialization(post_params) + post_params = self.parameters_to_tuples( + post_params, + collection_formats + ) + if files: + post_params.extend(self.files_parameters(files)) + + # auth setting + self.update_params_for_auth( + header_params, + query_params, + auth_settings, + resource_path, + method, + body, + request_auth=_request_auth + ) + + # body + if body: + body = self.sanitize_for_serialization(body) + + # request url + if _host is None or self.configuration.ignore_operation_servers: + url = self.configuration.host + resource_path + else: + # use server/host defined in path or operation instead + url = _host + resource_path + + # query parameters + if query_params: + query_params = self.sanitize_for_serialization(query_params) + url_query = self.parameters_to_url_query( + query_params, + collection_formats + ) + url += "?" + url_query + + return method, url, header_params, body, post_params + + + def call_api( + self, + method, + url, + header_params=None, + body=None, + post_params=None, + _request_timeout=None + ) -> rest.RESTResponse: + """Makes the HTTP request (synchronous) + :param method: Method to call. + :param url: Path to method endpoint. + :param header_params: Header parameters to be + placed in the request header. + :param body: Request body. + :param post_params dict: Request post form parameters, + for `application/x-www-form-urlencoded`, `multipart/form-data`. + :param _request_timeout: timeout setting for this request. + :return: RESTResponse + """ + + try: + # perform request and return response + response_data = self.rest_client.request( + method, url, + headers=header_params, + body=body, post_params=post_params, + _request_timeout=_request_timeout + ) + + except ApiException as e: + raise e + + return response_data + + def response_deserialize( + self, + response_data: rest.RESTResponse, + response_types_map: Optional[Dict[str, ApiResponseT]]=None + ) -> ApiResponse[ApiResponseT]: + """Deserializes response into an object. + :param response_data: RESTResponse object to be deserialized. + :param response_types_map: dict of response types. + :return: ApiResponse + """ + + msg = "RESTResponse.read() must be called before passing it to response_deserialize()" + assert response_data.data is not None, msg + + response_type = response_types_map.get(str(response_data.status), None) + if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599: + # if not found, look for '1XX', '2XX', etc. + response_type = response_types_map.get(str(response_data.status)[0] + "XX", None) + + # deserialize response data + response_text = None + return_data = None + try: + if response_type == "bytearray": + return_data = response_data.data + elif response_type == "file": + return_data = self.__deserialize_file(response_data) + elif response_type is not None: + match = None + content_type = response_data.getheader('content-type') + if content_type is not None: + match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type) + encoding = match.group(1) if match else "utf-8" + response_text = response_data.data.decode(encoding) + return_data = self.deserialize(response_text, response_type, content_type) + finally: + if not 200 <= response_data.status <= 299: + raise ApiException.from_response( + http_resp=response_data, + body=response_text, + data=return_data, + ) + + return ApiResponse( + status_code = response_data.status, + data = return_data, + headers = response_data.getheaders(), + raw_data = response_data.data + ) + + def sanitize_for_serialization(self, obj): + """Builds a JSON POST object. + + If obj is None, return None. + If obj is SecretStr, return obj.get_secret_value() + If obj is str, int, long, float, bool, return directly. + If obj is datetime.datetime, datetime.date + convert to string in iso8601 format. + If obj is list, sanitize each element in the list. + If obj is dict, return the dict. + If obj is OpenAPI model, return the properties dict. + + :param obj: The data to serialize. + :return: The serialized form of data. + """ + if obj is None: + return None + elif isinstance(obj, Enum): + return obj.value + elif isinstance(obj, SecretStr): + return obj.get_secret_value() + elif isinstance(obj, self.PRIMITIVE_TYPES): + return obj + elif isinstance(obj, list): + return [ + self.sanitize_for_serialization(sub_obj) for sub_obj in obj + ] + elif isinstance(obj, tuple): + return tuple( + self.sanitize_for_serialization(sub_obj) for sub_obj in obj + ) + elif isinstance(obj, (datetime.datetime, datetime.date)): + return obj.isoformat() + + elif isinstance(obj, dict): + obj_dict = obj + else: + # Convert model obj to dict except + # attributes `openapi_types`, `attribute_map` + # and attributes which value is not None. + # Convert attribute name to json key in + # model definition for request. + if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')): + obj_dict = obj.to_dict() + else: + obj_dict = obj.__dict__ + + return { + key: self.sanitize_for_serialization(val) + for key, val in obj_dict.items() + } + + def deserialize(self, response_text: str, response_type: str, content_type: Optional[str]): + """Deserializes response into an object. + + :param response: RESTResponse object to be deserialized. + :param response_type: class literal for + deserialized object, or string of class name. + :param content_type: content type of response. + + :return: deserialized object. + """ + + # fetch data from response object + if content_type is None: + try: + data = json.loads(response_text) + except ValueError: + data = response_text + elif content_type.startswith("application/json"): + if response_text == "": + data = "" + else: + data = json.loads(response_text) + elif content_type.startswith("text/plain"): + data = response_text + else: + raise ApiException( + status=0, + reason="Unsupported content type: {0}".format(content_type) + ) + + return self.__deserialize(data, response_type) + + def __deserialize(self, data, klass): + """Deserializes dict, list, str into an object. + + :param data: dict, list or str. + :param klass: class literal, or string of class name. + + :return: object. + """ + if data is None: + return None + + if isinstance(klass, str): + if klass.startswith('List['): + m = re.match(r'List\[(.*)]', klass) + assert m is not None, "Malformed List type definition" + sub_kls = m.group(1) + return [self.__deserialize(sub_data, sub_kls) + for sub_data in data] + + if klass.startswith('Dict['): + m = re.match(r'Dict\[([^,]*), (.*)]', klass) + assert m is not None, "Malformed Dict type definition" + sub_kls = m.group(2) + return {k: self.__deserialize(v, sub_kls) + for k, v in data.items()} + + # convert str to class + if klass in self.NATIVE_TYPES_MAPPING: + klass = self.NATIVE_TYPES_MAPPING[klass] + else: + klass = getattr(activitysmith_openapi.models, klass) + + if klass in self.PRIMITIVE_TYPES: + return self.__deserialize_primitive(data, klass) + elif klass == object: + return self.__deserialize_object(data) + elif klass == datetime.date: + return self.__deserialize_date(data) + elif klass == datetime.datetime: + return self.__deserialize_datetime(data) + elif issubclass(klass, Enum): + return self.__deserialize_enum(data, klass) + else: + return self.__deserialize_model(data, klass) + + def parameters_to_tuples(self, params, collection_formats): + """Get parameters as list of tuples, formatting collections. + + :param params: Parameters as dict or list of two-tuples + :param dict collection_formats: Parameter collection formats + :return: Parameters as list of tuples, collections formatted + """ + new_params: List[Tuple[str, str]] = [] + if collection_formats is None: + collection_formats = {} + for k, v in params.items() if isinstance(params, dict) else params: + if k in collection_formats: + collection_format = collection_formats[k] + if collection_format == 'multi': + new_params.extend((k, value) for value in v) + else: + if collection_format == 'ssv': + delimiter = ' ' + elif collection_format == 'tsv': + delimiter = '\t' + elif collection_format == 'pipes': + delimiter = '|' + else: # csv is the default + delimiter = ',' + new_params.append( + (k, delimiter.join(str(value) for value in v))) + else: + new_params.append((k, v)) + return new_params + + def parameters_to_url_query(self, params, collection_formats): + """Get parameters as list of tuples, formatting collections. + + :param params: Parameters as dict or list of two-tuples + :param dict collection_formats: Parameter collection formats + :return: URL query string (e.g. a=Hello%20World&b=123) + """ + new_params: List[Tuple[str, str]] = [] + if collection_formats is None: + collection_formats = {} + for k, v in params.items() if isinstance(params, dict) else params: + if isinstance(v, bool): + v = str(v).lower() + if isinstance(v, (int, float)): + v = str(v) + if isinstance(v, dict): + v = json.dumps(v) + + if k in collection_formats: + collection_format = collection_formats[k] + if collection_format == 'multi': + new_params.extend((k, str(value)) for value in v) + else: + if collection_format == 'ssv': + delimiter = ' ' + elif collection_format == 'tsv': + delimiter = '\t' + elif collection_format == 'pipes': + delimiter = '|' + else: # csv is the default + delimiter = ',' + new_params.append( + (k, delimiter.join(quote(str(value)) for value in v)) + ) + else: + new_params.append((k, quote(str(v)))) + + return "&".join(["=".join(map(str, item)) for item in new_params]) + + def files_parameters(self, files: Dict[str, Union[str, bytes]]): + """Builds form parameters. + + :param files: File parameters. + :return: Form parameters with files. + """ + params = [] + for k, v in files.items(): + if isinstance(v, str): + with open(v, 'rb') as f: + filename = os.path.basename(f.name) + filedata = f.read() + elif isinstance(v, bytes): + filename = k + filedata = v + else: + raise ValueError("Unsupported file value") + mimetype = ( + mimetypes.guess_type(filename)[0] + or 'application/octet-stream' + ) + params.append( + tuple([k, tuple([filename, filedata, mimetype])]) + ) + return params + + def select_header_accept(self, accepts: List[str]) -> Optional[str]: + """Returns `Accept` based on an array of accepts provided. + + :param accepts: List of headers. + :return: Accept (e.g. application/json). + """ + if not accepts: + return None + + for accept in accepts: + if re.search('json', accept, re.IGNORECASE): + return accept + + return accepts[0] + + def select_header_content_type(self, content_types): + """Returns `Content-Type` based on an array of content_types provided. + + :param content_types: List of content-types. + :return: Content-Type (e.g. application/json). + """ + if not content_types: + return None + + for content_type in content_types: + if re.search('json', content_type, re.IGNORECASE): + return content_type + + return content_types[0] + + def update_params_for_auth( + self, + headers, + queries, + auth_settings, + resource_path, + method, + body, + request_auth=None + ) -> None: + """Updates header and query params based on authentication setting. + + :param headers: Header parameters dict to be updated. + :param queries: Query parameters tuple list to be updated. + :param auth_settings: Authentication setting identifiers list. + :resource_path: A string representation of the HTTP request resource path. + :method: A string representation of the HTTP request method. + :body: A object representing the body of the HTTP request. + The object type is the return value of sanitize_for_serialization(). + :param request_auth: if set, the provided settings will + override the token in the configuration. + """ + if not auth_settings: + return + + if request_auth: + self._apply_auth_params( + headers, + queries, + resource_path, + method, + body, + request_auth + ) + else: + for auth in auth_settings: + auth_setting = self.configuration.auth_settings().get(auth) + if auth_setting: + self._apply_auth_params( + headers, + queries, + resource_path, + method, + body, + auth_setting + ) + + def _apply_auth_params( + self, + headers, + queries, + resource_path, + method, + body, + auth_setting + ) -> None: + """Updates the request parameters based on a single auth_setting + + :param headers: Header parameters dict to be updated. + :param queries: Query parameters tuple list to be updated. + :resource_path: A string representation of the HTTP request resource path. + :method: A string representation of the HTTP request method. + :body: A object representing the body of the HTTP request. + The object type is the return value of sanitize_for_serialization(). + :param auth_setting: auth settings for the endpoint + """ + if auth_setting['in'] == 'cookie': + headers['Cookie'] = auth_setting['value'] + elif auth_setting['in'] == 'header': + if auth_setting['type'] != 'http-signature': + headers[auth_setting['key']] = auth_setting['value'] + elif auth_setting['in'] == 'query': + queries.append((auth_setting['key'], auth_setting['value'])) + else: + raise ApiValueError( + 'Authentication token must be in `query` or `header`' + ) + + def __deserialize_file(self, response): + """Deserializes body to file + + Saves response body into a file in a temporary folder, + using the filename from the `Content-Disposition` header if provided. + + handle file downloading + save response body into a tmp file and return the instance + + :param response: RESTResponse. + :return: file path. + """ + fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path) + os.close(fd) + os.remove(path) + + content_disposition = response.getheader("Content-Disposition") + if content_disposition: + m = re.search( + r'filename=[\'"]?([^\'"\s]+)[\'"]?', + content_disposition + ) + assert m is not None, "Unexpected 'content-disposition' header value" + filename = m.group(1) + path = os.path.join(os.path.dirname(path), filename) + + with open(path, "wb") as f: + f.write(response.data) + + return path + + def __deserialize_primitive(self, data, klass): + """Deserializes string to primitive type. + + :param data: str. + :param klass: class literal. + + :return: int, long, float, str, bool. + """ + try: + return klass(data) + except UnicodeEncodeError: + return str(data) + except TypeError: + return data + + def __deserialize_object(self, value): + """Return an original value. + + :return: object. + """ + return value + + def __deserialize_date(self, string): + """Deserializes string to date. + + :param string: str. + :return: date. + """ + try: + return parse(string).date() + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason="Failed to parse `{0}` as date object".format(string) + ) + + def __deserialize_datetime(self, string): + """Deserializes string to datetime. + + The string should be in iso8601 datetime format. + + :param string: str. + :return: datetime. + """ + try: + return parse(string) + except ImportError: + return string + except ValueError: + raise rest.ApiException( + status=0, + reason=( + "Failed to parse `{0}` as datetime object" + .format(string) + ) + ) + + def __deserialize_enum(self, data, klass): + """Deserializes primitive type to enum. + + :param data: primitive type. + :param klass: class literal. + :return: enum value. + """ + try: + return klass(data) + except ValueError: + raise rest.ApiException( + status=0, + reason=( + "Failed to parse `{0}` as `{1}`" + .format(data, klass) + ) + ) + + def __deserialize_model(self, data, klass): + """Deserializes list or dict to model. + + :param data: dict, list. + :param klass: class literal. + :return: model object. + """ + + return klass.from_dict(data) diff --git a/activitysmith_openapi/api_response.py b/activitysmith_openapi/api_response.py new file mode 100644 index 0000000..9bc7c11 --- /dev/null +++ b/activitysmith_openapi/api_response.py @@ -0,0 +1,21 @@ +"""API response object.""" + +from __future__ import annotations +from typing import Optional, Generic, Mapping, TypeVar +from pydantic import Field, StrictInt, StrictBytes, BaseModel + +T = TypeVar("T") + +class ApiResponse(BaseModel, Generic[T]): + """ + API response object + """ + + status_code: StrictInt = Field(description="HTTP status code") + headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers") + data: T = Field(description="Deserialized data given the data type") + raw_data: StrictBytes = Field(description="Raw data (HTTP response body)") + + model_config = { + "arbitrary_types_allowed": True + } diff --git a/activitysmith_openapi/configuration.py b/activitysmith_openapi/configuration.py new file mode 100644 index 0000000..64c3ec4 --- /dev/null +++ b/activitysmith_openapi/configuration.py @@ -0,0 +1,459 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import copy +import logging +from logging import FileHandler +import multiprocessing +import sys +from typing import Optional +import urllib3 + +import http.client as httplib + +JSON_SCHEMA_VALIDATION_KEYWORDS = { + 'multipleOf', 'maximum', 'exclusiveMaximum', + 'minimum', 'exclusiveMinimum', 'maxLength', + 'minLength', 'pattern', 'maxItems', 'minItems' +} + +class Configuration: + """This class contains various settings of the API client. + + :param host: Base url. + :param ignore_operation_servers + Boolean to ignore operation servers for the API client. + Config will use `host` as the base url regardless of the operation servers. + :param api_key: Dict to store API key(s). + Each entry in the dict specifies an API key. + The dict key is the name of the security scheme in the OAS specification. + The dict value is the API key secret. + :param api_key_prefix: Dict to store API prefix (e.g. Bearer). + The dict key is the name of the security scheme in the OAS specification. + The dict value is an API key prefix when generating the auth data. + :param username: Username for HTTP basic authentication. + :param password: Password for HTTP basic authentication. + :param access_token: Access token. + :param server_index: Index to servers configuration. + :param server_variables: Mapping with string values to replace variables in + templated server configuration. The validation of enums is performed for + variables with defined enum values before. + :param server_operation_index: Mapping from operation ID to an index to server + configuration. + :param server_operation_variables: Mapping from operation ID to a mapping with + string values to replace variables in templated server configuration. + The validation of enums is performed for variables with defined enum + values before. + :param ssl_ca_cert: str - the path to a file of concatenated CA certificates + in PEM format. + :param retries: Number of retries for API requests. + + :Example: + """ + + _default = None + + def __init__(self, host=None, + api_key=None, api_key_prefix=None, + username=None, password=None, + access_token=None, + server_index=None, server_variables=None, + server_operation_index=None, server_operation_variables=None, + ignore_operation_servers=False, + ssl_ca_cert=None, + retries=None, + *, + debug: Optional[bool] = None + ) -> None: + """Constructor + """ + self._base_path = "https://activitysmith.com/api" if host is None else host + """Default Base url + """ + self.server_index = 0 if server_index is None and host is None else server_index + self.server_operation_index = server_operation_index or {} + """Default server index + """ + self.server_variables = server_variables or {} + self.server_operation_variables = server_operation_variables or {} + """Default server variables + """ + self.ignore_operation_servers = ignore_operation_servers + """Ignore operation servers + """ + self.temp_folder_path = None + """Temp file folder for downloading files + """ + # Authentication Settings + self.api_key = {} + if api_key: + self.api_key = api_key + """dict to store API key(s) + """ + self.api_key_prefix = {} + if api_key_prefix: + self.api_key_prefix = api_key_prefix + """dict to store API prefix (e.g. Bearer) + """ + self.refresh_api_key_hook = None + """function hook to refresh API key if expired + """ + self.username = username + """Username for HTTP basic authentication + """ + self.password = password + """Password for HTTP basic authentication + """ + self.access_token = access_token + """Access token + """ + self.logger = {} + """Logging Settings + """ + self.logger["package_logger"] = logging.getLogger("activitysmith_openapi") + self.logger["urllib3_logger"] = logging.getLogger("urllib3") + self.logger_format = '%(asctime)s %(levelname)s %(message)s' + """Log format + """ + self.logger_stream_handler = None + """Log stream handler + """ + self.logger_file_handler: Optional[FileHandler] = None + """Log file handler + """ + self.logger_file = None + """Debug file location + """ + if debug is not None: + self.debug = debug + else: + self.__debug = False + """Debug switch + """ + + self.verify_ssl = True + """SSL/TLS verification + Set this to false to skip verifying SSL certificate when calling API + from https server. + """ + self.ssl_ca_cert = ssl_ca_cert + """Set this to customize the certificate file to verify the peer. + """ + self.cert_file = None + """client certificate file + """ + self.key_file = None + """client key file + """ + self.assert_hostname = None + """Set this to True/False to enable/disable SSL hostname verification. + """ + self.tls_server_name = None + """SSL/TLS Server Name Indication (SNI) + Set this to the SNI value expected by the server. + """ + + self.connection_pool_maxsize = multiprocessing.cpu_count() * 5 + """urllib3 connection pool's maximum number of connections saved + per pool. urllib3 uses 1 connection as default value, but this is + not the best value when you are making a lot of possibly parallel + requests to the same host, which is often the case here. + cpu_count * 5 is used as default value to increase performance. + """ + + self.proxy: Optional[str] = None + """Proxy URL + """ + self.proxy_headers = None + """Proxy headers + """ + self.safe_chars_for_path_param = '' + """Safe chars for path_param + """ + self.retries = retries + """Adding retries to override urllib3 default value 3 + """ + # Enable client side validation + self.client_side_validation = True + + self.socket_options = None + """Options to pass down to the underlying urllib3 socket + """ + + self.datetime_format = "%Y-%m-%dT%H:%M:%S.%f%z" + """datetime format + """ + + self.date_format = "%Y-%m-%d" + """date format + """ + + def __deepcopy__(self, memo): + cls = self.__class__ + result = cls.__new__(cls) + memo[id(self)] = result + for k, v in self.__dict__.items(): + if k not in ('logger', 'logger_file_handler'): + setattr(result, k, copy.deepcopy(v, memo)) + # shallow copy of loggers + result.logger = copy.copy(self.logger) + # use setters to configure loggers + result.logger_file = self.logger_file + result.debug = self.debug + return result + + def __setattr__(self, name, value): + object.__setattr__(self, name, value) + + @classmethod + def set_default(cls, default): + """Set default instance of configuration. + + It stores default configuration, which can be + returned by get_default_copy method. + + :param default: object of Configuration + """ + cls._default = default + + @classmethod + def get_default_copy(cls): + """Deprecated. Please use `get_default` instead. + + Deprecated. Please use `get_default` instead. + + :return: The configuration object. + """ + return cls.get_default() + + @classmethod + def get_default(cls): + """Return the default configuration. + + This method returns newly created, based on default constructor, + object of Configuration class or returns a copy of default + configuration. + + :return: The configuration object. + """ + if cls._default is None: + cls._default = Configuration() + return cls._default + + @property + def logger_file(self): + """The logger file. + + If the logger_file is None, then add stream handler and remove file + handler. Otherwise, add file handler and remove stream handler. + + :param value: The logger_file path. + :type: str + """ + return self.__logger_file + + @logger_file.setter + def logger_file(self, value): + """The logger file. + + If the logger_file is None, then add stream handler and remove file + handler. Otherwise, add file handler and remove stream handler. + + :param value: The logger_file path. + :type: str + """ + self.__logger_file = value + if self.__logger_file: + # If set logging file, + # then add file handler and remove stream handler. + self.logger_file_handler = logging.FileHandler(self.__logger_file) + self.logger_file_handler.setFormatter(self.logger_formatter) + for _, logger in self.logger.items(): + logger.addHandler(self.logger_file_handler) + + @property + def debug(self): + """Debug status + + :param value: The debug status, True or False. + :type: bool + """ + return self.__debug + + @debug.setter + def debug(self, value): + """Debug status + + :param value: The debug status, True or False. + :type: bool + """ + self.__debug = value + if self.__debug: + # if debug status is True, turn on debug logging + for _, logger in self.logger.items(): + logger.setLevel(logging.DEBUG) + # turn on httplib debug + httplib.HTTPConnection.debuglevel = 1 + else: + # if debug status is False, turn off debug logging, + # setting log level to default `logging.WARNING` + for _, logger in self.logger.items(): + logger.setLevel(logging.WARNING) + # turn off httplib debug + httplib.HTTPConnection.debuglevel = 0 + + @property + def logger_format(self): + """The logger format. + + The logger_formatter will be updated when sets logger_format. + + :param value: The format string. + :type: str + """ + return self.__logger_format + + @logger_format.setter + def logger_format(self, value): + """The logger format. + + The logger_formatter will be updated when sets logger_format. + + :param value: The format string. + :type: str + """ + self.__logger_format = value + self.logger_formatter = logging.Formatter(self.__logger_format) + + def get_api_key_with_prefix(self, identifier, alias=None): + """Gets API key (with prefix if set). + + :param identifier: The identifier of apiKey. + :param alias: The alternative identifier of apiKey. + :return: The token for api key authentication. + """ + if self.refresh_api_key_hook is not None: + self.refresh_api_key_hook(self) + key = self.api_key.get(identifier, self.api_key.get(alias) if alias is not None else None) + if key: + prefix = self.api_key_prefix.get(identifier) + if prefix: + return "%s %s" % (prefix, key) + else: + return key + + def get_basic_auth_token(self): + """Gets HTTP basic authentication header (string). + + :return: The token for basic HTTP authentication. + """ + username = "" + if self.username is not None: + username = self.username + password = "" + if self.password is not None: + password = self.password + return urllib3.util.make_headers( + basic_auth=username + ':' + password + ).get('authorization') + + def auth_settings(self): + """Gets Auth Settings dict for api client. + + :return: The Auth Settings information dict. + """ + auth = {} + if self.access_token is not None: + auth['apiKeyAuth'] = { + 'type': 'bearer', + 'in': 'header', + 'format': 'API Key', + 'key': 'Authorization', + 'value': 'Bearer ' + self.access_token + } + return auth + + def to_debug_report(self): + """Gets the essential information for debugging. + + :return: The report for debugging. + """ + return "Python SDK Debug Report:\n"\ + "OS: {env}\n"\ + "Python Version: {pyversion}\n"\ + "Version of the API: 1.0.0\n"\ + "SDK Package Version: 0.1.0".\ + format(env=sys.platform, pyversion=sys.version) + + def get_host_settings(self): + """Gets an array of host settings + + :return: An array of host settings + """ + return [ + { + 'url': "https://activitysmith.com/api", + 'description': "No description provided", + } + ] + + def get_host_from_settings(self, index, variables=None, servers=None): + """Gets host URL based on the index and variables + :param index: array index of the host settings + :param variables: hash of variable and the corresponding value + :param servers: an array of host settings or None + :return: URL based on host settings + """ + if index is None: + return self._base_path + + variables = {} if variables is None else variables + servers = self.get_host_settings() if servers is None else servers + + try: + server = servers[index] + except IndexError: + raise ValueError( + "Invalid index {0} when selecting the host settings. " + "Must be less than {1}".format(index, len(servers))) + + url = server['url'] + + # go through variables and replace placeholders + for variable_name, variable in server.get('variables', {}).items(): + used_value = variables.get( + variable_name, variable['default_value']) + + if 'enum_values' in variable \ + and used_value not in variable['enum_values']: + raise ValueError( + "The variable `{0}` in the host URL has invalid value " + "{1}. Must be {2}.".format( + variable_name, variables[variable_name], + variable['enum_values'])) + + url = url.replace("{" + variable_name + "}", used_value) + + return url + + @property + def host(self): + """Return generated host.""" + return self.get_host_from_settings(self.server_index, variables=self.server_variables) + + @host.setter + def host(self, value): + """Fix base path.""" + self._base_path = value + self.server_index = None diff --git a/activitysmith_openapi/docs/ContentStateEnd.md b/activitysmith_openapi/docs/ContentStateEnd.md new file mode 100644 index 0000000..de4d136 --- /dev/null +++ b/activitysmith_openapi/docs/ContentStateEnd.md @@ -0,0 +1,36 @@ +# ContentStateEnd + +End payload. Required fields are title and current_step. number_of_steps is optional. + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**title** | **str** | | +**subtitle** | **str** | | [optional] +**number_of_steps** | **int** | | [optional] +**current_step** | **int** | | +**color** | **str** | Optional. Accent color for the Live Activity. Defaults to blue. | [optional] [default to 'blue'] +**step_color** | **str** | Optional. Overrides color for the current step. | [optional] +**auto_dismiss_minutes** | **int** | Optional. Minutes before the ended Live Activity is dismissed. Default 3. Set 0 for immediate dismissal. iOS will dismiss ended Live Activities after ~4 hours max. | [optional] [default to 3] + +## Example + +```python +from activitysmith_openapi.models.content_state_end import ContentStateEnd + +# TODO update the JSON string below +json = "{}" +# create an instance of ContentStateEnd from a JSON string +content_state_end_instance = ContentStateEnd.from_json(json) +# print the JSON string representation of the object +print(ContentStateEnd.to_json()) + +# convert the object into a dict +content_state_end_dict = content_state_end_instance.to_dict() +# create an instance of ContentStateEnd from a dict +content_state_end_from_dict = ContentStateEnd.from_dict(content_state_end_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/ContentStateStart.md b/activitysmith_openapi/docs/ContentStateStart.md new file mode 100644 index 0000000..cb9cf63 --- /dev/null +++ b/activitysmith_openapi/docs/ContentStateStart.md @@ -0,0 +1,36 @@ +# ContentStateStart + +Start payload requires title, number_of_steps, current_step, and type. + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**title** | **str** | | +**subtitle** | **str** | | [optional] +**number_of_steps** | **int** | | +**current_step** | **int** | | +**type** | **str** | | +**color** | **str** | Optional. Accent color for the Live Activity. Defaults to blue. | [optional] [default to 'blue'] +**step_color** | **str** | Optional. Overrides color for the current step. | [optional] + +## Example + +```python +from activitysmith_openapi.models.content_state_start import ContentStateStart + +# TODO update the JSON string below +json = "{}" +# create an instance of ContentStateStart from a JSON string +content_state_start_instance = ContentStateStart.from_json(json) +# print the JSON string representation of the object +print(ContentStateStart.to_json()) + +# convert the object into a dict +content_state_start_dict = content_state_start_instance.to_dict() +# create an instance of ContentStateStart from a dict +content_state_start_from_dict = ContentStateStart.from_dict(content_state_start_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/ContentStateUpdate.md b/activitysmith_openapi/docs/ContentStateUpdate.md new file mode 100644 index 0000000..2370b4d --- /dev/null +++ b/activitysmith_openapi/docs/ContentStateUpdate.md @@ -0,0 +1,35 @@ +# ContentStateUpdate + +Update payload. Required fields are title and current_step. number_of_steps is optional. + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**title** | **str** | | +**subtitle** | **str** | | [optional] +**number_of_steps** | **int** | | [optional] +**current_step** | **int** | | +**color** | **str** | Optional. Accent color for the Live Activity. Defaults to blue. | [optional] [default to 'blue'] +**step_color** | **str** | Optional. Overrides color for the current step. | [optional] + +## Example + +```python +from activitysmith_openapi.models.content_state_update import ContentStateUpdate + +# TODO update the JSON string below +json = "{}" +# create an instance of ContentStateUpdate from a JSON string +content_state_update_instance = ContentStateUpdate.from_json(json) +# print the JSON string representation of the object +print(ContentStateUpdate.to_json()) + +# convert the object into a dict +content_state_update_dict = content_state_update_instance.to_dict() +# create an instance of ContentStateUpdate from a dict +content_state_update_from_dict = ContentStateUpdate.from_dict(content_state_update_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/LiveActivitiesApi.md b/activitysmith_openapi/docs/LiveActivitiesApi.md new file mode 100644 index 0000000..885d37d --- /dev/null +++ b/activitysmith_openapi/docs/LiveActivitiesApi.md @@ -0,0 +1,251 @@ +# activitysmith_openapi.LiveActivitiesApi + +All URIs are relative to *https://activitysmith.com/api* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**end_live_activity**](LiveActivitiesApi.md#end_live_activity) | **POST** /live-activity/end | End a Live Activity +[**start_live_activity**](LiveActivitiesApi.md#start_live_activity) | **POST** /live-activity/start | Start a Live Activity +[**update_live_activity**](LiveActivitiesApi.md#update_live_activity) | **POST** /live-activity/update | Update a Live Activity + + +# **end_live_activity** +> LiveActivityEndResponse end_live_activity(live_activity_end_request) + +End a Live Activity + +Ends a Live Activity and archives its lifecycle. + +### Example + +* Bearer (API Key) Authentication (apiKeyAuth): + +```python +import activitysmith_openapi +from activitysmith_openapi.models.live_activity_end_request import LiveActivityEndRequest +from activitysmith_openapi.models.live_activity_end_response import LiveActivityEndResponse +from activitysmith_openapi.rest import ApiException +from pprint import pprint + +# Defining the host is optional and defaults to https://activitysmith.com/api +# See configuration.py for a list of all supported configuration parameters. +configuration = activitysmith_openapi.Configuration( + host = "https://activitysmith.com/api" +) + +# The client must configure the authentication and authorization parameters +# in accordance with the API server security policy. +# Examples for each auth method are provided below, use the example that +# satisfies your auth use case. + +# Configure Bearer authorization (API Key): apiKeyAuth +configuration = activitysmith_openapi.Configuration( + access_token = os.environ["BEARER_TOKEN"] +) + +# Enter a context with an instance of the API client +with activitysmith_openapi.ApiClient(configuration) as api_client: + # Create an instance of the API class + api_instance = activitysmith_openapi.LiveActivitiesApi(api_client) + live_activity_end_request = {"activity_id":"pLAr-Hnq9ZFW4sxlk43Lhbuok4GLh7UW","content_state":{"title":"ActivitySmith API Deployment","subtitle":"done","current_step":4,"auto_dismiss_minutes":3}} # LiveActivityEndRequest | + + try: + # End a Live Activity + api_response = api_instance.end_live_activity(live_activity_end_request) + print("The response of LiveActivitiesApi->end_live_activity:\n") + pprint(api_response) + except Exception as e: + print("Exception when calling LiveActivitiesApi->end_live_activity: %s\n" % e) +``` + + + +### Parameters + + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **live_activity_end_request** | [**LiveActivityEndRequest**](LiveActivityEndRequest.md)| | + +### Return type + +[**LiveActivityEndResponse**](LiveActivityEndResponse.md) + +### Authorization + +[apiKeyAuth](../README.md#apiKeyAuth) + +### HTTP request headers + + - **Content-Type**: application/json + - **Accept**: application/json + +### HTTP response details + +| Status code | Description | Response headers | +|-------------|-------------|------------------| +**200** | Live Activity ended | - | +**429** | Rate limit exceeded | - | + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **start_live_activity** +> LiveActivityStartResponse start_live_activity(live_activity_start_request) + +Start a Live Activity + +Starts a Live Activity on all registered devices and returns an activity_id. + +### Example + +* Bearer (API Key) Authentication (apiKeyAuth): + +```python +import activitysmith_openapi +from activitysmith_openapi.models.live_activity_start_request import LiveActivityStartRequest +from activitysmith_openapi.models.live_activity_start_response import LiveActivityStartResponse +from activitysmith_openapi.rest import ApiException +from pprint import pprint + +# Defining the host is optional and defaults to https://activitysmith.com/api +# See configuration.py for a list of all supported configuration parameters. +configuration = activitysmith_openapi.Configuration( + host = "https://activitysmith.com/api" +) + +# The client must configure the authentication and authorization parameters +# in accordance with the API server security policy. +# Examples for each auth method are provided below, use the example that +# satisfies your auth use case. + +# Configure Bearer authorization (API Key): apiKeyAuth +configuration = activitysmith_openapi.Configuration( + access_token = os.environ["BEARER_TOKEN"] +) + +# Enter a context with an instance of the API client +with activitysmith_openapi.ApiClient(configuration) as api_client: + # Create an instance of the API class + api_instance = activitysmith_openapi.LiveActivitiesApi(api_client) + live_activity_start_request = {"content_state":{"title":"ActivitySmith API Deployment","subtitle":"start","number_of_steps":4,"current_step":1,"type":"segmented_progress","color":"yellow"}} # LiveActivityStartRequest | + + try: + # Start a Live Activity + api_response = api_instance.start_live_activity(live_activity_start_request) + print("The response of LiveActivitiesApi->start_live_activity:\n") + pprint(api_response) + except Exception as e: + print("Exception when calling LiveActivitiesApi->start_live_activity: %s\n" % e) +``` + + + +### Parameters + + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **live_activity_start_request** | [**LiveActivityStartRequest**](LiveActivityStartRequest.md)| | + +### Return type + +[**LiveActivityStartResponse**](LiveActivityStartResponse.md) + +### Authorization + +[apiKeyAuth](../README.md#apiKeyAuth) + +### HTTP request headers + + - **Content-Type**: application/json + - **Accept**: application/json + +### HTTP response details + +| Status code | Description | Response headers | +|-------------|-------------|------------------| +**200** | Live Activity started | - | +**429** | Rate limit exceeded | - | + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + +# **update_live_activity** +> LiveActivityUpdateResponse update_live_activity(live_activity_update_request) + +Update a Live Activity + +Updates an existing Live Activity. If the per-activity token is not registered yet, the update is queued. + +### Example + +* Bearer (API Key) Authentication (apiKeyAuth): + +```python +import activitysmith_openapi +from activitysmith_openapi.models.live_activity_update_request import LiveActivityUpdateRequest +from activitysmith_openapi.models.live_activity_update_response import LiveActivityUpdateResponse +from activitysmith_openapi.rest import ApiException +from pprint import pprint + +# Defining the host is optional and defaults to https://activitysmith.com/api +# See configuration.py for a list of all supported configuration parameters. +configuration = activitysmith_openapi.Configuration( + host = "https://activitysmith.com/api" +) + +# The client must configure the authentication and authorization parameters +# in accordance with the API server security policy. +# Examples for each auth method are provided below, use the example that +# satisfies your auth use case. + +# Configure Bearer authorization (API Key): apiKeyAuth +configuration = activitysmith_openapi.Configuration( + access_token = os.environ["BEARER_TOKEN"] +) + +# Enter a context with an instance of the API client +with activitysmith_openapi.ApiClient(configuration) as api_client: + # Create an instance of the API class + api_instance = activitysmith_openapi.LiveActivitiesApi(api_client) + live_activity_update_request = {"activity_id":"pLAr-Hnq9ZFW4sxlk43Lhbuok4GLh7UW","content_state":{"title":"ActivitySmith API Deployment","subtitle":"npm i & pm2","current_step":3}} # LiveActivityUpdateRequest | + + try: + # Update a Live Activity + api_response = api_instance.update_live_activity(live_activity_update_request) + print("The response of LiveActivitiesApi->update_live_activity:\n") + pprint(api_response) + except Exception as e: + print("Exception when calling LiveActivitiesApi->update_live_activity: %s\n" % e) +``` + + + +### Parameters + + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **live_activity_update_request** | [**LiveActivityUpdateRequest**](LiveActivityUpdateRequest.md)| | + +### Return type + +[**LiveActivityUpdateResponse**](LiveActivityUpdateResponse.md) + +### Authorization + +[apiKeyAuth](../README.md#apiKeyAuth) + +### HTTP request headers + + - **Content-Type**: application/json + - **Accept**: application/json + +### HTTP response details + +| Status code | Description | Response headers | +|-------------|-------------|------------------| +**200** | Live Activity updated (or queued) | - | +**429** | Rate limit exceeded | - | + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + diff --git a/activitysmith_openapi/docs/LiveActivityEndRequest.md b/activitysmith_openapi/docs/LiveActivityEndRequest.md new file mode 100644 index 0000000..f2293b1 --- /dev/null +++ b/activitysmith_openapi/docs/LiveActivityEndRequest.md @@ -0,0 +1,30 @@ +# LiveActivityEndRequest + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**activity_id** | **str** | | +**content_state** | [**ContentStateEnd**](ContentStateEnd.md) | | + +## Example + +```python +from activitysmith_openapi.models.live_activity_end_request import LiveActivityEndRequest + +# TODO update the JSON string below +json = "{}" +# create an instance of LiveActivityEndRequest from a JSON string +live_activity_end_request_instance = LiveActivityEndRequest.from_json(json) +# print the JSON string representation of the object +print(LiveActivityEndRequest.to_json()) + +# convert the object into a dict +live_activity_end_request_dict = live_activity_end_request_instance.to_dict() +# create an instance of LiveActivityEndRequest from a dict +live_activity_end_request_from_dict = LiveActivityEndRequest.from_dict(live_activity_end_request_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/LiveActivityEndResponse.md b/activitysmith_openapi/docs/LiveActivityEndResponse.md new file mode 100644 index 0000000..d0630a3 --- /dev/null +++ b/activitysmith_openapi/docs/LiveActivityEndResponse.md @@ -0,0 +1,33 @@ +# LiveActivityEndResponse + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**success** | **bool** | | +**activity_id** | **str** | | +**devices_queued** | **int** | | [optional] +**devices_notified** | **int** | | [optional] +**timestamp** | **datetime** | | + +## Example + +```python +from activitysmith_openapi.models.live_activity_end_response import LiveActivityEndResponse + +# TODO update the JSON string below +json = "{}" +# create an instance of LiveActivityEndResponse from a JSON string +live_activity_end_response_instance = LiveActivityEndResponse.from_json(json) +# print the JSON string representation of the object +print(LiveActivityEndResponse.to_json()) + +# convert the object into a dict +live_activity_end_response_dict = live_activity_end_response_instance.to_dict() +# create an instance of LiveActivityEndResponse from a dict +live_activity_end_response_from_dict = LiveActivityEndResponse.from_dict(live_activity_end_response_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/LiveActivityLimitError.md b/activitysmith_openapi/docs/LiveActivityLimitError.md new file mode 100644 index 0000000..d661fc6 --- /dev/null +++ b/activitysmith_openapi/docs/LiveActivityLimitError.md @@ -0,0 +1,32 @@ +# LiveActivityLimitError + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**error** | **str** | | +**message** | **str** | | +**limit** | **int** | | +**active** | **int** | Current number of active Live Activities. | + +## Example + +```python +from activitysmith_openapi.models.live_activity_limit_error import LiveActivityLimitError + +# TODO update the JSON string below +json = "{}" +# create an instance of LiveActivityLimitError from a JSON string +live_activity_limit_error_instance = LiveActivityLimitError.from_json(json) +# print the JSON string representation of the object +print(LiveActivityLimitError.to_json()) + +# convert the object into a dict +live_activity_limit_error_dict = live_activity_limit_error_instance.to_dict() +# create an instance of LiveActivityLimitError from a dict +live_activity_limit_error_from_dict = LiveActivityLimitError.from_dict(live_activity_limit_error_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/LiveActivityStartRequest.md b/activitysmith_openapi/docs/LiveActivityStartRequest.md new file mode 100644 index 0000000..d9d2c9f --- /dev/null +++ b/activitysmith_openapi/docs/LiveActivityStartRequest.md @@ -0,0 +1,29 @@ +# LiveActivityStartRequest + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**content_state** | [**ContentStateStart**](ContentStateStart.md) | | + +## Example + +```python +from activitysmith_openapi.models.live_activity_start_request import LiveActivityStartRequest + +# TODO update the JSON string below +json = "{}" +# create an instance of LiveActivityStartRequest from a JSON string +live_activity_start_request_instance = LiveActivityStartRequest.from_json(json) +# print the JSON string representation of the object +print(LiveActivityStartRequest.to_json()) + +# convert the object into a dict +live_activity_start_request_dict = live_activity_start_request_instance.to_dict() +# create an instance of LiveActivityStartRequest from a dict +live_activity_start_request_from_dict = LiveActivityStartRequest.from_dict(live_activity_start_request_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/LiveActivityStartResponse.md b/activitysmith_openapi/docs/LiveActivityStartResponse.md new file mode 100644 index 0000000..4adcd16 --- /dev/null +++ b/activitysmith_openapi/docs/LiveActivityStartResponse.md @@ -0,0 +1,33 @@ +# LiveActivityStartResponse + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**success** | **bool** | | +**devices_notified** | **int** | | [optional] +**users_notified** | **int** | | [optional] +**activity_id** | **str** | | +**timestamp** | **datetime** | | + +## Example + +```python +from activitysmith_openapi.models.live_activity_start_response import LiveActivityStartResponse + +# TODO update the JSON string below +json = "{}" +# create an instance of LiveActivityStartResponse from a JSON string +live_activity_start_response_instance = LiveActivityStartResponse.from_json(json) +# print the JSON string representation of the object +print(LiveActivityStartResponse.to_json()) + +# convert the object into a dict +live_activity_start_response_dict = live_activity_start_response_instance.to_dict() +# create an instance of LiveActivityStartResponse from a dict +live_activity_start_response_from_dict = LiveActivityStartResponse.from_dict(live_activity_start_response_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/LiveActivityUpdateRequest.md b/activitysmith_openapi/docs/LiveActivityUpdateRequest.md new file mode 100644 index 0000000..385488b --- /dev/null +++ b/activitysmith_openapi/docs/LiveActivityUpdateRequest.md @@ -0,0 +1,30 @@ +# LiveActivityUpdateRequest + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**activity_id** | **str** | | +**content_state** | [**ContentStateUpdate**](ContentStateUpdate.md) | | + +## Example + +```python +from activitysmith_openapi.models.live_activity_update_request import LiveActivityUpdateRequest + +# TODO update the JSON string below +json = "{}" +# create an instance of LiveActivityUpdateRequest from a JSON string +live_activity_update_request_instance = LiveActivityUpdateRequest.from_json(json) +# print the JSON string representation of the object +print(LiveActivityUpdateRequest.to_json()) + +# convert the object into a dict +live_activity_update_request_dict = live_activity_update_request_instance.to_dict() +# create an instance of LiveActivityUpdateRequest from a dict +live_activity_update_request_from_dict = LiveActivityUpdateRequest.from_dict(live_activity_update_request_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/LiveActivityUpdateResponse.md b/activitysmith_openapi/docs/LiveActivityUpdateResponse.md new file mode 100644 index 0000000..daf2467 --- /dev/null +++ b/activitysmith_openapi/docs/LiveActivityUpdateResponse.md @@ -0,0 +1,33 @@ +# LiveActivityUpdateResponse + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**success** | **bool** | | +**activity_id** | **str** | | +**devices_queued** | **int** | | [optional] +**devices_notified** | **int** | | [optional] +**timestamp** | **datetime** | | + +## Example + +```python +from activitysmith_openapi.models.live_activity_update_response import LiveActivityUpdateResponse + +# TODO update the JSON string below +json = "{}" +# create an instance of LiveActivityUpdateResponse from a JSON string +live_activity_update_response_instance = LiveActivityUpdateResponse.from_json(json) +# print the JSON string representation of the object +print(LiveActivityUpdateResponse.to_json()) + +# convert the object into a dict +live_activity_update_response_dict = live_activity_update_response_instance.to_dict() +# create an instance of LiveActivityUpdateResponse from a dict +live_activity_update_response_from_dict = LiveActivityUpdateResponse.from_dict(live_activity_update_response_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/PushNotificationRequest.md b/activitysmith_openapi/docs/PushNotificationRequest.md new file mode 100644 index 0000000..5a101fa --- /dev/null +++ b/activitysmith_openapi/docs/PushNotificationRequest.md @@ -0,0 +1,31 @@ +# PushNotificationRequest + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**title** | **str** | | +**message** | **str** | | [optional] +**subtitle** | **str** | | [optional] + +## Example + +```python +from activitysmith_openapi.models.push_notification_request import PushNotificationRequest + +# TODO update the JSON string below +json = "{}" +# create an instance of PushNotificationRequest from a JSON string +push_notification_request_instance = PushNotificationRequest.from_json(json) +# print the JSON string representation of the object +print(PushNotificationRequest.to_json()) + +# convert the object into a dict +push_notification_request_dict = push_notification_request_instance.to_dict() +# create an instance of PushNotificationRequest from a dict +push_notification_request_from_dict = PushNotificationRequest.from_dict(push_notification_request_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/PushNotificationResponse.md b/activitysmith_openapi/docs/PushNotificationResponse.md new file mode 100644 index 0000000..a43196d --- /dev/null +++ b/activitysmith_openapi/docs/PushNotificationResponse.md @@ -0,0 +1,32 @@ +# PushNotificationResponse + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**success** | **bool** | | +**devices_notified** | **int** | | [optional] +**users_notified** | **int** | | [optional] +**timestamp** | **datetime** | | + +## Example + +```python +from activitysmith_openapi.models.push_notification_response import PushNotificationResponse + +# TODO update the JSON string below +json = "{}" +# create an instance of PushNotificationResponse from a JSON string +push_notification_response_instance = PushNotificationResponse.from_json(json) +# print the JSON string representation of the object +print(PushNotificationResponse.to_json()) + +# convert the object into a dict +push_notification_response_dict = push_notification_response_instance.to_dict() +# create an instance of PushNotificationResponse from a dict +push_notification_response_from_dict = PushNotificationResponse.from_dict(push_notification_response_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/PushNotificationsApi.md b/activitysmith_openapi/docs/PushNotificationsApi.md new file mode 100644 index 0000000..ed9fb65 --- /dev/null +++ b/activitysmith_openapi/docs/PushNotificationsApi.md @@ -0,0 +1,89 @@ +# activitysmith_openapi.PushNotificationsApi + +All URIs are relative to *https://activitysmith.com/api* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**send_push_notification**](PushNotificationsApi.md#send_push_notification) | **POST** /push-notification | Send a push notification + + +# **send_push_notification** +> PushNotificationResponse send_push_notification(push_notification_request) + +Send a push notification + +Sends a push notification to every paired device in your account. + +### Example + +* Bearer (API Key) Authentication (apiKeyAuth): + +```python +import activitysmith_openapi +from activitysmith_openapi.models.push_notification_request import PushNotificationRequest +from activitysmith_openapi.models.push_notification_response import PushNotificationResponse +from activitysmith_openapi.rest import ApiException +from pprint import pprint + +# Defining the host is optional and defaults to https://activitysmith.com/api +# See configuration.py for a list of all supported configuration parameters. +configuration = activitysmith_openapi.Configuration( + host = "https://activitysmith.com/api" +) + +# The client must configure the authentication and authorization parameters +# in accordance with the API server security policy. +# Examples for each auth method are provided below, use the example that +# satisfies your auth use case. + +# Configure Bearer authorization (API Key): apiKeyAuth +configuration = activitysmith_openapi.Configuration( + access_token = os.environ["BEARER_TOKEN"] +) + +# Enter a context with an instance of the API client +with activitysmith_openapi.ApiClient(configuration) as api_client: + # Create an instance of the API class + api_instance = activitysmith_openapi.PushNotificationsApi(api_client) + push_notification_request = {"title":"Build Failed 🚨","message":"CI pipeline failed on main branch"} # PushNotificationRequest | + + try: + # Send a push notification + api_response = api_instance.send_push_notification(push_notification_request) + print("The response of PushNotificationsApi->send_push_notification:\n") + pprint(api_response) + except Exception as e: + print("Exception when calling PushNotificationsApi->send_push_notification: %s\n" % e) +``` + + + +### Parameters + + +Name | Type | Description | Notes +------------- | ------------- | ------------- | ------------- + **push_notification_request** | [**PushNotificationRequest**](PushNotificationRequest.md)| | + +### Return type + +[**PushNotificationResponse**](PushNotificationResponse.md) + +### Authorization + +[apiKeyAuth](../README.md#apiKeyAuth) + +### HTTP request headers + + - **Content-Type**: application/json + - **Accept**: application/json + +### HTTP response details + +| Status code | Description | Response headers | +|-------------|-------------|------------------| +**200** | Push notification sent | - | +**429** | Rate limit exceeded | - | + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + diff --git a/activitysmith_openapi/docs/RateLimitError.md b/activitysmith_openapi/docs/RateLimitError.md new file mode 100644 index 0000000..0b8575d --- /dev/null +++ b/activitysmith_openapi/docs/RateLimitError.md @@ -0,0 +1,30 @@ +# RateLimitError + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**error** | **str** | | +**message** | **str** | | + +## Example + +```python +from activitysmith_openapi.models.rate_limit_error import RateLimitError + +# TODO update the JSON string below +json = "{}" +# create an instance of RateLimitError from a JSON string +rate_limit_error_instance = RateLimitError.from_json(json) +# print the JSON string representation of the object +print(RateLimitError.to_json()) + +# convert the object into a dict +rate_limit_error_dict = rate_limit_error_instance.to_dict() +# create an instance of RateLimitError from a dict +rate_limit_error_from_dict = RateLimitError.from_dict(rate_limit_error_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/docs/SendPushNotification429Response.md b/activitysmith_openapi/docs/SendPushNotification429Response.md new file mode 100644 index 0000000..e1738e1 --- /dev/null +++ b/activitysmith_openapi/docs/SendPushNotification429Response.md @@ -0,0 +1,32 @@ +# SendPushNotification429Response + + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**error** | **str** | | +**message** | **str** | | +**limit** | **int** | | +**active** | **int** | Current number of active Live Activities. | + +## Example + +```python +from activitysmith_openapi.models.send_push_notification429_response import SendPushNotification429Response + +# TODO update the JSON string below +json = "{}" +# create an instance of SendPushNotification429Response from a JSON string +send_push_notification429_response_instance = SendPushNotification429Response.from_json(json) +# print the JSON string representation of the object +print(SendPushNotification429Response.to_json()) + +# convert the object into a dict +send_push_notification429_response_dict = send_push_notification429_response_instance.to_dict() +# create an instance of SendPushNotification429Response from a dict +send_push_notification429_response_from_dict = SendPushNotification429Response.from_dict(send_push_notification429_response_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/activitysmith_openapi/exceptions.py b/activitysmith_openapi/exceptions.py new file mode 100644 index 0000000..31f4b93 --- /dev/null +++ b/activitysmith_openapi/exceptions.py @@ -0,0 +1,199 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + +from typing import Any, Optional +from typing_extensions import Self + +class OpenApiException(Exception): + """The base exception class for all OpenAPIExceptions""" + + +class ApiTypeError(OpenApiException, TypeError): + def __init__(self, msg, path_to_item=None, valid_classes=None, + key_type=None) -> None: + """ Raises an exception for TypeErrors + + Args: + msg (str): the exception message + + Keyword Args: + path_to_item (list): a list of keys an indices to get to the + current_item + None if unset + valid_classes (tuple): the primitive classes that current item + should be an instance of + None if unset + key_type (bool): False if our value is a value in a dict + True if it is a key in a dict + False if our item is an item in a list + None if unset + """ + self.path_to_item = path_to_item + self.valid_classes = valid_classes + self.key_type = key_type + full_msg = msg + if path_to_item: + full_msg = "{0} at {1}".format(msg, render_path(path_to_item)) + super(ApiTypeError, self).__init__(full_msg) + + +class ApiValueError(OpenApiException, ValueError): + def __init__(self, msg, path_to_item=None) -> None: + """ + Args: + msg (str): the exception message + + Keyword Args: + path_to_item (list) the path to the exception in the + received_data dict. None if unset + """ + + self.path_to_item = path_to_item + full_msg = msg + if path_to_item: + full_msg = "{0} at {1}".format(msg, render_path(path_to_item)) + super(ApiValueError, self).__init__(full_msg) + + +class ApiAttributeError(OpenApiException, AttributeError): + def __init__(self, msg, path_to_item=None) -> None: + """ + Raised when an attribute reference or assignment fails. + + Args: + msg (str): the exception message + + Keyword Args: + path_to_item (None/list) the path to the exception in the + received_data dict + """ + self.path_to_item = path_to_item + full_msg = msg + if path_to_item: + full_msg = "{0} at {1}".format(msg, render_path(path_to_item)) + super(ApiAttributeError, self).__init__(full_msg) + + +class ApiKeyError(OpenApiException, KeyError): + def __init__(self, msg, path_to_item=None) -> None: + """ + Args: + msg (str): the exception message + + Keyword Args: + path_to_item (None/list) the path to the exception in the + received_data dict + """ + self.path_to_item = path_to_item + full_msg = msg + if path_to_item: + full_msg = "{0} at {1}".format(msg, render_path(path_to_item)) + super(ApiKeyError, self).__init__(full_msg) + + +class ApiException(OpenApiException): + + def __init__( + self, + status=None, + reason=None, + http_resp=None, + *, + body: Optional[str] = None, + data: Optional[Any] = None, + ) -> None: + self.status = status + self.reason = reason + self.body = body + self.data = data + self.headers = None + + if http_resp: + if self.status is None: + self.status = http_resp.status + if self.reason is None: + self.reason = http_resp.reason + if self.body is None: + try: + self.body = http_resp.data.decode('utf-8') + except Exception: + pass + self.headers = http_resp.getheaders() + + @classmethod + def from_response( + cls, + *, + http_resp, + body: Optional[str], + data: Optional[Any], + ) -> Self: + if http_resp.status == 400: + raise BadRequestException(http_resp=http_resp, body=body, data=data) + + if http_resp.status == 401: + raise UnauthorizedException(http_resp=http_resp, body=body, data=data) + + if http_resp.status == 403: + raise ForbiddenException(http_resp=http_resp, body=body, data=data) + + if http_resp.status == 404: + raise NotFoundException(http_resp=http_resp, body=body, data=data) + + if 500 <= http_resp.status <= 599: + raise ServiceException(http_resp=http_resp, body=body, data=data) + raise ApiException(http_resp=http_resp, body=body, data=data) + + def __str__(self): + """Custom error messages for exception""" + error_message = "({0})\n"\ + "Reason: {1}\n".format(self.status, self.reason) + if self.headers: + error_message += "HTTP response headers: {0}\n".format( + self.headers) + + if self.data or self.body: + error_message += "HTTP response body: {0}\n".format(self.data or self.body) + + return error_message + + +class BadRequestException(ApiException): + pass + + +class NotFoundException(ApiException): + pass + + +class UnauthorizedException(ApiException): + pass + + +class ForbiddenException(ApiException): + pass + + +class ServiceException(ApiException): + pass + + +def render_path(path_to_item): + """Returns a string representation of a path""" + result = "" + for pth in path_to_item: + if isinstance(pth, int): + result += "[{0}]".format(pth) + else: + result += "['{0}']".format(pth) + return result diff --git a/activitysmith_openapi/models/__init__.py b/activitysmith_openapi/models/__init__.py new file mode 100644 index 0000000..d2659a2 --- /dev/null +++ b/activitysmith_openapi/models/__init__.py @@ -0,0 +1,30 @@ +# coding: utf-8 + +# flake8: noqa +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +# import models into model package +from activitysmith_openapi.models.content_state_end import ContentStateEnd +from activitysmith_openapi.models.content_state_start import ContentStateStart +from activitysmith_openapi.models.content_state_update import ContentStateUpdate +from activitysmith_openapi.models.live_activity_end_request import LiveActivityEndRequest +from activitysmith_openapi.models.live_activity_end_response import LiveActivityEndResponse +from activitysmith_openapi.models.live_activity_limit_error import LiveActivityLimitError +from activitysmith_openapi.models.live_activity_start_request import LiveActivityStartRequest +from activitysmith_openapi.models.live_activity_start_response import LiveActivityStartResponse +from activitysmith_openapi.models.live_activity_update_request import LiveActivityUpdateRequest +from activitysmith_openapi.models.live_activity_update_response import LiveActivityUpdateResponse +from activitysmith_openapi.models.push_notification_request import PushNotificationRequest +from activitysmith_openapi.models.push_notification_response import PushNotificationResponse +from activitysmith_openapi.models.rate_limit_error import RateLimitError +from activitysmith_openapi.models.send_push_notification429_response import SendPushNotification429Response diff --git a/activitysmith_openapi/models/content_state_end.py b/activitysmith_openapi/models/content_state_end.py new file mode 100644 index 0000000..b20b643 --- /dev/null +++ b/activitysmith_openapi/models/content_state_end.py @@ -0,0 +1,120 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator +from typing import Any, ClassVar, Dict, List, Optional +from typing_extensions import Annotated +from typing import Optional, Set +from typing_extensions import Self + +class ContentStateEnd(BaseModel): + """ + End payload. Required fields are title and current_step. number_of_steps is optional. + """ # noqa: E501 + title: StrictStr + subtitle: Optional[StrictStr] = None + number_of_steps: Optional[Annotated[int, Field(strict=True, ge=1)]] = None + current_step: Annotated[int, Field(strict=True, ge=1)] + color: Optional[StrictStr] = Field(default='blue', description="Optional. Accent color for the Live Activity. Defaults to blue.") + step_color: Optional[StrictStr] = Field(default=None, description="Optional. Overrides color for the current step.") + auto_dismiss_minutes: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=3, description="Optional. Minutes before the ended Live Activity is dismissed. Default 3. Set 0 for immediate dismissal. iOS will dismiss ended Live Activities after ~4 hours max.") + __properties: ClassVar[List[str]] = ["title", "subtitle", "number_of_steps", "current_step", "color", "step_color", "auto_dismiss_minutes"] + + @field_validator('color') + def color_validate_enum(cls, value): + """Validates the enum""" + if value is None: + return value + + if value not in set(['lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow']): + raise ValueError("must be one of enum values ('lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow')") + return value + + @field_validator('step_color') + def step_color_validate_enum(cls, value): + """Validates the enum""" + if value is None: + return value + + if value not in set(['lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow']): + raise ValueError("must be one of enum values ('lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow')") + return value + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of ContentStateEnd from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of ContentStateEnd from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "title": obj.get("title"), + "subtitle": obj.get("subtitle"), + "number_of_steps": obj.get("number_of_steps"), + "current_step": obj.get("current_step"), + "color": obj.get("color") if obj.get("color") is not None else 'blue', + "step_color": obj.get("step_color"), + "auto_dismiss_minutes": obj.get("auto_dismiss_minutes") if obj.get("auto_dismiss_minutes") is not None else 3 + }) + return _obj + + diff --git a/activitysmith_openapi/models/content_state_start.py b/activitysmith_openapi/models/content_state_start.py new file mode 100644 index 0000000..c129325 --- /dev/null +++ b/activitysmith_openapi/models/content_state_start.py @@ -0,0 +1,127 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator +from typing import Any, ClassVar, Dict, List, Optional +from typing_extensions import Annotated +from typing import Optional, Set +from typing_extensions import Self + +class ContentStateStart(BaseModel): + """ + Start payload requires title, number_of_steps, current_step, and type. + """ # noqa: E501 + title: StrictStr + subtitle: Optional[StrictStr] = None + number_of_steps: Annotated[int, Field(strict=True, ge=1)] + current_step: Annotated[int, Field(strict=True, ge=1)] + type: StrictStr + color: Optional[StrictStr] = Field(default='blue', description="Optional. Accent color for the Live Activity. Defaults to blue.") + step_color: Optional[StrictStr] = Field(default=None, description="Optional. Overrides color for the current step.") + __properties: ClassVar[List[str]] = ["title", "subtitle", "number_of_steps", "current_step", "type", "color", "step_color"] + + @field_validator('type') + def type_validate_enum(cls, value): + """Validates the enum""" + if value not in set(['segmented_progress']): + raise ValueError("must be one of enum values ('segmented_progress')") + return value + + @field_validator('color') + def color_validate_enum(cls, value): + """Validates the enum""" + if value is None: + return value + + if value not in set(['lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow']): + raise ValueError("must be one of enum values ('lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow')") + return value + + @field_validator('step_color') + def step_color_validate_enum(cls, value): + """Validates the enum""" + if value is None: + return value + + if value not in set(['lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow']): + raise ValueError("must be one of enum values ('lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow')") + return value + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of ContentStateStart from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of ContentStateStart from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "title": obj.get("title"), + "subtitle": obj.get("subtitle"), + "number_of_steps": obj.get("number_of_steps"), + "current_step": obj.get("current_step"), + "type": obj.get("type"), + "color": obj.get("color") if obj.get("color") is not None else 'blue', + "step_color": obj.get("step_color") + }) + return _obj + + diff --git a/activitysmith_openapi/models/content_state_update.py b/activitysmith_openapi/models/content_state_update.py new file mode 100644 index 0000000..08d425b --- /dev/null +++ b/activitysmith_openapi/models/content_state_update.py @@ -0,0 +1,118 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator +from typing import Any, ClassVar, Dict, List, Optional +from typing_extensions import Annotated +from typing import Optional, Set +from typing_extensions import Self + +class ContentStateUpdate(BaseModel): + """ + Update payload. Required fields are title and current_step. number_of_steps is optional. + """ # noqa: E501 + title: StrictStr + subtitle: Optional[StrictStr] = None + number_of_steps: Optional[Annotated[int, Field(strict=True, ge=1)]] = None + current_step: Annotated[int, Field(strict=True, ge=1)] + color: Optional[StrictStr] = Field(default='blue', description="Optional. Accent color for the Live Activity. Defaults to blue.") + step_color: Optional[StrictStr] = Field(default=None, description="Optional. Overrides color for the current step.") + __properties: ClassVar[List[str]] = ["title", "subtitle", "number_of_steps", "current_step", "color", "step_color"] + + @field_validator('color') + def color_validate_enum(cls, value): + """Validates the enum""" + if value is None: + return value + + if value not in set(['lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow']): + raise ValueError("must be one of enum values ('lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow')") + return value + + @field_validator('step_color') + def step_color_validate_enum(cls, value): + """Validates the enum""" + if value is None: + return value + + if value not in set(['lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow']): + raise ValueError("must be one of enum values ('lime', 'green', 'cyan', 'blue', 'purple', 'magenta', 'red', 'orange', 'yellow')") + return value + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of ContentStateUpdate from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of ContentStateUpdate from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "title": obj.get("title"), + "subtitle": obj.get("subtitle"), + "number_of_steps": obj.get("number_of_steps"), + "current_step": obj.get("current_step"), + "color": obj.get("color") if obj.get("color") is not None else 'blue', + "step_color": obj.get("step_color") + }) + return _obj + + diff --git a/activitysmith_openapi/models/live_activity_end_request.py b/activitysmith_openapi/models/live_activity_end_request.py new file mode 100644 index 0000000..a96fac6 --- /dev/null +++ b/activitysmith_openapi/models/live_activity_end_request.py @@ -0,0 +1,93 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, StrictStr +from typing import Any, ClassVar, Dict, List +from activitysmith_openapi.models.content_state_end import ContentStateEnd +from typing import Optional, Set +from typing_extensions import Self + +class LiveActivityEndRequest(BaseModel): + """ + LiveActivityEndRequest + """ # noqa: E501 + activity_id: StrictStr + content_state: ContentStateEnd + __properties: ClassVar[List[str]] = ["activity_id", "content_state"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of LiveActivityEndRequest from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + # override the default output from pydantic by calling `to_dict()` of content_state + if self.content_state: + _dict['content_state'] = self.content_state.to_dict() + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of LiveActivityEndRequest from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "activity_id": obj.get("activity_id"), + "content_state": ContentStateEnd.from_dict(obj["content_state"]) if obj.get("content_state") is not None else None + }) + return _obj + + diff --git a/activitysmith_openapi/models/live_activity_end_response.py b/activitysmith_openapi/models/live_activity_end_response.py new file mode 100644 index 0000000..b7224cc --- /dev/null +++ b/activitysmith_openapi/models/live_activity_end_response.py @@ -0,0 +1,96 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from datetime import datetime +from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr +from typing import Any, ClassVar, Dict, List, Optional +from typing import Optional, Set +from typing_extensions import Self + +class LiveActivityEndResponse(BaseModel): + """ + LiveActivityEndResponse + """ # noqa: E501 + success: StrictBool + activity_id: StrictStr + devices_queued: Optional[StrictInt] = None + devices_notified: Optional[StrictInt] = None + timestamp: datetime + __properties: ClassVar[List[str]] = ["success", "activity_id", "devices_queued", "devices_notified", "timestamp"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of LiveActivityEndResponse from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of LiveActivityEndResponse from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "success": obj.get("success"), + "activity_id": obj.get("activity_id"), + "devices_queued": obj.get("devices_queued"), + "devices_notified": obj.get("devices_notified"), + "timestamp": obj.get("timestamp") + }) + return _obj + + diff --git a/activitysmith_openapi/models/live_activity_limit_error.py b/activitysmith_openapi/models/live_activity_limit_error.py new file mode 100644 index 0000000..f33b7e4 --- /dev/null +++ b/activitysmith_openapi/models/live_activity_limit_error.py @@ -0,0 +1,93 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr +from typing import Any, ClassVar, Dict, List +from typing import Optional, Set +from typing_extensions import Self + +class LiveActivityLimitError(BaseModel): + """ + LiveActivityLimitError + """ # noqa: E501 + error: StrictStr + message: StrictStr + limit: StrictInt + active: StrictInt = Field(description="Current number of active Live Activities.") + __properties: ClassVar[List[str]] = ["error", "message", "limit", "active"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of LiveActivityLimitError from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of LiveActivityLimitError from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "error": obj.get("error"), + "message": obj.get("message"), + "limit": obj.get("limit"), + "active": obj.get("active") + }) + return _obj + + diff --git a/activitysmith_openapi/models/live_activity_start_request.py b/activitysmith_openapi/models/live_activity_start_request.py new file mode 100644 index 0000000..56367a2 --- /dev/null +++ b/activitysmith_openapi/models/live_activity_start_request.py @@ -0,0 +1,91 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict +from typing import Any, ClassVar, Dict, List +from activitysmith_openapi.models.content_state_start import ContentStateStart +from typing import Optional, Set +from typing_extensions import Self + +class LiveActivityStartRequest(BaseModel): + """ + LiveActivityStartRequest + """ # noqa: E501 + content_state: ContentStateStart + __properties: ClassVar[List[str]] = ["content_state"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of LiveActivityStartRequest from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + # override the default output from pydantic by calling `to_dict()` of content_state + if self.content_state: + _dict['content_state'] = self.content_state.to_dict() + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of LiveActivityStartRequest from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "content_state": ContentStateStart.from_dict(obj["content_state"]) if obj.get("content_state") is not None else None + }) + return _obj + + diff --git a/activitysmith_openapi/models/live_activity_start_response.py b/activitysmith_openapi/models/live_activity_start_response.py new file mode 100644 index 0000000..51dc4ab --- /dev/null +++ b/activitysmith_openapi/models/live_activity_start_response.py @@ -0,0 +1,96 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from datetime import datetime +from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr +from typing import Any, ClassVar, Dict, List, Optional +from typing import Optional, Set +from typing_extensions import Self + +class LiveActivityStartResponse(BaseModel): + """ + LiveActivityStartResponse + """ # noqa: E501 + success: StrictBool + devices_notified: Optional[StrictInt] = None + users_notified: Optional[StrictInt] = None + activity_id: StrictStr + timestamp: datetime + __properties: ClassVar[List[str]] = ["success", "devices_notified", "users_notified", "activity_id", "timestamp"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of LiveActivityStartResponse from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of LiveActivityStartResponse from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "success": obj.get("success"), + "devices_notified": obj.get("devices_notified"), + "users_notified": obj.get("users_notified"), + "activity_id": obj.get("activity_id"), + "timestamp": obj.get("timestamp") + }) + return _obj + + diff --git a/activitysmith_openapi/models/live_activity_update_request.py b/activitysmith_openapi/models/live_activity_update_request.py new file mode 100644 index 0000000..c816538 --- /dev/null +++ b/activitysmith_openapi/models/live_activity_update_request.py @@ -0,0 +1,93 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, StrictStr +from typing import Any, ClassVar, Dict, List +from activitysmith_openapi.models.content_state_update import ContentStateUpdate +from typing import Optional, Set +from typing_extensions import Self + +class LiveActivityUpdateRequest(BaseModel): + """ + LiveActivityUpdateRequest + """ # noqa: E501 + activity_id: StrictStr + content_state: ContentStateUpdate + __properties: ClassVar[List[str]] = ["activity_id", "content_state"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of LiveActivityUpdateRequest from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + # override the default output from pydantic by calling `to_dict()` of content_state + if self.content_state: + _dict['content_state'] = self.content_state.to_dict() + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of LiveActivityUpdateRequest from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "activity_id": obj.get("activity_id"), + "content_state": ContentStateUpdate.from_dict(obj["content_state"]) if obj.get("content_state") is not None else None + }) + return _obj + + diff --git a/activitysmith_openapi/models/live_activity_update_response.py b/activitysmith_openapi/models/live_activity_update_response.py new file mode 100644 index 0000000..4ffa9c9 --- /dev/null +++ b/activitysmith_openapi/models/live_activity_update_response.py @@ -0,0 +1,96 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from datetime import datetime +from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt, StrictStr +from typing import Any, ClassVar, Dict, List, Optional +from typing import Optional, Set +from typing_extensions import Self + +class LiveActivityUpdateResponse(BaseModel): + """ + LiveActivityUpdateResponse + """ # noqa: E501 + success: StrictBool + activity_id: StrictStr + devices_queued: Optional[StrictInt] = None + devices_notified: Optional[StrictInt] = None + timestamp: datetime + __properties: ClassVar[List[str]] = ["success", "activity_id", "devices_queued", "devices_notified", "timestamp"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of LiveActivityUpdateResponse from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of LiveActivityUpdateResponse from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "success": obj.get("success"), + "activity_id": obj.get("activity_id"), + "devices_queued": obj.get("devices_queued"), + "devices_notified": obj.get("devices_notified"), + "timestamp": obj.get("timestamp") + }) + return _obj + + diff --git a/activitysmith_openapi/models/push_notification_request.py b/activitysmith_openapi/models/push_notification_request.py new file mode 100644 index 0000000..464677a --- /dev/null +++ b/activitysmith_openapi/models/push_notification_request.py @@ -0,0 +1,91 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, StrictStr +from typing import Any, ClassVar, Dict, List, Optional +from typing import Optional, Set +from typing_extensions import Self + +class PushNotificationRequest(BaseModel): + """ + PushNotificationRequest + """ # noqa: E501 + title: StrictStr + message: Optional[StrictStr] = None + subtitle: Optional[StrictStr] = None + __properties: ClassVar[List[str]] = ["title", "message", "subtitle"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of PushNotificationRequest from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of PushNotificationRequest from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "title": obj.get("title"), + "message": obj.get("message"), + "subtitle": obj.get("subtitle") + }) + return _obj + + diff --git a/activitysmith_openapi/models/push_notification_response.py b/activitysmith_openapi/models/push_notification_response.py new file mode 100644 index 0000000..73e297d --- /dev/null +++ b/activitysmith_openapi/models/push_notification_response.py @@ -0,0 +1,94 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from datetime import datetime +from pydantic import BaseModel, ConfigDict, StrictBool, StrictInt +from typing import Any, ClassVar, Dict, List, Optional +from typing import Optional, Set +from typing_extensions import Self + +class PushNotificationResponse(BaseModel): + """ + PushNotificationResponse + """ # noqa: E501 + success: StrictBool + devices_notified: Optional[StrictInt] = None + users_notified: Optional[StrictInt] = None + timestamp: datetime + __properties: ClassVar[List[str]] = ["success", "devices_notified", "users_notified", "timestamp"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of PushNotificationResponse from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of PushNotificationResponse from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "success": obj.get("success"), + "devices_notified": obj.get("devices_notified"), + "users_notified": obj.get("users_notified"), + "timestamp": obj.get("timestamp") + }) + return _obj + + diff --git a/activitysmith_openapi/models/rate_limit_error.py b/activitysmith_openapi/models/rate_limit_error.py new file mode 100644 index 0000000..5881109 --- /dev/null +++ b/activitysmith_openapi/models/rate_limit_error.py @@ -0,0 +1,89 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + +from pydantic import BaseModel, ConfigDict, StrictStr +from typing import Any, ClassVar, Dict, List +from typing import Optional, Set +from typing_extensions import Self + +class RateLimitError(BaseModel): + """ + RateLimitError + """ # noqa: E501 + error: StrictStr + message: StrictStr + __properties: ClassVar[List[str]] = ["error", "message"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of RateLimitError from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([ + ]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of RateLimitError from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "error": obj.get("error"), + "message": obj.get("message") + }) + return _obj + + diff --git a/activitysmith_openapi/models/send_push_notification429_response.py b/activitysmith_openapi/models/send_push_notification429_response.py new file mode 100644 index 0000000..596f793 --- /dev/null +++ b/activitysmith_openapi/models/send_push_notification429_response.py @@ -0,0 +1,137 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import json +import pprint +from pydantic import BaseModel, ConfigDict, Field, StrictStr, ValidationError, field_validator +from typing import Any, List, Optional +from activitysmith_openapi.models.live_activity_limit_error import LiveActivityLimitError +from activitysmith_openapi.models.rate_limit_error import RateLimitError +from pydantic import StrictStr, Field +from typing import Union, List, Set, Optional, Dict +from typing_extensions import Literal, Self + +SENDPUSHNOTIFICATION429RESPONSE_ONE_OF_SCHEMAS = ["LiveActivityLimitError", "RateLimitError"] + +class SendPushNotification429Response(BaseModel): + """ + SendPushNotification429Response + """ + # data type: RateLimitError + oneof_schema_1_validator: Optional[RateLimitError] = None + # data type: LiveActivityLimitError + oneof_schema_2_validator: Optional[LiveActivityLimitError] = None + actual_instance: Optional[Union[LiveActivityLimitError, RateLimitError]] = None + one_of_schemas: Set[str] = { "LiveActivityLimitError", "RateLimitError" } + + model_config = ConfigDict( + validate_assignment=True, + protected_namespaces=(), + ) + + + def __init__(self, *args, **kwargs) -> None: + if args: + if len(args) > 1: + raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`") + if kwargs: + raise ValueError("If a position argument is used, keyword arguments cannot be used.") + super().__init__(actual_instance=args[0]) + else: + super().__init__(**kwargs) + + @field_validator('actual_instance') + def actual_instance_must_validate_oneof(cls, v): + instance = SendPushNotification429Response.model_construct() + error_messages = [] + match = 0 + # validate data type: RateLimitError + if not isinstance(v, RateLimitError): + error_messages.append(f"Error! Input type `{type(v)}` is not `RateLimitError`") + else: + match += 1 + # validate data type: LiveActivityLimitError + if not isinstance(v, LiveActivityLimitError): + error_messages.append(f"Error! Input type `{type(v)}` is not `LiveActivityLimitError`") + else: + match += 1 + if match > 1: + # more than 1 match + raise ValueError("Multiple matches found when setting `actual_instance` in SendPushNotification429Response with oneOf schemas: LiveActivityLimitError, RateLimitError. Details: " + ", ".join(error_messages)) + elif match == 0: + # no match + raise ValueError("No match found when setting `actual_instance` in SendPushNotification429Response with oneOf schemas: LiveActivityLimitError, RateLimitError. Details: " + ", ".join(error_messages)) + else: + return v + + @classmethod + def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self: + return cls.from_json(json.dumps(obj)) + + @classmethod + def from_json(cls, json_str: str) -> Self: + """Returns the object represented by the json string""" + instance = cls.model_construct() + error_messages = [] + match = 0 + + # deserialize data into RateLimitError + try: + instance.actual_instance = RateLimitError.from_json(json_str) + match += 1 + except (ValidationError, ValueError) as e: + error_messages.append(str(e)) + # deserialize data into LiveActivityLimitError + try: + instance.actual_instance = LiveActivityLimitError.from_json(json_str) + match += 1 + except (ValidationError, ValueError) as e: + error_messages.append(str(e)) + + if match > 1: + # more than 1 match + raise ValueError("Multiple matches found when deserializing the JSON string into SendPushNotification429Response with oneOf schemas: LiveActivityLimitError, RateLimitError. Details: " + ", ".join(error_messages)) + elif match == 0: + # no match + raise ValueError("No match found when deserializing the JSON string into SendPushNotification429Response with oneOf schemas: LiveActivityLimitError, RateLimitError. Details: " + ", ".join(error_messages)) + else: + return instance + + def to_json(self) -> str: + """Returns the JSON representation of the actual instance""" + if self.actual_instance is None: + return "null" + + if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json): + return self.actual_instance.to_json() + else: + return json.dumps(self.actual_instance) + + def to_dict(self) -> Optional[Union[Dict[str, Any], LiveActivityLimitError, RateLimitError]]: + """Returns the dict representation of the actual instance""" + if self.actual_instance is None: + return None + + if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict): + return self.actual_instance.to_dict() + else: + # primitive type + return self.actual_instance + + def to_str(self) -> str: + """Returns the string representation of the actual instance""" + return pprint.pformat(self.model_dump()) + + diff --git a/activitysmith_openapi/rest.py b/activitysmith_openapi/rest.py new file mode 100644 index 0000000..f191331 --- /dev/null +++ b/activitysmith_openapi/rest.py @@ -0,0 +1,257 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import io +import json +import re +import ssl + +import urllib3 + +from activitysmith_openapi.exceptions import ApiException, ApiValueError + +SUPPORTED_SOCKS_PROXIES = {"socks5", "socks5h", "socks4", "socks4a"} +RESTResponseType = urllib3.HTTPResponse + + +def is_socks_proxy_url(url): + if url is None: + return False + split_section = url.split("://") + if len(split_section) < 2: + return False + else: + return split_section[0].lower() in SUPPORTED_SOCKS_PROXIES + + +class RESTResponse(io.IOBase): + + def __init__(self, resp) -> None: + self.response = resp + self.status = resp.status + self.reason = resp.reason + self.data = None + + def read(self): + if self.data is None: + self.data = self.response.data + return self.data + + def getheaders(self): + """Returns a dictionary of the response headers.""" + return self.response.headers + + def getheader(self, name, default=None): + """Returns a given response header.""" + return self.response.headers.get(name, default) + + +class RESTClientObject: + + def __init__(self, configuration) -> None: + # urllib3.PoolManager will pass all kw parameters to connectionpool + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/poolmanager.py#L75 # noqa: E501 + # https://github.com/shazow/urllib3/blob/f9409436f83aeb79fbaf090181cd81b784f1b8ce/urllib3/connectionpool.py#L680 # noqa: E501 + # Custom SSL certificates and client certificates: http://urllib3.readthedocs.io/en/latest/advanced-usage.html # noqa: E501 + + # cert_reqs + if configuration.verify_ssl: + cert_reqs = ssl.CERT_REQUIRED + else: + cert_reqs = ssl.CERT_NONE + + pool_args = { + "cert_reqs": cert_reqs, + "ca_certs": configuration.ssl_ca_cert, + "cert_file": configuration.cert_file, + "key_file": configuration.key_file, + } + if configuration.assert_hostname is not None: + pool_args['assert_hostname'] = ( + configuration.assert_hostname + ) + + if configuration.retries is not None: + pool_args['retries'] = configuration.retries + + if configuration.tls_server_name: + pool_args['server_hostname'] = configuration.tls_server_name + + + if configuration.socket_options is not None: + pool_args['socket_options'] = configuration.socket_options + + if configuration.connection_pool_maxsize is not None: + pool_args['maxsize'] = configuration.connection_pool_maxsize + + # https pool manager + self.pool_manager: urllib3.PoolManager + + if configuration.proxy: + if is_socks_proxy_url(configuration.proxy): + from urllib3.contrib.socks import SOCKSProxyManager + pool_args["proxy_url"] = configuration.proxy + pool_args["headers"] = configuration.proxy_headers + self.pool_manager = SOCKSProxyManager(**pool_args) + else: + pool_args["proxy_url"] = configuration.proxy + pool_args["proxy_headers"] = configuration.proxy_headers + self.pool_manager = urllib3.ProxyManager(**pool_args) + else: + self.pool_manager = urllib3.PoolManager(**pool_args) + + def request( + self, + method, + url, + headers=None, + body=None, + post_params=None, + _request_timeout=None + ): + """Perform requests. + + :param method: http request method + :param url: http request url + :param headers: http request headers + :param body: request json body, for `application/json` + :param post_params: request post parameters, + `application/x-www-form-urlencoded` + and `multipart/form-data` + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + """ + method = method.upper() + assert method in [ + 'GET', + 'HEAD', + 'DELETE', + 'POST', + 'PUT', + 'PATCH', + 'OPTIONS' + ] + + if post_params and body: + raise ApiValueError( + "body parameter cannot be used with post_params parameter." + ) + + post_params = post_params or {} + headers = headers or {} + + timeout = None + if _request_timeout: + if isinstance(_request_timeout, (int, float)): + timeout = urllib3.Timeout(total=_request_timeout) + elif ( + isinstance(_request_timeout, tuple) + and len(_request_timeout) == 2 + ): + timeout = urllib3.Timeout( + connect=_request_timeout[0], + read=_request_timeout[1] + ) + + try: + # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE` + if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']: + + # no content type provided or payload is json + content_type = headers.get('Content-Type') + if ( + not content_type + or re.search('json', content_type, re.IGNORECASE) + ): + request_body = None + if body is not None: + request_body = json.dumps(body) + r = self.pool_manager.request( + method, + url, + body=request_body, + timeout=timeout, + headers=headers, + preload_content=False + ) + elif content_type == 'application/x-www-form-urlencoded': + r = self.pool_manager.request( + method, + url, + fields=post_params, + encode_multipart=False, + timeout=timeout, + headers=headers, + preload_content=False + ) + elif content_type == 'multipart/form-data': + # must del headers['Content-Type'], or the correct + # Content-Type which generated by urllib3 will be + # overwritten. + del headers['Content-Type'] + # Ensures that dict objects are serialized + post_params = [(a, json.dumps(b)) if isinstance(b, dict) else (a,b) for a, b in post_params] + r = self.pool_manager.request( + method, + url, + fields=post_params, + encode_multipart=True, + timeout=timeout, + headers=headers, + preload_content=False + ) + # Pass a `string` parameter directly in the body to support + # other content types than JSON when `body` argument is + # provided in serialized form. + elif isinstance(body, str) or isinstance(body, bytes): + r = self.pool_manager.request( + method, + url, + body=body, + timeout=timeout, + headers=headers, + preload_content=False + ) + elif headers['Content-Type'] == 'text/plain' and isinstance(body, bool): + request_body = "true" if body else "false" + r = self.pool_manager.request( + method, + url, + body=request_body, + preload_content=False, + timeout=timeout, + headers=headers) + else: + # Cannot generate the request from given parameters + msg = """Cannot prepare a request message for provided + arguments. Please check that your arguments match + declared content type.""" + raise ApiException(status=0, reason=msg) + # For `GET`, `HEAD` + else: + r = self.pool_manager.request( + method, + url, + fields={}, + timeout=timeout, + headers=headers, + preload_content=False + ) + except urllib3.exceptions.SSLError as e: + msg = "\n".join([type(e).__name__, str(e)]) + raise ApiException(status=0, reason=msg) + + return RESTResponse(r) diff --git a/activitysmith_openapi/test/__init__.py b/activitysmith_openapi/test/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/activitysmith_openapi/test/test_content_state_end.py b/activitysmith_openapi/test/test_content_state_end.py new file mode 100644 index 0000000..c1ac5fd --- /dev/null +++ b/activitysmith_openapi/test/test_content_state_end.py @@ -0,0 +1,59 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.content_state_end import ContentStateEnd + +class TestContentStateEnd(unittest.TestCase): + """ContentStateEnd unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> ContentStateEnd: + """Test ContentStateEnd + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `ContentStateEnd` + """ + model = ContentStateEnd() + if include_optional: + return ContentStateEnd( + title = '', + subtitle = '', + number_of_steps = 1, + current_step = 1, + color = 'blue', + step_color = 'lime', + auto_dismiss_minutes = 0 + ) + else: + return ContentStateEnd( + title = '', + current_step = 1, + ) + """ + + def testContentStateEnd(self): + """Test ContentStateEnd""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_content_state_start.py b/activitysmith_openapi/test/test_content_state_start.py new file mode 100644 index 0000000..66c3b70 --- /dev/null +++ b/activitysmith_openapi/test/test_content_state_start.py @@ -0,0 +1,61 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.content_state_start import ContentStateStart + +class TestContentStateStart(unittest.TestCase): + """ContentStateStart unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> ContentStateStart: + """Test ContentStateStart + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `ContentStateStart` + """ + model = ContentStateStart() + if include_optional: + return ContentStateStart( + title = '', + subtitle = '', + number_of_steps = 1, + current_step = 1, + type = 'segmented_progress', + color = 'blue', + step_color = 'lime' + ) + else: + return ContentStateStart( + title = '', + number_of_steps = 1, + current_step = 1, + type = 'segmented_progress', + ) + """ + + def testContentStateStart(self): + """Test ContentStateStart""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_content_state_update.py b/activitysmith_openapi/test/test_content_state_update.py new file mode 100644 index 0000000..a96945b --- /dev/null +++ b/activitysmith_openapi/test/test_content_state_update.py @@ -0,0 +1,58 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.content_state_update import ContentStateUpdate + +class TestContentStateUpdate(unittest.TestCase): + """ContentStateUpdate unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> ContentStateUpdate: + """Test ContentStateUpdate + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `ContentStateUpdate` + """ + model = ContentStateUpdate() + if include_optional: + return ContentStateUpdate( + title = '', + subtitle = '', + number_of_steps = 1, + current_step = 1, + color = 'blue', + step_color = 'lime' + ) + else: + return ContentStateUpdate( + title = '', + current_step = 1, + ) + """ + + def testContentStateUpdate(self): + """Test ContentStateUpdate""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_live_activities_api.py b/activitysmith_openapi/test/test_live_activities_api.py new file mode 100644 index 0000000..ccbe719 --- /dev/null +++ b/activitysmith_openapi/test/test_live_activities_api.py @@ -0,0 +1,52 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.api.live_activities_api import LiveActivitiesApi + + +class TestLiveActivitiesApi(unittest.TestCase): + """LiveActivitiesApi unit test stubs""" + + def setUp(self) -> None: + self.api = LiveActivitiesApi() + + def tearDown(self) -> None: + pass + + def test_end_live_activity(self) -> None: + """Test case for end_live_activity + + End a Live Activity + """ + pass + + def test_start_live_activity(self) -> None: + """Test case for start_live_activity + + Start a Live Activity + """ + pass + + def test_update_live_activity(self) -> None: + """Test case for update_live_activity + + Update a Live Activity + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_live_activity_end_request.py b/activitysmith_openapi/test/test_live_activity_end_request.py new file mode 100644 index 0000000..3522eb4 --- /dev/null +++ b/activitysmith_openapi/test/test_live_activity_end_request.py @@ -0,0 +1,68 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.live_activity_end_request import LiveActivityEndRequest + +class TestLiveActivityEndRequest(unittest.TestCase): + """LiveActivityEndRequest unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> LiveActivityEndRequest: + """Test LiveActivityEndRequest + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `LiveActivityEndRequest` + """ + model = LiveActivityEndRequest() + if include_optional: + return LiveActivityEndRequest( + activity_id = '', + content_state = activitysmith_openapi.models.content_state_end.ContentStateEnd( + title = '', + subtitle = '', + number_of_steps = 1, + current_step = 1, + color = 'blue', + step_color = 'lime', + auto_dismiss_minutes = 0, ) + ) + else: + return LiveActivityEndRequest( + activity_id = '', + content_state = activitysmith_openapi.models.content_state_end.ContentStateEnd( + title = '', + subtitle = '', + number_of_steps = 1, + current_step = 1, + color = 'blue', + step_color = 'lime', + auto_dismiss_minutes = 0, ), + ) + """ + + def testLiveActivityEndRequest(self): + """Test LiveActivityEndRequest""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_live_activity_end_response.py b/activitysmith_openapi/test/test_live_activity_end_response.py new file mode 100644 index 0000000..c0225c8 --- /dev/null +++ b/activitysmith_openapi/test/test_live_activity_end_response.py @@ -0,0 +1,58 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.live_activity_end_response import LiveActivityEndResponse + +class TestLiveActivityEndResponse(unittest.TestCase): + """LiveActivityEndResponse unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> LiveActivityEndResponse: + """Test LiveActivityEndResponse + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `LiveActivityEndResponse` + """ + model = LiveActivityEndResponse() + if include_optional: + return LiveActivityEndResponse( + success = True, + activity_id = '', + devices_queued = 56, + devices_notified = 56, + timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f') + ) + else: + return LiveActivityEndResponse( + success = True, + activity_id = '', + timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + ) + """ + + def testLiveActivityEndResponse(self): + """Test LiveActivityEndResponse""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_live_activity_limit_error.py b/activitysmith_openapi/test/test_live_activity_limit_error.py new file mode 100644 index 0000000..c618fef --- /dev/null +++ b/activitysmith_openapi/test/test_live_activity_limit_error.py @@ -0,0 +1,58 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.live_activity_limit_error import LiveActivityLimitError + +class TestLiveActivityLimitError(unittest.TestCase): + """LiveActivityLimitError unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> LiveActivityLimitError: + """Test LiveActivityLimitError + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `LiveActivityLimitError` + """ + model = LiveActivityLimitError() + if include_optional: + return LiveActivityLimitError( + error = '', + message = '', + limit = 56, + active = 56 + ) + else: + return LiveActivityLimitError( + error = '', + message = '', + limit = 56, + active = 56, + ) + """ + + def testLiveActivityLimitError(self): + """Test LiveActivityLimitError""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_live_activity_start_request.py b/activitysmith_openapi/test/test_live_activity_start_request.py new file mode 100644 index 0000000..3d30c25 --- /dev/null +++ b/activitysmith_openapi/test/test_live_activity_start_request.py @@ -0,0 +1,66 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.live_activity_start_request import LiveActivityStartRequest + +class TestLiveActivityStartRequest(unittest.TestCase): + """LiveActivityStartRequest unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> LiveActivityStartRequest: + """Test LiveActivityStartRequest + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `LiveActivityStartRequest` + """ + model = LiveActivityStartRequest() + if include_optional: + return LiveActivityStartRequest( + content_state = activitysmith_openapi.models.content_state_start.ContentStateStart( + title = '', + subtitle = '', + number_of_steps = 1, + current_step = 1, + type = 'segmented_progress', + color = 'blue', + step_color = 'lime', ) + ) + else: + return LiveActivityStartRequest( + content_state = activitysmith_openapi.models.content_state_start.ContentStateStart( + title = '', + subtitle = '', + number_of_steps = 1, + current_step = 1, + type = 'segmented_progress', + color = 'blue', + step_color = 'lime', ), + ) + """ + + def testLiveActivityStartRequest(self): + """Test LiveActivityStartRequest""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_live_activity_start_response.py b/activitysmith_openapi/test/test_live_activity_start_response.py new file mode 100644 index 0000000..f5db9b6 --- /dev/null +++ b/activitysmith_openapi/test/test_live_activity_start_response.py @@ -0,0 +1,58 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.live_activity_start_response import LiveActivityStartResponse + +class TestLiveActivityStartResponse(unittest.TestCase): + """LiveActivityStartResponse unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> LiveActivityStartResponse: + """Test LiveActivityStartResponse + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `LiveActivityStartResponse` + """ + model = LiveActivityStartResponse() + if include_optional: + return LiveActivityStartResponse( + success = True, + devices_notified = 56, + users_notified = 56, + activity_id = '', + timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f') + ) + else: + return LiveActivityStartResponse( + success = True, + activity_id = '', + timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + ) + """ + + def testLiveActivityStartResponse(self): + """Test LiveActivityStartResponse""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_live_activity_update_request.py b/activitysmith_openapi/test/test_live_activity_update_request.py new file mode 100644 index 0000000..6896096 --- /dev/null +++ b/activitysmith_openapi/test/test_live_activity_update_request.py @@ -0,0 +1,66 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.live_activity_update_request import LiveActivityUpdateRequest + +class TestLiveActivityUpdateRequest(unittest.TestCase): + """LiveActivityUpdateRequest unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> LiveActivityUpdateRequest: + """Test LiveActivityUpdateRequest + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `LiveActivityUpdateRequest` + """ + model = LiveActivityUpdateRequest() + if include_optional: + return LiveActivityUpdateRequest( + activity_id = '', + content_state = activitysmith_openapi.models.content_state_update.ContentStateUpdate( + title = '', + subtitle = '', + number_of_steps = 1, + current_step = 1, + color = 'blue', + step_color = 'lime', ) + ) + else: + return LiveActivityUpdateRequest( + activity_id = '', + content_state = activitysmith_openapi.models.content_state_update.ContentStateUpdate( + title = '', + subtitle = '', + number_of_steps = 1, + current_step = 1, + color = 'blue', + step_color = 'lime', ), + ) + """ + + def testLiveActivityUpdateRequest(self): + """Test LiveActivityUpdateRequest""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_live_activity_update_response.py b/activitysmith_openapi/test/test_live_activity_update_response.py new file mode 100644 index 0000000..7695340 --- /dev/null +++ b/activitysmith_openapi/test/test_live_activity_update_response.py @@ -0,0 +1,58 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.live_activity_update_response import LiveActivityUpdateResponse + +class TestLiveActivityUpdateResponse(unittest.TestCase): + """LiveActivityUpdateResponse unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> LiveActivityUpdateResponse: + """Test LiveActivityUpdateResponse + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `LiveActivityUpdateResponse` + """ + model = LiveActivityUpdateResponse() + if include_optional: + return LiveActivityUpdateResponse( + success = True, + activity_id = '', + devices_queued = 56, + devices_notified = 56, + timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f') + ) + else: + return LiveActivityUpdateResponse( + success = True, + activity_id = '', + timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + ) + """ + + def testLiveActivityUpdateResponse(self): + """Test LiveActivityUpdateResponse""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_push_notification_request.py b/activitysmith_openapi/test/test_push_notification_request.py new file mode 100644 index 0000000..f583937 --- /dev/null +++ b/activitysmith_openapi/test/test_push_notification_request.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.push_notification_request import PushNotificationRequest + +class TestPushNotificationRequest(unittest.TestCase): + """PushNotificationRequest unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> PushNotificationRequest: + """Test PushNotificationRequest + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `PushNotificationRequest` + """ + model = PushNotificationRequest() + if include_optional: + return PushNotificationRequest( + title = '', + message = '', + subtitle = '' + ) + else: + return PushNotificationRequest( + title = '', + ) + """ + + def testPushNotificationRequest(self): + """Test PushNotificationRequest""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_push_notification_response.py b/activitysmith_openapi/test/test_push_notification_response.py new file mode 100644 index 0000000..042ea3e --- /dev/null +++ b/activitysmith_openapi/test/test_push_notification_response.py @@ -0,0 +1,56 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.push_notification_response import PushNotificationResponse + +class TestPushNotificationResponse(unittest.TestCase): + """PushNotificationResponse unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> PushNotificationResponse: + """Test PushNotificationResponse + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `PushNotificationResponse` + """ + model = PushNotificationResponse() + if include_optional: + return PushNotificationResponse( + success = True, + devices_notified = 56, + users_notified = 56, + timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f') + ) + else: + return PushNotificationResponse( + success = True, + timestamp = datetime.datetime.strptime('2013-10-20 19:20:30.00', '%Y-%m-%d %H:%M:%S.%f'), + ) + """ + + def testPushNotificationResponse(self): + """Test PushNotificationResponse""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_push_notifications_api.py b/activitysmith_openapi/test/test_push_notifications_api.py new file mode 100644 index 0000000..f28a870 --- /dev/null +++ b/activitysmith_openapi/test/test_push_notifications_api.py @@ -0,0 +1,38 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.api.push_notifications_api import PushNotificationsApi + + +class TestPushNotificationsApi(unittest.TestCase): + """PushNotificationsApi unit test stubs""" + + def setUp(self) -> None: + self.api = PushNotificationsApi() + + def tearDown(self) -> None: + pass + + def test_send_push_notification(self) -> None: + """Test case for send_push_notification + + Send a push notification + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_rate_limit_error.py b/activitysmith_openapi/test/test_rate_limit_error.py new file mode 100644 index 0000000..22f368d --- /dev/null +++ b/activitysmith_openapi/test/test_rate_limit_error.py @@ -0,0 +1,54 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.rate_limit_error import RateLimitError + +class TestRateLimitError(unittest.TestCase): + """RateLimitError unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> RateLimitError: + """Test RateLimitError + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `RateLimitError` + """ + model = RateLimitError() + if include_optional: + return RateLimitError( + error = '', + message = '' + ) + else: + return RateLimitError( + error = '', + message = '', + ) + """ + + def testRateLimitError(self): + """Test RateLimitError""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/activitysmith_openapi/test/test_send_push_notification429_response.py b/activitysmith_openapi/test/test_send_push_notification429_response.py new file mode 100644 index 0000000..5466f95 --- /dev/null +++ b/activitysmith_openapi/test/test_send_push_notification429_response.py @@ -0,0 +1,58 @@ +# coding: utf-8 + +""" + ActivitySmith API + + Send push notifications and Live Activities to your own devices via a single API key. + + The version of the OpenAPI document: 1.0.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from activitysmith_openapi.models.send_push_notification429_response import SendPushNotification429Response + +class TestSendPushNotification429Response(unittest.TestCase): + """SendPushNotification429Response unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> SendPushNotification429Response: + """Test SendPushNotification429Response + include_optional is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `SendPushNotification429Response` + """ + model = SendPushNotification429Response() + if include_optional: + return SendPushNotification429Response( + error = '', + message = '', + limit = 56, + active = 56 + ) + else: + return SendPushNotification429Response( + error = '', + message = '', + limit = 56, + active = 56, + ) + """ + + def testSendPushNotification429Response(self): + """Test SendPushNotification429Response""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main()