Partial: Remove six.

Author: Poogles

flask_restplus/postman.py

@@ -1,13 +1,12 @@
 from time import time
 from uuid import uuid5, NAMESPACE_URL
 
-from six import iteritems
-from six.moves.urllib.parse import urlencode
+from urllib.parse import urlencode
 
 
 def clean(data):
     '''Remove all keys where value is None'''
-    return dict((k, v) for k, v in iteritems(data) if v is not None)
+    return dict((k, v) for k, v in data.items() if v is not None)
 
 
 DEFAULT_VARS = {
@@ -52,15 +51,15 @@ def headers(self):
 
         # Add security headers if needed (global then local)
         for security in self.collection.api.__schema__.get('security', []):
-            for key, header in iteritems(self.collection.apikeys):
+            for key, header in self.collection.apikeys.items():
                 if key in security:
                     headers[header] = ''
         for security in self.operation.get('security', []):
-            for key, header in iteritems(self.collection.apikeys):
+            for key, header in self.collection.apikeys.items():
                 if key in security:
                     headers[header] = ''
 
-        lines = [':'.join(line) for line in iteritems(headers)]
+        lines = [':'.join(line) for line in headers.items()]
         return '\n'.join(lines)
 
     @property
@@ -95,7 +94,7 @@ def process_url(self, urlvars=False):
         params.update(dict((p['name'], p) for p in self.operation.get('parameters', [])))
         if not params:
             return url, None
-        for name, param in iteritems(params):
+        for name, param in params.items():
             if param['in'] == 'path':
                 url = url.replace('{%s}' % name, ':%s' % name)
                 path_vars[name] = DEFAULT_VARS.get(param['type'], '')
@@ -157,10 +156,10 @@ def requests(self):
                 'summary': 'The API Swagger specifications as JSON',
             })
         # Then iter over API paths and methods
-        for path, operations in iteritems(self.api.__schema__['paths']):
+        for path, operations in self.api.__schema__['paths'].items():
             path_params = operations.get('parameters', [])
 
-            for method, operation in iteritems(operations):
+            for method, operation in operations.items():
                 if method != 'parameters':
                     yield Request(self, path, path_params, method, operation)
 
@@ -173,7 +172,7 @@ def folders(self):
     def apikeys(self):
         return dict(
             (name, secdef['name'])
-            for name, secdef in iteritems(self.api.__schema__.get('securityDefinitions'))
+            for name, secdef in self.api.__schema__.get('securityDefinitions').items()
             if secdef.get('in') == 'header' and secdef.get('type') == 'apiKey'
         )
 

flask_restplus/swagger.py

@@ -2,12 +2,7 @@
 import re
 
 from inspect import isclass, getdoc
-try:
-    from collections.abc import OrderedDict, Hashable
-except ImportError:
-    # TODO Remove this to drop Python2 support
-    from collections import OrderedDict, Hashable
-from six import string_types, itervalues, iteritems, iterkeys
+from collections import OrderedDict, Hashable
 
 from flask import current_app
 from werkzeug.routing import parse_rule
@@ -18,10 +13,7 @@
 from .utils import merge, not_none, not_none_sorted
 from ._http import HTTPStatus
 
