Rename "schema_cls" -> "schema_class"

src/webargs/asyncparser.py

@@ -126,7 +126,7 @@ def use_args(
         # Optimization: If argmap is passed as a dictionary, we only need
         # to generate a Schema once
         if isinstance(argmap, Mapping):
-            argmap = core.dict2schema(argmap, self.schema_cls)()
+            argmap = core.dict2schema(argmap, self.schema_class)()
 
         def decorator(func: typing.Callable) -> typing.Callable:
             req_ = request_obj

src/webargs/core.py

@@ -51,7 +51,7 @@ def _callable_or_raise(obj):
         return obj
 
 
-def dict2schema(dct, schema_cls=ma.Schema):
+def dict2schema(dct, schema_class=ma.Schema):
     """Generate a `marshmallow.Schema` class given a dictionary of
     `Fields <marshmallow.fields.Field>`.
     """
@@ -64,7 +64,7 @@ class Meta(object):
             register = False
 
     attrs["Meta"] = Meta
-    return type(str(""), (schema_cls,), attrs)
+    return type(str(""), (schema_class,), attrs)
 
 
 def is_multiple(field):
@@ -165,7 +165,7 @@ class Parser(object):
     #: Default locations to check for data
     DEFAULT_LOCATIONS = ("querystring", "form", "json")
     #: The marshmallow Schema class to use when creating new schemas
-    DEFAULT_SCHEMA_CLS = ma.Schema
+    DEFAULT_SCHEMA_CLASS = ma.Schema
     #: Default status code to return for validation errors
     DEFAULT_VALIDATION_STATUS = DEFAULT_VALIDATION_STATUS
     #: Default error message for validation errors
@@ -182,10 +182,10 @@ class Parser(object):
         "files": "parse_files",
     }
 
-    def __init__(self, locations=None, error_handler=None, schema_cls=None):
+    def __init__(self, locations=None, error_handler=None, schema_class=None):
         self.locations = locations or self.DEFAULT_LOCATIONS
         self.error_callback = _callable_or_raise(error_handler)
-        self.schema_cls = schema_cls or self.DEFAULT_SCHEMA_CLS
+        self.schema_class = schema_class or self.DEFAULT_SCHEMA_CLASS
         #: A short-lived cache to store results from processing request bodies.
         self._cache = {}
 
@@ -313,7 +313,7 @@ def _get_schema(self, argmap, req):
         elif callable(argmap):
             schema = argmap(req)
         else:
-            schema = dict2schema(argmap, self.schema_cls)()
+            schema = dict2schema(argmap, self.schema_class)()
         if MARSHMALLOW_VERSION_INFO[0] < 3 and not schema.strict:
             warnings.warn(
                 "It is highly recommended that you set strict=True on your schema "
@@ -443,7 +443,7 @@ def greet(args):
         # Optimization: If argmap is passed as a dictionary, we only need
         # to generate a Schema once
         if isinstance(argmap, Mapping):
-            argmap = dict2schema(argmap, self.schema_cls)()
+            argmap = dict2schema(argmap, self.schema_class)()
 
         def decorator(func):
             req_ = request_obj

src/webargs/pyramidparser.py

@@ -137,7 +137,7 @@ def use_args(
         # Optimization: If argmap is passed as a dictionary, we only need
         # to generate a Schema once
         if isinstance(argmap, collections.Mapping):
-            argmap = core.dict2schema(argmap, self.schema_cls)()
+            argmap = core.dict2schema(argmap, self.schema_class)()
 
         def decorator(func):
             @functools.wraps(func)

tests/test_core.py

@@ -1055,7 +1055,7 @@ def test_parse_with_error_status_code_and_headers(web_request):
 
 
 @mock.patch("webargs.core.Parser.parse_json")
-def test_custom_schema_cls(parse_json, web_request):
+def test_custom_schema_class(parse_json, web_request):
     class CustomSchema(Schema):
         @pre_load
         def pre_load(self, data):
@@ -1064,21 +1064,21 @@ def pre_load(self, data):
 
     parse_json.return_value = "hello"
     argmap = {"value": fields.Str()}
-    p = Parser(schema_cls=CustomSchema)
+    p = Parser(schema_class=CustomSchema)
     ret = p.parse(argmap, web_request)
     assert ret == {"value": "hello world"}
 
 
 @mock.patch("webargs.core.Parser.parse_json")
-def test_custom_default_schema_cls(parse_json, web_request):
+def test_custom_default_schema_class(parse_json, web_request):
     class CustomSchema(Schema):
         @pre_load
         def pre_load(self, data):
             data["value"] += " world"
             return data
 
     class CustomParser(Parser):
-        DEFAULT_SCHEMA_CLS = CustomSchema
+        DEFAULT_SCHEMA_CLASS = CustomSchema
 
     parse_json.return_value = "hello"
     argmap = {"value": fields.Str()}