Use Cases
Practical scenarios demonstrating pydantic-resolve's capabilities in data composition and resolution.
Simple Data Aggregation
Aggregate data from multiple data sources with automatic concurrency for same-level requests.
from pydantic import BaseModel
from pydantic_resolve import Resolver
class ReturnData(BaseModel):
data: List[str] = []
async def resolve_data(self):
return await get_data()
records: List[Record] = []
async def resolve_records(self):
return await get_records()
retData = ReturnData()
retData = await Resolver().resolve(retData)
Hierarchical Data Composition
Leverage DataLoader to compose multi-layer relational data. Initialize root entities and let pydantic-resolve handle nested relationship resolution.
from pydantic import BaseModel
from pydantic_resolve import Resolver, LoaderDepend
class Company(BaseModel):
id: int
name: str
offices: List[Office] = []
def resolve_offices(self, loader=LoaderDepend(OfficeLoader)):
return loader.load(self.id)
class Office(BaseModel):
id: int
company_id: int
name: str
members: List[Member] = []
def resolve_members(self, loader=LoaderDepend(MemberLoader)):
return loader.load(self.id)
class Member(BaseModel):
id: int
office_id: int
name: str
companies = [
Company(id=1, name='Aston'),
Compay(id=2, name="Nicc"),
Company(id=3, name="Carxx")]
companies = await Resolver().resolve(companies)
Data Transformation and Enhancement
Apply business logic and data transformations at any node in the object graph without manual tree traversal.
from pydantic import BaseModel
from pydantic_resolve import Resolver
class Owner(BaseModel):
__pydantic_resolve_expose__ = { 'name': 'owner_name' }
name: str
items: List[Item]
class Item(BaseModel):
name: str
description: str = ''
def resolve_description(self, ancestor_context):
return f'this is item: {self.name}, it belongs to {ancestor_context['owner_name']}'
owners = [
dict(name="alice", items=[dict(name='car'), dict(name="house")]),
dict(name="bob", items=[dict(name='shoe'), dict(name="pen")]),
]
owners = await Resolver.resolve([Owner.parse_obj(o) for o in owners])
Recursive Data Structure Resolution
Handle self-referential models and recursive data structures with built-in parent context access.
Compute derived fields using parent node information:
from pydantic import BaseModel
from pydantic_resolve import Resolver
class Tag(BaseModel):
name: str
full_path: str = ''
def resolve_full_path(self, parent):
if parent:
return f'{parent.full_path}/{self.name}'
else:
return self.name
children: List[Tag] = []
tag_data = dict(name='root', children=[
dict(name='a', children=[
dict(name='b', children=[
dict(name='e', chidrent=[])
])
])
])
tag = Tag.parse_obj(tag_data)
tag = await Resolver().resolve(tag)
Tree construction from flat data structures using primed loaders:
from __future__ import annotations
from collections import defaultdict
import asyncio
from typing import List
from pydantic import BaseModel
from pydantic_resolve import Resolver, LoaderDepend
from pydantic_resolve.utils.dataloader import ListEmptyLoader
roots = [{ 'id': 1, 'content': 'root' }, {'id': 6, 'content': '6'}]
records = [
{'id': 2, 'parent': 1, 'content': '2'},
{'id': 3, 'parent': 1, 'content': '3'},
{'id': 4, 'parent': 2, 'content': '4'},
{'id': 5, 'parent': 3, 'content': '5'},
{'id': 7, 'parent': 6, 'content': '7'},
]
class Tree(BaseModel):
id: int
content: str
children: List[Tree] = []
def resolve_children(self, loader=LoaderDepend(ListEmptyLoader)):
return loader.load(self.id)
async def main():
import json
loader = ListEmptyLoader()
# prime parent-child mappings for tree construction
_records = defaultdict(list)
for r in records:
_records[r['parent']].append(r)
for k, v in _records.items():
loader.prime(k, v)
trees = [Tree(**r) for r in roots]
trees = await Resolver(
loader_instances={ ListEmptyLoader: loader }
).resolve(trees)
trees = [t.dict() for t in trees]
print(json.dumps(trees, indent=2))