def init_db(app: FastAPI) -> None:
register_tortoise(
app,
db_url=os.environ.get("DATABASE_URL"),
modules={"models": ["app.models.tortoiseORM"]},
generate_schemas=False,
add_exception_handlers=False,
)
Tortoise.init_models(['app.models.tortoiseORM'], 'models')
from tortoise.models import Model
from tortoise import fields, Tortoise
class Record(Model):
id = fields.IntField(pk=True)
name = fields.CharField(max_length=255)
text = fields.TextField(blank=True, null=True)
is_important = fields.BooleanField(default=False)
create_date = fields.DatetimeField(auto_now_add=True)
edit_date = fields.DatetimeField(auto_now=True)
creator = fields.ForeignKeyField('models.User', related_name='records')
class Meta:
ordering = ['-edit_date']
Tortoise.init_models(['src.app.users.models', 'src.app.records.models'],
'models')
created_at = fields.DatetimeField(auto_now_add=True)
updated_at = fields.DatetimeField(auto_now=True)
class Meta:
"""Meta data."""
table = "assignment"
def __str__(self: "Assignment") -> str:
"""The string representative for course class."""
return f"{self.title}"
Tortoise.init_models(["teached.courses.models"], "models")
CourseListPydantic = pydantic_model_creator(
Course,
name="CourseList",
exclude=(
"id",
"overview",
"video",
"is_drift",
"is_active",
"enrollments",
"requirements",
"reviews",
"is_active",
"languages.id",
"requirements.id",
from tortoise import Tortoise Tortoise.init_models(["__main__"], "app.models")
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from tortoise import Tortoise
from tortoise.contrib.fastapi import register_tortoise
from .settings import Settings
Tortoise.init_models(["server.models"], "models")
from .routers import episode, auth
from .load_data import load_data
app = FastAPI()
app.add_middleware(
CORSMiddleware,
allow_origins=Settings.ORIGINS,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.include_router(episode)
app.include_router(auth)
@app.get("/load_data/")
async def load_data_view():
return await load_data()
TORTOISE_ORM = {
"connections": {
"""Submission models."""
from tortoise import Tortoise
from tortoise import fields
from app.models.db.base import BaseModel
class Submission(BaseModel):
"""Submission models."""
url = fields.CharField(max_length=1024, null=False)
challenge = fields.ForeignKeyField("models.Challenge", related_name="submissions")
user = fields.ForeignKeyField("models.User", related_name="submissions")
def __str__(self) -> str:
return str(self.url)
class PydanticMeta: # pylint: disable=too-few-public-methods
"""Serializations options."""
exclude_raw_fields = True
Tortoise.init_models(
["app.models.db.submission", "app.models.db.user", "app.models.db.challenge", ], "models"
) # pydantic schema hack
""" @Author: YangCheng @contact: [email protected] @Software: Y.C @Time: 2020/7/21 15:22 """ from typing import List from pydantic import BaseModel, Field from tortoise import Tortoise from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator from lib.tortoise.pydantic import json_encoders from .models import Tag, Category, Article Tortoise.init_models(["apps.blog.models"], "models") class PydanticResponse(BaseModel): index: int limit: int total: int # -*- tag -*- # Tag create/update TagCreateRequest = pydantic_model_creator(Tag, name="TagCreateRequest", exclude_readonly=True) TagCreateResponse = pydantic_model_creator(Category, name="TagCreateResponse",
meta example:
{
"album": "album name",
"key": "D♭ Major",
"camelot": "3B",
"bpm": "102",
"duration": 205
}
"""
name = fields.CharField(max_length=255, null=True)
author_name = fields.CharField(max_length=255, null=True)
cover_url = fields.CharField(max_length=255, null=True)
preview_url = fields.CharField(max_length=255, null=True)
youtube_id = fields.CharField(max_length=255, null=True)
spotify_id = fields.CharField(max_length=255, null=True)
recommended = fields.BooleanField(null=True, default=False)
meta = fields.JSONField()
def __str__(self) -> str:
return f"{self.author_name} - {self.name}"
class PydanticMeta: # pylint: disable=too-few-public-methods
"""Serializations options."""
exclude = ("challenges", )
Tortoise.init_models(["app.models.db.track"], "models") # pydantic schema hack
table = "teacher"
class Student(models.Model):
"""The student model."""
id = fields.UUIDField(pk=True)
user = fields.OneToOneField("models.User",
related_name="students",
on_delete=fields.CASCADE)
class Meta:
"""Meta data."""
table = "student"
Tortoise.init_models(["teached.users.models"], "models")
UserPydantic = pydantic_model_creator(User,
name="User",
exclude=("password", "id",
"is_superuser"))
UserPersonalInfoPydantic = pydantic_model_creator(
User,
name="UserIn",
include=("full_name", "phone_number", "bio"),
exclude_readonly=True,
)
class Meta:
table = "answers"
class Subject(Model):
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")
from tortoise.models import Model from tortoise import fields from tortoise.fields import data from tortoise.contrib.pydantic import pydantic_model_creator import uuid from datetime import datetime from tortoise import Tortoise from models.user import User, Room Tortoise.init_models(["models.room"], "models") Room_Pydantic = pydantic_model_creator(Room, name="Room")
from fastapi_users import models
from tortoise import Tortoise
from tortoise.contrib.pydantic import PydanticModel
from fastapi_users.db import TortoiseUserDatabase
from config import DBPaths
from src.users.models import UserModel
Tortoise.init_models(DBPaths.users, 'models')
class User(models.BaseUser, PydanticModel):
class Config:
orm_mode = True
orig_model = UserModel
class UserCreate(models.BaseUserCreate):
pass
class UserUpdate(User, models.BaseUserUpdate):
pass
class UserDB(User, models.BaseUserDB):
pass
user_db = TortoiseUserDatabase(UserDB, UserModel)
# ADD - init
launch_tools.init_from_func(folder_scripts='__fast_api_app/init',
func_name='first_init')
if getattr(GeneralConfig, 'FAST_API_EXT_LAUNCH', None):
for launch_folder in GeneralConfig.FAST_API_EXT_LAUNCH:
launch_tools.init_from_func(folder_scripts=launch_folder,
func_name='first_init')
if FastApiConfig in GeneralConfig.__bases__ and GeneralConfig.DEFAULT_DB_URI:
# Чтобы работал педантик и прочие радости
from tortoise import Tortoise
from .__tools import tortoise as tor_tools
Tortoise.init_models(['aerich.models', *tor_tools.models_inspector()],
'models')
APP_INIT = True
"""
Отдельное приложение под названием "Предварительная инициализация".
Зачем? ASGI слишком крут - и может порвать в щепки файловую систему.
Поэтому всё что нужно сделать с файлами и даже с БД лучше делать заранее.
Тоесть любая важная подготовка файлов - их интроспекция и первоначальные объекты в системе -
создавать тут.
"""
def pre_launch():
"""
Отдельная инициализация от самого приложения -
фактически именно в этом скрипте, запущенным ДО старта ASGI
# Settings
from config import settings
# Pydantic
from pydantic import BaseModel, Field
# Tortoise ORM
from tortoise import Tortoise
from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator
# Models
from .models import Angel, Contact
# Init models to get all related fields
Tortoise.init_models(settings.DB_PATHS, app_label="models")
###################
# Contact Schemas #
###################
ContactDto = pydantic_model_creator(
Contact,
exclude=(
"id",
"angel",
"angel_id",
"created",
"updated",
),
)
def tutor_id(self) -> int:
return self.tutor.id
def student_ids(self) -> List[int]:
try:
return [student.id for student in self.students]
except NoValuesFetched:
return []
class PydanticMeta:
exclude = ["tutor", "students"]
computed = ("tutor_id", "student_ids")
Tortoise.init_models(["app.models.tortoise"], "models")
User_Pydnatic = pydantic_model_creator(User, name="User")
_UserIn_Pydnatic = pydantic_model_creator(User,
name="UserIn",
exclude_readonly=True)
Category_Pydnatic = pydantic_model_creator(Category, name="Category")
_CategoryIn_Pydnatic = pydantic_model_creator(Category,
name="CategoryIn",
exclude_readonly=True)
Review_Pydnatic = pydantic_model_creator(Review, name="Reviews")
ReviewIn_Pydnatic = pydantic_model_creator(Review,
name="ReviewIn",
exclude_readonly=True)
exclude = ('comments', )
class Comment(models.Model):
""" Comment class """
user: fields.ForeignKeyRelation['User'] = fields.ForeignKeyField(
'models.User', related_name="comments", on_delete=fields.CASCADE)
post: fields.ForeignKeyRelation[Post] = fields.ForeignKeyField(
'models.Post', related_name="comments", on_delete=fields.CASCADE)
parent: fields.ForeignKeyNullableRelation[
'Comment'] = fields.ForeignKeyField("models.Comment",
on_delete=fields.SET_NULL,
null=True,
related_name='children')
text = fields.TextField(max_length=2000)
create_at = fields.DatetimeField(auto_now_add=True)
update_at = fields.DatetimeField(auto_now=True)
is_published = fields.BooleanField(default=True)
is_deleted = fields.BooleanField(default=False)
children: fields.ReverseRelation["Comment"]
def __str__(self):
return "{} - {}".format(self.user, self.post)
class PydanticMeta:
exclude = ('post', )
Tortoise.init_models(["src.app.blog.models"], "models")
'models.User', related_name='projects', through="team_project")
class PydanticMeta:
backward_relations = False
exclude = ["category__children"]
class Task(models.Model):
""" Model task by project
"""
description = fields.TextField()
create_date = fields.DatetimeField(auto_now_add=True)
start_date = fields.DatetimeField(null=True)
end_date = fields.DatetimeField(null=True)
project = fields.ForeignKeyField('models.Project', related_name='tasks')
worker = fields.ForeignKeyField('models.User',
related_name='tasks',
null=True)
class CommentTask(models.Model):
""" Model comment by task
"""
user = fields.ForeignKeyField('models.User', related_name='task_comments')
task = fields.ForeignKeyField('models.Task', related_name='comments')
message = fields.CharField(max_length=1000)
create_date = fields.DatetimeField(auto_now_add=True)
Tortoise.init_models(["src.app.board.models"], "models")
from tortoise import Tortoise Tortoise.init_models(["_models_"], "models")
from tortoise import Tortoise
from tortoise.contrib.pydantic import pydantic_model_creator
from .role import Role
from .user import User
# Initialize model relationships
Tortoise.init_models(["src.models"], "models")
# User serialization
UserPydantic = pydantic_model_creator(User, exclude=("role",))
UserWithRelations = pydantic_model_creator(User, name="UserWithRelations")
# Role serialization
RolePydantic = pydantic_model_creator(Role, exclude=("users",))
RoleWithRelations = pydantic_model_creator(Role, name="RoleWithRelations")
'user.confirmation')
class BaseProfile(BaseModel):
first_name: str
last_name: str
class CreateProfile(BaseProfile):
user_id: str
class UpdateProfile(BaseProfile):
pass
class ProfileAddCity(BaseModel):
cities: list[int]
class ProfileMe(BaseProfile):
cities: CreateCity
Tortoise.init_models(settings.MODELS, 'models')
Profile_Pydantic = pydantic_model_creator(Profile, name='Profile')
ProfileIn_Pydantic = pydantic_model_creator(Profile,
name='Profile',
exclude_readonly=True)
from tortoise import Tortoise from .models import Comment, Post, User Tortoise.init_models([__name__], "models")
video_url = fields.CharField(200)
type = fields.ForeignKeyField('models.SessionType')
flags = fields.ManyToManyField('models.Flag', related_name='sessions')
def registered_people(self) -> int:
return 1 # todo -> 1 is dummy value
class PydanticMeta:
computed = ('registered_people', )
Tortoise.init_models(["main"], "models")
Session_Pydantic = pydantic_model_creator(Session, name='Session')
SessionIn_Pydantic = pydantic_model_creator(Session, name='SessionIn', exclude_readonly=True)
from pprint import pprint
pprint(Session_Pydantic.schema())
pprint(SessionIn_Pydantic.schema())
SessionType_Pydantic = pydantic_model_creator(SessionType, name='SessionType')
SessionTypeIn_Pydantic = pydantic_model_creator(SessionType, name='SessionTypeIn', exclude_readonly=True)
Flag_Pydantic = pydantic_model_creator(Flag, name='Flag')
FlagIn_Pydantic = pydantic_model_creator(Flag, name='FlagIn', exclude_readonly=True)
from tortoise import fields, Tortoise
from tortoise.models import Model
from src.app.utils.enums import UserRole
from src.app.base.absctract_models import UserAbstract
class User(UserAbstract):
role = fields.IntEnumField(enum_type=UserRole)
def __str__(self) -> str:
return self.email
Tortoise.init_models(['src.app.user.models'], 'models')
class PydanticMeta:
max_recursion = 1
class Report(AbstractModel):
data = fields.JSONField(description="报告内容")
tasks = fields.ForeignKeyField('models.Task', related_name='Reports')
start = fields.CharField(description="测试开始时间", max_length=255)
end = fields.CharField(description="测试结束时间", max_length=255)
class PydanticMeta:
max_recursion = 1
# 解决pydantic_model_creator 生成的模型中 缺少外键关联字段
Tortoise.init_models(["db.models"], "models")
# 返回模型
User_Pydantic = pydantic_model_creator(User, name="User", exclude=["password"])
# 输入模型 exclude_readonly 只读字段 非必填
UserIn_Pydantic = pydantic_model_creator(User,
name="UserIn",
exclude=["avatar"],
exclude_readonly=True)
Project_Pydantic = pydantic_model_creator(Project, name="Project")
ProjectIn_Pydantic = pydantic_model_creator(Project,
name="ProjectIn",
exclude_readonly=True)
from ..planner.endpoints import planner_endpoints
from ..baby_tracker.endpoints import router as baby_router
# Create ASGI app:
app = FastAPI()
app.include_router(authentication.router)
app.include_router(secrets_router)
app.include_router(heating_endpoints.router)
app.include_router(crud_endpoints.router)
app.include_router(planner_endpoints.router)
app.include_router(baby_router)
# CORS Permissions:
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# Register tortoise-orm models:
Tortoise.init_models(["api.db.models", "api.baby_tracker.models"], "models")
register_tortoise(
app,
db_url=f"sqlite://{os.path.abspath(os.getcwd())}/api/db/db.sqlite3",
modules={"models": ["api.db.models", "api.baby_tracker.models"]},
generate_schemas=True,
add_exception_handlers=True,
)
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import asyncio
import json
from tortoise import Tortoise
from distrobuild_scheduler.sigul import check_sigul_key
Tortoise.init_models(["distrobuild.models"], "distrobuild")
from distrobuild.settings import TORTOISE_ORM, settings
from distrobuild.session import message_cipher
# noinspection PyUnresolvedReferences
from distrobuild_scheduler import init_channel, build_package, import_package, logger, periodic_tasks, merge_scratch
async def consume_messages(i: int):
from distrobuild_scheduler import channel
queue = await channel.declare_queue(settings.routing_key,
auto_delete=False)
async with queue.iterator() as queue_iter:
if self.start_time.date() == datetime.today().date():
return True
else:
return False
class User(Model):
id = fields.UUIDField(pk=True)
# identifier = fields.UUIDField()
anonymous = fields.BooleanField(default=False)
name = fields.CharField(max_length=50)
email = fields.CharField(max_length=50)
username = fields.CharField(max_length=50)
current_room: fields.ForeignKeyRelation[Room] = fields.ForeignKeyField(
"models.Room", related_name="users", null=True)
teams: fields.ManyToManyRelation[Team] = fields.ManyToManyField(
"models.Team", related_name="members", through="user_team", default=[])
async def change_room(self, room: Room):
self.current_room = room
await self.save()
async def leave_room(self, room: Room):
await self.current_room
Tortoise.init_models(["models.user"], "models")
User_Pydantic = pydantic_model_creator(User, name="user")
def test_early_init(self):
self.maxDiff = None
Event_TooEarly = pydantic_model_creator(Event)
self.assertEqual(
Event_TooEarly.schema(),
{
"title": "Event",
"type": "object",
"description": "The Event model docstring.<br/><br/>This is multiline docs.",
"properties": {
"id": {"title": "Id", "type": "integer", "maximum": 2147483647, "minimum": 1},
"name": {
"title": "Name",
"type": "string",
"description": "The Event NAME<br/>It's pretty important",
"maxLength": 255,
},
"created_at": {
"title": "Created At",
"type": "string",
"format": "date-time",
"readOnly": True,
},
},
"required": ["id", "name", "created_at"],
"additionalProperties": False,
},
)
self.assertEqual(
Event.describe(),
{
"name": "None.Event",
"app": None,
"table": "",
"abstract": False,
"description": "The Event model docstring.",
"docstring": "The Event model docstring.\n\nThis is multiline docs.",
"unique_together": [],
"indexes": [],
"pk_field": {
"name": "id",
"field_type": "IntField",
"db_column": "id",
"python_type": "int",
"generated": True,
"nullable": False,
"unique": True,
"indexed": True,
"default": None,
"description": None,
"docstring": None,
"constraints": {"ge": 1, "le": 2147483647},
"db_field_types": {"": "INT"},
},
"data_fields": [
{
"name": "name",
"field_type": "CharField",
"db_column": "name",
"python_type": "str",
"generated": False,
"nullable": False,
"unique": False,
"indexed": False,
"default": None,
"description": "The Event NAME",
"docstring": "The Event NAME\nIt's pretty important",
"constraints": {"max_length": 255},
"db_field_types": {"": "VARCHAR(255)"},
},
{
"name": "created_at",
"field_type": "DatetimeField",
"db_column": "created_at",
"python_type": "datetime.datetime",
"generated": False,
"nullable": False,
"unique": False,
"indexed": False,
"default": None,
"description": None,
"docstring": None,
"constraints": {"readOnly": True},
"db_field_types": {
"": "TIMESTAMP",
"mssql": "DATETIME2",
"mysql": "DATETIME(6)",
"postgres": "TIMESTAMPTZ",
"oracle": "TIMESTAMP WITH TIME ZONE",
},
"auto_now_add": True,
"auto_now": False,
},
],
"fk_fields": [
{
"name": "tournament",
"field_type": "ForeignKeyFieldInstance",
"python_type": "None",
"generated": False,
"nullable": True,
"unique": False,
"indexed": False,
"default": None,
"description": None,
"docstring": None,
"constraints": {},
"raw_field": None,
"on_delete": "CASCADE",
"db_constraint": True,
}
],
"backward_fk_fields": [],
"o2o_fields": [],
"backward_o2o_fields": [],
"m2m_fields": [],
},
)
Tortoise.init_models(["tests.test_early_init"], "models")
Event_Pydantic = pydantic_model_creator(Event)
self.assertEqual(
Event_Pydantic.schema(),
{
"title": "Event",
"type": "object",
"description": "The Event model docstring.<br/><br/>This is multiline docs.",
"properties": {
"id": {"title": "Id", "type": "integer", "maximum": 2147483647, "minimum": 1},
"name": {
"title": "Name",
"type": "string",
"description": "The Event NAME<br/>It's pretty important",
"maxLength": 255,
},
"created_at": {
"title": "Created At",
"type": "string",
"format": "date-time",
"readOnly": True,
},
"tournament": {
"title": "Tournament",
"nullable": True,
"allOf": [{"$ref": "#/definitions/tests.test_early_init.Tournament.leaf"}],
},
},
"definitions": {
"tests.test_early_init.Tournament.leaf": {
"title": "Tournament",
"type": "object",
"properties": {
"id": {
"title": "Id",
"type": "integer",
"maximum": 2147483647,
"minimum": 1,
},
"name": {"title": "Name", "type": "string", "maxLength": 100},
"created_at": {
"title": "Created At",
"type": "string",
"format": "date-time",
"readOnly": True,
},
},
"required": ["id", "name", "created_at"],
"additionalProperties": False,
}
},
"required": ["id", "name", "created_at"],
"additionalProperties": False,
},
)
self.assertEqual(
Event.describe(),
{
"name": "models.Event",
"app": "models",
"table": "event",
"abstract": False,
"description": "The Event model docstring.",
"docstring": "The Event model docstring.\n\nThis is multiline docs.",
"unique_together": [],
"indexes": [],
"pk_field": {
"name": "id",
"field_type": "IntField",
"db_column": "id",
"db_field_types": {"": "INT"},
"python_type": "int",
"generated": True,
"nullable": False,
"unique": True,
"indexed": True,
"default": None,
"description": None,
"docstring": None,
"constraints": {"ge": 1, "le": 2147483647},
},
"data_fields": [
{
"name": "name",
"field_type": "CharField",
"db_column": "name",
"db_field_types": {"": "VARCHAR(255)"},
"python_type": "str",
"generated": False,
"nullable": False,
"unique": False,
"indexed": False,
"default": None,
"description": "The Event NAME",
"docstring": "The Event NAME\nIt's pretty important",
"constraints": {"max_length": 255},
},
{
"name": "created_at",
"field_type": "DatetimeField",
"db_column": "created_at",
"db_field_types": {
"": "TIMESTAMP",
"mssql": "DATETIME2",
"mysql": "DATETIME(6)",
"postgres": "TIMESTAMPTZ",
"oracle": "TIMESTAMP WITH TIME ZONE",
},
"python_type": "datetime.datetime",
"generated": False,
"nullable": False,
"unique": False,
"indexed": False,
"default": None,
"description": None,
"docstring": None,
"constraints": {"readOnly": True},
"auto_now_add": True,
"auto_now": False,
},
{
"name": "tournament_id",
"field_type": "IntField",
"db_column": "tournament_id",
"db_field_types": {"": "INT"},
"python_type": "int",
"generated": False,
"nullable": True,
"unique": False,
"indexed": False,
"default": None,
"description": None,
"docstring": None,
"constraints": {"ge": 1, "le": 2147483647},
},
],
"fk_fields": [
{
"name": "tournament",
"field_type": "ForeignKeyFieldInstance",
"raw_field": "tournament_id",
"python_type": "models.Tournament",
"generated": False,
"nullable": True,
"on_delete": "CASCADE",
"unique": False,
"indexed": False,
"default": None,
"description": None,
"docstring": None,
"constraints": {},
"db_constraint": True,
}
],
"backward_fk_fields": [],
"o2o_fields": [],
"backward_o2o_fields": [],
"m2m_fields": [],
},
)
from tortoise import Tortoise, fields
class User(Model):
id = fields.IntField(pk=True)
username = fields.CharField(50, unique=True)
password_hash = fields.CharField(128)
items = fields.ReverseRelation['Item']
@classmethod
async def get_user(cls, username):
return cls.get(username=username)
def verify_password(self, password):
return bcrypt.verify(password, self.password_hash)
class PydanticMeta:
exclude = []
class Item(Model):
id = fields.IntField(pk=True)
name = fields.CharField(150)
user: fields.ForeignKeyRelation[User] = fields.ForeignKeyField(
"models.User", related_name="items")
Tortoise.init_models(['api.models'], 'models')
