py-08-pydantic-orders

# Order validation (pydantic v2)

Implement **`solution.py`** using **pydantic v2**
(`from pydantic import BaseModel, ...`).

Define a model `Order` and a parsing helper:

```python
from pydantic import BaseModel

class Order(BaseModel):
    id: int
    customer: str
    quantity: int
    unit_price: float
    # plus a derived `total`

def parse_orders(rows: list[dict]) -> list[Order]:
    ...
```

### `Order` field rules

- `id: int`
- `customer: str` — must be **non-empty** (after no special trimming required; an
  empty string `""` is invalid).
- `quantity: int` — must be **strictly greater than 0**.
- `unit_price: float` — must be **greater than or equal to 0**.
- `total: float` — a **derived/computed** value equal to `quantity * unit_price`.
  Callers should be able to read `order.total`. You may implement it as a
  `@computed_field` property or as a validated field that is always recomputed —
  but it must reflect `quantity * unit_price` and not be settable to an arbitrary
  inconsistent value.

Use pydantic's standard constraint mechanisms (e.g. `Field(gt=0)`,
`Field(ge=0)`, `Field(min_length=1)`, or `field_validator`).

### `parse_orders(rows)`

- Takes a list of dicts and returns a list of validated `Order` instances, one per
  input row, in order.
- If **any** row is invalid, it must raise pydantic's
  `pydantic.ValidationError` (do not catch and swallow it; do not return partial
  results in that case — letting the exception propagate from the first invalid
  row is fine).

Example:

```python
orders = parse_orders([
    {"id": 1, "customer": "Acme", "quantity": 3, "unit_price": 2.5},
])
orders[0].total           # 7.5

parse_orders([{"id": 2, "customer": "X", "quantity": 0, "unit_price": 1.0}])
# raises pydantic.ValidationError  (quantity must be > 0)
```

import pytest
from pydantic import ValidationError

from solution import Order, parse_orders


def test_valid_parse():
    orders = parse_orders([
        {"id": 1, "customer": "Acme", "quantity": 3, "unit_price": 2.5},
        {"id": 2, "customer": "Beta", "quantity": 1, "unit_price": 10.0},
    ])
    assert len(orders) == 2
    assert isinstance(orders[0], Order)
    assert orders[0].id == 1
    assert orders[0].customer == "Acme"


def test_computed_total():
    orders = parse_orders([
        {"id": 1, "customer": "Acme", "quantity": 3, "unit_price": 2.5},
    ])
    assert orders[0].total == pytest.approx(7.5)


def test_total_zero_price():
    orders = parse_orders([
        {"id": 1, "customer": "Acme", "quantity": 4, "unit_price": 0.0},
    ])
    assert orders[0].total == pytest.approx(0.0)


def test_invalid_quantity_zero_raises():
    with pytest.raises(ValidationError):
        parse_orders([{"id": 2, "customer": "X", "quantity": 0, "unit_price": 1.0}])


def test_invalid_negative_quantity_raises():
    with pytest.raises(ValidationError):
        parse_orders([{"id": 2, "customer": "X", "quantity": -1, "unit_price": 1.0}])


def test_invalid_negative_price_raises():
    with pytest.raises(ValidationError):
        parse_orders([{"id": 3, "customer": "Y", "quantity": 1, "unit_price": -0.01}])


def test_empty_customer_raises():
    with pytest.raises(ValidationError):
        parse_orders([{"id": 4, "customer": "", "quantity": 1, "unit_price": 1.0}])


def test_one_bad_row_in_batch_raises():
    rows = [
        {"id": 1, "customer": "Acme", "quantity": 3, "unit_price": 2.5},
        {"id": 2, "customer": "Beta", "quantity": 0, "unit_price": 1.0},  # bad
    ]
    with pytest.raises(ValidationError):
        parse_orders(rows)


def test_total_serialized_in_dump():
    o = parse_orders([{"id": 1, "customer": "Acme", "quantity": 2, "unit_price": 3.0}])[0]
    data = o.model_dump()
    assert data["total"] == pytest.approx(6.0)

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

