How do I use args as a parameter in Pydantic?

In Pydantic, you typically don't directly use args as a parameter in the model definition itself. Pydantic models are designed to have explicitly defined fields with specific types. However, you can use args in custom validators or when initializing the model, but not as a direct field.

Here's a breakdown of how you can handle variable arguments with Pydantic:

1. Using a List or Tuple Field:

- The most common approach is to define a field that accepts a list or tuple. This allows you to pass a variable number of arguments as a single field.

- Example:

from pydantic import BaseModel

class MyModel(BaseModel):
  items: list[str]

# Usage
model = MyModel(items=["apple", "banana", "cherry"])
print(model)
# Output: items=['apple', 'banana', 'cherry']

2. Using a Custom Validator:

- If you need more complex validation or processing of the arguments, you can use a custom validator. This allows you to handle the arguments before they are assigned to the model.

- Example:

from pydantic import BaseModel, validator

class MyModel(BaseModel):
  processed_items: list[str] = []

  @validator("processed_items", pre=True, always=True)
  def validate_items(cls, value):
    if isinstance(value, list):
      return [item.upper() for item in value]
    return []

# Usage
model = MyModel(processed_items=["apple", "banana", "cherry"])
print(model)
# Output: processed_items=['APPLE', 'BANANA', 'CHERRY']

3. Initializing with `args` (Not Recommended for Direct Field Assignment):

- You can use args when initializing the model, but you'll need to handle the arguments manually within the model's __init__ method or a custom validator. This is generally less clean and less explicit than using a list or tuple field.

- Example (Not Recommended):

from pydantic import BaseModel

class MyModel(BaseModel):
  items: list[str] = []

  def __init__(self, args, kwargs):
    super().__init__(kwargs)
    self.items.extend(args)

# Usage
model = MyModel("apple", "banana", "cherry")
print(model)
# Output: items=['apple', 'banana', 'cherry']

Key Considerations:

- Explicit Fields: Pydantic is designed for explicit field definitions. Using args directly as a field bypasses this and makes your model less clear.

- Validation: Using a list or tuple field allows Pydantic to validate the type of the items within the list or tuple.

- Clarity: Explicitly defining a list or tuple field makes your model's structure and expected input clearer to other developers.

In summary, while you can technically use args during initialization, it's generally better to use a list or tuple field for variable arguments in Pydantic models. If you need more complex handling, use a custom validator.

Learn more about this