Upgrade swagger version and use cursor object

Author: phil-ma

docs/DraftsRead.md

@@ -3,7 +3,7 @@
 ## Properties
 Name | Type | Description | Notes
 ------------ | ------------- | ------------- | -------------
-**cursor** | **object** | Information about paginated results | [optional] 
+**cursor** | [**Cursor**](Cursor.md) |  | [optional] 
 **data** | [**list[DraftMetaRead]**](DraftMetaRead.md) | A list of draft metadata objects | [optional] 
 
 [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

dyspatch_client/api/drafts_api.py

@@ -38,19 +38,19 @@ def localizations_localization_id_get(self, localization_id, target_language, **
 
         Returns a specific localization object with a matching ID.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async=True
-        >>> thread = api.localizations_localization_id_get(localization_id, target_language, async=True)
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.localizations_localization_id_get(localization_id, target_language, async_req=True)
         >>> result = thread.get()
 
-        :param async bool
+        :param async_req bool
         :param str localization_id: A localization ID (required)
         :param str target_language: The type of templating language to compile as. Should only be used for visual templates. (required)
         :return: LocalizationRead
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        if kwargs.get('async'):
+        if kwargs.get('async_req'):
             return self.localizations_localization_id_get_with_http_info(localization_id, target_language, **kwargs)  # noqa: E501
         else:
             (data) = self.localizations_localization_id_get_with_http_info(localization_id, target_language, **kwargs)  # noqa: E501
@@ -61,11 +61,11 @@ def localizations_localization_id_get_with_http_info(self, localization_id, targ
 
         Returns a specific localization object with a matching ID.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async=True
-        >>> thread = api.localizations_localization_id_get_with_http_info(localization_id, target_language, async=True)
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.localizations_localization_id_get_with_http_info(localization_id, target_language, async_req=True)
         >>> result = thread.get()
 
-        :param async bool
+        :param async_req bool
         :param str localization_id: A localization ID (required)
         :param str target_language: The type of templating language to compile as. Should only be used for visual templates. (required)
         :return: LocalizationRead
@@ -74,7 +74,7 @@ def localizations_localization_id_get_with_http_info(self, localization_id, targ
         """
 
         all_params = ['localization_id', 'target_language']  # noqa: E501
-        all_params.append('async')
+        all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
         all_params.append('_request_timeout')
@@ -130,7 +130,7 @@ def localizations_localization_id_get_with_http_info(self, localization_id, targ
             files=local_var_files,
             response_type='LocalizationRead',  # noqa: E501
             auth_settings=auth_settings,
-            async=params.get('async'),
+            async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
             _preload_content=params.get('_preload_content', True),
             _request_timeout=params.get('_request_timeout'),

dyspatch_client/api/localizations_api.py

@@ -38,18 +38,18 @@ def templates_get(self, **kwargs):  # noqa: E501
 
         Gets a list of Template Metadata objects for all templates. Up to 25 results returned before results are paginated.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async=True
-        >>> thread = api.templates_get(async=True)
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.templates_get(async_req=True)
         >>> result = thread.get()
 
-        :param async bool
+        :param async_req bool
         :param str cursor: A cursor value used to retrieve a specific page from a paginated result set.
         :return: TemplatesRead
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        if kwargs.get('async'):
+        if kwargs.get('async_req'):
             return self.templates_get_with_http_info(**kwargs)  # noqa: E501
         else:
             (data) = self.templates_get_with_http_info(**kwargs)  # noqa: E501
@@ -60,19 +60,19 @@ def templates_get_with_http_info(self, **kwargs):  # noqa: E501
 
         Gets a list of Template Metadata objects for all templates. Up to 25 results returned before results are paginated.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async=True
-        >>> thread = api.templates_get_with_http_info(async=True)
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.templates_get_with_http_info(async_req=True)
         >>> result = thread.get()
 
-        :param async bool
+        :param async_req bool
         :param str cursor: A cursor value used to retrieve a specific page from a paginated result set.
         :return: TemplatesRead
                  If the method is called asynchronously,
                  returns the request thread.
         """
 
         all_params = ['cursor']  # noqa: E501
-        all_params.append('async')
+        all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
         all_params.append('_request_timeout')
@@ -118,7 +118,7 @@ def templates_get_with_http_info(self, **kwargs):  # noqa: E501
             files=local_var_files,
             response_type='TemplatesRead',  # noqa: E501
             auth_settings=auth_settings,
-            async=params.get('async'),
+            async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
             _preload_content=params.get('_preload_content', True),
             _request_timeout=params.get('_request_timeout'),
@@ -129,19 +129,19 @@ def templates_template_id_get(self, template_id, target_language, **kwargs):  #
 
         Gets a template object with the matching ID. If the template has published content the \"compiled\" field will contain the template .  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async=True
-        >>> thread = api.templates_template_id_get(template_id, target_language, async=True)
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.templates_template_id_get(template_id, target_language, async_req=True)
         >>> result = thread.get()
 
-        :param async bool
+        :param async_req bool
         :param str template_id: A template ID (required)
         :param str target_language: The type of templating language to compile as. Should only be used for visual templates. (required)
         :return: TemplateRead
                  If the method is called asynchronously,
                  returns the request thread.
         """
         kwargs['_return_http_data_only'] = True
-        if kwargs.get('async'):
+        if kwargs.get('async_req'):
             return self.templates_template_id_get_with_http_info(template_id, target_language, **kwargs)  # noqa: E501
         else:
             (data) = self.templates_template_id_get_with_http_info(template_id, target_language, **kwargs)  # noqa: E501
@@ -152,11 +152,11 @@ def templates_template_id_get_with_http_info(self, template_id, target_language,
 
         Gets a template object with the matching ID. If the template has published content the \"compiled\" field will contain the template .  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
-        asynchronous HTTP request, please pass async=True
-        >>> thread = api.templates_template_id_get_with_http_info(template_id, target_language, async=True)
+        asynchronous HTTP request, please pass async_req=True
+        >>> thread = api.templates_template_id_get_with_http_info(template_id, target_language, async_req=True)
         >>> result = thread.get()
 
-        :param async bool
+        :param async_req bool
         :param str template_id: A template ID (required)
         :param str target_language: The type of templating language to compile as. Should only be used for visual templates. (required)
         :return: TemplateRead
@@ -165,7 +165,7 @@ def templates_template_id_get_with_http_info(self, template_id, target_language,
         """
 
         all_params = ['template_id', 'target_language']  # noqa: E501
-        all_params.append('async')
+        all_params.append('async_req')
         all_params.append('_return_http_data_only')
         all_params.append('_preload_content')
         all_params.append('_request_timeout')
@@ -221,7 +221,7 @@ def templates_template_id_get_with_http_info(self, template_id, target_language,
             files=local_var_files,
             response_type='TemplateRead',  # noqa: E501
             auth_settings=auth_settings,
-            async=params.get('async'),
+            async_req=params.get('async_req'),
             _return_http_data_only=params.get('_return_http_data_only'),
             _preload_content=params.get('_preload_content', True),
             _request_timeout=params.get('_request_timeout'),

dyspatch_client/api/templates_api.py

@@ -66,7 +66,8 @@ def __init__(self, configuration=None, header_name=None, header_value=None,
             configuration = Configuration()
         self.configuration = configuration
 
-        self.pool = ThreadPool()
+        # Use the pool property to lazily initialize the ThreadPool.
+        self._pool = None
         self.rest_client = rest.RESTClientObject(configuration)
         self.default_headers = {}
         if header_name is not None:
@@ -76,8 +77,15 @@ def __init__(self, configuration=None, header_name=None, header_value=None,
         self.user_agent = 'Swagger-Codegen/3.0.1/python'
 
     def __del__(self):
-        self.pool.close()
-        self.pool.join()
+        if self._pool is not None:
+            self._pool.close()
+            self._pool.join()
+
+    @property
+    def pool(self):
+        if self._pool is None:
+            self._pool = ThreadPool()
+        return self._pool
 
     @property
     def user_agent(self):
@@ -274,12 +282,12 @@ def __deserialize(self, data, klass):
     def call_api(self, resource_path, method,
                  path_params=None, query_params=None, header_params=None,
                  body=None, post_params=None, files=None,
-                 response_type=None, auth_settings=None, async=None,
+                 response_type=None, auth_settings=None, async_req=None,
                  _return_http_data_only=None, collection_formats=None,
                  _preload_content=True, _request_timeout=None):
         """Makes the HTTP request (synchronous) and returns deserialized data.
 
-        To make an async request, set the async parameter.
+        To make an async request, set the async_req parameter.
 
         :param resource_path: Path to method endpoint.
         :param method: Method to call.
@@ -294,7 +302,7 @@ def call_api(self, resource_path, method,
         :param response: Response data type.
         :param files dict: key -> filename, value -> filepath,
             for `multipart/form-data`.
-        :param async bool: execute request asynchronously
+        :param async_req bool: execute request asynchronously
         :param _return_http_data_only: response data without head status code
                                        and headers
         :param collection_formats: dict of collection formats for path, query,
@@ -307,13 +315,13 @@ def call_api(self, resource_path, method,
                                  timeout. It can also be a pair (tuple) of
                                  (connection, read) timeouts.
         :return:
-            If async parameter is True,
+            If async_req parameter is True,
             the request will be called asynchronously.
             The method will return the request thread.
-            If parameter async is False or missing,
+            If parameter async_req is False or missing,
             then the method will return the response directly.
         """
-        if not async:
+        if not async_req:
             return self.__call_api(resource_path, method,
                                    path_params, query_params, header_params,
                                    body, post_params, files,
@@ -541,7 +549,7 @@ def __deserialize_primitive(self, data, klass):
         try:
             return klass(data)
         except UnicodeEncodeError:
-            return six.u(data)
+            return six.text_type(data)
         except TypeError:
             return data
 
@@ -591,6 +599,9 @@ def __deserialize_datatime(self, string):
                 )
             )
 
+    def __hasattr(self, object, name):
+        return name in object.__class__.__dict__
+
     def __deserialize_model(self, data, klass):
         """Deserializes list or dict to model.
 
@@ -599,7 +610,8 @@ def __deserialize_model(self, data, klass):
         :return: model object.
         """
 
-        if not klass.swagger_types and not hasattr(klass, 'get_real_child_model'):
+        if (not klass.swagger_types and
+                not self.__hasattr(klass, 'get_real_child_model')):
             return data
 
         kwargs = {}
@@ -613,7 +625,13 @@ def __deserialize_model(self, data, klass):
 
         instance = klass(**kwargs)
 
-        if hasattr(instance, 'get_real_child_model'):
+        if (isinstance(instance, dict) and
+                klass.swagger_types is not None and
+                isinstance(data, dict)):
+            for key, value in data.items():
+                if key not in klass.swagger_types:
+                    instance[key] = value
+        if self.__hasattr(instance, 'get_real_child_model'):
             klass_name = instance.get_real_child_model(data)
             if klass_name:
                 instance = self.__deserialize(data, klass_name)

dyspatch_client/api_client.py

@@ -23,29 +23,22 @@
 from six.moves import http_client as httplib
 
 
-class TypeWithDefault(type):
-    def __init__(cls, name, bases, dct):
-        super(TypeWithDefault, cls).__init__(name, bases, dct)
-        cls._default = None
-
-    def __call__(cls):
-        if cls._default is None:
-            cls._default = type.__call__(cls)
-        return copy.copy(cls._default)
-
-    def set_default(cls, default):
-        cls._default = copy.copy(default)
-
-
-class Configuration(six.with_metaclass(TypeWithDefault, object)):
+class Configuration(object):
     """NOTE: This class is auto generated by the swagger code generator program.
 
     Ref: https://github.com/swagger-api/swagger-codegen
     Do not edit the class manually.
     """
 
+    _default = None
+
     def __init__(self):
         """Constructor"""
+        if self._default:
+            for key in self._default.__dict__.keys():
+                self.__dict__[key] = copy.copy(self._default.__dict__[key])
+            return
+
         # Default Base url
         self.host = "https://api.dyspatch.io"
         # Temp file folder for downloading files
@@ -101,6 +94,10 @@ def __init__(self):
         # Safe chars for path_param
         self.safe_chars_for_path_param = ''
 
+    @classmethod
+    def set_default(cls, default):
+        cls._default = default
+
     @property
     def logger_file(self):
         """The logger file.

dyspatch_client/configuration.py

@@ -153,6 +153,9 @@ def to_dict(self):
                 ))
             else:
                 result[attr] = value
+        if issubclass(APIError, dict):
+            for key, value in self.items():
+                result[key] = value
 
         return result
 

dyspatch_client/models/api_error.py

@@ -89,6 +89,9 @@ def to_dict(self):
                 ))
             else:
                 result[attr] = value
+        if issubclass(Body, dict):
+            for key, value in self.items():
+                result[key] = value
 
         return result
 

dyspatch_client/models/body.py

@@ -209,6 +209,9 @@ def to_dict(self):
                 ))
             else:
                 result[attr] = value
+        if issubclass(CompiledRead, dict):
+            for key, value in self.items():
+                result[key] = value
 
         return result
 

dyspatch_client/models/compiled_read.py

@@ -61,6 +61,9 @@ def to_dict(self):
                 ))
             else:
                 result[attr] = value
+        if issubclass(CreatedAt, dict):
+            for key, value in self.items():
+                result[key] = value
 
         return result