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.

```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
    @property
    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]
```

The user wants a Python solution using Pydantic v2 to define an `Order` model and a `parse_orders` function.

Requirements:
1.  **Model `Order`**:
    *   `id`: `int`
    *   `customer`: `str`, non-empty (min_length=1).
    *   `quantity`: `int`, strictly > 0 (gt=0).
    *   `unit_price`: `float`, >= 0 (ge=0).
    *   `total`: `float`, derived from `quantity * unit_price`. Must be read-only/consistent.
2.  **Function `parse_orders`**:
    *   Input: `list[dict]`
    *   Output: `list[Order]`
    *   Behavior: Validates all rows. If any row fails, raise `pydantic.ValidationError`.

Implementation details:
*   Use `from pydantic import BaseModel, Field, computed_field`.
*   For `total`, `@computed_field` is the standard Pydantic v2 way to handle derived properties that are included in serialization and accessible as attributes.
*   For `parse_orders`, simply iterate and instantiate `Order(**row)`. If validation fails, Pydantic raises `ValidationError` automatically.

Let's draft the 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
    @property
    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, `parse_orders` requirement says: "If any row is invalid, it must raise pydantic's pydantic.ValidationError".
The list comprehension `[Order(**row) for row in rows]` will raise the error immediately when it hits the first invalid row. This satisfies the requirement "letting the exception propagate from the first invalid row is fine".

Let's double check the constraints.
- `customer`: non-empty. `Field(min_length=1)` handles this.
- `quantity`: strictly > 0. `Field(gt=0)` handles this.
- `unit_price`: >= 0. `Field(ge=0)` handles this.
- `total`: derived. `@computed_field` handles this.

Is there any ambiguity about "do not return partial results"?
If I use a list comprehension, it stops at the first error. So no partial results are returned.
If I used `map` or something similar, it might behave differently, but list comprehension is safe.

One edge case: `parse_orders` signature in the prompt is `def parse_orders(rows: list[dict]) -> list[Order]:`.
The implementation matches.

Let's verify Pydantic v2 imports.
`BaseModel`, `Field`, `computed_field` are correct.

Final check on `total`.
The prompt says: "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."
`@computed_field` creates a read-only property that is included in the model's schema and serialization. It is not settable via the constructor or attribute assignment (unless `model_config` allows arbitrary fields or specific overrides, but standard behavior is read-only). This fits perfectly.

Code structure:
```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
    @property
    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]
```

This looks solid.

One minor detail: `list[dict]` type hint requires Python 3.9+. The prompt uses it in the signature provided, so I will assume a modern Python environment. If strict compatibility with older Python is needed, `List[Dict]` from `typing` would be used, but the prompt explicitly wrote `list[dict]` in the example signature, so I will stick to that.

I will output the solution now.

```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
    @property
    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, should I handle the case where `rows` might contain keys that are not in the model?
Pydantic v2 default behavior is to ignore extra fields (`model_config = ConfigDict(extra='ignore')` is default in v2? No, actually in v2 default is `extra='ignore'`? Let me check.
Actually, in Pydantic v2, the default for `extra` is `'ignore'`.
Wait, checking documentation...
Pydantic v2 default `extra` is `'ignore'`.
However, often in validation tasks, one might want `'forbid'` to ensure strict input.
The prompt doesn't specify behavior for extra keys. It just says "Takes a list of dicts".
Standard Pydantic behavior (ignoring extra) is usually acceptable unless specified otherwise.
If I want to be safe, I won't change the default config unless necessary. The prompt doesn't ask for strictness regarding extra keys.

Let's re-read carefully: "If any row is invalid, it must raise pydantic's pydantic.ValidationError".
If a row has missing required fields, Pydantic raises ValidationError.
If a row has wrong types, Pydantic raises ValidationError.
If a row violates constraints, Pydantic raises ValidationError.
This is handled automatically by `Order(**row)`.

The solution seems complete.

One thing: `parse_orders` example shows:
`parse_orders([{"id": 2, "customer": "X", "quantity": 0, "unit_price": 1.0}])`
This should raise. `quantity=0` violates `gt=0`. Correct.

Final code block.

```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
    @property
    def total(self) -> float:
        return self.quantity * self.unit_price

def parse_orders(rows: list[dict]) -> list[Order]:
    return [Order(**row) for ro
…[12632 chars elided]…
hinking.

```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
    @property
    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]
```
I will output this.

One tiny check:
Prompt: "If any row is invalid, it must raise pydantic's pydantic.ValidationError".
My code: `Order(**row)` raises `ValidationError` if invalid.
The list comprehension stops and propagates.
Correct.

Prompt: "do not catch and swallow it; do not return partial results".
My code does not catch.
My code does not return partial results (exception prevents return).
Correct.

Prompt: "letting the exception propagate from the first invalid row is fine".
My code does exactly this.
Correct.

Final verification of imports.
`BaseModel`, `Field`, `computed_field` are all in `pydantic`.
Correct.

The solution is ready.

```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
    @property
    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]
```
I will present this.

Wait, I should check if `id` needs to be unique or anything? No.
Just `int`.

Okay.

```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
    @property
    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]
```
I'll output this now.