rename arguments -> parameters (#217)

* rename arguments -> parameters

* revert to arguments_schema

Author: samuelcolvin

pydantic_core/_types.py

@@ -279,7 +279,7 @@ class CallableSchema(TypedDict):
     type: Literal['callable']
 
 
-class ArgumentInfo(TypedDict):
+class Parameter(TypedDict):
     name: str
     mode: Literal['positional_only', 'positional_or_keyword', 'keyword_only']
     schema: Schema
@@ -290,7 +290,7 @@ class ArgumentInfo(TypedDict):
 
 class ArgumentsSchema(TypedDict, total=False):
     type: Required[Literal['arguments']]
-    arguments_schema: Required[List[ArgumentInfo]]
+    arguments_schema: Required[List[Parameter]]
     populate_by_name: bool
     var_args_schema: Schema
     var_kwargs_schema: Schema

src/validators/arguments.rs

@@ -13,7 +13,7 @@ use crate::SchemaError;
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
 #[derive(Debug, Clone)]
-struct Argument {
+struct Parameter {
     positional: bool,
     name: String,
     kw_lookup_key: Option<LookupKey>,
@@ -25,8 +25,8 @@ struct Argument {
 
 #[derive(Debug, Clone)]
 pub struct ArgumentsValidator {
-    arguments: Vec<Argument>,
-    positional_args_count: usize,
+    parameters: Vec<Parameter>,
+    positional_params_count: usize,
     var_args_validator: Option<Box<CombinedValidator>>,
     var_kwargs_validator: Option<Box<CombinedValidator>>,
 }
@@ -43,20 +43,20 @@ impl BuildValidator for ArgumentsValidator {
 
         let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
 
-        let arguments_list: &PyList = schema.get_as_req(intern!(py, "arguments_schema"))?;
-        let mut arguments: Vec<Argument> = Vec::with_capacity(arguments_list.len());
+        let arguments_schema: &PyList = schema.get_as_req(intern!(py, "arguments_schema"))?;
+        let mut parameters: Vec<Parameter> = Vec::with_capacity(arguments_schema.len());
 
-        let mut positional_args_count = 0;
+        let mut positional_params_count = 0;
         let mut had_default_arg = false;
 
-        for (arg_index, arg) in arguments_list.iter().enumerate() {
+        for (arg_index, arg) in arguments_schema.iter().enumerate() {
             let arg: &PyDict = arg.cast_as()?;
 
             let name: String = arg.get_as_req(intern!(py, "name"))?;
             let mode: &str = arg.get_as_req(intern!(py, "mode"))?;
             let positional = mode == "positional_only" || mode == "positional_or_keyword";
             if positional {
-                positional_args_count = arg_index + 1;
+                positional_params_count = arg_index + 1;
             }
 
             let mut kw_lookup_key = None;
@@ -74,7 +74,7 @@ impl BuildValidator for ArgumentsValidator {
 
             let schema: &PyAny = arg
                 .get_as_req(intern!(py, "schema"))
-                .map_err(|err| SchemaError::new_err(format!("Argument \"{}\":\n  {}", name, err)))?;
+                .map_err(|err| SchemaError::new_err(format!("Parameter \"{}\":\n  {}", name, err)))?;
 
             let validator = build_validator(schema, config, build_context)?;
 
@@ -87,7 +87,7 @@ impl BuildValidator for ArgumentsValidator {
             } else if default.is_some() || default_factory.is_some() {
                 had_default_arg = true;
             }
-            arguments.push(Argument {
+            parameters.push(Parameter {
                 positional,
                 kw_lookup_key,
                 name,
@@ -99,8 +99,8 @@ impl BuildValidator for ArgumentsValidator {
         }
 
         Ok(Self {
-            arguments,
-            positional_args_count,
+            parameters,
+            positional_params_count,
             var_args_validator: match schema.get_item(intern!(py, "var_args_schema")) {
                 Some(v) => Some(Box::new(build_validator(v, config, build_context)?)),
                 None => None,
@@ -149,24 +149,24 @@ impl Validator for ArgumentsValidator {
     ) -> ValResult<'data, PyObject> {
         let args = input.validate_args()?;
 
-        let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_args_count);
+        let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_params_count);
         let output_kwargs = PyDict::new(py);
         let mut errors: Vec<ValLineError> = Vec::new();
-        let mut used_kwargs: AHashSet<&str> = AHashSet::with_capacity(self.arguments.len());
+        let mut used_kwargs: AHashSet<&str> = AHashSet::with_capacity(self.parameters.len());
 
         macro_rules! process {
             ($args:ident, $get_method:ident, $get_macro:ident, $slice_macro:ident) => {{
                 // go through arguments getting the value from args or kwargs and validating it
-                for (index, argument_info) in self.arguments.iter().enumerate() {
+                for (index, parameter) in self.parameters.iter().enumerate() {
                     let mut pos_value = None;
                     if let Some(args) = $args.args {
-                        if argument_info.positional {
+                        if parameter.positional {
                             pos_value = $get_macro!(args, index);
                         }
                     }
                     let mut kw_value = None;
                     if let Some(kwargs) = $args.kwargs {
-                        if let Some(ref lookup_key) = argument_info.kw_lookup_key {
+                        if let Some(ref lookup_key) = parameter.kw_lookup_key {
                             if let Some((key, value)) = lookup_key.$get_method(kwargs)? {
                                 used_kwargs.insert(key);
                                 kw_value = Some(value);
@@ -179,11 +179,11 @@ impl Validator for ArgumentsValidator {
                             errors.push(ValLineError::new_with_loc(
                                 ErrorKind::MultipleArgumentValues,
                                 kw_value,
-                                argument_info.name.clone(),
+                                parameter.name.clone(),
                             ));
                         }
                         (Some(pos_value), None) => {
-                            match argument_info
+                            match parameter
                                 .validator
                                 .validate(py, pos_value, extra, slots, recursion_guard)
                             {
@@ -195,71 +195,71 @@ impl Validator for ArgumentsValidator {
                             }
                         }
                         (None, Some(kw_value)) => {
-                            match argument_info
+                            match parameter
                                 .validator
                                 .validate(py, kw_value, extra, slots, recursion_guard)
                             {
-                                Ok(value) => output_kwargs.set_item(argument_info.kwarg_key.as_ref().unwrap(), value)?,
+                                Ok(value) => output_kwargs.set_item(parameter.kwarg_key.as_ref().unwrap(), value)?,
                                 Err(ValError::LineErrors(line_errors)) => {
                                     errors.extend(
                                         line_errors
                                             .into_iter()
-                                            .map(|err| err.with_outer_location(argument_info.name.clone().into())),
+                                            .map(|err| err.with_outer_location(parameter.name.clone().into())),
                                     );
                                 }
                                 Err(err) => return Err(err),
                             }
                         }
                         (None, None) => {
-                            if let Some(ref default) = argument_info.default {
-                                if let Some(ref kwarg_key) = argument_info.kwarg_key {
+                            if let Some(ref default) = parameter.default {
+                                if let Some(ref kwarg_key) = parameter.kwarg_key {
                                     output_kwargs.set_item(kwarg_key, default)?;
                                 } else {
                                     output_args.push(default.clone_ref(py));
                                 }
-                            } else if let Some(ref default_factory) = argument_info.default_factory {
+                            } else if let Some(ref default_factory) = parameter.default_factory {
                                 let default = default_factory.call0(py)?;
-                                if let Some(ref kwarg_key) = argument_info.kwarg_key {
+                                if let Some(ref kwarg_key) = parameter.kwarg_key {
                                     output_kwargs.set_item(kwarg_key, default)?;
                                 } else {
                                     output_args.push(default);
                                 }
-                            } else if argument_info.kwarg_key.is_some() {
+                            } else if parameter.kwarg_key.is_some() {
                                 errors.push(ValLineError::new_with_loc(
                                     ErrorKind::MissingKeywordArgument,
                                     input,
-                                    argument_info.name.clone(),
+                                    parameter.name.clone(),
                                 ));
                             } else {
                                 errors.push(ValLineError::new_with_loc(ErrorKind::MissingPositionalArgument, input, index));
                             };
                         }
                     }
                 }
-                // if there are args check any where index > positional_args_count since they won't have been checked yet
+                // if there are args check any where index > positional_params_count since they won't have been checked yet
                 if let Some(args) = $args.args {
                     let len = args.len();
-                    if len > self.positional_args_count {
+                    if len > self.positional_params_count {
                         if let Some(ref validator) = self.var_args_validator {
-                            for (index, item) in $slice_macro!(args, self.positional_args_count, len).iter().enumerate() {
+                            for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
                                 match validator.validate(py, item, extra, slots, recursion_guard) {
                                     Ok(value) => output_args.push(value),
                                     Err(ValError::LineErrors(line_errors)) => {
                                         errors.extend(
                                             line_errors
                                                 .into_iter()
-                                                .map(|err| err.with_outer_location((index + self.positional_args_count).into())),
+                                                .map(|err| err.with_outer_location((index + self.positional_params_count).into())),
                                         );
                                     }
                                     Err(err) => return Err(err),
                                 }
                             }
                         } else {
-                            for (index, item) in $slice_macro!(args, self.positional_args_count, len).iter().enumerate() {
+                            for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
                                 errors.push(ValLineError::new_with_loc(
                                     ErrorKind::UnexpectedPositionalArgument,
                                     item,
-                                    index + self.positional_args_count,
+                                    index + self.positional_params_count,
                                 ));
                             }
                         }

src/validators/union.rs

@@ -58,10 +58,10 @@ impl Validator for UnionValidator {
     ) -> ValResult<'data, PyObject> {
         if extra.strict.unwrap_or(self.strict) {
             let mut errors: Vec<ValLineError> = Vec::with_capacity(self.choices.len());
-            let strict_strict = extra.as_strict();
+            let strict_extra = extra.as_strict();
 
             for validator in &self.choices {
-                let line_errors = match validator.validate(py, input, &strict_strict, slots, recursion_guard) {
+                let line_errors = match validator.validate(py, input, &strict_extra, slots, recursion_guard) {
                     Err(ValError::LineErrors(line_errors)) => line_errors,
                     otherwise => return otherwise,
                 };
@@ -77,11 +77,11 @@ impl Validator for UnionValidator {
         } else {
             // 1st pass: check if the value is an exact instance of one of the Union types,
             // e.g. use validate in strict mode
-            let strict_strict = extra.as_strict();
+            let strict_extra = extra.as_strict();
             if let Some(res) = self
                 .choices
                 .iter()
-                .map(|validator| validator.validate(py, input, &strict_strict, slots, recursion_guard))
+                .map(|validator| validator.validate(py, input, &strict_extra, slots, recursion_guard))
                 .find(ValResult::is_ok)
             {
                 return res;

tests/validators/test_arguments.py

@@ -638,7 +638,7 @@ def test_repr():
             ],
         }
     )
-    assert 'positional_args_count:1,' in plain_repr(v)
+    assert 'positional_params_count:1,' in plain_repr(v)
 
 
 def test_build_non_default_follows():