To solve this problem, we need to implement a Pydantic model `Order` that validates and computes the total price of an order based on given constraints. Additionally, we need a function `parse_orders` that parses a list of dictionaries into a list of validated `Order` instances.

### Approach
1. **Define the Order Model**: The `Order` model will include fields for `id`, `customer`, `quantity`, and `unit_price`, each with specific constraints. The `total` field will be a computed value derived from `quantity` and `unit_price`.
2. **Constraints**:
   - `id` must be an integer.
   - `customer` must be a non-empty string.
   - `quantity` must be a positive integer.
   - `unit_price` must be a non-negative float.
3. **Computed Field**: The `total` field is computed using the product of `quantity` and `unit_price` and is read-only.
4. **Parsing Function**: The `parse_orders` function will convert each dictionary in the input list into an `Order` instance, raising a `ValidationError` if any dictionary is invalid.

### Solution Code
```python
from pydantic import BaseModel, Field, computed_field

class Order(BaseModel):
    id: int
    customer: str = Field(..., min_length=1)
    quantity: int = Field(..., gt=0)
    unit_price: float = Field(..., ge=0)

    @computed_field
    def total(self) -> float:
        return self.quantity * self.unit_price

def parse_orders(rows: list[dict]) -> list[Order]:
    return [Order(**row) for row in rows]
```

### Explanation
- **Order Model**: The `Order` model uses Pydantic's `Field` to enforce constraints on each field. The `total` field is computed using the `@computed_field` decorator, ensuring it is always the product of `quantity` and `unit_price`.
- **parse_orders Function**: This function iterates over each dictionary in the input list, converting each into an `Order` instance. If any dictionary fails validation, a `ValidationError` is raised, ensuring only valid `Order` instances are returned.

Okay, I need to solve this problem using Pydantic v2. Let's see what the task is.

So, the problem is to define a Pydantic model called Order and a parsing function called parse_orders. The Order model has several fields with specific constraints, and one of them, total, is a derived value based on quantity and unit_price.

First, let's look at the Order model requirements:

- id is an integer.
- customer is a non-empty string. So, it can't be an empty string.
- quantity must be strictly greater than 0.
- unit_price must be greater than or equal to 0.
- total is a computed field equal to quantity multiplied by unit_price.

The parse_orders function takes a list of dictionaries and returns a list of Order instances. If any row is invalid, it should raise a ValidationError.

Hmm, how do I approach this?

I remember that in Pydantic v2, models are defined with classes inheriting from BaseModel. Each field can have validators or be defined with Field to add constraints.

So, for the Order model:

- id: int. That's straightforward.
- customer: str, must be non-empty. So, I can use Field(min_length=1) or maybe a validator to check it's not empty.
- quantity: int, must be >0. So, Field(gt=0).
- unit_price: float, must be >=0. So, Field(ge=0).

For the total field, since it's derived, I can't just add it as a normal field. I think Pydantic v2 allows computed fields using @computed_field. So, I'll need to use that.

Wait, how does @computed_field work? I think it's used as a decorator for a property method. So, I'll define a method in the Order model that calculates total and mark it with @computed_field.

Alternatively, I could use a validator to compute it, but I think using computed_field is better for this case.

So, the steps are:

1. Define the Order model with the four fields (id, customer, quantity, unit_price) and the computed total.

2. Implement the computed_field for total.

3. In the parse_orders function, create a list of Order instances by iterating over each row in the input list and instantiating Order with each row's data. If any row is invalid, the ValidationError will be raised.

Wait, but how does the parse_orders function handle validation? Because when you create an instance of Order, if the data is invalid, it raises a ValidationError. So, in the parse_orders function, I need to loop through each row and try to create an Order instance. If any of them fail, the exception is raised.

But wait, in the example given, when the second row is invalid, the function raises the error. So, the function should process each row in order, and if any row is invalid, the function raises the error immediately.

So, in the parse_orders function, I can loop through each row, and for each, create an Order instance. If any creation fails, the exception is raised, and the function doesn't proceed further.

Wait, but in the example, the function is called with a list, and it returns a list of Order instances. So, the function needs to process all rows, but if any row is invalid, the entire function raises an error.

