async def test_bulk(
bulk_in: BulkIn,
model=Depends(get_model)
):
qs = model.filter(pk__in=bulk_in.pk_list)
pydantic = pydantic_queryset_creator(model)
ret = await pydantic.from_queryset(qs)
return ret.dict()
async def run():
await Tortoise.init(db_url="sqlite://:memory:",
modules={"models": ["__main__"]})
await Tortoise.generate_schemas()
Event_Pydantic = pydantic_model_creator(Event)
Event_Pydantic_List = pydantic_queryset_creator(Event)
Tournament_Pydantic = pydantic_model_creator(Tournament)
Team_Pydantic = pydantic_model_creator(Team)
# print(Event_Pydantic_List.schema_json(indent=4))
# print(Event_Pydantic.schema_json(indent=4))
# print(Tournament_Pydantic.schema_json(indent=4))
# print(Team_Pydantic.schema_json(indent=4))
tournament = await Tournament.create(name="New Tournament")
tournament2 = await Tournament.create(name="Old Tournament")
await Event.create(name="Empty")
event = await Event.create(name="Test", tournament=tournament)
event2 = await Event.create(name="TestLast", tournament=tournament)
event3 = await Event.create(name="Test2", tournament=tournament2)
await Address.create(city="Santa Monica", street="Ocean", event=event)
await Address.create(city="Somewhere Else", street="Lane", event=event2)
team1 = await Team.create(name="Onesies")
team2 = await Team.create(name="T-Shirts")
team3 = await Team.create(name="Alternates")
await event.participants.add(team1, team2, team3)
await event2.participants.add(team1, team2)
await event3.participants.add(team1, team3)
p = await Event_Pydantic.from_tortoise_orm(await Event.get(name="Test"))
print("One Event:", p.json(indent=4))
p = await Tournament_Pydantic.from_tortoise_orm(
await Tournament.get(name="New Tournament"))
print("One Tournament:", p.json(indent=4))
p = await Team_Pydantic.from_tortoise_orm(await Team.get(name="Onesies"))
print("One Team:", p.json(indent=4))
pl = await Event_Pydantic_List.from_queryset(
Event.filter(address__event_id__isnull=True))
print("All Events without addresses:", pl.json(indent=4))
date = fields.DatetimeField()
# image = fields.CharField(max_length=1000)
# owner: fields.ForeignKeyRelation['User'] = fields.ForeignKeyField(
# 'models.User', related_name='items'
# )
def min_price(self) -> float:
return self.price + ((self.price * self.min_per)/100)
def mid_price(self) -> float:
mid = (self.max_per + self.min_per)/2
return self.price + ((self.price * mid)/100)
def max_price(self) -> float:
return self.price + ((self.price * self.max_per)/100)
class PydanticMeta:
computed = ("min_price", "mid_price", "max_price")
"""Пользователи"""
UserPydantic = pydantic_model_creator(User, name="User")
UserInPydantic = pydantic_model_creator(User, name="UserIn", exclude_readonly=True)
UserPydanticList = pydantic_queryset_creator(User)
UserInPydanticList = pydantic_queryset_creator(User, include=('id',))
"""Продукт"""
ItemPydantic = pydantic_model_creator(Item, name="Items")
ItemInPydantic = pydantic_model_creator(Item, name="ItemsIn", exclude_readonly=True)
ItemPydanticList = pydantic_queryset_creator(Item)
id = fields.IntField(pk=True)
email = fields.CharField(max_length=100, unique=True)
hashed_password = fields.CharField(max_length=1000)
is_active = fields.BooleanField(default=True)
# При сохранении хеширование пароля по умолчанию
async def save(self, *args, **kwargs) -> None:
self.hashed_password = "******"
await super().save(*args, **kwargs)
class PydanticMeta:
exclude = ['hashed_password']
class Item(models.Model):
"""Модель items"""
id = fields.IntField(pk=True)
title = fields.CharField(max_length=100)
description = fields.TextField()
owner = fields.ForeignKeyField('models.User', related_name='items')
class PydanticMeta:
allow_cycles = False
UserPydantic = pydantic_model_creator(User, name="User")
UserInPydantic = pydantic_model_creator(User, name="UserIn", exclude_readonly=True)
UserPydanticList = pydantic_queryset_creator(User)
ItemPydantic = pydantic_model_creator(Item, name="Items")
class JobListOut(BaseModel):
rows: pydantic_queryset_creator(Job)
total: int
# -*- tag -*-
# Tag create/update
TagCreateRequest = pydantic_model_creator(Tag,
name="TagCreateRequest",
exclude_readonly=True)
TagCreateResponse = pydantic_model_creator(Category,
name="TagCreateResponse",
exclude=["articles"])
TagCreateResponse.Config.json_encoders = json_encoders
# Tag List
TagListSerializer = pydantic_queryset_creator(Tag,
name="TagListSerializer",
exclude=["articles"])
class TagListResponse(PydanticResponse):
results: List[TagListSerializer]
class TagResponse(BaseModel):
id: int
name: str
# -*- Category -*-
# Category create/update
CategoryCreateRequest = pydantic_model_creator(Category,
@staticmethod
async def get_weather_for_cities(cities: list) -> None:
tasks = []
for city in cities:
task = asyncio.create_task(City.get_weather(city))
tasks.append(task)
await asyncio.gather(*tasks)
class PydanticMeta:
computed = ('weather', )
class CreateCity(BaseModel):
title: str
class CityAll(BaseModel):
id: int
title: str
Tortoise.init_models(settings.MODELS, 'models')
City_Pydantic = pydantic_model_creator(City, name='City')
CityIn_Pydantic = pydantic_model_creator(City,
name='City',
exclude_readonly=True)
City_Pydantic_List = pydantic_queryset_creator(City)
Business,
CustomerDepositTransaction,
DebitTransaction,
TransactionStatus,
)
# Customer
InputCustomerSchema = pydantic_model_creator(Customer,
exclude=("id", "wallets",
"created_at",
"modified_at"))
OutputCustomerSchema = pydantic_model_creator(Customer)
# CustomerWallet
OutputCustomerWalletSchema = pydantic_model_creator(CustomerWallet)
OutputCustomerWalletListSchema = pydantic_queryset_creator(CustomerWallet)
# Business
InputBusinessSchema = pydantic_model_creator(Business,
exclude=("id", "wallets",
"created_at",
"modified_at"))
OutputBusinessSchema = pydantic_model_creator(Business)
# BusinessWallet
OutputBusinessWalletSchema = pydantic_model_creator(BusinessWallet)
# CustomerDepositTransaction
InputDepositTransactionSchema = pydantic_model_creator(
CustomerDepositTransaction,
exclude=("id", "customer_wallet", "created_at", "status", "error"),
This references a Tournament
"""
id = fields.IntField(pk=True)
name = fields.CharField(max_length=100)
#: The date-time the Tournament record was created at
created_at = fields.DatetimeField(auto_now_add=True)
class Meta:
# Define the default ordering
# the pydantic serialiser will use this to order the results
ordering = ["name"]
# Create a list of models for population from a queryset.
Tournament_Pydantic_List = pydantic_queryset_creator(Tournament)
# Print JSON-schema
print(Tournament_Pydantic_List.schema_json(indent=4))
async def run():
await Tortoise.init(db_url="sqlite://:memory:", modules={"models": ["__main__"]})
await Tortoise.generate_schemas()
# Create objects
await Tournament.create(name="New Tournament")
await Tournament.create(name="Another")
await Tournament.create(name="Last Tournament")
# Serialise it
tourpy = await Tournament_Pydantic_List.from_queryset(Tournament.all())
# pylint: skip-file
"""Text pydantic schemas"""
from typing import List
from pydantic.main import BaseModel
from tortoise.contrib.pydantic import pydantic_model_creator
from tortoise.contrib.pydantic import pydantic_queryset_creator
from app.models.db import Text
TextOut = pydantic_model_creator(Text, name="Text")
TextList = pydantic_queryset_creator(Text, name="TextList")
class TextListOut(BaseModel):
count: int
items: List[TextOut] # type: ignore
title = fields.CharField(max_length=300)
class Meta:
table = "posts"
def datatype(self) -> str:
return "posts"
Post_Pydantic = pydantic_model_creator(Posts, name="Post")
PostIn_Pydantic = pydantic_model_creator(Posts,
name="PostIn",
exclude_readonly=True)
PostsList_Pydantic = pydantic_queryset_creator(
Posts,
name="Posts_List_Query",
include=(tuple(["fetched_utc"])),
computed=(tuple(["fetched_utc_ts", "datatype", "datapath"])),
)
Posts_Display = pydantic_model_creator(
Posts,
name="Posts_Display_Model",
exclude=(tuple(["fetched_utc", "created_utc"])),
)
class Comments(Basedatamodel):
"""
The Comments model
"""
from datetime import datetime
from typing import Any
from typing import Dict
from typing import List
from typing import Optional
from uuid import UUID
from pydantic import BaseModel
from pydantic import validator
from tortoise.contrib.pydantic import pydantic_model_creator
from tortoise.contrib.pydantic import pydantic_queryset_creator
from app.models.db.challenge import Challenge
ChallengeOut = pydantic_model_creator(Challenge, name="Challenge")
ChallengeList = pydantic_queryset_creator(Challenge, name="ChallengeList")
class ChallengeListOut(BaseModel):
count: int
items: List[ChallengeOut] # type: ignore
class ChallengeIn(BaseModel):
name: str
challenge_end: datetime
vote_end: datetime
is_public: bool = True
is_open: bool = True
track_id: UUID
from models import Users, Image, Faces
from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator
User_Pydantic = pydantic_model_creator(Users, name="User")
UserIn_Pydantic = pydantic_model_creator(Users,
name="UserIn",
exclude_readonly=True)
Image_Pydantic = pydantic_model_creator(Image, name="Image")
Faces_Pydantic_List = pydantic_queryset_creator(Faces)
Faces_Pydantic = pydantic_model_creator(Faces)
from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator from app.models.models import User # build `Pydantic Model` User_Pydantic = pydantic_model_creator(User) User_Pydantic_List = pydantic_queryset_creator(User)
# pylint: skip-file
"""User pydantic schemas"""
from typing import List
from pydantic import BaseModel
from tortoise.contrib.pydantic import pydantic_model_creator
from tortoise.contrib.pydantic import pydantic_queryset_creator
from app.models.db.user import User
UserOut = pydantic_model_creator(User, name="User")
UserIn = pydantic_model_creator(User, name="UserIn", exclude_readonly=True)
UserList = pydantic_queryset_creator(User, name="UserList")
class UserListOut(BaseModel):
count: int
items: List[UserOut] # type: ignore
'''
Description:
Version: 1.0
Autor: Moyu
Date: 2020-11-24 14:42:46
LastEditors: Moyu
LastEditTime: 2020-11-25 16:36:30
'''
from typing import Any, List
import models
from pydantic import BaseModel
from schemas.response import AbstractPageResult, AbstractResponse
from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator
SysUserResponse = pydantic_model_creator(models.SysUser, exclude=['password'])
SysUserListResponse = pydantic_queryset_creator(models.SysUser, exclude=['password'])
class LoginResponse(AbstractResponse):
user: SysUserResponse
token: str
expires_at: int
class UserListResponse(AbstractPageResult):
items: SysUserListResponse = []
AngelCreateDtoBase = pydantic_model_creator(
Angel,
exclude=(
"id",
"guardian",
"contacts",
"address",
"guardian_id",
"address_id",
"created",
"updated",
),
)
AngelListDto = pydantic_queryset_creator(Angel, exclude=("guardian", ))
class AngelDto(AngelDtoBase):
"""Angel Schema."""
photo: str = Field("",
example="https://mosine.googlestorage.2515-1515-145")
address: AddressDto
surgeries: List[str] = Field(...)
alergies: List[str] = Field(...)
medicines: List[str] = Field(...)
contacts: List[ContactDtoAngel]
class AngelCreateDto(AngelCreateDtoBase):
id = fields.IntField(pk=True)
name = fields.CharField(max_length=50, unique=True, null=False)
questions: fields.ReverseRelation["Question"]
class Meta:
table = "subjects"
Tortoise.init_models(["database.models"], "models")
User_Pydantic = pydantic_model_creator(User, name="User", exclude=("password",))
UserIn_Pydantic = pydantic_model_creator(User, name="UserIn", exclude_readonly=True)
Quiz_Pydantic = pydantic_model_creator(Quiz, name="Quiz")
QuizIn_Pydantic = pydantic_model_creator(Quiz, name="QuizIn", exclude_readonly=True)
Quiz_Pydantic_List = pydantic_queryset_creator(Quiz)
Question_Pydantic = pydantic_model_creator(Question, name="Question")
QuestionIn_Pydantic = pydantic_model_creator(Question, name="QuestionIn", exclude_readonly=True)
QuizQuestion_Pydantic = pydantic_model_creator(Question, name="QuizQuestion")
QuizQuestionIn_Pydantic = pydantic_model_creator(Question, name="QuizQuestionIn", exclude_readonly=True)
Answer_Pydantic = pydantic_model_creator(Answer, name="Answer")
AnswerIn_Pydantic = pydantic_model_creator(Answer, name="AnswerIn", exclude_readonly=True)
Subject_Pydantic = pydantic_model_creator(Subject, name="Subject", exclude=("questions",))
SubjectIn_Pydantic = pydantic_model_creator(Subject, name="SubjectIn", exclude_readonly=True)
Subject_Pydantic_List = pydantic_queryset_creator(Subject, sort_alphabetically=True, exclude=("questions",))
import re
from typing import List
from pydantic import validator
from pydantic.main import BaseModel
from tortoise.contrib.pydantic import pydantic_model_creator
from tortoise.contrib.pydantic import pydantic_queryset_creator
from app.models.db import Submission
SOUNDCLOUD_REGEX = re.compile(
r"https://soundcloud.com/[a-zA-Z-0-9]*/[A-Za-z-0-9]*")
SubmissionOut = pydantic_model_creator(Submission, name="Submission")
SubmissionList = pydantic_queryset_creator(Submission, name="SubmissionList")
class SubmissionListOut(BaseModel):
count: int
items: List[SubmissionOut] # type: ignore
class SubmissionIn(BaseModel):
url: str
@validator("url")
def url_is_soundcloud(cls, value: str) -> str:
if SOUNDCLOUD_REGEX.findall(value):
return value
# pylint: skip-file
"""Vote pydantic schemas"""
from typing import List
from uuid import UUID
from pydantic.main import BaseModel
from tortoise.contrib.pydantic import pydantic_model_creator
from tortoise.contrib.pydantic import pydantic_queryset_creator
from app.models.db import Vote
VoteOut = pydantic_model_creator(Vote, name="Vote")
VoteList = pydantic_queryset_creator(Vote, name="VoteList")
class VoteListOut(BaseModel):
count: int
items: List[VoteOut] # type: ignore
class VoteIn(BaseModel):
submission_id: UUID
class VoteCount(BaseModel):
count: int
"id",
"parent",
"created_at",
"updated_at",
"deleted_at",
"sort",
"title",
"icon",
"keep_alive",
),
computed=("meta", ),
)
print(SysMenu_Pydantic.schema_json())
SysMenu_List_Pydantic = pydantic_queryset_creator(
SysMenu,
exclude=(
"id",
"parent",
"created_at",
"updated_at",
"deleted_at",
"sort",
"title",
"icon",
"keep_alive",
),
computed=("meta", ),
allow_cycles=True,
)
from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator
from historedge_backend.models import User, Page, PageVisit
InputUserSchema = pydantic_model_creator(User,
exclude=("id", "created_at",
"modified_at"))
OutputUserSchema = pydantic_model_creator(User)
OutputPageListSchema = pydantic_queryset_creator(Page)
OutputPageVisitListSchema = pydantic_queryset_creator(PageVisit)