-try:
-    from urllib.parse import quote
-except ImportError:
-    from urllib import quote
+from urllib.parse import quote
 
 #: Maps Flask/Werkzeug rooting types to Swagger ones
 PATH_TYPES = {
@@ -98,7 +90,7 @@ def _param_to_header(param):
 
 
 def _clean_header(header):
-    if isinstance(header, string_types):
+    if isinstance(header, str):
         header = {'description': header}
     typedef = header.get('type', 'string')
     if isinstance(typedef, Hashable) and typedef in PY_TYPES:
@@ -212,7 +204,7 @@ def as_dict(self):
             'basePath': basepath,
             'paths': not_none_sorted(paths),
             'info': infos,
-            'produces': list(iterkeys(self.api.representations)),
+            'produces': list(self.api.representations.keys()),
             'consumes': ['application/json'],
             'securityDefinitions': self.api.authorizations or None,
             'security': self.security_requirements(self.api.security) or None,
@@ -233,7 +225,7 @@ def extract_tags(self, api):
         tags = []
         by_name = {}
         for tag in api.tags:
-            if isinstance(tag, string_types):
+            if isinstance(tag, str):
                 tag = {'name': tag}
             elif isinstance(tag, (list, tuple)):
                 tag = {'name': tag[0], 'description': tag[1]}
@@ -296,7 +288,7 @@ def extract_resource_doc(self, resource, url, route_doc=None):
                 method_doc['docstring'] = parse_docstring(method_impl)
                 method_params = self.expected_params(method_doc)
                 method_params = merge(method_params, method_doc.get('params', {}))
-                inherited_params = OrderedDict((k, v) for k, v in iteritems(params) if k in method_params)
+                inherited_params = OrderedDict((k, v) for k, v in params.items() if k in method_params)
                 method_doc['params'] = merge(inherited_params, method_params)
                 for name, param in method_doc['params'].items():
                     key = (name, param.get('in', 'query'))
@@ -361,7 +353,7 @@ def expected_params(self, doc):
 
     def register_errors(self):
         responses = {}
-        for exception, handler in iteritems(self.api.error_handlers):
+        for exception, handler in self.api.error_handlers.items():
             doc = parse_docstring(handler)
             response = {
                 'description': doc['summary']
@@ -423,7 +415,7 @@ def vendor_fields(self, doc, method):
         '''
         return dict(
             (k if k.startswith('x-') else 'x-{0}'.format(k), v)
-            for k, v in iteritems(doc[method].get('vendor', {}))
+            for k, v in doc[method].get('vendor', {}).items()
         )
 
     def description_for(self, doc, method):
@@ -444,7 +436,7 @@ def operation_id_for(self, doc, method):
 
     def parameters_for(self, doc):
         params = []
-        for name, param in iteritems(doc['params']):
+        for name, param in doc['params'].items():
             param['name'] = name
             if 'type' not in param and 'schema' not in param:
                 param['type'] = 'string'
@@ -473,7 +465,7 @@ def parameters_for(self, doc):
                 'format': 'mask',
                 'description': 'An optional fields mask',
             }
-            if isinstance(mask, string_types):
+            if isinstance(mask, str):
                 param['default'] = mask
             params.append(param)
 
@@ -485,9 +477,9 @@ def responses_for(self, doc, method):
 
         for d in doc, doc[method]:
             if 'responses' in d:
-                for code, response in iteritems(d['responses']):
+                for code, response in d['responses'].items():
                     code = str(code)
-                    if isinstance(response, string_types):
+                    if isinstance(response, str):
                         description = response
                         model = None
                         kwargs = {}
@@ -517,8 +509,8 @@ def responses_for(self, doc, method):
                 responses[code]['schema'] = self.serialize_schema(d['model'])
 
             if 'docstring' in d:
-                for name, description in iteritems(d['docstring']['raises']):
-                    for exception, handler in iteritems(self.api.error_handlers):
+                for name, description in d['docstring']['raises'].items():
+                    for exception, handler in self.api.error_handlers.items():
                         error_responses = getattr(handler, '__apidoc__', {}).get('responses', {})
                         code = str(list(error_responses.keys())[0]) if error_responses else None
                         if code and exception.__name__ == name:
@@ -535,17 +527,17 @@ def process_headers(self, response, doc, method=None, headers=None):
             response['headers'] = dict(
                 (k, _clean_header(v)) for k, v
                 in itertools.chain(
-                    iteritems(doc.get('headers', {})),
-                    iteritems(method_doc.get('headers', {})),
-                    iteritems(headers or {})
+                    doc.get('headers', {}).items(),
+                    method_doc.get('headers', {}).items(),
+                    headers.items() if headers else dict().items()
                 )
             )
         return response
 
     def serialize_definitions(self):
         return dict(
             (name, model.__schema__)
-            for name, model in iteritems(self._registered_models)
+            for name, model in self._registered_models.items()
         )
 
     def serialize_schema(self, model):
@@ -560,7 +552,7 @@ def serialize_schema(self, model):
             self.register_model(model)
             return ref(model)
 
-        elif isinstance(model, string_types):
+        elif isinstance(model, str):
             self.register_model(model)
             return ref(model)
 
@@ -585,13 +577,13 @@ def register_model(self, model):
             for parent in specs.__parents__:
                 self.register_model(parent)
         if isinstance(specs, Model):
-            for field in itervalues(specs):
+            for field in specs.values():
                 self.register_field(field)
         return ref(model)
 
     def register_field(self, field):
         if isinstance(field, fields.Polymorph):
-            for model in itervalues(field.mapping):
+            for model in field.mapping.values():
                 self.register_model(model)
         elif isinstance(field, fields.Nested):
             self.register_model(field.nested)
@@ -620,12 +612,12 @@ def security_requirements(self, value):
             return []
 
     def security_requirement(self, value):
-        if isinstance(value, (string_types)):
+        if isinstance(value, (str)):
             return {value: []}
         elif isinstance(value, dict):
             return dict(
                 (k, v if isinstance(v, (list, tuple)) else [v])
-                for k, v in iteritems(value)
+                for k, v in value.items()
             )
         else:
             return None

flask_restx/api.py

@@ -4,7 +4,6 @@
 import logging
 import operator
 import re
-import six
 import sys
 import warnings
 
@@ -509,7 +508,7 @@ def add_namespace(self, ns, path=None):
             urls = self.ns_urls(ns, r.urls)
             self.register_resource(ns, r.resource, *urls, **r.kwargs)
         # Register models
-        for name, definition in six.iteritems(ns.models):
+        for name, definition in ns.models.items():
             self.models[name] = definition
         if not self.blueprint and self.app is not None:
             self._configure_namespace_logger(self.app, ns)
@@ -586,7 +585,7 @@ def _own_and_child_error_handlers(self):
         rv = OrderedDict()
         rv.update(self.error_handlers)
         for ns in self.namespaces:
-            for exception, handler in six.iteritems(ns.error_handlers):
+            for exception, handler in ns.error_handlers.items():
                 rv[exception] = handler
         return rv
 
@@ -704,7 +703,7 @@ def handle_error(self, e):
 
         headers = Headers()
 
-        for typecheck, handler in six.iteritems(self._own_and_child_error_handlers):
+        for typecheck, handler in self._own_and_child_error_handlers.items():
             if isinstance(e, typecheck):
                 result = handler(e)
                 default_data, code, headers = unpack(

flask_restx/fields.py

@@ -7,8 +7,7 @@
 from decimal import Decimal, ROUND_HALF_EVEN
 from email.utils import formatdate
 
-from six import iteritems, itervalues, text_type, string_types
-from six.moves.urllib.parse import urlparse, urlunparse
+from urllib.parse import urlparse, urlunparse
 
 from flask import url_for, request
 from werkzeug.utils import cached_property
@@ -56,7 +55,7 @@ class MarshallingError(RestError):
     def __init__(self, underlying_exception):
         # just put the contextual representation of the error to hint on what
         # went wrong without exposing internals
-        super(MarshallingError, self).__init__(text_type(underlying_exception))
+        super(MarshallingError, self).__init__(str(underlying_exception))
 
 
 def is_indexable_but_not_string(obj):
@@ -424,9 +423,7 @@ def schema(self):
 
 class String(StringMixin, Raw):
     """
-    Marshal a value as a string. Uses ``six.text_type`` so values will
-    be converted to :class:`unicode` in python2 and :class:`str` in
-    python3.
+    Marshal a value as a string.
     """
 
     def __init__(self, *args, **kwargs):
@@ -437,7 +434,7 @@ def __init__(self, *args, **kwargs):
 
     def format(self, value):
         try:
-            return text_type(value)
+            return str(value)
         except ValueError as ve:
             raise MarshallingError(ve)
 
@@ -493,7 +490,7 @@ class Arbitrary(NumberMixin, Raw):
     """
 
     def format(self, value):
-        return text_type(Decimal(value))
+        return str(Decimal(value))
 
 
 ZERO = Decimal()
@@ -512,7 +509,7 @@ def format(self, value):
         dvalue = Decimal(value)
         if not dvalue.is_normal() and dvalue != ZERO:
             raise MarshallingError("Invalid Fixed precision number.")
-        return text_type(dvalue.quantize(self.precision, rounding=ROUND_HALF_EVEN))
+        return str(dvalue.quantize(self.precision, rounding=ROUND_HALF_EVEN))
 
 
 class Boolean(Raw):
@@ -549,7 +546,7 @@ def __init__(self, dt_format="iso8601", **kwargs):
     def parse(self, value):
         if value is None:
             return None
-        elif isinstance(value, string_types):
+        elif isinstance(value, str):
             parser = (
                 datetime_from_iso8601
                 if self.dt_format == "iso8601"
@@ -621,7 +618,7 @@ def __init__(self, **kwargs):
     def parse(self, value):
         if value is None:
             return None
-        elif isinstance(value, string_types):
+        elif isinstance(value, str):
             return date_from_iso8601(value)
         elif isinstance(value, datetime):
             return value.date()
@@ -682,7 +679,7 @@ class FormattedString(StringMixin, Raw):
 
     def __init__(self, src_str, **kwargs):
         super(FormattedString, self).__init__(**kwargs)
-        self.src_str = text_type(src_str)
+        self.src_str = str(src_str)
 
     def output(self, key, obj, **kwargs):
         try:
@@ -732,7 +729,7 @@ class Polymorph(Nested):
 
     def __init__(self, mapping, required=False, **kwargs):
         self.mapping = mapping
-        parent = self.resolve_ancestor(list(itervalues(mapping)))
+        parent = self.resolve_ancestor(list(mapping.values()))
         super(Polymorph, self).__init__(parent, allow_null=not required, **kwargs)
 
     def output(self, key, obj, ordered=False, **kwargs):
@@ -749,7 +746,7 @@ def output(self, key, obj, ordered=False, **kwargs):
             raise ValueError("Polymorph field only accept class instances")
 
         candidates = [
-            fields for cls, fields in iteritems(self.mapping) if type(value) == cls
+            fields for cls, fields in self.mapping.items() if type(value) == cls
         ]
 
         if len(candidates) <= 0:
@@ -822,7 +819,7 @@ def _flatten(self, obj):
         if obj == self._obj and self._flat is not None:
             return self._flat
         if isinstance(obj, dict):
-            self._flat = [x for x in iteritems(obj)]
+            self._flat = [x for x in obj.items()]
         else:
 
             def __match_attributes(attribute):