Wait, no. The example shows that when the second row is invalid, the function raises an error. So, the function should process each row in order, and if any row is invalid, it raises the error, and the function doesn't return anything.

Wait, but the function is supposed to return a list of Order instances. So, perhaps it should process all rows, but if any row is invalid, the function raises an error. So, it's not about stopping at the first invalid row, but processing all rows and ensuring all are valid before returning the list.

Wait, the problem statement says: "If any row is invalid, it must raise pydantic's ValidationError." So, the function should validate all rows, and if any is invalid, raise the error. So, it's not about stopping at the first invalid row, but checking all rows and raising an error if any is invalid.

Wait, but in the example, the function is called with a single row, and it raises an error if that row is invalid. So, perhaps the function should process each row, and if any row is invalid, the function raises the error. So, the function should process all rows, but if any row is invalid, the function raises an error, not returning a partial list.

So, in the parse_orders function, I need to create a list of Order instances by iterating through each row. For each row, I attempt to create an Order instance. If any row fails, the function raises the ValidationError.

So, the code for parse_orders would be something like:

def parse_orders(rows: list[dict]) -> list[Order]:
    return [Order(**row) for row in rows]

But wait, that would create a list comprehension. If any row is invalid, the Order constructor would raise a ValidationError, which would propagate up. So, the function would raise the error, and the list would not be returned.

But in the example, the function is called with a single row, and it returns a list with one Order instance. So, the list comprehension approach should work.

Wait, but in the example, the function is called with a list containing one row, and it returns a list with one Order. So, the list comprehension should handle that.

But wait, what about when multiple rows are invalid? For example, if the first row is invalid, the list comprehension would raise an error when trying to create the first Order, and the function would stop there, not processing the rest. But the problem statement says that if any row is invalid, the function should raise an error. So, the function should process all rows, but if any is invalid, it raises an error.

Wait, no. The function is supposed to return a list of Order instances for all valid rows. But if any row is invalid, the function should raise an error. So, the function must process all rows, and if any is invalid, it raises an error.

Wait, but the list comprehension approach would stop at the first invalid row and raise an error, not processing the rest. So, that's not correct.

So, perhaps the function should process all rows, and if any row is invalid, collect all the errors and raise a single ValidationError with all the issues
…[6537 chars elided]…
Now, putting it all together.

The Order model has four fields with constraints, and a computed total.

The parse_orders function takes a list of dicts and returns a list of Order instances, raising ValidationError if any row is invalid.

So, the code for solution.py would be:

from pydantic import BaseModel, computed_field

class Order(BaseModel):
    id: int
    customer: str
    quantity: int
    unit_price: float

    @computed_field
    def total(self) -> float:
        return self.quantity * self.unit_price

def parse_orders(rows: list[dict]) -> list[Order]:
    return [Order(**row) for row in rows]

Wait, but in the problem statement, the function is supposed to return a list of Order instances, one per input row, in order. So, the list comprehension should handle that.

But wait, what about the constraints? For example, if a row has customer as an empty string, the model should reject it, raising a ValidationError.

Yes, because the customer field is defined with min_length=1, so any empty string would cause a validation error.

Wait, no. Wait, in the model definition, I didn't add any constraints yet. Oh right, I need to add the constraints using Field.

So, I need to modify the model to include the constraints.

So, the model should be:

class Order(BaseModel):
    id: int
    customer: str = Field(..., min_length=1)
    quantity: int = Field(..., gt=0)
    unit_price: float = Field(..., ge=0)

    @computed_field
    def total(self) -> float:
        return self.quantity * self.unit_price

Yes, that's correct.

So, putting it all together, the solution.py would have the Order model with these constraints and the computed total.

Testing the example:

orders = parse_orders([{"id": 1, "customer": "Acme", "quantity": 3, "unit_price": 2.5}])
orders[0].total should be 7.5.

Another test case: parse_orders([{"id": 2, "customer": "X", "quantity": 0, "unit_price": 1.0}]) should raise ValidationError because quantity is 0, which is not >0.

So, the code should handle that.

I think that's the correct approach.