validate-with-resolute

Immutable object modifications with the Result pattern, inspired by C# records.

Wraps dataclass and Pydantic model construction/modification in resolute so validation errors are returned, never raised.

Installation

pip install validate-with-resolute

Requires Python 3.13+.

Usage

Record base class (recommended)

Inherit from Record to get .from_() and .with_() with full type checking and IDE autocomplete.

from dataclasses import dataclass
from validate_with_resolute import Record

@dataclass
class User(Record):
    name: str
    age: int

# Safe construction
result = User.from_(name="Bob", age=25)
if result.is_success:
    user = result.value

# Safe modification — original unchanged
result = user.with_(name="Alice", age=30)
if result.is_success:
    print(result.value.name)  # "Alice"
    print(user.name)          # "Bob"

Works with Pydantic:

from pydantic import BaseModel, field_validator
from validate_with_resolute import Record

class User(BaseModel, Record):
    name: str
    age: int

    @field_validator('age')
    @classmethod
    def validate_age(cls, v: int) -> int:
        if v < 0:
            raise ValueError('age must be positive')
        return v

result = User.from_(name="Bob", age=-5)
if result.has_errors:
    print(result.errors)  # validation errors captured, not raised

user = User(name="Bob", age=25)
result = user.with_(age=-5)  # same — errors captured

modify() standalone function

No inheritance required:

from dataclasses import dataclass
from validate_with_resolute import modify

@dataclass
class User:
    name: str
    age: int

user = User(name="Bob", age=25)
result = modify(user, name="Alice", age=30)
if result.is_success:
    print(result.value.name)  # "Alice"

@with_modify decorator

Adds .with_() to an existing class without inheritance. Type checkers require # type: ignore[attr-defined] on call sites.

from validate_with_resolute import with_modify

@with_modify
@dataclass
class User:
    name: str
    age: int

result = user.with_(name="Alice")  # type: ignore[attr-defined]

Prefer Record or modify() instead.

Result API

All functions return Resolute[T] from the resolute package:

result.is_success   # True on success
result.has_errors   # True on failure
result.value        # Modified object (success only)
result.errors       # List of captured errors (failure only)

Supported types

Type checking

The package ships a py.typed marker and full generic annotations. result.value is typed as T.

Nested objects

new_address = modify(address, city="LA").value
result = modify(person, address=new_address)

License

MIT