code stringlengths 110 18.9k | apis list | extract_api stringlengths 123 24.4k |
|---|---|---|
from typing import Optional
from sqlalchemy import create_engine, select
from sqlalchemy.orm import Session
from sqlmodel import Field, SQLModel
def test_allow_instantiation_without_arguments(clear_sqlmodel):
class Item(SQLModel):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
description: Optional[str] = None
class Config:
table = True
engine = create_engine("sqlite:///:memory:")
SQLModel.metadata.create_all(engine)
with Session(engine) as db:
item = Item()
item.name = "Rick"
db.add(item)
db.commit()
result = db.execute(select(Item)).scalars().all()
assert len(result) == 1
assert isinstance(item.id, int)
SQLModel.metadata.clear()
| [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.SQLModel.metadata.clear"
] | [((426, 461), 'sqlalchemy.create_engine', 'create_engine', (['"""sqlite:///:memory:"""'], {}), "('sqlite:///:memory:')\n", (439, 461), False, 'from sqlalchemy import create_engine, select\n'), ((466, 502), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (494, 502), False, 'from sqlmodel import Field, SQLModel\n'), ((751, 776), 'sqlmodel.SQLModel.metadata.clear', 'SQLModel.metadata.clear', ([], {}), '()\n', (774, 776), False, 'from sqlmodel import Field, SQLModel\n'), ((266, 303), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (271, 303), False, 'from sqlmodel import Field, SQLModel\n'), ((512, 527), 'sqlalchemy.orm.Session', 'Session', (['engine'], {}), '(engine)\n', (519, 527), False, 'from sqlalchemy.orm import Session\n'), ((653, 665), 'sqlalchemy.select', 'select', (['Item'], {}), '(Item)\n', (659, 665), False, 'from sqlalchemy import create_engine, select\n')] |
"""Initial
Revision ID: ec941f1f8242
Revises: <PASSWORD>
Create Date: 2021-10-10 18:34:18.294594
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = '<KEY>'
down_revision = 'd<PASSWORD>'
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('plant',
sa.Column('id', sa.Integer(), nullable=True),
sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_plant_id'), 'plant', ['id'], unique=False)
op.create_index(op.f('ix_plant_name'), 'plant', ['name'], unique=False)
op.drop_index('ix_hero_age', table_name='hero')
op.drop_index('ix_hero_id', table_name='hero')
op.drop_index('ix_hero_name', table_name='hero')
op.drop_index('ix_hero_secret_name', table_name='hero')
op.drop_table('hero')
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('hero',
sa.Column('birth_date', sa.DATETIME(), nullable=True),
sa.Column('id', sa.INTEGER(), nullable=True),
sa.Column('name', sa.VARCHAR(), nullable=False),
sa.Column('secret_name', sa.VARCHAR(), nullable=False),
sa.Column('age', sa.INTEGER(), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_index('ix_hero_secret_name', 'hero', ['secret_name'], unique=False)
op.create_index('ix_hero_name', 'hero', ['name'], unique=False)
op.create_index('ix_hero_id', 'hero', ['id'], unique=False)
op.create_index('ix_hero_age', 'hero', ['age'], unique=False)
op.drop_index(op.f('ix_plant_name'), table_name='plant')
op.drop_index(op.f('ix_plant_id'), table_name='plant')
op.drop_table('plant')
# ### end Alembic commands ###
| [
"sqlmodel.sql.sqltypes.AutoString"
] | [((726, 773), 'alembic.op.drop_index', 'op.drop_index', (['"""ix_hero_age"""'], {'table_name': '"""hero"""'}), "('ix_hero_age', table_name='hero')\n", (739, 773), False, 'from alembic import op\n'), ((778, 824), 'alembic.op.drop_index', 'op.drop_index', (['"""ix_hero_id"""'], {'table_name': '"""hero"""'}), "('ix_hero_id', table_name='hero')\n", (791, 824), False, 'from alembic import op\n'), ((829, 877), 'alembic.op.drop_index', 'op.drop_index', (['"""ix_hero_name"""'], {'table_name': '"""hero"""'}), "('ix_hero_name', table_name='hero')\n", (842, 877), False, 'from alembic import op\n'), ((882, 937), 'alembic.op.drop_index', 'op.drop_index', (['"""ix_hero_secret_name"""'], {'table_name': '"""hero"""'}), "('ix_hero_secret_name', table_name='hero')\n", (895, 937), False, 'from alembic import op\n'), ((942, 963), 'alembic.op.drop_table', 'op.drop_table', (['"""hero"""'], {}), "('hero')\n", (955, 963), False, 'from alembic import op\n'), ((1429, 1506), 'alembic.op.create_index', 'op.create_index', (['"""ix_hero_secret_name"""', '"""hero"""', "['secret_name']"], {'unique': '(False)'}), "('ix_hero_secret_name', 'hero', ['secret_name'], unique=False)\n", (1444, 1506), False, 'from alembic import op\n'), ((1511, 1574), 'alembic.op.create_index', 'op.create_index', (['"""ix_hero_name"""', '"""hero"""', "['name']"], {'unique': '(False)'}), "('ix_hero_name', 'hero', ['name'], unique=False)\n", (1526, 1574), False, 'from alembic import op\n'), ((1579, 1638), 'alembic.op.create_index', 'op.create_index', (['"""ix_hero_id"""', '"""hero"""', "['id']"], {'unique': '(False)'}), "('ix_hero_id', 'hero', ['id'], unique=False)\n", (1594, 1638), False, 'from alembic import op\n'), ((1643, 1704), 'alembic.op.create_index', 'op.create_index', (['"""ix_hero_age"""', '"""hero"""', "['age']"], {'unique': '(False)'}), "('ix_hero_age', 'hero', ['age'], unique=False)\n", (1658, 1704), False, 'from alembic import op\n'), ((1829, 1851), 'alembic.op.drop_table', 'op.drop_table', (['"""plant"""'], {}), "('plant')\n", (1842, 1851), False, 'from alembic import op\n'), ((538, 567), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""id"""'], {}), "('id')\n", (561, 567), True, 'import sqlalchemy as sa\n'), ((594, 613), 'alembic.op.f', 'op.f', (['"""ix_plant_id"""'], {}), "('ix_plant_id')\n", (598, 613), False, 'from alembic import op\n'), ((666, 687), 'alembic.op.f', 'op.f', (['"""ix_plant_name"""'], {}), "('ix_plant_name')\n", (670, 687), False, 'from alembic import op\n'), ((1389, 1418), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""id"""'], {}), "('id')\n", (1412, 1418), True, 'import sqlalchemy as sa\n'), ((1723, 1744), 'alembic.op.f', 'op.f', (['"""ix_plant_name"""'], {}), "('ix_plant_name')\n", (1727, 1744), False, 'from alembic import op\n'), ((1784, 1803), 'alembic.op.f', 'op.f', (['"""ix_plant_id"""'], {}), "('ix_plant_id')\n", (1788, 1803), False, 'from alembic import op\n'), ((429, 441), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (439, 441), True, 'import sqlalchemy as sa\n'), ((481, 515), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (513, 515), False, 'import sqlmodel\n'), ((1140, 1153), 'sqlalchemy.DATETIME', 'sa.DATETIME', ([], {}), '()\n', (1151, 1153), True, 'import sqlalchemy as sa\n'), ((1191, 1203), 'sqlalchemy.INTEGER', 'sa.INTEGER', ([], {}), '()\n', (1201, 1203), True, 'import sqlalchemy as sa\n'), ((1243, 1255), 'sqlalchemy.VARCHAR', 'sa.VARCHAR', ([], {}), '()\n', (1253, 1255), True, 'import sqlalchemy as sa\n'), ((1303, 1315), 'sqlalchemy.VARCHAR', 'sa.VARCHAR', ([], {}), '()\n', (1313, 1315), True, 'import sqlalchemy as sa\n'), ((1355, 1367), 'sqlalchemy.INTEGER', 'sa.INTEGER', ([], {}), '()\n', (1365, 1367), True, 'import sqlalchemy as sa\n')] |
from datetime import datetime
from typing import Optional
from sqlmodel import Field, SQLModel, Relationship
from sqlalchemy import Column
from sqlalchemy.dialects.postgresql import JSON
class ZeroShotInferenceBase(SQLModel):
text: str = Field(nullable=False, index=True)
candidate_labels: list[str] = Field(
nullable=False, index=True, sa_column=Column(JSON)
)
class ZeroShotInference(ZeroShotInferenceBase, table=True):
id: Optional[int] = Field(default=None, nullable=False, primary_key=True)
result: dict[str, float] = Field(nullable=False, sa_column=Column(JSON))
created_at: Optional[datetime]
updated_at: Optional[datetime]
created_by_id: Optional[int] = Field(default=None, foreign_key="user.id")
created_by: "User" = Relationship(
sa_relationship_kwargs={
"lazy": "selectin",
"primaryjoin": "ZeroShotInference.created_by_id == User.id",
}
)
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((244, 277), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'index': '(True)'}), '(nullable=False, index=True)\n', (249, 277), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((470, 523), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'nullable': '(False)', 'primary_key': '(True)'}), '(default=None, nullable=False, primary_key=True)\n', (475, 523), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((706, 748), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""user.id"""'}), "(default=None, foreign_key='user.id')\n", (711, 748), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((774, 896), 'sqlmodel.Relationship', 'Relationship', ([], {'sa_relationship_kwargs': "{'lazy': 'selectin', 'primaryjoin':\n 'ZeroShotInference.created_by_id == User.id'}"}), "(sa_relationship_kwargs={'lazy': 'selectin', 'primaryjoin':\n 'ZeroShotInference.created_by_id == User.id'})\n", (786, 896), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((365, 377), 'sqlalchemy.Column', 'Column', (['JSON'], {}), '(JSON)\n', (371, 377), False, 'from sqlalchemy import Column\n'), ((587, 599), 'sqlalchemy.Column', 'Column', (['JSON'], {}), '(JSON)\n', (593, 599), False, 'from sqlalchemy import Column\n')] |
# Copyright 2021 Modelyst LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
import os
import sys
import pytest
from psycopg import connect as pg3_connect
from sqlalchemy import MetaData
from sqlmodel import Session, create_engine, text
from dbgen.configuration import config
from dbgen.core.entity import BaseEntity
from dbgen.core.metadata import meta_registry
@pytest.fixture()
def clear_registry():
# Clear the tables in the metadata for the default base model
BaseEntity.metadata.clear()
# Clear the Models associated with the registry, to avoid warnings
BaseEntity._sa_registry.dispose()
yield
BaseEntity.metadata.clear()
BaseEntity._sa_registry.dispose()
@pytest.fixture(scope="module")
def sql_engine():
dsn = os.environ.get('TEST_DSN', config.main_dsn)
engine = create_engine(dsn)
return engine
@pytest.fixture(scope="function")
def connection(sql_engine):
"""sql_engine connection"""
metadata = MetaData()
metadata.reflect(sql_engine)
metadata.drop_all(sql_engine)
connection = sql_engine.connect()
yield connection
connection.close()
@pytest.fixture(scope="function")
def session(connection):
transaction = connection.begin()
session = Session(bind=connection, autocommit=False, autoflush=True)
yield session
transaction.rollback()
transaction.close()
session.close()
@pytest.fixture(scope="function")
def seed_db(connection):
connection.execute(text("CREATE table users (id serial primary key, name text);"))
for user in range(100):
connection.execute(text(f"INSERT into users(name) values ('user_{user}');"))
connection.commit()
yield
connection.execute(text("drop table users;"))
connection.commit()
@pytest.fixture(scope="function")
def make_db(connection):
pass
metadata = MetaData()
metadata.reflect(connection)
metadata.drop_all(connection)
BaseEntity.metadata.create_all(connection)
connection.commit()
yield
BaseEntity.metadata.drop_all(connection)
connection.commit()
@pytest.fixture(scope="function")
def raw_connection(make_db, sql_engine):
raw = sql_engine.raw_connection()
yield raw
raw.close()
@pytest.fixture(scope="function")
def raw_pg3_connection(make_db, sql_engine):
connection = pg3_connect(str(sql_engine.url))
yield connection
connection.close()
@pytest.fixture
def debug_logger():
custom_logger = logging.getLogger("dbgen")
custom_logger.propagate = True
custom_logger.setLevel(logging.DEBUG)
log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s Test"
formatter = logging.Formatter(log_format)
console_handler = logging.StreamHandler(stream=sys.stdout)
console_handler.setFormatter(formatter)
custom_logger.addHandler(console_handler)
return custom_logger
@pytest.fixture(scope='function')
def recreate_meta(connection):
connection.execute(text(f'create schema if not exists {config.meta_schema}'))
meta_registry.metadata.drop_all(connection)
meta_registry.metadata.create_all(connection)
yield
| [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.text"
] | [((903, 919), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (917, 919), False, 'import pytest\n'), ((1232, 1262), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (1246, 1262), False, 'import pytest\n'), ((1388, 1420), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (1402, 1420), False, 'import pytest\n'), ((1659, 1691), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (1673, 1691), False, 'import pytest\n'), ((1919, 1951), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (1933, 1951), False, 'import pytest\n'), ((2288, 2320), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (2302, 2320), False, 'import pytest\n'), ((2602, 2634), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (2616, 2634), False, 'import pytest\n'), ((2747, 2779), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (2761, 2779), False, 'import pytest\n'), ((3386, 3418), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (3400, 3418), False, 'import pytest\n'), ((1012, 1039), 'dbgen.core.entity.BaseEntity.metadata.clear', 'BaseEntity.metadata.clear', ([], {}), '()\n', (1037, 1039), False, 'from dbgen.core.entity import BaseEntity\n'), ((1115, 1148), 'dbgen.core.entity.BaseEntity._sa_registry.dispose', 'BaseEntity._sa_registry.dispose', ([], {}), '()\n', (1146, 1148), False, 'from dbgen.core.entity import BaseEntity\n'), ((1163, 1190), 'dbgen.core.entity.BaseEntity.metadata.clear', 'BaseEntity.metadata.clear', ([], {}), '()\n', (1188, 1190), False, 'from dbgen.core.entity import BaseEntity\n'), ((1195, 1228), 'dbgen.core.entity.BaseEntity._sa_registry.dispose', 'BaseEntity._sa_registry.dispose', ([], {}), '()\n', (1226, 1228), False, 'from dbgen.core.entity import BaseEntity\n'), ((1291, 1334), 'os.environ.get', 'os.environ.get', (['"""TEST_DSN"""', 'config.main_dsn'], {}), "('TEST_DSN', config.main_dsn)\n", (1305, 1334), False, 'import os\n'), ((1348, 1366), 'sqlmodel.create_engine', 'create_engine', (['dsn'], {}), '(dsn)\n', (1361, 1366), False, 'from sqlmodel import Session, create_engine, text\n'), ((1496, 1506), 'sqlalchemy.MetaData', 'MetaData', ([], {}), '()\n', (1504, 1506), False, 'from sqlalchemy import MetaData\n'), ((1768, 1826), 'sqlmodel.Session', 'Session', ([], {'bind': 'connection', 'autocommit': '(False)', 'autoflush': '(True)'}), '(bind=connection, autocommit=False, autoflush=True)\n', (1775, 1826), False, 'from sqlmodel import Session, create_engine, text\n'), ((2371, 2381), 'sqlalchemy.MetaData', 'MetaData', ([], {}), '()\n', (2379, 2381), False, 'from sqlalchemy import MetaData\n'), ((2453, 2495), 'dbgen.core.entity.BaseEntity.metadata.create_all', 'BaseEntity.metadata.create_all', (['connection'], {}), '(connection)\n', (2483, 2495), False, 'from dbgen.core.entity import BaseEntity\n'), ((2534, 2574), 'dbgen.core.entity.BaseEntity.metadata.drop_all', 'BaseEntity.metadata.drop_all', (['connection'], {}), '(connection)\n', (2562, 2574), False, 'from dbgen.core.entity import BaseEntity\n'), ((2977, 3003), 'logging.getLogger', 'logging.getLogger', (['"""dbgen"""'], {}), "('dbgen')\n", (2994, 3003), False, 'import logging\n'), ((3175, 3204), 'logging.Formatter', 'logging.Formatter', (['log_format'], {}), '(log_format)\n', (3192, 3204), False, 'import logging\n'), ((3227, 3267), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (3248, 3267), False, 'import logging\n'), ((3536, 3579), 'dbgen.core.metadata.meta_registry.metadata.drop_all', 'meta_registry.metadata.drop_all', (['connection'], {}), '(connection)\n', (3567, 3579), False, 'from dbgen.core.metadata import meta_registry\n'), ((3584, 3629), 'dbgen.core.metadata.meta_registry.metadata.create_all', 'meta_registry.metadata.create_all', (['connection'], {}), '(connection)\n', (3617, 3629), False, 'from dbgen.core.metadata import meta_registry\n'), ((2000, 2062), 'sqlmodel.text', 'text', (['"""CREATE table users (id serial primary key, name text);"""'], {}), "('CREATE table users (id serial primary key, name text);')\n", (2004, 2062), False, 'from sqlmodel import Session, create_engine, text\n'), ((2234, 2259), 'sqlmodel.text', 'text', (['"""drop table users;"""'], {}), "('drop table users;')\n", (2238, 2259), False, 'from sqlmodel import Session, create_engine, text\n'), ((3473, 3530), 'sqlmodel.text', 'text', (['f"""create schema if not exists {config.meta_schema}"""'], {}), "(f'create schema if not exists {config.meta_schema}')\n", (3477, 3530), False, 'from sqlmodel import Session, create_engine, text\n'), ((2119, 2175), 'sqlmodel.text', 'text', (['f"""INSERT into users(name) values (\'user_{user}\');"""'], {}), '(f"INSERT into users(name) values (\'user_{user}\');")\n', (2123, 2175), False, 'from sqlmodel import Session, create_engine, text\n')] |
"""Governance Database Tables/Models.
Models of the Traction tables for Governance and related data. This includes ledger
related tables for schemas and credential definitions.
"""
import uuid
from datetime import datetime
from typing import List
from sqlmodel import Field, Relationship
from sqlalchemy import (
Column,
func,
String,
select,
desc,
text,
UniqueConstraint,
)
from sqlalchemy.dialects.postgresql import TIMESTAMP, ARRAY, UUID
from sqlmodel.ext.asyncio.session import AsyncSession
from api.db.models.base import BaseModel
from api.endpoints.models.v1.errors import (
NotFoundError,
)
class SchemaTemplate(BaseModel, table=True):
"""SchemaTemplate.
This is the model for the Schema table (postgresql specific dialects in use).
Schemas are registered on the ledger, so there can be only one...
However, each Tenant can import the same schema for their own purposes. For now,
there will be redundancy in the Schema data, we are going to wait on usage to
determine if we need to normalize and have a singular table for Schemas for all and
then join table for Schema/Tenant.
There is already a table for v0 API named tenantschema and this is named differently
to avoid confusion and interference. When v0 is retired/deleted, perhaps we change
the name then...
For a given tenant, the schema can be found by the schema_template_id (Traction id)
or schema_id (ledger id).
Attributes:
schema_template_id: Traction ID
tenant_id: Traction Tenant ID, owner of this Contact
schema_id: This will be the ledger schema id - this is not a UUID
name: a "pretty" name for the schema, this can be different than the name on the
ledger (schema_name).
status: Status of the schema as it is being endorsed and registered
tags: Set by tenant for arbitrary grouping of their Schemas
deleted: Schema/Tenant "soft" delete indicator.
imported: When True, this tenant imported the schema, otherwise they created it
version: version, on ledger
attributes: list of attribute names, on ledger
schema_name: name as is appears on the ledger
transaction_id: id used when schema is being endorsed and registered
state: The underlying AcaPy endorser state
created_at: Timestamp when record was created in Traction
updated_at: Timestamp when record was last modified in Traction
"""
__tablename__ = "schema_template"
__table_args__ = (UniqueConstraint("tenant_id", "schema_id"),)
schema_template_id: uuid.UUID = Field(
sa_column=Column(
UUID(as_uuid=True),
primary_key=True,
server_default=text("gen_random_uuid()"),
)
)
tenant_id: uuid.UUID = Field(foreign_key="tenant.id", index=True)
schema_id: str = Field(nullable=True, index=True)
name: str = Field(nullable=False)
status: str = Field(nullable=False)
tags: List[str] = Field(sa_column=Column(ARRAY(String)))
deleted: bool = Field(nullable=False, default=False)
imported: bool = Field(nullable=False, default=False)
state: str = Field(nullable=False)
# ledger data ---
version: str = Field(nullable=False)
attributes: List[str] = Field(sa_column=Column(ARRAY(String)))
schema_name: str = Field(nullable=True)
transaction_id: str = Field(nullable=True)
# --- ledger data
created_at: datetime = Field(
sa_column=Column(TIMESTAMP, nullable=False, server_default=func.now())
)
updated_at: datetime = Field(
sa_column=Column(
TIMESTAMP, nullable=False, server_default=func.now(), onupdate=func.now()
)
)
@classmethod
async def get_by_id(
cls: "SchemaTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
schema_template_id: uuid.UUID,
deleted: bool | None = False,
) -> "SchemaTemplate":
"""Get SchemaTemplate by schema_template_id.
Find and return the database SchemaTemplate record
Args:
db: database session
tenant_id: Traction ID of tenant making the call
schema_template_id: Traction ID of Schema Template
Returns: The Traction SchemaTemplate (db) record
Raises:
NotFoundError: if the SchemaTemplate cannot be found by ID and deleted flag
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.where(cls.schema_template_id == schema_template_id)
.where(cls.deleted == deleted)
)
q_result = await db.execute(q)
db_rec = q_result.scalar_one_or_none()
if not db_rec:
raise NotFoundError(
code="schema_template.id_not_found",
title="Schema Template does not exist",
detail=f"Schema Template does not exist for id<{schema_template_id}>",
)
return db_rec
@classmethod
async def get_by_schema_id(
cls: "SchemaTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
schema_id: str,
deleted: bool | None = False,
) -> "SchemaTemplate":
"""Get SchemaTemplate by schema_id.
Find and return the database SchemaTemplate record
Args:
db: database session
tenant_id: Traction ID of tenant making the call
schema_id: Ledger Schema ID of Schema Template
Returns: The Traction SchemaTemplate (db) record
Raises:
NotFoundError: if the SchemaTemplate cannot be found by schema ID and deleted
flag
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.where(cls.schema_id == schema_id)
.where(cls.deleted == deleted)
)
q_result = await db.execute(q)
db_rec = q_result.scalar_one_or_none()
if not db_rec:
raise NotFoundError(
code="schema_template.schema_id_not_found",
title="Schema Template does not exist",
detail=f"Schema Template does not exist for schema_id<{schema_id}>",
)
return db_rec
@classmethod
async def get_by_transaction_id(
cls: "SchemaTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
transaction_id: str,
deleted: bool | None = False,
) -> "SchemaTemplate":
"""Get SchemaTemplate by transaction_id.
Find and return the database SchemaTemplate record
Args:
db: database session
tenant_id: Traction ID of tenant making the call
transaction_id: Transaction ID from endorser
Returns: The Traction SchemaTemplate (db) record
Raises:
NotFoundError: if the SchemaTemplate cannot be found by schema ID and deleted
flag
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.where(cls.transaction_id == transaction_id)
.where(cls.deleted == deleted)
)
q_result = await db.execute(q)
db_rec = q_result.scalar_one_or_none()
if not db_rec:
raise NotFoundError(
code="schema_template.transaction_id_not_found",
title="Schema Template does not exist",
detail=f"Schema Template does not exist for transaction_id<{transaction_id}>", # noqa: E501
)
return db_rec
@classmethod
async def list_by_tenant_id(
cls: "SchemaTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
) -> List["SchemaTemplate"]:
"""List by Tenant ID.
Find and return list of SchemaTemplate records for Tenant.
Args:
db: database session
tenant_id: Traction ID of Tenant
Returns: List of Traction SchemaTemplate (db) records in descending order
"""
q = select(cls).where(cls.tenant_id == tenant_id).order_by(desc(cls.updated_at))
q_result = await db.execute(q)
db_recs = q_result.scalars()
return db_recs
class CredentialTemplate(BaseModel, table=True):
"""Credential Template.
Model for the Credential Definition table (postgresql specific dialects in use).
This will track Credential Definitions for the Tenants.
For a given tenant, the Credential Tempalte can be found by the
credential_template_id (Traction id) or cred_def_id (ledger id).
Attributes:
credential_template_id: Traction ID
tenant_id: Traction Tenant ID
schema_template_id: Traction ID for Schema Template
cred_def_id: Credential Definition ID from the ledger
schema_id: Ledger ID of Schema this credential definition is for
name: based on SchemaTemplate.name, but allow override here...
status: Status of the credential definition as it is being endorsed and registered
deleted: Credential Definition "soft" delete indicator.
transaction_id: id used when schema is being endorsed and registered
tags: Set by tenant for arbitrary grouping of Credential Templates/Definitions
tag: tag used to create the credential definition (on ledger)
attributes: list of attribute names (on ledger)
state: The underlying AcaPy endorser state
revocation_enabled: when True, subsequent Credentials can be revoked.
revocation_registry_size: how large the default revocation registry is
revocation_registry_state: The underlying AcaPy endorser state for revocation
created_at: Timestamp when record was created in Traction
updated_at: Timestamp when record was last modified in Traction
"""
__tablename__ = "credential_template"
credential_template_id: uuid.UUID = Field(
sa_column=Column(
UUID(as_uuid=True),
primary_key=True,
server_default=text("gen_random_uuid()"),
)
)
tenant_id: uuid.UUID = Field(foreign_key="tenant.id", nullable=False, index=True)
schema_template_id: uuid.UUID = Field(
foreign_key="schema_template.schema_template_id", nullable=False, index=True
)
cred_def_id: str = Field(nullable=True, index=True)
schema_id: str = Field(nullable=True)
name: str = Field(nullable=False)
status: str = Field(nullable=False)
tags: List[str] = Field(sa_column=Column(ARRAY(String)))
deleted: bool = Field(nullable=False, default=False)
state: str = Field(nullable=False)
# ledger(ish) data ---
transaction_id: str = Field(nullable=True)
tag: str = Field(nullable=False)
attributes: List[str] = Field(sa_column=Column(ARRAY(String)))
revocation_enabled: bool = Field(nullable=False, default=False)
revocation_registry_size: int = Field(nullable=True, default=None)
revocation_registry_state: str = Field(nullable=False)
# --- ledger data
# relationships ---
issuer_credentials: List["IssuerCredential"] = Relationship( # noqa: F821
back_populates="credential_template"
)
# --- relationships
created_at: datetime = Field(
sa_column=Column(TIMESTAMP, nullable=False, server_default=func.now())
)
updated_at: datetime = Field(
sa_column=Column(
TIMESTAMP, nullable=False, server_default=func.now(), onupdate=func.now()
)
)
@classmethod
async def get_by_id(
cls: "CredentialTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
credential_template_id: uuid.UUID,
deleted: bool | None = False,
) -> "CredentialTemplate":
"""Get CredentialDefinition by cred def id.
Find and return the database CredentialTemplate record
Args:
db: database session
tenant_id: Traction ID of tenant making the call
credential_template_id: Traction ID of CredentialTemplate
Returns: The Traction CredentialTemplate (db) record
Raises:
NotFoundError: if the CredentialTemplate cannot be found by ID and deleted
flag
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.where(cls.credential_template_id == credential_template_id)
.where(cls.deleted == deleted)
)
q_result = await db.execute(q)
db_rec = q_result.scalar_one_or_none()
if not db_rec:
raise NotFoundError(
code="credential_template.id_not_found",
title="Credential Template does not exist",
detail=f"Credential Template does not exist for id<{credential_template_id}>", # noqa: E501
)
return db_rec
@classmethod
async def get_by_cred_def_id(
cls: "CredentialTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
cred_def_id: str,
deleted: bool | None = False,
) -> "CredentialTemplate":
"""Get CredentialDefinition by cred def id.
Find and return the database CredentialTemplate record
Args:
db: database session
tenant_id: Traction ID of tenant making the call
cred_def_id: Ledger Cred Def ID of CredentialTemplate
Returns: The Traction CredentialTemplate (db) record
Raises:
NotFoundError: if the CredentialTemplate cannot be found by Cred Def ID and
deleted flag
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.where(cls.cred_def_id == cred_def_id)
.where(cls.deleted == deleted)
)
q_result = await db.execute(q)
db_rec = q_result.scalar_one_or_none()
if not db_rec:
raise NotFoundError(
code="credential_template.cred_def_id_not_found",
title="Credential Template does not exist",
detail=f"Credential Template does not exist for cred_def_id<{cred_def_id}>", # noqa: E501
)
return db_rec
@classmethod
async def get_by_transaction_id(
cls: "CredentialTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
transaction_id: str,
deleted: bool | None = False,
) -> "CredentialTemplate":
"""Get CredentialTemplate by transaction_id.
Find and return the database CredentialTemplate record
Args:
db: database session
tenant_id: Traction ID of tenant making the call
transaction_id: Transaction ID from endorser
Returns: The Traction CredentialTemplate (db) record
Raises:
NotFoundError: if the CredentialTemplate cannot be found by schema ID and
deleted flag
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.where(cls.transaction_id == transaction_id)
.where(cls.deleted == deleted)
)
q_result = await db.execute(q)
db_rec = q_result.scalar_one_or_none()
if not db_rec:
raise NotFoundError(
code="credential_template.transaction_id_not_found",
title="Credential Template does not exist",
detail=f"Credential Template does not exist for transaction_id<{transaction_id}>", # noqa: E501
)
return db_rec
@classmethod
async def get_by_schema_and_tag(
cls: "CredentialTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
schema_id: str,
tag: str,
) -> "CredentialTemplate":
"""Get CredentialTemplate by schema id (ledger) and tag.
Use this to determine if we can create a new template. If we have a tag for
this schema, then we cannot reliably create the cred def on the ledger.
Args:
db: database session
tenant_id: Traction ID of tenant making the call
schema_id: ledger schema id
tag: cred def tag
Returns: The Traction CredentialTemplate (db) record or None
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.where(cls.schema_id == schema_id)
.where(cls.tag == tag)
)
q_result = await db.execute(q)
db_rec = q_result.scalar_one_or_none()
return db_rec
@classmethod
async def list_by_schema_template_id(
cls: "CredentialTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
schema_template_id: uuid.UUID,
status: str | None = None,
) -> List["CredentialTemplate"]:
"""List by Schema Template ID.
Find and return list of Credential Template records for Schema (Tenant).
tenant_id: Traction ID of tenant making the call
schema_template_id: Traction ID of SchemaTemplate
status: optional, if provided return only items that have this status
Returns: List of Traction CredentialTemplate (db) records in descending order
"""
filters = [
cls.tenant_id == tenant_id,
cls.schema_template_id == schema_template_id,
]
if status:
filters.append(cls.status == status)
q = select(cls).filter(*filters).order_by(desc(cls.updated_at))
q_result = await db.execute(q)
db_recs = q_result.scalars()
return db_recs
@classmethod
async def list_by_schema_id(
cls: "CredentialTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
schema_id: str,
) -> List["CredentialTemplate"]:
"""List by Schema ID.
Find and return list of Credential Template records for Schema (Tenant).
tenant_id: Traction ID of tenant making the call
schema_id: Ledger ID of Schema
Returns: List of Traction CredentialTemplate (db) records in descending order
"""
q = (
select(cls)
.where(cls.schema_id == schema_id)
.where(cls.tenant_id == tenant_id)
.order_by(desc(cls.created_at))
)
q_result = await db.execute(q)
db_recs = q_result.scalars()
return db_recs
@classmethod
async def list_by_tenant_id(
cls: "CredentialTemplate",
db: AsyncSession,
tenant_id: uuid.UUID,
) -> List["CredentialTemplate"]:
"""List by Tenant ID.
Find and return list of Credential Template records for Tenant.
tenant_id: Traction ID of tenant making the call
Returns: List of Traction CredentialTemplate (db) records in descending order
"""
q = select(cls).where(cls.tenant_id == tenant_id).order_by(desc(cls.updated_at))
q_result = await db.execute(q)
db_recs = q_result.scalars()
return db_recs
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((2795, 2837), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""tenant.id"""', 'index': '(True)'}), "(foreign_key='tenant.id', index=True)\n", (2800, 2837), False, 'from sqlmodel import Field, Relationship\n'), ((2859, 2891), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)', 'index': '(True)'}), '(nullable=True, index=True)\n', (2864, 2891), False, 'from sqlmodel import Field, Relationship\n'), ((2909, 2930), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (2914, 2930), False, 'from sqlmodel import Field, Relationship\n'), ((2950, 2971), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (2955, 2971), False, 'from sqlmodel import Field, Relationship\n'), ((3053, 3089), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'default': '(False)'}), '(nullable=False, default=False)\n', (3058, 3089), False, 'from sqlmodel import Field, Relationship\n'), ((3111, 3147), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'default': '(False)'}), '(nullable=False, default=False)\n', (3116, 3147), False, 'from sqlmodel import Field, Relationship\n'), ((3166, 3187), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (3171, 3187), False, 'from sqlmodel import Field, Relationship\n'), ((3230, 3251), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (3235, 3251), False, 'from sqlmodel import Field, Relationship\n'), ((3342, 3362), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (3347, 3362), False, 'from sqlmodel import Field, Relationship\n'), ((3389, 3409), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (3394, 3409), False, 'from sqlmodel import Field, Relationship\n'), ((10018, 10076), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""tenant.id"""', 'nullable': '(False)', 'index': '(True)'}), "(foreign_key='tenant.id', nullable=False, index=True)\n", (10023, 10076), False, 'from sqlmodel import Field, Relationship\n'), ((10113, 10200), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""schema_template.schema_template_id"""', 'nullable': '(False)', 'index': '(True)'}), "(foreign_key='schema_template.schema_template_id', nullable=False,\n index=True)\n", (10118, 10200), False, 'from sqlmodel import Field, Relationship\n'), ((10234, 10266), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)', 'index': '(True)'}), '(nullable=True, index=True)\n', (10239, 10266), False, 'from sqlmodel import Field, Relationship\n'), ((10288, 10308), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (10293, 10308), False, 'from sqlmodel import Field, Relationship\n'), ((10326, 10347), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (10331, 10347), False, 'from sqlmodel import Field, Relationship\n'), ((10366, 10387), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (10371, 10387), False, 'from sqlmodel import Field, Relationship\n'), ((10469, 10505), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'default': '(False)'}), '(nullable=False, default=False)\n', (10474, 10505), False, 'from sqlmodel import Field, Relationship\n'), ((10523, 10544), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (10528, 10544), False, 'from sqlmodel import Field, Relationship\n'), ((10599, 10619), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (10604, 10619), False, 'from sqlmodel import Field, Relationship\n'), ((10635, 10656), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (10640, 10656), False, 'from sqlmodel import Field, Relationship\n'), ((10755, 10791), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'default': '(False)'}), '(nullable=False, default=False)\n', (10760, 10791), False, 'from sqlmodel import Field, Relationship\n'), ((10828, 10862), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)', 'default': 'None'}), '(nullable=True, default=None)\n', (10833, 10862), False, 'from sqlmodel import Field, Relationship\n'), ((10900, 10921), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (10905, 10921), False, 'from sqlmodel import Field, Relationship\n'), ((11020, 11070), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""credential_template"""'}), "(back_populates='credential_template')\n", (11032, 11070), False, 'from sqlmodel import Field, Relationship\n'), ((2522, 2564), 'sqlalchemy.UniqueConstraint', 'UniqueConstraint', (['"""tenant_id"""', '"""schema_id"""'], {}), "('tenant_id', 'schema_id')\n", (2538, 2564), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((4731, 4902), 'api.endpoints.models.v1.errors.NotFoundError', 'NotFoundError', ([], {'code': '"""schema_template.id_not_found"""', 'title': '"""Schema Template does not exist"""', 'detail': 'f"""Schema Template does not exist for id<{schema_template_id}>"""'}), "(code='schema_template.id_not_found', title=\n 'Schema Template does not exist', detail=\n f'Schema Template does not exist for id<{schema_template_id}>')\n", (4744, 4902), False, 'from api.endpoints.models.v1.errors import NotFoundError\n'), ((5973, 6149), 'api.endpoints.models.v1.errors.NotFoundError', 'NotFoundError', ([], {'code': '"""schema_template.schema_id_not_found"""', 'title': '"""Schema Template does not exist"""', 'detail': 'f"""Schema Template does not exist for schema_id<{schema_id}>"""'}), "(code='schema_template.schema_id_not_found', title=\n 'Schema Template does not exist', detail=\n f'Schema Template does not exist for schema_id<{schema_id}>')\n", (5986, 6149), False, 'from api.endpoints.models.v1.errors import NotFoundError\n'), ((7243, 7434), 'api.endpoints.models.v1.errors.NotFoundError', 'NotFoundError', ([], {'code': '"""schema_template.transaction_id_not_found"""', 'title': '"""Schema Template does not exist"""', 'detail': 'f"""Schema Template does not exist for transaction_id<{transaction_id}>"""'}), "(code='schema_template.transaction_id_not_found', title=\n 'Schema Template does not exist', detail=\n f'Schema Template does not exist for transaction_id<{transaction_id}>')\n", (7256, 7434), False, 'from api.endpoints.models.v1.errors import NotFoundError\n'), ((8045, 8065), 'sqlalchemy.desc', 'desc', (['cls.updated_at'], {}), '(cls.updated_at)\n', (8049, 8065), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((12470, 12657), 'api.endpoints.models.v1.errors.NotFoundError', 'NotFoundError', ([], {'code': '"""credential_template.id_not_found"""', 'title': '"""Credential Template does not exist"""', 'detail': 'f"""Credential Template does not exist for id<{credential_template_id}>"""'}), "(code='credential_template.id_not_found', title=\n 'Credential Template does not exist', detail=\n f'Credential Template does not exist for id<{credential_template_id}>')\n", (12483, 12657), False, 'from api.endpoints.models.v1.errors import NotFoundError\n'), ((13787, 13981), 'api.endpoints.models.v1.errors.NotFoundError', 'NotFoundError', ([], {'code': '"""credential_template.cred_def_id_not_found"""', 'title': '"""Credential Template does not exist"""', 'detail': 'f"""Credential Template does not exist for cred_def_id<{cred_def_id}>"""'}), "(code='credential_template.cred_def_id_not_found', title=\n 'Credential Template does not exist', detail=\n f'Credential Template does not exist for cred_def_id<{cred_def_id}>')\n", (13800, 13981), False, 'from api.endpoints.models.v1.errors import NotFoundError\n'), ((15113, 15316), 'api.endpoints.models.v1.errors.NotFoundError', 'NotFoundError', ([], {'code': '"""credential_template.transaction_id_not_found"""', 'title': '"""Credential Template does not exist"""', 'detail': 'f"""Credential Template does not exist for transaction_id<{transaction_id}>"""'}), "(code='credential_template.transaction_id_not_found', title=\n 'Credential Template does not exist', detail=\n f'Credential Template does not exist for transaction_id<{transaction_id}>')\n", (15126, 15316), False, 'from api.endpoints.models.v1.errors import NotFoundError\n'), ((17323, 17343), 'sqlalchemy.desc', 'desc', (['cls.updated_at'], {}), '(cls.updated_at)\n', (17327, 17343), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((18114, 18134), 'sqlalchemy.desc', 'desc', (['cls.created_at'], {}), '(cls.created_at)\n', (18118, 18134), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((18754, 18774), 'sqlalchemy.desc', 'desc', (['cls.updated_at'], {}), '(cls.updated_at)\n', (18758, 18774), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((2648, 2666), 'sqlalchemy.dialects.postgresql.UUID', 'UUID', ([], {'as_uuid': '(True)'}), '(as_uuid=True)\n', (2652, 2666), False, 'from sqlalchemy.dialects.postgresql import TIMESTAMP, ARRAY, UUID\n'), ((3017, 3030), 'sqlalchemy.dialects.postgresql.ARRAY', 'ARRAY', (['String'], {}), '(String)\n', (3022, 3030), False, 'from sqlalchemy.dialects.postgresql import TIMESTAMP, ARRAY, UUID\n'), ((3303, 3316), 'sqlalchemy.dialects.postgresql.ARRAY', 'ARRAY', (['String'], {}), '(String)\n', (3308, 3316), False, 'from sqlalchemy.dialects.postgresql import TIMESTAMP, ARRAY, UUID\n'), ((9871, 9889), 'sqlalchemy.dialects.postgresql.UUID', 'UUID', ([], {'as_uuid': '(True)'}), '(as_uuid=True)\n', (9875, 9889), False, 'from sqlalchemy.dialects.postgresql import TIMESTAMP, ARRAY, UUID\n'), ((10433, 10446), 'sqlalchemy.dialects.postgresql.ARRAY', 'ARRAY', (['String'], {}), '(String)\n', (10438, 10446), False, 'from sqlalchemy.dialects.postgresql import TIMESTAMP, ARRAY, UUID\n'), ((10708, 10721), 'sqlalchemy.dialects.postgresql.ARRAY', 'ARRAY', (['String'], {}), '(String)\n', (10713, 10721), False, 'from sqlalchemy.dialects.postgresql import TIMESTAMP, ARRAY, UUID\n'), ((2725, 2750), 'sqlalchemy.text', 'text', (['"""gen_random_uuid()"""'], {}), "('gen_random_uuid()')\n", (2729, 2750), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((3534, 3544), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (3542, 3544), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((3666, 3676), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (3674, 3676), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((3687, 3697), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (3695, 3697), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((9948, 9973), 'sqlalchemy.text', 'text', (['"""gen_random_uuid()"""'], {}), "('gen_random_uuid()')\n", (9952, 9973), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((11225, 11235), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (11233, 11235), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((11357, 11367), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (11365, 11367), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((11378, 11388), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (11386, 11388), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((7990, 8001), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (7996, 8001), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((17285, 17296), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (17291, 17296), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((18699, 18710), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (18705, 18710), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((4427, 4438), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (4433, 4438), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((5687, 5698), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (5693, 5698), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((6947, 6958), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (6953, 6958), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((12158, 12169), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (12164, 12169), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((13497, 13508), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (13503, 13508), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((14817, 14828), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (14823, 14828), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((16135, 16146), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (16141, 16146), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n'), ((17986, 17997), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (17992, 17997), False, 'from sqlalchemy import Column, func, String, select, desc, text, UniqueConstraint\n')] |
import typing as t
if t.TYPE_CHECKING:
from .other import DB_AccessToken, DB_APIKey
from .discussions import DB_Discussion
from datetime import datetime
from sqlmodel import SQLModel, Field, Relationship, Column, JSON
from ..extensions.tags import DB_Tag, DB_TagUser
class DB_User(SQLModel, table=True):
__tablename__ = 'users'
id: t.Optional[int] = Field(default=None, primary_key=True)
"""The ID of the user. This is handled by the database."""
username: str = Field(max_length=100, sa_column_kwargs={"unique": True})
"""The user's username."""
email: str = Field(max_length=150, sa_column_kwargs={"unique": True})
"""The user's E-mail address."""
is_email_confirmed: bool = Field(default=False)
"""Whether or not the user confirmed their E-mail address."""
password: str = Field(max_length=100)
"""The user's password (<PASSWORD>)."""
avatar_url: t.Optional[str] = Field(max_length=100)
"""The file name of user's avatar. Avatars are located in the `public/assets/avatars` directory of your forum root."""
preferences: t.Dict[str, bool] = Field(sa_column=Column(JSON), default={"notify_discussionRenamed_alert": True,"notify_postLiked_alert": True,"notify_discussionLocked_alert": True,"notify_postMentioned_alert": True,"notify_postMentioned_email": False,"notify_userMentioned_alert": True,"notify_userMentioned_email": False,"notify_newPost_alert": True, "notify_newPost_email": True, "notify_userSuspended_alert": True, "notify_userUnsuspended_alert": True, "followAfterReply": True, "discloseOnline": True, "indexProfile": True, "locale": None })
"""The user's preferences (e. g.: for notifications)."""
joined_at: t.Optional[datetime] = Field(default=None)
"""When did the user join the forum."""
last_seen_at: t.Optional[datetime] = Field(default=None)
"""When was the user last seen at."""
marked_all_as_read_at: t.Optional[datetime] = Field(default=None)
"""When did the user mark all discussions as read."""
read_notifications_at: t.Optional[datetime] = Field(default=None)
"""When did the user read their notifications."""
discussion_count: int = Field(default=0)
"""The user's discussion count."""
comment_count: int = Field(default=0)
"""The user's comment (post) count."""
access_tokens: t.List['DB_AccessToken'] = Relationship(back_populates='user')
"""List of access tokens belonging to this user."""
api_keys: t.List['DB_APIKey'] = Relationship(back_populates='user')
"""List of API keys that perform actions on behalf of this user."""
discussions: t.List['DB_Discussion'] = Relationship(back_populates='author')
"""List of discussions that this user made."""
tags: t.List['DB_Tag'] = Relationship(back_populates='users', link_model=DB_TagUser)
"""Tags that have relationship with this user."""
| [
"sqlmodel.Relationship",
"sqlmodel.Field",
"sqlmodel.Column"
] | [((372, 409), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (377, 409), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((494, 550), 'sqlmodel.Field', 'Field', ([], {'max_length': '(100)', 'sa_column_kwargs': "{'unique': True}"}), "(max_length=100, sa_column_kwargs={'unique': True})\n", (499, 550), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((600, 656), 'sqlmodel.Field', 'Field', ([], {'max_length': '(150)', 'sa_column_kwargs': "{'unique': True}"}), "(max_length=150, sa_column_kwargs={'unique': True})\n", (605, 656), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((725, 745), 'sqlmodel.Field', 'Field', ([], {'default': '(False)'}), '(default=False)\n', (730, 745), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((832, 853), 'sqlmodel.Field', 'Field', ([], {'max_length': '(100)'}), '(max_length=100)\n', (837, 853), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((933, 954), 'sqlmodel.Field', 'Field', ([], {'max_length': '(100)'}), '(max_length=100)\n', (938, 954), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((1728, 1747), 'sqlmodel.Field', 'Field', ([], {'default': 'None'}), '(default=None)\n', (1733, 1747), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((1833, 1852), 'sqlmodel.Field', 'Field', ([], {'default': 'None'}), '(default=None)\n', (1838, 1852), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((1945, 1964), 'sqlmodel.Field', 'Field', ([], {'default': 'None'}), '(default=None)\n', (1950, 1964), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((2073, 2092), 'sqlmodel.Field', 'Field', ([], {'default': 'None'}), '(default=None)\n', (2078, 2092), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((2176, 2192), 'sqlmodel.Field', 'Field', ([], {'default': '(0)'}), '(default=0)\n', (2181, 2192), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((2257, 2273), 'sqlmodel.Field', 'Field', ([], {'default': '(0)'}), '(default=0)\n', (2262, 2273), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((2364, 2399), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""user"""'}), "(back_populates='user')\n", (2376, 2399), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((2492, 2527), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""user"""'}), "(back_populates='user')\n", (2504, 2527), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((2643, 2680), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""author"""'}), "(back_populates='author')\n", (2655, 2680), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((2762, 2821), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""users"""', 'link_model': 'DB_TagUser'}), "(back_populates='users', link_model=DB_TagUser)\n", (2774, 2821), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n'), ((1131, 1143), 'sqlmodel.Column', 'Column', (['JSON'], {}), '(JSON)\n', (1137, 1143), False, 'from sqlmodel import SQLModel, Field, Relationship, Column, JSON\n')] |
# Creazione entità "base", editor support, creazione, id automatici
# https://sqlmodel.tiangolo.com/tutorial/insert/
from typing import Optional
from sqlmodel import Field, SQLModel, Session, create_engine
class Tag(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
class ProductType(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"
engine = create_engine(sqlite_url, echo=True)
def create_db_and_tables():
SQLModel.metadata.create_all(engine)
def create_entities():
tag_offerta = Tag(name="Offerta")
tag_maionese = Tag(name="Con Maionese")
tag_nomayo = Tag(name="No mayo")
tipo_panino = ProductType(name="panino")
tipo_bibita = ProductType(name="bibita")
with Session(engine) as session:
session.add(tag_offerta)
session.add(tag_maionese)
session.add(tag_nomayo)
session.add(tipo_panino)
session.add(tipo_bibita)
session.commit()
print("After committing the session")
print("Tag 1:", tag_offerta)
# No refresh, no print
# https://sqlmodel.tiangolo.com/tutorial/automatic-id-none-refresh/
print("Product Type 1:", tipo_panino)
# Refresh automatica se accedo ad un attributo
print("Name of product Type 1:", tipo_panino.name)
# Refresh esplicita
session.refresh(tipo_bibita)
session.refresh(tag_maionese)
print("Product Type 2:", tipo_bibita)
print("After the session closes")
print("Tag 2:", tag_maionese)
def main():
create_db_and_tables()
create_entities()
if __name__ == "__main__":
main()
| [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.create_engine",
"sqlmodel.Session"
] | [((525, 561), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (538, 561), False, 'from sqlmodel import Field, SQLModel, Session, create_engine\n'), ((265, 302), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (270, 302), False, 'from sqlmodel import Field, SQLModel, Session, create_engine\n'), ((384, 421), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (389, 421), False, 'from sqlmodel import Field, SQLModel, Session, create_engine\n'), ((596, 632), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (624, 632), False, 'from sqlmodel import Field, SQLModel, Session, create_engine\n'), ((876, 891), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (883, 891), False, 'from sqlmodel import Field, SQLModel, Session, create_engine\n')] |
from sqlmodel import create_engine
engine = create_engine("sqlite:///database.db")
del create_engine
from .models import DuelData
from .session import Session, SessionManager
| [
"sqlmodel.create_engine"
] | [((45, 83), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///database.db"""'], {}), "('sqlite:///database.db')\n", (58, 83), False, 'from sqlmodel import create_engine\n')] |
from typing import Optional
from sqlmodel import Field, SQLModel
from fastapi_server.models.user import User
class ChatMessage(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
timestamp: int
message: str
user_id: int = Field(foreign_key='user.id')
user: User
| [
"sqlmodel.Field"
] | [((178, 215), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (183, 215), False, 'from sqlmodel import Field, SQLModel\n'), ((271, 299), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""user.id"""'}), "(foreign_key='user.id')\n", (276, 299), False, 'from sqlmodel import Field, SQLModel\n')] |
"""add school abbreviations and acronyms
Revision ID: 41f361ac6a74
Revises: c<PASSWORD>
Create Date: 2022-06-07 03:48:15.445488+00:00
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = "41f361ac6a74"
down_revision = "c1b1ed99e50d"
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column(
"schools",
sa.Column(
"abbreviations",
postgresql.ARRAY(sqlmodel.sql.sqltypes.AutoString()),
nullable=False,
server_default=sa.text("array[]::varchar[]"),
),
)
op.add_column(
"schools",
sa.Column(
"alternatives",
postgresql.ARRAY(sqlmodel.sql.sqltypes.AutoString()),
nullable=False,
server_default=sa.text("array[]::varchar[]"),
),
)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column("schools", "alternatives")
op.drop_column("schools", "abbreviations")
# ### end Alembic commands ###
| [
"sqlmodel.sql.sqltypes.AutoString"
] | [((1100, 1141), 'alembic.op.drop_column', 'op.drop_column', (['"""schools"""', '"""alternatives"""'], {}), "('schools', 'alternatives')\n", (1114, 1141), False, 'from alembic import op\n'), ((1146, 1188), 'alembic.op.drop_column', 'op.drop_column', (['"""schools"""', '"""abbreviations"""'], {}), "('schools', 'abbreviations')\n", (1160, 1188), False, 'from alembic import op\n'), ((582, 616), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (614, 616), False, 'import sqlmodel\n'), ((674, 703), 'sqlalchemy.text', 'sa.text', (['"""array[]::varchar[]"""'], {}), "('array[]::varchar[]')\n", (681, 703), True, 'import sqlalchemy as sa\n'), ((836, 870), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (868, 870), False, 'import sqlmodel\n'), ((928, 957), 'sqlalchemy.text', 'sa.text', (['"""array[]::varchar[]"""'], {}), "('array[]::varchar[]')\n", (935, 957), True, 'import sqlalchemy as sa\n')] |
"""v1-tenant_token
Revision ID: <KEY>
Revises: <KEY>
Create Date: 2022-05-18 14:55:32.794587
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = "<KEY>"
down_revision = "<KEY>"
branch_labels = None
depends_on = None
def upgrade():
op.add_column(
"tenant",
sa.Column("wallet_token", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
)
op.create_index(op.f("ix_tenant_name"), "tenant", ["name"], unique=False)
def downgrade():
op.drop_index(op.f("ix_tenant_name"), table_name="tenant")
op.drop_column("tenant", "wallet_token")
| [
"sqlmodel.sql.sqltypes.AutoString"
] | [((596, 636), 'alembic.op.drop_column', 'op.drop_column', (['"""tenant"""', '"""wallet_token"""'], {}), "('tenant', 'wallet_token')\n", (610, 636), False, 'from alembic import op\n'), ((452, 474), 'alembic.op.f', 'op.f', (['"""ix_tenant_name"""'], {}), "('ix_tenant_name')\n", (456, 474), False, 'from alembic import op\n'), ((547, 569), 'alembic.op.f', 'op.f', (['"""ix_tenant_name"""'], {}), "('ix_tenant_name')\n", (551, 569), False, 'from alembic import op\n'), ((374, 408), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (406, 408), False, 'import sqlmodel\n')] |
from typing import Any, Dict, List, Optional, Union
from pydantic.networks import EmailStr
from app.crud.base_sqlmodel import CRUDBase
from sqlmodel.ext.asyncio.session import AsyncSession
from sqlmodel import select
from app.schemas.user import IUserCreate, IUserUpdate
from app.models.user import User
from app.core.security import verify_password, get_password_hash
from datetime import datetime
class CRUDUser(CRUDBase[User, IUserCreate, IUserUpdate]):
async def get_by_email(
self, db_session: AsyncSession, *, email: str
) -> Optional[User]:
users = await db_session.exec(select(User).where(User.email == email))
return users.first()
async def get_user_by_id(self, db_session: AsyncSession, id: int) -> Optional[User]:
return await super().get(db_session, id=id)
async def create(self, db_session: AsyncSession, *, obj_in: IUserCreate) -> User:
db_obj = User(
first_name=obj_in.first_name,
last_name=obj_in.last_name,
email=obj_in.email,
is_superuser=obj_in.is_superuser,
hashed_password=get_password_hash(obj_in.password),
created_at=datetime.utcnow(),
updated_at=datetime.utcnow(),
role_id=obj_in.role_id,
)
db_session.add(db_obj)
await db_session.commit()
await db_session.refresh(db_obj)
return db_obj
def update(
self,
db_session: AsyncSession,
*,
db_obj: User,
obj_in: Union[IUserUpdate, Dict[str, Any]]
) -> User:
if isinstance(obj_in, dict):
update_data = obj_in
else:
update_data = obj_in.dict(exclude_unset=True)
update_data["updated_at"] = datetime.utcnow()
update_data["first_name"] = obj_in.first_name
update_data["last_name"] = obj_in.last_name
response = super().update(db_session, db_obj=db_obj, obj_in=update_data)
return response
async def update_is_active(
self,
db_session: AsyncSession,
*,
db_obj: List[User],
obj_in: Union[int, str, Dict[str, Any]]
) -> Union[User, None]:
response = None
for x in db_obj:
setattr(x, "is_active", obj_in.is_active)
setattr(x, "updated_at", datetime.utcnow())
db_session.add(x)
await db_session.commit()
await db_session.refresh(x)
response.append(x)
return response
async def authenticate(
self, db_session: AsyncSession, *, email: EmailStr, password: str
) -> Optional[User]:
user = await self.get_by_email(db_session, email=email)
if not user:
return None
if not verify_password(password, user.hashed_password):
return None
return user
user = CRUDUser(User)
| [
"sqlmodel.select"
] | [((1751, 1768), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (1766, 1768), False, 'from datetime import datetime\n'), ((2751, 2798), 'app.core.security.verify_password', 'verify_password', (['password', 'user.hashed_password'], {}), '(password, user.hashed_password)\n', (2766, 2798), False, 'from app.core.security import verify_password, get_password_hash\n'), ((1114, 1148), 'app.core.security.get_password_hash', 'get_password_hash', (['obj_in.password'], {}), '(obj_in.password)\n', (1131, 1148), False, 'from app.core.security import verify_password, get_password_hash\n'), ((1173, 1190), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (1188, 1190), False, 'from datetime import datetime\n'), ((1215, 1232), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (1230, 1232), False, 'from datetime import datetime\n'), ((2317, 2334), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (2332, 2334), False, 'from datetime import datetime\n'), ((604, 616), 'sqlmodel.select', 'select', (['User'], {}), '(User)\n', (610, 616), False, 'from sqlmodel import select\n')] |
"""v1-contact-invitation-key
Revision ID: <KEY>
Revises: e40469d1045a
Create Date: 2022-05-11 15:23:29.495804
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = "<KEY>"
down_revision = "e40469d1045a"
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column(
"contact",
sa.Column("invitation_key", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
)
op.execute("UPDATE contact SET invitation_key = 'v0'")
op.alter_column("contact", "invitation_key", nullable=False)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column("contact", "invitation_key")
# ### end Alembic commands ###
| [
"sqlmodel.sql.sqltypes.AutoString"
] | [((529, 583), 'alembic.op.execute', 'op.execute', (['"""UPDATE contact SET invitation_key = \'v0\'"""'], {}), '("UPDATE contact SET invitation_key = \'v0\'")\n', (539, 583), False, 'from alembic import op\n'), ((588, 648), 'alembic.op.alter_column', 'op.alter_column', (['"""contact"""', '"""invitation_key"""'], {'nullable': '(False)'}), "('contact', 'invitation_key', nullable=False)\n", (603, 648), False, 'from alembic import op\n'), ((773, 816), 'alembic.op.drop_column', 'op.drop_column', (['"""contact"""', '"""invitation_key"""'], {}), "('contact', 'invitation_key')\n", (787, 816), False, 'from alembic import op\n'), ((467, 501), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (499, 501), False, 'import sqlmodel\n')] |
from typing import Optional
from sqlalchemy import UniqueConstraint
from sqlmodel import Field, Relationship, SQLModel
from db.base import BaseDBModel
from model.item import Item
from model.warehouse import Warehouse
class InventoryEditableFields(SQLModel):
item_id: int = Field(foreign_key="item.id")
warehouse_id: int = Field(foreign_key="warehouse.id")
quantity: float
class Inventory(BaseDBModel, InventoryEditableFields, table=True):
__table_args__ = (UniqueConstraint("id", "item_id", "warehouse_id"),)
item: Optional[Item] = Relationship(back_populates="item_inventories")
warehouse: Optional[Warehouse] = Relationship(back_populates="warehouse_inventories")
class InventoryRead(SQLModel):
quantity: int
item: Optional[Item] = None
warehouse: Optional[Warehouse] = None
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((281, 309), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""item.id"""'}), "(foreign_key='item.id')\n", (286, 309), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((334, 367), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""warehouse.id"""'}), "(foreign_key='warehouse.id')\n", (339, 367), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((558, 605), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""item_inventories"""'}), "(back_populates='item_inventories')\n", (570, 605), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((643, 695), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""warehouse_inventories"""'}), "(back_populates='warehouse_inventories')\n", (655, 695), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((479, 528), 'sqlalchemy.UniqueConstraint', 'UniqueConstraint', (['"""id"""', '"""item_id"""', '"""warehouse_id"""'], {}), "('id', 'item_id', 'warehouse_id')\n", (495, 528), False, 'from sqlalchemy import UniqueConstraint\n')] |
import logging
from sqlmodel import SQLModel, create_engine
import json
from dataclasses import dataclass
from etl.stores import run as etl_stores
from etl.sales import run as etl_sales
from etl.products import run as etl_products
# config to define variables
@dataclass
class Config:
stores_url: str
stores_filepath: str
db_conn_uri: str
log_level: str
# TODO convert this to a DAG or a pipeline
if __name__ == '__main__':
# load the config
config_dict = {}
with open('config.json', 'r') as f:
config_dict = json.load(f)
if config_dict['log_level'] == 'DEBUG':
config_dict['log_level'] = logging.DEBUG
else:
config_dict['log_level'] = logging.INFO
# create the config object
config = Config(**config_dict)
# setup logging
logging.basicConfig()
logging.getLogger().setLevel(config.log_level)
# create the database engine
engine = create_engine(config.db_conn_uri)
# create the sqlmodel metadata for the engine
SQLModel.metadata.create_all(engine)
# handle stores
etl_stores(config.stores_filepath, config.stores_url, engine)
# handle products
etl_products(engine)
# handle sales data
etl_sales(engine)
| [
"sqlmodel.create_engine",
"sqlmodel.SQLModel.metadata.create_all"
] | [((807, 828), 'logging.basicConfig', 'logging.basicConfig', ([], {}), '()\n', (826, 828), False, 'import logging\n'), ((927, 960), 'sqlmodel.create_engine', 'create_engine', (['config.db_conn_uri'], {}), '(config.db_conn_uri)\n', (940, 960), False, 'from sqlmodel import SQLModel, create_engine\n'), ((1016, 1052), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (1044, 1052), False, 'from sqlmodel import SQLModel, create_engine\n'), ((1078, 1139), 'etl.stores.run', 'etl_stores', (['config.stores_filepath', 'config.stores_url', 'engine'], {}), '(config.stores_filepath, config.stores_url, engine)\n', (1088, 1139), True, 'from etl.stores import run as etl_stores\n'), ((1167, 1187), 'etl.products.run', 'etl_products', (['engine'], {}), '(engine)\n', (1179, 1187), True, 'from etl.products import run as etl_products\n'), ((1220, 1237), 'etl.sales.run', 'etl_sales', (['engine'], {}), '(engine)\n', (1229, 1237), True, 'from etl.sales import run as etl_sales\n'), ((547, 559), 'json.load', 'json.load', (['f'], {}), '(f)\n', (556, 559), False, 'import json\n'), ((833, 852), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (850, 852), False, 'import logging\n')] |
from typing import Any
import sqlalchemy.exc
from ariadne import convert_kwargs_to_snake_case
from graphql.type.definition import GraphQLResolveInfo
from graphql_relay.node.node import from_global_id
from sqlmodel import select
from ariadne_example.app.db.session import Session, engine
from ariadne_example.app.core.struсtures import TaskStatusEnum, TASK_QUEUES
from ariadne_example.app.models import Task
from ariadne_example.app.core.exceptions import NotFoundError
@convert_kwargs_to_snake_case
def resolve_create_task(
obj: Any,
info: GraphQLResolveInfo,
user_id: str,
task_input: dict,
) -> int:
with Session(engine) as session:
local_user_id, _ = from_global_id(user_id)
try:
task = Task(
title=task_input.get("title"),
created_at=task_input.get("created_at"),
status=task_input.get("status"),
user_id=local_user_id
)
session.add(task)
session.commit()
session.refresh(task)
except sqlalchemy.exc.IntegrityError:
raise NotFoundError(msg='Не найден пользователь с таким user_id')
return task.id
@convert_kwargs_to_snake_case
async def resolve_change_task_status(
obj: Any,
info: GraphQLResolveInfo,
new_status: TaskStatusEnum,
task_id: str,
) -> None:
with Session(engine) as session:
local_task_id, _ = from_global_id(task_id)
try:
statement = select(Task).where(Task.id == local_task_id)
task = session.execute(statement)
task.status = new_status
session.add(task)
session.commit()
session.refresh(task)
except sqlalchemy.exc.IntegrityError:
raise NotFoundError(msg='Не найдена задача с таким task_id')
for queue in TASK_QUEUES:
queue.put(task)
| [
"sqlmodel.select"
] | [((646, 661), 'ariadne_example.app.db.session.Session', 'Session', (['engine'], {}), '(engine)\n', (653, 661), False, 'from ariadne_example.app.db.session import Session, engine\n'), ((701, 724), 'graphql_relay.node.node.from_global_id', 'from_global_id', (['user_id'], {}), '(user_id)\n', (715, 724), False, 'from graphql_relay.node.node import from_global_id\n'), ((1408, 1423), 'ariadne_example.app.db.session.Session', 'Session', (['engine'], {}), '(engine)\n', (1415, 1423), False, 'from ariadne_example.app.db.session import Session, engine\n'), ((1463, 1486), 'graphql_relay.node.node.from_global_id', 'from_global_id', (['task_id'], {}), '(task_id)\n', (1477, 1486), False, 'from graphql_relay.node.node import from_global_id\n'), ((1125, 1184), 'ariadne_example.app.core.exceptions.NotFoundError', 'NotFoundError', ([], {'msg': '"""Не найден пользователь с таким user_id"""'}), "(msg='Не найден пользователь с таким user_id')\n", (1138, 1184), False, 'from ariadne_example.app.core.exceptions import NotFoundError\n'), ((1809, 1863), 'ariadne_example.app.core.exceptions.NotFoundError', 'NotFoundError', ([], {'msg': '"""Не найдена задача с таким task_id"""'}), "(msg='Не найдена задача с таким task_id')\n", (1822, 1863), False, 'from ariadne_example.app.core.exceptions import NotFoundError\n'), ((1524, 1536), 'sqlmodel.select', 'select', (['Task'], {}), '(Task)\n', (1530, 1536), False, 'from sqlmodel import select\n')] |
"""init
Revision ID: fb8ce6ce7c6b
Revises:
Create Date: 2021-11-27 16:52:18.035895
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = "fb8ce6ce7c6b"
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table(
"appid_error",
sa.Column("pk", sa.Integer(), nullable=True),
sa.Column("appid", sa.Integer(), nullable=False),
sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("reason", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.PrimaryKeyConstraint("pk"),
sa.UniqueConstraint("appid"),
)
op.create_table(
"category",
sa.Column("pk", sa.Integer(), nullable=True),
sa.Column("id", sa.Integer(), nullable=False),
sa.Column(
"description", sqlmodel.sql.sqltypes.AutoString(), nullable=False
),
sa.PrimaryKeyConstraint("pk"),
)
op.create_table(
"genre",
sa.Column("pk", sa.Integer(), nullable=True),
sa.Column("id", sa.Integer(), nullable=False),
sa.Column(
"description", sqlmodel.sql.sqltypes.AutoString(), nullable=False
),
sa.PrimaryKeyConstraint("pk"),
)
op.create_table(
"steam_app",
sa.Column("pk", sa.Integer(), nullable=True),
sa.Column("appid", sa.Integer(), nullable=False),
sa.Column("type", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("is_free", sa.Boolean(), nullable=True),
sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.Column(
"controller_support",
sqlmodel.sql.sqltypes.AutoString(),
nullable=True,
),
sa.Column("metacritic_score", sa.Integer(), nullable=True),
sa.Column(
"metacritic_url", sqlmodel.sql.sqltypes.AutoString(), nullable=True
),
sa.Column("recommendations", sa.Integer(), nullable=True),
sa.Column("achievements_total", sa.Integer(), nullable=True),
sa.Column("release_date", sa.Date(), nullable=True),
sa.Column("created", sa.DateTime(), nullable=False),
sa.Column("updated", sa.DateTime(), nullable=False),
sa.PrimaryKeyConstraint("pk"),
)
op.create_index(
op.f("ix_steam_app_appid"), "steam_app", ["appid"], unique=True
)
op.create_index(
op.f("ix_steam_app_name"), "steam_app", ["name"], unique=False
)
op.create_table(
"achievement",
sa.Column("pk", sa.Integer(), nullable=True),
sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.Column("percent", sa.Float(), nullable=False),
sa.Column("steam_app_pk", sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(
["steam_app_pk"],
["steam_app.pk"],
),
sa.PrimaryKeyConstraint("pk"),
)
op.create_table(
"categorysteamapplink",
sa.Column("category_pk", sa.Integer(), nullable=True),
sa.Column("steam_app_pk", sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(
["category_pk"],
["category.pk"],
),
sa.ForeignKeyConstraint(
["steam_app_pk"],
["steam_app.pk"],
),
sa.PrimaryKeyConstraint("category_pk", "steam_app_pk"),
)
op.create_table(
"genresteammapplink",
sa.Column("genre_pk", sa.Integer(), nullable=True),
sa.Column("steam_app_pk", sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(
["genre_pk"],
["genre.pk"],
),
sa.ForeignKeyConstraint(
["steam_app_pk"],
["steam_app.pk"],
),
sa.PrimaryKeyConstraint("genre_pk", "steam_app_pk"),
)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_table("genresteammapplink")
op.drop_table("categorysteamapplink")
op.drop_table("achievement")
op.drop_index(op.f("ix_steam_app_name"), table_name="steam_app")
op.drop_index(op.f("ix_steam_app_appid"), table_name="steam_app")
op.drop_table("steam_app")
op.drop_table("genre")
op.drop_table("category")
op.drop_table("appid_error")
# ### end Alembic commands ###
| [
"sqlmodel.sql.sqltypes.AutoString"
] | [((4084, 4119), 'alembic.op.drop_table', 'op.drop_table', (['"""genresteammapplink"""'], {}), "('genresteammapplink')\n", (4097, 4119), False, 'from alembic import op\n'), ((4124, 4161), 'alembic.op.drop_table', 'op.drop_table', (['"""categorysteamapplink"""'], {}), "('categorysteamapplink')\n", (4137, 4161), False, 'from alembic import op\n'), ((4166, 4194), 'alembic.op.drop_table', 'op.drop_table', (['"""achievement"""'], {}), "('achievement')\n", (4179, 4194), False, 'from alembic import op\n'), ((4338, 4364), 'alembic.op.drop_table', 'op.drop_table', (['"""steam_app"""'], {}), "('steam_app')\n", (4351, 4364), False, 'from alembic import op\n'), ((4369, 4391), 'alembic.op.drop_table', 'op.drop_table', (['"""genre"""'], {}), "('genre')\n", (4382, 4391), False, 'from alembic import op\n'), ((4396, 4421), 'alembic.op.drop_table', 'op.drop_table', (['"""category"""'], {}), "('category')\n", (4409, 4421), False, 'from alembic import op\n'), ((4426, 4454), 'alembic.op.drop_table', 'op.drop_table', (['"""appid_error"""'], {}), "('appid_error')\n", (4439, 4454), False, 'from alembic import op\n'), ((687, 716), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""pk"""'], {}), "('pk')\n", (710, 716), True, 'import sqlalchemy as sa\n'), ((726, 754), 'sqlalchemy.UniqueConstraint', 'sa.UniqueConstraint', (['"""appid"""'], {}), "('appid')\n", (745, 754), True, 'import sqlalchemy as sa\n'), ((1028, 1057), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""pk"""'], {}), "('pk')\n", (1051, 1057), True, 'import sqlalchemy as sa\n'), ((1328, 1357), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""pk"""'], {}), "('pk')\n", (1351, 1357), True, 'import sqlalchemy as sa\n'), ((2380, 2409), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""pk"""'], {}), "('pk')\n", (2403, 2409), True, 'import sqlalchemy as sa\n'), ((2446, 2472), 'alembic.op.f', 'op.f', (['"""ix_steam_app_appid"""'], {}), "('ix_steam_app_appid')\n", (2450, 2472), False, 'from alembic import op\n'), ((2545, 2570), 'alembic.op.f', 'op.f', (['"""ix_steam_app_name"""'], {}), "('ix_steam_app_name')\n", (2549, 2570), False, 'from alembic import op\n'), ((2921, 2980), 'sqlalchemy.ForeignKeyConstraint', 'sa.ForeignKeyConstraint', (["['steam_app_pk']", "['steam_app.pk']"], {}), "(['steam_app_pk'], ['steam_app.pk'])\n", (2944, 2980), True, 'import sqlalchemy as sa\n'), ((3025, 3054), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""pk"""'], {}), "('pk')\n", (3048, 3054), True, 'import sqlalchemy as sa\n'), ((3250, 3307), 'sqlalchemy.ForeignKeyConstraint', 'sa.ForeignKeyConstraint', (["['category_pk']", "['category.pk']"], {}), "(['category_pk'], ['category.pk'])\n", (3273, 3307), True, 'import sqlalchemy as sa\n'), ((3352, 3411), 'sqlalchemy.ForeignKeyConstraint', 'sa.ForeignKeyConstraint', (["['steam_app_pk']", "['steam_app.pk']"], {}), "(['steam_app_pk'], ['steam_app.pk'])\n", (3375, 3411), True, 'import sqlalchemy as sa\n'), ((3456, 3510), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""category_pk"""', '"""steam_app_pk"""'], {}), "('category_pk', 'steam_app_pk')\n", (3479, 3510), True, 'import sqlalchemy as sa\n'), ((3701, 3752), 'sqlalchemy.ForeignKeyConstraint', 'sa.ForeignKeyConstraint', (["['genre_pk']", "['genre.pk']"], {}), "(['genre_pk'], ['genre.pk'])\n", (3724, 3752), True, 'import sqlalchemy as sa\n'), ((3797, 3856), 'sqlalchemy.ForeignKeyConstraint', 'sa.ForeignKeyConstraint', (["['steam_app_pk']", "['steam_app.pk']"], {}), "(['steam_app_pk'], ['steam_app.pk'])\n", (3820, 3856), True, 'import sqlalchemy as sa\n'), ((3901, 3952), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""genre_pk"""', '"""steam_app_pk"""'], {}), "('genre_pk', 'steam_app_pk')\n", (3924, 3952), True, 'import sqlalchemy as sa\n'), ((4213, 4238), 'alembic.op.f', 'op.f', (['"""ix_steam_app_name"""'], {}), "('ix_steam_app_name')\n", (4217, 4238), False, 'from alembic import op\n'), ((4282, 4308), 'alembic.op.f', 'op.f', (['"""ix_steam_app_appid"""'], {}), "('ix_steam_app_appid')\n", (4286, 4308), False, 'from alembic import op\n'), ((433, 445), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (443, 445), True, 'import sqlalchemy as sa\n'), ((490, 502), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (500, 502), True, 'import sqlalchemy as sa\n'), ((547, 581), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (579, 581), False, 'import sqlmodel\n'), ((627, 661), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (659, 661), False, 'import sqlmodel\n'), ((827, 839), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (837, 839), True, 'import sqlalchemy as sa\n'), ((881, 893), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (891, 893), True, 'import sqlalchemy as sa\n'), ((958, 992), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (990, 992), False, 'import sqlmodel\n'), ((1127, 1139), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1137, 1139), True, 'import sqlalchemy as sa\n'), ((1181, 1193), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1191, 1193), True, 'import sqlalchemy as sa\n'), ((1258, 1292), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1290, 1292), False, 'import sqlmodel\n'), ((1431, 1443), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1441, 1443), True, 'import sqlalchemy as sa\n'), ((1488, 1500), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1498, 1500), True, 'import sqlalchemy as sa\n'), ((1545, 1579), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1577, 1579), False, 'import sqlmodel\n'), ((1626, 1638), 'sqlalchemy.Boolean', 'sa.Boolean', ([], {}), '()\n', (1636, 1638), True, 'import sqlalchemy as sa\n'), ((1682, 1716), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1714, 1716), False, 'import sqlmodel\n'), ((1800, 1834), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1832, 1834), False, 'import sqlmodel\n'), ((1912, 1924), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1922, 1924), True, 'import sqlalchemy as sa\n'), ((1991, 2025), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2023, 2025), False, 'import sqlmodel\n'), ((2089, 2101), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (2099, 2101), True, 'import sqlalchemy as sa\n'), ((2159, 2171), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (2169, 2171), True, 'import sqlalchemy as sa\n'), ((2223, 2232), 'sqlalchemy.Date', 'sa.Date', ([], {}), '()\n', (2230, 2232), True, 'import sqlalchemy as sa\n'), ((2279, 2292), 'sqlalchemy.DateTime', 'sa.DateTime', ([], {}), '()\n', (2290, 2292), True, 'import sqlalchemy as sa\n'), ((2340, 2353), 'sqlalchemy.DateTime', 'sa.DateTime', ([], {}), '()\n', (2351, 2353), True, 'import sqlalchemy as sa\n'), ((2682, 2694), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (2692, 2694), True, 'import sqlalchemy as sa\n'), ((2738, 2772), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2770, 2772), False, 'import sqlmodel\n'), ((2820, 2830), 'sqlalchemy.Float', 'sa.Float', ([], {}), '()\n', (2828, 2830), True, 'import sqlalchemy as sa\n'), ((2883, 2895), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (2893, 2895), True, 'import sqlalchemy as sa\n'), ((3148, 3160), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (3158, 3160), True, 'import sqlalchemy as sa\n'), ((3212, 3224), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (3222, 3224), True, 'import sqlalchemy as sa\n'), ((3599, 3611), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (3609, 3611), True, 'import sqlalchemy as sa\n'), ((3663, 3675), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (3673, 3675), True, 'import sqlalchemy as sa\n')] |
from typing import TYPE_CHECKING, Any, Dict, Optional, Union
from uuid import UUID, uuid4
from pydantic import PositiveFloat, validator
from sqlmodel import Column, Field, Relationship, SQLModel
from sqlmodel.sql.sqltypes import GUID
if TYPE_CHECKING:
from .user import User
class BaseItem(SQLModel):
code: str = Field(description="Item code", min_length=1)
name: str = Field(description="Item Name", min_length=1)
cost: Optional[float] = Field(description="Production/Buy cost of the item", ge=0)
value: PositiveFloat = Field(description="Sugested sell value of item")
amount: int = Field(default=0, description="Quantity of itens avaliable", ge=0)
class CreateItem(BaseItem):
@validator("value")
def validate_value(cls, value: Union[str, float], values: Dict[str, Any]) -> float:
if isinstance(value, str):
if "," in value and "." not in value:
value = value.replace(",", ".")
value = float(value)
if (values.get("cost") or 0) >= value:
raise ValueError("The sugested sell value must be higher then buy value!")
return value
class UpdateItem(BaseItem):
id: UUID = Field(description="ID do item")
@validator("value")
def validate_value(cls, value: Union[str, float], values: Dict[str, Any]) -> float:
if isinstance(value, str):
value = float(value)
if (values.get("cost") or 0) >= value:
raise ValueError("The sugested sell value must be higher then buy value!")
return value
class QueryItem(SQLModel):
name: Optional[str] = Field(description="Name of the item for query")
code: Optional[str] = Field(description="Code of the item for query")
avaliable: Optional[bool] = Field(description="Flag to identify if the item is avaliable")
class Item(BaseItem, table=True):
__tablename__ = "items"
id: UUID = Field(default_factory=uuid4, description="ID do item", sa_column=Column("id", GUID(), primary_key=True))
owner_id: UUID = Field(description="User ID that owns the file", foreign_key="users.id")
owner: "User" = Relationship()
@property
def avaliable(self) -> bool:
return self.amount > 0
| [
"sqlmodel.sql.sqltypes.GUID",
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((325, 369), 'sqlmodel.Field', 'Field', ([], {'description': '"""Item code"""', 'min_length': '(1)'}), "(description='Item code', min_length=1)\n", (330, 369), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((386, 430), 'sqlmodel.Field', 'Field', ([], {'description': '"""Item Name"""', 'min_length': '(1)'}), "(description='Item Name', min_length=1)\n", (391, 430), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((459, 517), 'sqlmodel.Field', 'Field', ([], {'description': '"""Production/Buy cost of the item"""', 'ge': '(0)'}), "(description='Production/Buy cost of the item', ge=0)\n", (464, 517), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((545, 593), 'sqlmodel.Field', 'Field', ([], {'description': '"""Sugested sell value of item"""'}), "(description='Sugested sell value of item')\n", (550, 593), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((612, 677), 'sqlmodel.Field', 'Field', ([], {'default': '(0)', 'description': '"""Quantity of itens avaliable"""', 'ge': '(0)'}), "(default=0, description='Quantity of itens avaliable', ge=0)\n", (617, 677), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((713, 731), 'pydantic.validator', 'validator', (['"""value"""'], {}), "('value')\n", (722, 731), False, 'from pydantic import PositiveFloat, validator\n'), ((1189, 1220), 'sqlmodel.Field', 'Field', ([], {'description': '"""ID do item"""'}), "(description='ID do item')\n", (1194, 1220), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((1227, 1245), 'pydantic.validator', 'validator', (['"""value"""'], {}), "('value')\n", (1236, 1245), False, 'from pydantic import PositiveFloat, validator\n'), ((1614, 1661), 'sqlmodel.Field', 'Field', ([], {'description': '"""Name of the item for query"""'}), "(description='Name of the item for query')\n", (1619, 1661), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((1688, 1735), 'sqlmodel.Field', 'Field', ([], {'description': '"""Code of the item for query"""'}), "(description='Code of the item for query')\n", (1693, 1735), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((1768, 1830), 'sqlmodel.Field', 'Field', ([], {'description': '"""Flag to identify if the item is avaliable"""'}), "(description='Flag to identify if the item is avaliable')\n", (1773, 1830), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((2037, 2108), 'sqlmodel.Field', 'Field', ([], {'description': '"""User ID that owns the file"""', 'foreign_key': '"""users.id"""'}), "(description='User ID that owns the file', foreign_key='users.id')\n", (2042, 2108), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((2129, 2143), 'sqlmodel.Relationship', 'Relationship', ([], {}), '()\n', (2141, 2143), False, 'from sqlmodel import Column, Field, Relationship, SQLModel\n'), ((1989, 1995), 'sqlmodel.sql.sqltypes.GUID', 'GUID', ([], {}), '()\n', (1993, 1995), False, 'from sqlmodel.sql.sqltypes import GUID\n')] |
"""Issuer Database Tables/Models.
Models of the Traction tables for Issuer and related data.
"""
import uuid
from datetime import datetime
from typing import List, Optional
from sqlalchemy.orm import selectinload
from sqlmodel import Field, Relationship
from sqlalchemy import (
Column,
func,
String,
select,
desc,
JSON,
text,
)
from sqlalchemy.dialects.postgresql import UUID, TIMESTAMP, ARRAY
from sqlmodel.ext.asyncio.session import AsyncSession
from api.db.models.base import BaseModel
from api.db.models.v1.contact import Contact
from api.db.models.v1.governance import CredentialTemplate
from api.endpoints.models.v1.errors import (
NotFoundError,
)
class IssuerCredential(BaseModel, table=True):
"""Issuer Credential.
Model for the Issuer Credential table (postgresql specific dialects in use).
This will track Issuer Credentials for the Tenants.
Attributes:
issuer_credential_id: Traction ID for issuer credential
credential_template_id: Traction Credential Template ID
contact_id: Traction Contact ID
cred_def_id: Credential Definition ID (ledger)
tenant_id: Traction Tenant ID
status: Business and Tenant indicator for Credential state; independent of AcaPy
Credential Exchange state
external_reference_id: Set by tenant to correlate this Credential with entity in
external system
revoked: when True, this credential has been revoked
deleted: Issuer Credential "soft" delete indicator.
preview_persisted: when True, store the credential attributes and preview
tags: Set by tenant for arbitrary grouping of Credentials
comment: Comment supplied when issuing
credential_preview: attributes (list of name / values ) for offered/issued cred.
This will be empty once offer is made and preview_persisted = False.
revocation_comment: comment entered when revoking Credential
state: The underlying AcaPy credential exchange state
thread_id: AcaPy thread id
credential_exchange_id: AcaPy id for the credential exchange
revoc_reg_id: revocation registry id (needed for revocation)
revocation_id: credential revocation id (needed for revocation)
created_at: Timestamp when record was created in Traction
updated_at: Timestamp when record was last modified in Traction
"""
__tablename__ = "issuer_credential"
issuer_credential_id: uuid.UUID = Field(
sa_column=Column(
UUID(as_uuid=True),
primary_key=True,
server_default=text("gen_random_uuid()"),
)
)
credential_template_id: uuid.UUID = Field(
foreign_key="credential_template.credential_template_id", index=True
)
tenant_id: uuid.UUID = Field(foreign_key="tenant.id", index=True)
contact_id: uuid.UUID = Field(foreign_key="contact.contact_id", index=True)
status: str = Field(nullable=False)
external_reference_id: str = Field(nullable=True)
revoked: bool = Field(nullable=False, default=False)
deleted: bool = Field(nullable=False, default=False)
tags: List[str] = Field(sa_column=Column(ARRAY(String)))
preview_persisted: bool = Field(nullable=False, default=False)
comment: str = Field(nullable=True)
revocation_comment: str = Field(nullable=True)
# acapy data ---
state: str = Field(nullable=False)
cred_def_id: str = Field(nullable=False, index=True)
thread_id: str = Field(nullable=True)
credential_exchange_id: str = Field(nullable=True)
revoc_reg_id: str = Field(nullable=True)
revocation_id: str = Field(nullable=True)
credential_preview: dict = Field(default={}, sa_column=Column(JSON))
# --- acapy data
# relationships ---
contact: Optional[Contact] = Relationship(back_populates="issuer_credentials")
credential_template: Optional[CredentialTemplate] = Relationship(
back_populates="issuer_credentials"
)
# --- relationships
created_at: datetime = Field(
sa_column=Column(TIMESTAMP, nullable=False, server_default=func.now())
)
updated_at: datetime = Field(
sa_column=Column(
TIMESTAMP, nullable=False, server_default=func.now(), onupdate=func.now()
)
)
@classmethod
async def get_by_id(
cls: "IssuerCredential",
db: AsyncSession,
tenant_id: uuid.UUID,
issuer_credential_id: uuid.UUID,
deleted: bool | None = False,
) -> "IssuerCredential":
"""Get IssuerCredential by id.
Find and return the database CredentialDefinition record
Args:
db: database session
tenant_id: Traction ID of tenant making the call
issuer_credential_id: Traction ID of IssuerCredential
Returns: The Traction IssuerCredential (db) record
Raises:
NotFoundError: if the IssuerCredential cannot be found by ID and deleted
flag
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.where(cls.issuer_credential_id == issuer_credential_id)
.where(cls.deleted == deleted)
.options(selectinload(cls.contact), selectinload(cls.credential_template))
)
q_result = await db.execute(q)
db_rec = q_result.scalar_one_or_none()
if not db_rec:
raise NotFoundError(
code="issuer_credential.id_not_found",
title="Issuer Credential does not exist",
detail=f"Issuer Credential does not exist for id<{issuer_credential_id}>", # noqa: E501
)
return db_rec
@classmethod
async def get_by_credential_exchange_id(
cls: "IssuerCredential",
db: AsyncSession,
tenant_id: uuid.UUID,
credential_exchange_id: str,
) -> "IssuerCredential":
"""Get IssuerCredential by Credential Exchange ID.
Find and return the database IssuerCredential record
Args:
db: database session
tenant_id: Traction ID of tenant making the call
credential_exchange_id: acapy message Credential Exchange ID
Returns: The Traction IssuerCredential (db) record
Raises:
NotFoundError: if the IssuerCredential cannot be found by ID and deleted
flag
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.where(cls.credential_exchange_id == credential_exchange_id)
.options(selectinload(cls.contact), selectinload(cls.credential_template))
)
q_result = await db.execute(q)
db_rec = q_result.scalar_one_or_none()
if not db_rec:
raise NotFoundError(
code="issuer_credential.credential_exchange_id_not_found",
title="Issuer Credential does not exist",
detail=f"Issuer Credential does not exist for credential exchange id<{credential_exchange_id}>", # noqa: E501
)
return db_rec
@classmethod
async def list_by_credential_template_id(
cls: "IssuerCredential",
db: AsyncSession,
tenant_id: uuid.UUID,
credential_template_id: uuid.UUID,
) -> List["IssuerCredential"]:
"""List by Credential Template ID.
Find and return list of Issuer Credential records for Credential Template.
tenant_id: Traction ID of tenant making the call
credential_template_id: Traction ID of Credential Template
Returns: List of Traction IssuerCredential (db) records in descending order
"""
q = (
select(cls)
.where(cls.credential_template_id == credential_template_id)
.where(cls.tenant_id == tenant_id)
.options(selectinload(cls.contact), selectinload(cls.credential_template))
.order_by(desc(cls.updated_at))
)
q_result = await db.execute(q)
db_recs = q_result.scalars()
return db_recs
@classmethod
async def list_by_cred_def_id(
cls: "IssuerCredential",
db: AsyncSession,
tenant_id: uuid.UUID,
cred_def_id: str,
) -> List["IssuerCredential"]:
"""List by Cred Def ID.
Find and return list of Issuer Credential records for Cred. Def.
tenant_id: Traction ID of tenant making the call
cred_def_id: Traction ID of Credential Definition
Returns: List of Traction IssuerCredential (db) records in descending order
"""
q = (
select(cls)
.where(cls.cred_def_id == cred_def_id)
.where(cls.tenant_id == tenant_id)
.options(selectinload(cls.contact), selectinload(cls.credential_template))
.order_by(desc(cls.updated_at))
)
q_result = await db.execute(q)
db_recs = q_result.scalars()
return db_recs
@classmethod
async def list_by_contact_id(
cls: "IssuerCredential",
db: AsyncSession,
tenant_id: uuid.UUID,
contact_id: uuid.UUID,
) -> List["IssuerCredential"]:
"""List by Contact ID.
Find and return list of Issuer Credential records for Contact.
tenant_id: Traction ID of tenant making the call
contact_id: Traction ID of Contact
Returns: List of Traction IssuerCredential (db) records in descending order
"""
q = (
select(cls)
.where(cls.contact_id == contact_id)
.where(cls.tenant_id == tenant_id)
.options(selectinload(cls.contact), selectinload(cls.credential_template))
.order_by(desc(cls.updated_at))
)
q_result = await db.execute(q)
db_recs = q_result.scalars()
return db_recs
@classmethod
async def list_by_tenant_id(
cls: "IssuerCredential",
db: AsyncSession,
tenant_id: uuid.UUID,
) -> List["IssuerCredential"]:
"""List by Tenant ID.
Find and return list of Issuer Credential records for Tenant.
tenant_id: Traction ID of tenant making the call
Returns: List of Traction Issuer Credential (db) records in descending order
"""
q = (
select(cls)
.where(cls.tenant_id == tenant_id)
.options(selectinload(cls.contact), selectinload(cls.credential_template))
.order_by(desc(cls.updated_at))
)
q_result = await db.execute(q)
db_recs = q_result.scalars()
return db_recs
@classmethod
async def list_by_thread_id(
cls: "IssuerCredential",
db: AsyncSession,
tenant_id: uuid.UUID,
thread_id: str,
) -> List["IssuerCredential"]:
"""List by Thread ID.
Find and return list of Issuer Credential records for Thread ID.
tenant_id: Traction ID of tenant making the call
thread_id: AcaPy Thread ID of Issuer Credential
Returns: List of Traction IssuerCredential (db) records in descending order
"""
q = (
select(cls)
.where(cls.thread_id == thread_id)
.where(cls.tenant_id == tenant_id)
.options(selectinload(cls.contact), selectinload(cls.credential_template))
.order_by(desc(cls.updated_at))
)
q_result = await db.execute(q)
db_recs = q_result.scalars()
return db_recs
class IssuerCredentialTimeline(BaseModel, table=True):
"""Issuer Credential Timeline.
Model for Issuer Credential Timeline table (postgresql specific dialects in use).
Timeline represents history of changes to status and/or state.
Attributes:
issuer_credential_timeline_id: Unique ID in table
issuer_credential_id: Traction Issuer Credential ID
status: Business and Tenant indicator for Issuer Credential state; independent of
AcaPy Credential State
state: The underlying AcaPy Credential state
created_at: Timestamp when record was created in Traction
"""
__tablename__ = "issuer_credential_timeline"
issuer_credential_timeline_id: uuid.UUID = Field(
sa_column=Column(
UUID(as_uuid=True),
primary_key=True,
server_default=text("gen_random_uuid()"),
)
)
issuer_credential_id: uuid.UUID = Field(
foreign_key="issuer_credential.issuer_credential_id", index=True
)
status: str = Field(nullable=False)
state: str = Field(nullable=False)
created_at: datetime = Field(
sa_column=Column(TIMESTAMP, nullable=False, server_default=func.now())
)
@classmethod
async def list_by_issuer_credential_id(
cls: "IssuerCredentialTimeline",
db: AsyncSession,
issuer_credential_id: UUID,
) -> List:
"""List by Issuer Credential ID.
Find and return list of Timeline records for Issuer Credential.
Args:
db: database session
issuer_credential_id: Traction ID of Issuer Credential
Returns: List of Traction Issuer Credential Timeline (db) records in descending
order
"""
q = (
select(cls)
.where(cls.issuer_credential_id == issuer_credential_id)
.order_by(desc(cls.created_at))
)
q_result = await db.execute(q)
db_items = q_result.scalars()
return db_items
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((2667, 2742), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""credential_template.credential_template_id"""', 'index': '(True)'}), "(foreign_key='credential_template.credential_template_id', index=True)\n", (2672, 2742), False, 'from sqlmodel import Field, Relationship\n'), ((2784, 2826), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""tenant.id"""', 'index': '(True)'}), "(foreign_key='tenant.id', index=True)\n", (2789, 2826), False, 'from sqlmodel import Field, Relationship\n'), ((2855, 2906), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""contact.contact_id"""', 'index': '(True)'}), "(foreign_key='contact.contact_id', index=True)\n", (2860, 2906), False, 'from sqlmodel import Field, Relationship\n'), ((2925, 2946), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (2930, 2946), False, 'from sqlmodel import Field, Relationship\n'), ((2980, 3000), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (2985, 3000), False, 'from sqlmodel import Field, Relationship\n'), ((3021, 3057), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'default': '(False)'}), '(nullable=False, default=False)\n', (3026, 3057), False, 'from sqlmodel import Field, Relationship\n'), ((3078, 3114), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'default': '(False)'}), '(nullable=False, default=False)\n', (3083, 3114), False, 'from sqlmodel import Field, Relationship\n'), ((3206, 3242), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'default': '(False)'}), '(nullable=False, default=False)\n', (3211, 3242), False, 'from sqlmodel import Field, Relationship\n'), ((3263, 3283), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (3268, 3283), False, 'from sqlmodel import Field, Relationship\n'), ((3314, 3334), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (3319, 3334), False, 'from sqlmodel import Field, Relationship\n'), ((3374, 3395), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (3379, 3395), False, 'from sqlmodel import Field, Relationship\n'), ((3419, 3452), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)', 'index': '(True)'}), '(nullable=False, index=True)\n', (3424, 3452), False, 'from sqlmodel import Field, Relationship\n'), ((3474, 3494), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (3479, 3494), False, 'from sqlmodel import Field, Relationship\n'), ((3529, 3549), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (3534, 3549), False, 'from sqlmodel import Field, Relationship\n'), ((3574, 3594), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (3579, 3594), False, 'from sqlmodel import Field, Relationship\n'), ((3620, 3640), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (3625, 3640), False, 'from sqlmodel import Field, Relationship\n'), ((3793, 3842), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""issuer_credentials"""'}), "(back_populates='issuer_credentials')\n", (3805, 3842), False, 'from sqlmodel import Field, Relationship\n'), ((3899, 3948), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""issuer_credentials"""'}), "(back_populates='issuer_credentials')\n", (3911, 3948), False, 'from sqlmodel import Field, Relationship\n'), ((12401, 12472), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""issuer_credential.issuer_credential_id"""', 'index': '(True)'}), "(foreign_key='issuer_credential.issuer_credential_id', index=True)\n", (12406, 12472), False, 'from sqlmodel import Field, Relationship\n'), ((12506, 12527), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (12511, 12527), False, 'from sqlmodel import Field, Relationship\n'), ((12545, 12566), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (12550, 12566), False, 'from sqlmodel import Field, Relationship\n'), ((3700, 3712), 'sqlalchemy.Column', 'Column', (['JSON'], {}), '(JSON)\n', (3706, 3712), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((5189, 5214), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.contact'], {}), '(cls.contact)\n', (5201, 5214), False, 'from sqlalchemy.orm import selectinload\n'), ((5216, 5253), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.credential_template'], {}), '(cls.credential_template)\n', (5228, 5253), False, 'from sqlalchemy.orm import selectinload\n'), ((5392, 5571), 'api.endpoints.models.v1.errors.NotFoundError', 'NotFoundError', ([], {'code': '"""issuer_credential.id_not_found"""', 'title': '"""Issuer Credential does not exist"""', 'detail': 'f"""Issuer Credential does not exist for id<{issuer_credential_id}>"""'}), "(code='issuer_credential.id_not_found', title=\n 'Issuer Credential does not exist', detail=\n f'Issuer Credential does not exist for id<{issuer_credential_id}>')\n", (5405, 5571), False, 'from api.endpoints.models.v1.errors import NotFoundError\n'), ((6543, 6568), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.contact'], {}), '(cls.contact)\n', (6555, 6568), False, 'from sqlalchemy.orm import selectinload\n'), ((6570, 6607), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.credential_template'], {}), '(cls.credential_template)\n', (6582, 6607), False, 'from sqlalchemy.orm import selectinload\n'), ((6746, 6971), 'api.endpoints.models.v1.errors.NotFoundError', 'NotFoundError', ([], {'code': '"""issuer_credential.credential_exchange_id_not_found"""', 'title': '"""Issuer Credential does not exist"""', 'detail': 'f"""Issuer Credential does not exist for credential exchange id<{credential_exchange_id}>"""'}), "(code='issuer_credential.credential_exchange_id_not_found',\n title='Issuer Credential does not exist', detail=\n f'Issuer Credential does not exist for credential exchange id<{credential_exchange_id}>'\n )\n", (6759, 6971), False, 'from api.endpoints.models.v1.errors import NotFoundError\n'), ((7909, 7929), 'sqlalchemy.desc', 'desc', (['cls.updated_at'], {}), '(cls.updated_at)\n', (7913, 7929), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((8812, 8832), 'sqlalchemy.desc', 'desc', (['cls.updated_at'], {}), '(cls.updated_at)\n', (8816, 8832), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((9699, 9719), 'sqlalchemy.desc', 'desc', (['cls.updated_at'], {}), '(cls.updated_at)\n', (9703, 9719), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((10459, 10479), 'sqlalchemy.desc', 'desc', (['cls.updated_at'], {}), '(cls.updated_at)\n', (10463, 10479), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((11350, 11370), 'sqlalchemy.desc', 'desc', (['cls.updated_at'], {}), '(cls.updated_at)\n', (11354, 11370), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((13338, 13358), 'sqlalchemy.desc', 'desc', (['cls.created_at'], {}), '(cls.created_at)\n', (13342, 13358), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((2507, 2525), 'sqlalchemy.dialects.postgresql.UUID', 'UUID', ([], {'as_uuid': '(True)'}), '(as_uuid=True)\n', (2511, 2525), False, 'from sqlalchemy.dialects.postgresql import UUID, TIMESTAMP, ARRAY\n'), ((3160, 3173), 'sqlalchemy.dialects.postgresql.ARRAY', 'ARRAY', (['String'], {}), '(String)\n', (3165, 3173), False, 'from sqlalchemy.dialects.postgresql import UUID, TIMESTAMP, ARRAY\n'), ((12243, 12261), 'sqlalchemy.dialects.postgresql.UUID', 'UUID', ([], {'as_uuid': '(True)'}), '(as_uuid=True)\n', (12247, 12261), False, 'from sqlalchemy.dialects.postgresql import UUID, TIMESTAMP, ARRAY\n'), ((2584, 2609), 'sqlalchemy.text', 'text', (['"""gen_random_uuid()"""'], {}), "('gen_random_uuid()')\n", (2588, 2609), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((4089, 4099), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (4097, 4099), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((4221, 4231), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (4229, 4231), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((4242, 4252), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (4250, 4252), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((7821, 7846), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.contact'], {}), '(cls.contact)\n', (7833, 7846), False, 'from sqlalchemy.orm import selectinload\n'), ((7848, 7885), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.credential_template'], {}), '(cls.credential_template)\n', (7860, 7885), False, 'from sqlalchemy.orm import selectinload\n'), ((8724, 8749), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.contact'], {}), '(cls.contact)\n', (8736, 8749), False, 'from sqlalchemy.orm import selectinload\n'), ((8751, 8788), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.credential_template'], {}), '(cls.credential_template)\n', (8763, 8788), False, 'from sqlalchemy.orm import selectinload\n'), ((9611, 9636), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.contact'], {}), '(cls.contact)\n', (9623, 9636), False, 'from sqlalchemy.orm import selectinload\n'), ((9638, 9675), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.credential_template'], {}), '(cls.credential_template)\n', (9650, 9675), False, 'from sqlalchemy.orm import selectinload\n'), ((10371, 10396), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.contact'], {}), '(cls.contact)\n', (10383, 10396), False, 'from sqlalchemy.orm import selectinload\n'), ((10398, 10435), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.credential_template'], {}), '(cls.credential_template)\n', (10410, 10435), False, 'from sqlalchemy.orm import selectinload\n'), ((11262, 11287), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.contact'], {}), '(cls.contact)\n', (11274, 11287), False, 'from sqlalchemy.orm import selectinload\n'), ((11289, 11326), 'sqlalchemy.orm.selectinload', 'selectinload', (['cls.credential_template'], {}), '(cls.credential_template)\n', (11301, 11326), False, 'from sqlalchemy.orm import selectinload\n'), ((12320, 12345), 'sqlalchemy.text', 'text', (['"""gen_random_uuid()"""'], {}), "('gen_random_uuid()')\n", (12324, 12345), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((12668, 12678), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (12676, 12678), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((13235, 13246), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (13241, 13246), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((6390, 6401), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (6396, 6401), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((10291, 10302), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (10297, 10302), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((4997, 5008), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (5003, 5008), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((7668, 7679), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (7674, 7679), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((8593, 8604), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (8599, 8604), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((9482, 9493), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (9488, 9493), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n'), ((11135, 11146), 'sqlalchemy.select', 'select', (['cls'], {}), '(cls)\n', (11141, 11146), False, 'from sqlalchemy import Column, func, String, select, desc, JSON, text\n')] |
"""init
Revision ID: 3b7e032d2384
Revises:
Create Date: 2021-10-01 02:25:02.820531
"""
import sqlalchemy as sa
import sqlmodel
from alembic import op
# revision identifiers, used by Alembic.
revision = "3b7e032d2384"
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table(
"prep",
sa.Column("address", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("country", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("city", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("email", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("website", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("details", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("p2p_endpoint", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("node_address", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("status", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("penalty", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("grade", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("last_updated_block", sa.Integer(), nullable=True),
sa.Column("last_updated_timestamp", sa.Integer(), nullable=True),
sa.Column("created_block", sa.Integer(), nullable=True),
sa.Column("created_timestamp", sa.Integer(), nullable=True),
sa.Column("logo_256", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("logo_1024", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("logo_svg", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("steemit", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("twitter", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("youtube", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("facebook", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("github", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("reddit", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("keybase", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("telegram", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("wechat", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("api_endpoint", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("server_country", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("server_city", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.Column("server_type", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
sa.PrimaryKeyConstraint("address"),
)
op.create_index(op.f("ix_prep_address"), "prep", ["address"], unique=False)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f("ix_prep_address"), table_name="prep")
op.drop_table("prep")
# ### end Alembic commands ###
| [
"sqlmodel.sql.sqltypes.AutoString"
] | [((3285, 3306), 'alembic.op.drop_table', 'op.drop_table', (['"""prep"""'], {}), "('prep')\n", (3298, 3306), False, 'from alembic import op\n'), ((2977, 3011), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""address"""'], {}), "('address')\n", (3000, 3011), True, 'import sqlalchemy as sa\n'), ((3039, 3062), 'alembic.op.f', 'op.f', (['"""ix_prep_address"""'], {}), "('ix_prep_address')\n", (3043, 3062), False, 'from alembic import op\n'), ((3237, 3260), 'alembic.op.f', 'op.f', (['"""ix_prep_address"""'], {}), "('ix_prep_address')\n", (3241, 3260), False, 'from alembic import op\n'), ((429, 463), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (461, 463), False, 'import sqlmodel\n'), ((508, 542), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (540, 542), False, 'import sqlmodel\n'), ((589, 623), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (621, 623), False, 'import sqlmodel\n'), ((667, 701), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (699, 701), False, 'import sqlmodel\n'), ((746, 780), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (778, 780), False, 'import sqlmodel\n'), ((827, 861), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (859, 861), False, 'import sqlmodel\n'), ((908, 942), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (940, 942), False, 'import sqlmodel\n'), ((994, 1028), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1026, 1028), False, 'import sqlmodel\n'), ((1080, 1114), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1112, 1114), False, 'import sqlmodel\n'), ((1160, 1194), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1192, 1194), False, 'import sqlmodel\n'), ((1241, 1275), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1273, 1275), False, 'import sqlmodel\n'), ((1320, 1354), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1352, 1354), False, 'import sqlmodel\n'), ((1412, 1424), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1422, 1424), True, 'import sqlalchemy as sa\n'), ((1486, 1498), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1496, 1498), True, 'import sqlalchemy as sa\n'), ((1551, 1563), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1561, 1563), True, 'import sqlalchemy as sa\n'), ((1620, 1632), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1630, 1632), True, 'import sqlalchemy as sa\n'), ((1680, 1714), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1712, 1714), False, 'import sqlmodel\n'), ((1763, 1797), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1795, 1797), False, 'import sqlmodel\n'), ((1845, 1879), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1877, 1879), False, 'import sqlmodel\n'), ((1926, 1960), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1958, 1960), False, 'import sqlmodel\n'), ((2007, 2041), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2039, 2041), False, 'import sqlmodel\n'), ((2088, 2122), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2120, 2122), False, 'import sqlmodel\n'), ((2170, 2204), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2202, 2204), False, 'import sqlmodel\n'), ((2250, 2284), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2282, 2284), False, 'import sqlmodel\n'), ((2330, 2364), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2362, 2364), False, 'import sqlmodel\n'), ((2411, 2445), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2443, 2445), False, 'import sqlmodel\n'), ((2493, 2527), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2525, 2527), False, 'import sqlmodel\n'), ((2573, 2607), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2605, 2607), False, 'import sqlmodel\n'), ((2659, 2693), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2691, 2693), False, 'import sqlmodel\n'), ((2747, 2781), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2779, 2781), False, 'import sqlmodel\n'), ((2832, 2866), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2864, 2866), False, 'import sqlmodel\n'), ((2917, 2951), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (2949, 2951), False, 'import sqlmodel\n')] |
import json
import requests
import base64, hashlib, hmac, time
import email.utils
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import padding
from urllib.parse import urlparse
from db.db import async_session
from models.users import RemoteUser
from sqlmodel import select
from activitypub.activitystreams import ActivityTypes
async def send_activity(private_key: str, user_id: str, target_id: str, body: dict):
# 1. Fetch target inbox
# 1.1 Check if we know the user's inbox
async with async_session() as s:
statement = select(RemoteUser).where(RemoteUser.remote_id == target_id)
results = await s.execute(statement)
user = results.first()
if user:
inbox = user[0].inbox
else:
# 1.2 If not, fetch from remote server
resp = requests.get(target_id, headers={'accept': 'application/activity+json'})
target = resp.json()
inbox = target['inbox']
remote_user = RemoteUser(remote_id=target_id, inbox=target['inbox'], public_key=target['publicKey']['publicKeyPem'])
async with async_session() as s:
s.add(remote_user)
await s.commit()
# 2. Send activity to target inbox
private_key = serialization.load_pem_private_key(private_key.encode('utf-8'), password=None)
urlparts = urlparse(target_id)
m = hashlib.sha256()
m.update(json.dumps(body).encode('utf-8'))
digestHash = base64.b64encode(m.digest()).decode()
created_timestamp = int(time.time())
header_time = email.utils.formatdate(created_timestamp, usegmt=True)
toSign = '(request-target): post {}\nhost: {}\ndate: {}\ndigest: SHA-256={}'.format(
urlparts.path,
urlparts.netloc,
header_time,
digestHash
)
signed = private_key.sign(
toSign.encode('utf-8'),
padding.PKCS1v15(),
hashes.SHA256()
)
signature = 'keyId="{}#main-key",headers="(request-target) host date digest",signature="{}"'.format(
user_id,
base64.b64encode(signed).decode(),
)
headers = {
'Content-type': 'application/ld+json',
'Host': urlparts.netloc,
'Date': header_time,
'Signature': signature,
'Digest': 'SHA-256={}'.format(digestHash)
}
resp = requests.post(inbox, json=body, headers=headers)
print(resp.text) | [
"sqlmodel.select"
] | [((1382, 1401), 'urllib.parse.urlparse', 'urlparse', (['target_id'], {}), '(target_id)\n', (1390, 1401), False, 'from urllib.parse import urlparse\n'), ((1411, 1427), 'hashlib.sha256', 'hashlib.sha256', ([], {}), '()\n', (1425, 1427), False, 'import base64, hashlib, hmac, time\n'), ((2347, 2395), 'requests.post', 'requests.post', (['inbox'], {'json': 'body', 'headers': 'headers'}), '(inbox, json=body, headers=headers)\n', (2360, 2395), False, 'import requests\n'), ((567, 582), 'db.db.async_session', 'async_session', ([], {}), '()\n', (580, 582), False, 'from db.db import async_session\n'), ((865, 937), 'requests.get', 'requests.get', (['target_id'], {'headers': "{'accept': 'application/activity+json'}"}), "(target_id, headers={'accept': 'application/activity+json'})\n", (877, 937), False, 'import requests\n'), ((1022, 1129), 'models.users.RemoteUser', 'RemoteUser', ([], {'remote_id': 'target_id', 'inbox': "target['inbox']", 'public_key': "target['publicKey']['publicKeyPem']"}), "(remote_id=target_id, inbox=target['inbox'], public_key=target[\n 'publicKey']['publicKeyPem'])\n", (1032, 1129), False, 'from models.users import RemoteUser\n'), ((1559, 1570), 'time.time', 'time.time', ([], {}), '()\n', (1568, 1570), False, 'import base64, hashlib, hmac, time\n'), ((1901, 1919), 'cryptography.hazmat.primitives.asymmetric.padding.PKCS1v15', 'padding.PKCS1v15', ([], {}), '()\n', (1917, 1919), False, 'from cryptography.hazmat.primitives.asymmetric import padding\n'), ((1929, 1944), 'cryptography.hazmat.primitives.hashes.SHA256', 'hashes.SHA256', ([], {}), '()\n', (1942, 1944), False, 'from cryptography.hazmat.primitives import hashes, serialization\n'), ((1144, 1159), 'db.db.async_session', 'async_session', ([], {}), '()\n', (1157, 1159), False, 'from db.db import async_session\n'), ((609, 627), 'sqlmodel.select', 'select', (['RemoteUser'], {}), '(RemoteUser)\n', (615, 627), False, 'from sqlmodel import select\n'), ((1441, 1457), 'json.dumps', 'json.dumps', (['body'], {}), '(body)\n', (1451, 1457), False, 'import json\n'), ((2082, 2106), 'base64.b64encode', 'base64.b64encode', (['signed'], {}), '(signed)\n', (2098, 2106), False, 'import base64, hashlib, hmac, time\n')] |
from typing import Any, Dict, List
from uuid import UUID
from sqlalchemy.orm import selectinload
from sqlmodel import select
from sqlmodel.ext.asyncio.session import AsyncSession
from service.crud.base import CRUDBase, ModelType
from service.models.models import Topic, TopicBase, TopicCreate, TopicModel, Word
class CRUDTopic(CRUDBase[Topic, TopicCreate, TopicBase]):
async def get_model_topics(
self, db: AsyncSession, *, model_id: UUID, version: int, with_words: bool = False
) -> List[ModelType]:
statement = (
select(self.model)
.join(TopicModel)
.filter(TopicModel.model_id == model_id, TopicModel.version == version)
.order_by(-self.model.count)
)
if with_words:
statement = statement.options(selectinload(self.model.top_words))
return (await db.execute(statement)).scalars().all()
async def save_topics(
self, db: AsyncSession, *, topics: List[Dict[str, Any]], model: TopicModel
) -> None:
for topic in topics:
db_obj = self.model.from_orm(
TopicCreate.parse_obj({**topic, "topic_model_id": model.id})
)
db.add(db_obj)
for word in topic["top_words"]:
db.add(Word.parse_obj({**word, "topic": db_obj}))
await db.commit()
topic = CRUDTopic(Topic)
| [
"sqlmodel.select"
] | [((805, 839), 'sqlalchemy.orm.selectinload', 'selectinload', (['self.model.top_words'], {}), '(self.model.top_words)\n', (817, 839), False, 'from sqlalchemy.orm import selectinload\n'), ((1115, 1175), 'service.models.models.TopicCreate.parse_obj', 'TopicCreate.parse_obj', (["{**topic, 'topic_model_id': model.id}"], {}), "({**topic, 'topic_model_id': model.id})\n", (1136, 1175), False, 'from service.models.models import Topic, TopicBase, TopicCreate, TopicModel, Word\n'), ((1284, 1325), 'service.models.models.Word.parse_obj', 'Word.parse_obj', (["{**word, 'topic': db_obj}"], {}), "({**word, 'topic': db_obj})\n", (1298, 1325), False, 'from service.models.models import Topic, TopicBase, TopicCreate, TopicModel, Word\n'), ((556, 574), 'sqlmodel.select', 'select', (['self.model'], {}), '(self.model)\n', (562, 574), False, 'from sqlmodel import select\n')] |
"""domain tag
Revision ID: 3321586ad6c4
Revises: <PASSWORD>
Create Date: 2021-11-27 19:30:48.062908
"""
import sqlalchemy as sa
import sqlmodel
import sqlmodel.sql.sqltypes
from alembic import op
# revision identifiers, used by Alembic.
revision = "3321586ad6c4"
down_revision = "7c2a518ed636"
branch_labels = None
depends_on = None
def upgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.add_column(
"domains",
sa.Column(
"tag", sqlmodel.sql.sqltypes.AutoString(), server_default="", nullable=False
),
)
# ### end Alembic commands ###
def downgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column("domains", "tag")
# ### end Alembic commands ###
| [
"sqlmodel.sql.sqltypes.AutoString"
] | [((722, 754), 'alembic.op.drop_column', 'op.drop_column', (['"""domains"""', '"""tag"""'], {}), "('domains', 'tag')\n", (736, 754), False, 'from alembic import op\n'), ((503, 537), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (535, 537), False, 'import sqlmodel\n')] |
from typing import Optional
from sqlmodel import Field, SQLModel
from alchemical import Alchemical
db = Alchemical('sqlite:///users.sqlite', model_class=SQLModel)
class User(db.Model, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str = Field(max_length=128)
def __repr__(self):
return f'<User {self.name}>'
db.drop_all()
db.create_all()
with db.begin() as session:
for name in ['mary', 'joe', 'susan']:
session.add(User(name=name))
with db.Session() as session:
print(session.scalars(User.select()).all())
| [
"sqlmodel.Field"
] | [((106, 164), 'alchemical.Alchemical', 'Alchemical', (['"""sqlite:///users.sqlite"""'], {'model_class': 'SQLModel'}), "('sqlite:///users.sqlite', model_class=SQLModel)\n", (116, 164), False, 'from alchemical import Alchemical\n'), ((225, 262), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (230, 262), False, 'from sqlmodel import Field, SQLModel\n'), ((279, 300), 'sqlmodel.Field', 'Field', ([], {'max_length': '(128)'}), '(max_length=128)\n', (284, 300), False, 'from sqlmodel import Field, SQLModel\n')] |
"""
dayong.operations
~~~~~~~~~~~~~~~~~
Data model operations which include retrieval and update commands.
"""
from typing import Any
import tanjun
from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
from sqlmodel import SQLModel, select
from sqlmodel.engine.result import ScalarResult
from sqlmodel.ext.asyncio.session import AsyncSession
from dayong.abc import Database
from dayong.core.configs import DayongConfig, DayongDynamicLoader
class DatabaseImpl(Database):
"""Implementaion of a database connection for transacting and interacting with
database tables —those that derive from SQLModel.
"""
_conn: AsyncEngine
@staticmethod
async def update(instance: Any, update: Any) -> Any:
"""Overwrite value of class attribute.
Args:
instance (Any): A Class instance.
update (Any): A dictionary containing the attributes to be overwritten.
Returns:
Any: A class instance with updated attribute values.
"""
for key, value in update.items():
setattr(instance, key, value)
return instance
async def connect(
self, config: DayongConfig = tanjun.injected(type=DayongConfig)
) -> None:
self._conn = create_async_engine(
config.database_uri
if config.database_uri
else DayongDynamicLoader().load().database_uri
)
async def create_table(self) -> None:
async with self._conn.begin() as conn:
await conn.run_sync(SQLModel.metadata.create_all)
async def add_row(self, table_model: SQLModel) -> None:
async with AsyncSession(self._conn) as session:
session.add(table_model)
await session.commit()
async def remove_row(self, table_model: SQLModel, attribute: str) -> None:
model = type(table_model)
async with AsyncSession(self._conn) as session:
# Temp ignore incompatible type passed to `exec()`. See:
# https://github.com/tiangolo/sqlmodel/issues/54
# https://github.com/tiangolo/sqlmodel/pull/58
row: ScalarResult[Any] = await session.exec(
select(model).where(
getattr(model, attribute) == getattr(table_model, attribute)
) # type: ignore
)
await session.delete(row.one())
await session.commit()
async def get_row(self, table_model: SQLModel, attribute: str) -> ScalarResult[Any]:
model = type(table_model)
async with AsyncSession(self._conn) as session:
# Temp ignore incompatible type passed to `exec()`. See:
# https://github.com/tiangolo/sqlmodel/issues/54
# https://github.com/tiangolo/sqlmodel/pull/58
row: ScalarResult[Any] = await session.exec(
select(model).where(
getattr(model, attribute) == getattr(table_model, attribute)
) # type: ignore
)
return row
async def get_all_row(self, table_model: type[SQLModel]) -> ScalarResult[Any]:
async with AsyncSession(self._conn) as session:
return await session.exec(select(table_model)) # type: ignore
async def update_row(self, table_model: SQLModel, attribute: str) -> None:
model = type(table_model)
table = table_model.__dict__
async with AsyncSession(self._conn) as session:
row: ScalarResult[Any] = await session.exec(
select(model).where(
getattr(model, attribute) == getattr(table_model, attribute)
) # type: ignore
)
task = row.one()
task = await self.update(task, table)
session.add(task)
await session.commit()
await session.refresh(task)
| [
"sqlmodel.ext.asyncio.session.AsyncSession",
"sqlmodel.select"
] | [((1190, 1224), 'tanjun.injected', 'tanjun.injected', ([], {'type': 'DayongConfig'}), '(type=DayongConfig)\n', (1205, 1224), False, 'import tanjun\n'), ((1650, 1674), 'sqlmodel.ext.asyncio.session.AsyncSession', 'AsyncSession', (['self._conn'], {}), '(self._conn)\n', (1662, 1674), False, 'from sqlmodel.ext.asyncio.session import AsyncSession\n'), ((1892, 1916), 'sqlmodel.ext.asyncio.session.AsyncSession', 'AsyncSession', (['self._conn'], {}), '(self._conn)\n', (1904, 1916), False, 'from sqlmodel.ext.asyncio.session import AsyncSession\n'), ((2563, 2587), 'sqlmodel.ext.asyncio.session.AsyncSession', 'AsyncSession', (['self._conn'], {}), '(self._conn)\n', (2575, 2587), False, 'from sqlmodel.ext.asyncio.session import AsyncSession\n'), ((3134, 3158), 'sqlmodel.ext.asyncio.session.AsyncSession', 'AsyncSession', (['self._conn'], {}), '(self._conn)\n', (3146, 3158), False, 'from sqlmodel.ext.asyncio.session import AsyncSession\n'), ((3417, 3441), 'sqlmodel.ext.asyncio.session.AsyncSession', 'AsyncSession', (['self._conn'], {}), '(self._conn)\n', (3429, 3441), False, 'from sqlmodel.ext.asyncio.session import AsyncSession\n'), ((3209, 3228), 'sqlmodel.select', 'select', (['table_model'], {}), '(table_model)\n', (3215, 3228), False, 'from sqlmodel import SQLModel, select\n'), ((1366, 1387), 'dayong.core.configs.DayongDynamicLoader', 'DayongDynamicLoader', ([], {}), '()\n', (1385, 1387), False, 'from dayong.core.configs import DayongConfig, DayongDynamicLoader\n'), ((2191, 2204), 'sqlmodel.select', 'select', (['model'], {}), '(model)\n', (2197, 2204), False, 'from sqlmodel import SQLModel, select\n'), ((2862, 2875), 'sqlmodel.select', 'select', (['model'], {}), '(model)\n', (2868, 2875), False, 'from sqlmodel import SQLModel, select\n'), ((3527, 3540), 'sqlmodel.select', 'select', (['model'], {}), '(model)\n', (3533, 3540), False, 'from sqlmodel import SQLModel, select\n')] |
from sqlmodel import Field, SQLModel
from pydantic import EmailStr
from fastapi_utils.guid_type import GUID, GUID_DEFAULT_SQLITE
import uuid
class User(SQLModel, table=True):
id: str = Field(default=str(GUID_DEFAULT_SQLITE()))
email: EmailStr = Field(primary_key=True)
firstName: str
lastName: str
disabled: bool = True
class UserResult:
id: str
class UserInDB(User):
hashed_password: str | [
"sqlmodel.Field"
] | [((254, 277), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (259, 277), False, 'from sqlmodel import Field, SQLModel\n'), ((208, 229), 'fastapi_utils.guid_type.GUID_DEFAULT_SQLITE', 'GUID_DEFAULT_SQLITE', ([], {}), '()\n', (227, 229), False, 'from fastapi_utils.guid_type import GUID, GUID_DEFAULT_SQLITE\n')] |
from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
from geoalchemy2.types import Geometry
from sqlmodel import Session, cast, select
from .database import engine
from .models import Country
app = FastAPI()
templates = Jinja2Templates(directory="geo_info_svg/templates")
@app.get("/", response_class=HTMLResponse)
async def test(request: Request):
with Session(engine) as session:
countries = session.exec(
select( # type: ignore
Country.name,
Country.population,
cast(Country.geometry, Geometry).ST_XMin(),
cast(Country.geometry, Geometry).ST_YMin(),
cast(Country.geometry, Geometry).ST_XMax(),
cast(Country.geometry, Geometry).ST_YMax(),
Country.geometry.ST_AsSVG(),
)
.order_by(Country.population.desc()) # type: ignore
.limit(10)
).all()
return templates.TemplateResponse(
"countries.html", {"request": request, "countries": countries}
)
| [
"sqlmodel.cast",
"sqlmodel.Session"
] | [((274, 283), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (281, 283), False, 'from fastapi import FastAPI, Request\n'), ((296, 347), 'fastapi.templating.Jinja2Templates', 'Jinja2Templates', ([], {'directory': '"""geo_info_svg/templates"""'}), "(directory='geo_info_svg/templates')\n", (311, 347), False, 'from fastapi.templating import Jinja2Templates\n'), ((436, 451), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (443, 451), False, 'from sqlmodel import Session, cast, select\n'), ((616, 648), 'sqlmodel.cast', 'cast', (['Country.geometry', 'Geometry'], {}), '(Country.geometry, Geometry)\n', (620, 648), False, 'from sqlmodel import Session, cast, select\n'), ((676, 708), 'sqlmodel.cast', 'cast', (['Country.geometry', 'Geometry'], {}), '(Country.geometry, Geometry)\n', (680, 708), False, 'from sqlmodel import Session, cast, select\n'), ((736, 768), 'sqlmodel.cast', 'cast', (['Country.geometry', 'Geometry'], {}), '(Country.geometry, Geometry)\n', (740, 768), False, 'from sqlmodel import Session, cast, select\n'), ((796, 828), 'sqlmodel.cast', 'cast', (['Country.geometry', 'Geometry'], {}), '(Country.geometry, Geometry)\n', (800, 828), False, 'from sqlmodel import Session, cast, select\n')] |
from sqlmodel import create_engine
from pyflarum.database.session import FlarumDatabase
from pyflarum.database.flarum.core.users import DB_User
DATABASE = FlarumDatabase(create_engine('sqlite:///tests/database/database.db'))
if __name__ == "__main__":
with DATABASE:
DATABASE.create_user(username='test_wfkeoge', password=b'<PASSWORD>', email='<EMAIL>')
saved = DATABASE.generic_filter(DB_User, username='test_wfkeoge').first()
print(saved)
| [
"sqlmodel.create_engine"
] | [((173, 226), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite:///tests/database/database.db"""'], {}), "('sqlite:///tests/database/database.db')\n", (186, 226), False, 'from sqlmodel import create_engine\n')] |
from sqlmodel import Field
from taskana_api.entities.tasks import TaskBase
class Task(TaskBase, table=True):
id: int = Field(primary_key=True)
| [
"sqlmodel.Field"
] | [((126, 149), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (131, 149), False, 'from sqlmodel import Field\n')] |
"""Patron CRUD controller."""
from typing import Any, Dict
import sqlmodel
from sqlmodel.ext.asyncio import session as aio_session
from app.core import security
from app.crud import base
from app.models import patron
class PatronCRUD(base.BaseCRUD[patron.Patron, patron.PatronCreate,
patron.PatronUpdate]):
"""CRUD controller for patrons.
It contains Create, Read, Update, and Delete methods and additional
methods for authentication and read by username.
"""
@classmethod
async def update(
cls, session: aio_session.AsyncSession, *, model_db: patron.Patron,
model_in: patron.PatronUpdate | Dict[str, Any]) -> patron.Patron:
"""Updates a patron.
Args:
session: The database session.
patron_db: The current patron's data.
patron_in: The updated patron's data.
Returns:
The updated patron.
"""
if isinstance(model_in, dict):
update_data = model_in
else:
update_data = model_in.dict(exclude_unset=True)
if update_data.get("password"):
hashed_password = security.get_password_hash(
update_data["password"])
del update_data["password"]
update_data["hashed_password"] = hashed_password
return await super().update(session,
model_db=model_db,
model_in=update_data)
@classmethod
async def get_by_username(cls, session: aio_session.AsyncSession,
username: str) -> patron.Patron | None:
"""Gets a patron by their username.
Args:
session: The database session.
username: The patron's username.
Returns:
The patron with the given username.
"""
patrons = await session.exec(
sqlmodel.select(
patron.Patron).where(patron.Patron.username == username))
return patrons.first()
@classmethod
async def authenticate(cls, session: aio_session.AsyncSession, *,
username: str, password: str) -> patron.Patron:
"""Authenticates the patron with given username and password.
Args:
session: The database session.
username: The patron's username.
password: The <PASSWORD>.
Returns:
The authenticated patron.
"""
user = await PatronCRUD.get_by_username(session, username)
if not user:
return None
if not security.verify_password(password, user.hashed_password):
return None
return user
| [
"sqlmodel.select"
] | [((1179, 1230), 'app.core.security.get_password_hash', 'security.get_password_hash', (["update_data['password']"], {}), "(update_data['password'])\n", (1205, 1230), False, 'from app.core import security\n'), ((2634, 2690), 'app.core.security.verify_password', 'security.verify_password', (['password', 'user.hashed_password'], {}), '(password, user.hashed_password)\n', (2658, 2690), False, 'from app.core import security\n'), ((1941, 1971), 'sqlmodel.select', 'sqlmodel.select', (['patron.Patron'], {}), '(patron.Patron)\n', (1956, 1971), False, 'import sqlmodel\n')] |
import os
from sqlmodel import create_engine, Session, select, update
from functools import lru_cache
from typing import Union
from sqlalchemy.exc import NoResultFound
engine = create_engine(os.environ.get('DB_CONN'))
# Grim hack to get the imports working with crawler and main.
# TODO: Split poke models and other common functions out into a separate package the api+crawler can share.
# TODO: After split crawler code out into a separate part of the repo and create an individual Docker image for it.
try:
from poke.poke_model import pokemon as pokemon_model
except:
from poke_model import pokemon as pokemon_model
@lru_cache(maxsize=16)
def get_pokemon(poke_id: int) -> pokemon_model:
""" Get a pokemon's data from the database from its ID.
Args:
poke_id: ID of the pokemon you want the data for.
Returns:
pokemon_model object containing the data for the pokemon found in the DB.
Raises:
NoResultFound: If there isn't a pokemon in the DB with the passed in ID.
"""
with Session(engine) as session:
poke = session.exec(select(pokemon_model).where(pokemon_model.id == poke_id)).one()
return poke
def get_total_pokemon() -> int:
""" Get the total number of pokemon in the database.
Returns:
int: Number of pokemon in the database.
"""
with Session(engine) as session:
return session.query(pokemon_model).count()
def upsert_pokemon(pokemon: Union[pokemon_model, list[pokemon_model]]) -> None:
""" Takes an individual, or list of pokemon_models that are to be added or updated in place.
Args:
pokemon: pokemon_model objects that are to be created/updated in place in the DB
"""
with Session(engine) as session:
if isinstance(pokemon, list):
# TODO: add bulk inserts
raise NotImplementedError
p = session.exec(select(pokemon_model).where(pokemon_model.id == pokemon.id))
try:
p.one() # see if there was a result for that poke_id
# TODO: Only update if the values are different than in the DB.
update(pokemon_model).where(pokemon_model.id == pokemon.id).values(pokemon.__dict__)
except NoResultFound:
session.add(pokemon)
session.commit()
| [
"sqlmodel.Session",
"sqlmodel.select",
"sqlmodel.update"
] | [((633, 654), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': '(16)'}), '(maxsize=16)\n', (642, 654), False, 'from functools import lru_cache\n'), ((193, 218), 'os.environ.get', 'os.environ.get', (['"""DB_CONN"""'], {}), "('DB_CONN')\n", (207, 218), False, 'import os\n'), ((1039, 1054), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1046, 1054), False, 'from sqlmodel import create_engine, Session, select, update\n'), ((1349, 1364), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1356, 1364), False, 'from sqlmodel import create_engine, Session, select, update\n'), ((1726, 1741), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1733, 1741), False, 'from sqlmodel import create_engine, Session, select, update\n'), ((1894, 1915), 'sqlmodel.select', 'select', (['pokemon_model'], {}), '(pokemon_model)\n', (1900, 1915), False, 'from sqlmodel import create_engine, Session, select, update\n'), ((1095, 1116), 'sqlmodel.select', 'select', (['pokemon_model'], {}), '(pokemon_model)\n', (1101, 1116), False, 'from sqlmodel import create_engine, Session, select, update\n'), ((2123, 2144), 'sqlmodel.update', 'update', (['pokemon_model'], {}), '(pokemon_model)\n', (2129, 2144), False, 'from sqlmodel import create_engine, Session, select, update\n')] |
from datetime import date
from typing import List, Optional
from rich.console import Console, ConsoleOptions, RenderResult
from rich.text import Text
from sqlmodel import Field, Relationship, SQLModel
class SpokenLanguageMovieLink(SQLModel, table=True):
spoken_language_id: Optional[int] = Field(
default=None, foreign_key="spoken_language.local_id", primary_key=True
)
movie_id: Optional[int] = Field(
default=None, foreign_key="movie.local_id", primary_key=True
)
class SpokenLanguage(SQLModel, table=True):
__tablename__ = "spoken_language"
local_id: Optional[int] = Field(default=None, primary_key=True)
english_name: Optional[str] = None
iso_639_1: Optional[str] = None
name: str
movies: List["Movie"] = Relationship(
back_populates="spoken_languages", link_model=SpokenLanguageMovieLink
)
def __rich_repr__(self):
yield self.name
class ProductionCountryMovieLink(SQLModel, table=True):
production_country_id: Optional[int] = Field(
default=None, foreign_key="production_country.local_id", primary_key=True
)
movie_id: Optional[int] = Field(
default=None, foreign_key="movie.local_id", primary_key=True
)
class ProductionCountry(SQLModel, table=True):
__tablename__ = "production_country"
local_id: Optional[int] = Field(default=None, primary_key=True)
iso_3166_1: Optional[str] = None
name: str
movies: List["Movie"] = Relationship(
back_populates="production_countries", link_model=ProductionCountryMovieLink
)
def __rich_repr__(self):
yield self.name
class ProductionCompanyMovieLink(SQLModel, table=True):
production_company_id: Optional[int] = Field(
default=None, foreign_key="production_company.local_id", primary_key=True
)
movie_id: Optional[int] = Field(
default=None, foreign_key="movie.local_id", primary_key=True
)
class ProductionCompany(SQLModel, table=True):
__tablename__ = "production_company"
local_id: Optional[int] = Field(default=None, primary_key=True)
id: int
name: str
origin_country: Optional[str] = None
logo_path: Optional[str] = None
movies: List["Movie"] = Relationship(
back_populates="production_companies", link_model=ProductionCompanyMovieLink
)
def __rich_repr__(self):
yield self.name
class Collection(SQLModel, table=True):
local_id: Optional[int] = Field(default=None, primary_key=True)
id: int
name: str
poster_path: Optional[str] = None
backdrop_path: Optional[str] = None
movies: List["Movie"] = Relationship(back_populates="collection")
def __rich_repr__(self):
yield self.name
class GenreMovieLink(SQLModel, table=True):
genre_id: Optional[int] = Field(
default=None, foreign_key="genre.local_id", primary_key=True
)
movie_id: Optional[int] = Field(
default=None, foreign_key="movie.local_id", primary_key=True
)
class Genre(SQLModel, table=True):
local_id: Optional[int] = Field(default=None, primary_key=True)
id: int
name: str
movies: List["Movie"] = Relationship(
back_populates="genres", link_model=GenreMovieLink
)
def __rich_repr__(self):
yield self.name
class Movie(SQLModel, table=True):
local_id: Optional[int] = Field(default=None, primary_key=True)
adult: Optional[bool] = None
backdrop_path: Optional[str] = None
collection_id: Optional[int] = Field(
default=None, foreign_key="collection.local_id"
)
collection: Optional[Collection] = Relationship(back_populates="movies")
budget: Optional[int] = None
genres: List[Genre] = Relationship(
back_populates="movies", link_model=GenreMovieLink
)
homepage: Optional[str] = None
id: int
imdb_id: Optional[str] = None
original_language: Optional[str] = None
original_title: Optional[str] = None
overview: Optional[str] = None
popularity: Optional[float] = None
poster_path: Optional[str] = None
production_companies: List[ProductionCompany] = Relationship(
back_populates="movies", link_model=ProductionCompanyMovieLink
)
production_countries: List[ProductionCountry] = Relationship(
back_populates="movies", link_model=ProductionCountryMovieLink
)
release_date: Optional[date] = Field(None, index=True)
revenue: Optional[int] = None
runtime: Optional[int] = None
spoken_languages: List[SpokenLanguage] = Relationship(
back_populates="movies", link_model=SpokenLanguageMovieLink
)
status: Optional[str] = None
tagline: Optional[str] = None
title: str = Field(..., index=True)
video: Optional[bool] = None
vote_average: Optional[float] = None
vote_count: Optional[int] = None
def __rich_repr__(self):
yield self.title
yield "overview", self.overview
yield "release_date", self.release_date
yield "runtime", f"{self.runtime} min"
yield "genres", self.genres
yield "collection", self.collection
yield "spoken_languages", self.spoken_languages
yield "revenue", f"{self.revenue / 1e6:.1f}M"
def __rich_console__(
self, console: Console, options: ConsoleOptions
) -> RenderResult:
yield Text(f"{self.title}", justify="center", style="bold magenta")
release_date_str = self.release_date.strftime("%b %d, %Y")
yield Text(f"Released: {release_date_str}")
yield Text(f"Runtime: {self.runtime} min")
genres_str = ", ".join([g.name for g in self.genres])
yield Text(f"Genres: {genres_str}")
return
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((297, 374), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""spoken_language.local_id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='spoken_language.local_id', primary_key=True)\n", (302, 374), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((419, 486), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""movie.local_id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='movie.local_id', primary_key=True)\n", (424, 486), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((615, 652), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (620, 652), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((770, 858), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""spoken_languages"""', 'link_model': 'SpokenLanguageMovieLink'}), "(back_populates='spoken_languages', link_model=\n SpokenLanguageMovieLink)\n", (782, 858), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((1023, 1108), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""production_country.local_id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='production_country.local_id', primary_key=True\n )\n", (1028, 1108), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((1148, 1215), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""movie.local_id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='movie.local_id', primary_key=True)\n", (1153, 1215), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((1350, 1387), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (1355, 1387), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((1467, 1562), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""production_countries"""', 'link_model': 'ProductionCountryMovieLink'}), "(back_populates='production_countries', link_model=\n ProductionCountryMovieLink)\n", (1479, 1562), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((1727, 1812), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""production_company.local_id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='production_company.local_id', primary_key=True\n )\n", (1732, 1812), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((1852, 1919), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""movie.local_id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='movie.local_id', primary_key=True)\n", (1857, 1919), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((2054, 2091), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (2059, 2091), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((2223, 2318), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""production_companies"""', 'link_model': 'ProductionCompanyMovieLink'}), "(back_populates='production_companies', link_model=\n ProductionCompanyMovieLink)\n", (2235, 2318), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((2454, 2491), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (2459, 2491), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((2624, 2665), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""collection"""'}), "(back_populates='collection')\n", (2636, 2665), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((2796, 2863), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""genre.local_id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='genre.local_id', primary_key=True)\n", (2801, 2863), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((2908, 2975), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""movie.local_id"""', 'primary_key': '(True)'}), "(default=None, foreign_key='movie.local_id', primary_key=True)\n", (2913, 2975), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((3057, 3094), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (3062, 3094), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((3149, 3213), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""genres"""', 'link_model': 'GenreMovieLink'}), "(back_populates='genres', link_model=GenreMovieLink)\n", (3161, 3213), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((3349, 3386), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (3354, 3386), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((3495, 3549), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""collection.local_id"""'}), "(default=None, foreign_key='collection.local_id')\n", (3500, 3549), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((3603, 3640), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""movies"""'}), "(back_populates='movies')\n", (3615, 3640), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((3700, 3764), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""movies"""', 'link_model': 'GenreMovieLink'}), "(back_populates='movies', link_model=GenreMovieLink)\n", (3712, 3764), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((4109, 4185), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""movies"""', 'link_model': 'ProductionCompanyMovieLink'}), "(back_populates='movies', link_model=ProductionCompanyMovieLink)\n", (4121, 4185), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((4252, 4328), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""movies"""', 'link_model': 'ProductionCountryMovieLink'}), "(back_populates='movies', link_model=ProductionCountryMovieLink)\n", (4264, 4328), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((4378, 4401), 'sqlmodel.Field', 'Field', (['None'], {'index': '(True)'}), '(None, index=True)\n', (4383, 4401), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((4515, 4588), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""movies"""', 'link_model': 'SpokenLanguageMovieLink'}), "(back_populates='movies', link_model=SpokenLanguageMovieLink)\n", (4527, 4588), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((4687, 4709), 'sqlmodel.Field', 'Field', (['...'], {'index': '(True)'}), '(..., index=True)\n', (4692, 4709), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((5322, 5383), 'rich.text.Text', 'Text', (['f"""{self.title}"""'], {'justify': '"""center"""', 'style': '"""bold magenta"""'}), "(f'{self.title}', justify='center', style='bold magenta')\n", (5326, 5383), False, 'from rich.text import Text\n'), ((5466, 5503), 'rich.text.Text', 'Text', (['f"""Released: {release_date_str}"""'], {}), "(f'Released: {release_date_str}')\n", (5470, 5503), False, 'from rich.text import Text\n'), ((5518, 5554), 'rich.text.Text', 'Text', (['f"""Runtime: {self.runtime} min"""'], {}), "(f'Runtime: {self.runtime} min')\n", (5522, 5554), False, 'from rich.text import Text\n'), ((5632, 5661), 'rich.text.Text', 'Text', (['f"""Genres: {genres_str}"""'], {}), "(f'Genres: {genres_str}')\n", (5636, 5661), False, 'from rich.text import Text\n')] |
from typing import Optional
from uuid import UUID
from ecoindex.models import Result
from sqlmodel import Field
class ApiEcoindex(Result, table=True):
id: Optional[UUID] = Field(
default=None, description="Analysis ID of type `UUID`", primary_key=True
)
host: str = Field(
default=..., title="Web page host", description="Host name of the web page"
)
version: int = Field(
default=1,
title="API version",
description="Version number of the API used to run the test",
)
| [
"sqlmodel.Field"
] | [((179, 258), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'description': '"""Analysis ID of type `UUID`"""', 'primary_key': '(True)'}), "(default=None, description='Analysis ID of type `UUID`', primary_key=True)\n", (184, 258), False, 'from sqlmodel import Field\n'), ((289, 376), 'sqlmodel.Field', 'Field', ([], {'default': '...', 'title': '"""Web page host"""', 'description': '"""Host name of the web page"""'}), "(default=..., title='Web page host', description=\n 'Host name of the web page')\n", (294, 376), False, 'from sqlmodel import Field\n'), ((405, 509), 'sqlmodel.Field', 'Field', ([], {'default': '(1)', 'title': '"""API version"""', 'description': '"""Version number of the API used to run the test"""'}), "(default=1, title='API version', description=\n 'Version number of the API used to run the test')\n", (410, 509), False, 'from sqlmodel import Field\n')] |
from typing import Optional, List
from sqlmodel import SQLModel, Field, Relationship
class SongBase(SQLModel):
name: str
artist: str
year: Optional[int] = None
class Song(SongBase, table=True):
id: int = Field(primary_key=True)
class SongRead(SongBase):
id: int
class SongCreate(SongBase):
pass
class Increment(SQLModel, table=True):
id: int = Field(primary_key=True)
# #############################################################################
class ListingBase(SQLModel):
url: str
class Listing(ListingBase, table=True):
__tablename__ = 'listings'
id: int = Field(primary_key=True)
images: List["Image"] = Relationship(back_populates="listing",
sa_relationship_kwargs={'lazy': 'selectin'})
class ListingRead(ListingBase):
id: str
# #############################################################################
class ImageBase(SQLModel):
url: str
size_x: float
size_y: float
listing_id: Optional[int] = Field(default=None, foreign_key="listings.id")
class Image(ImageBase, table=True):
__tablename__ = 'images'
id: int = Field(primary_key=True)
listing: Optional[Listing] = Relationship(back_populates="images",
sa_relationship_kwargs={'lazy': 'selectin'})
class ImageRead(ImageBase):
id: int
class ImageReadWithListings(ImageRead):
listing: Optional[Listing] = None
class ListingReadWithImages(ListingRead):
images: List["ImageRead"] = []
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((224, 247), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (229, 247), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((379, 402), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (384, 402), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((617, 640), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (622, 640), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((669, 756), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""listing"""', 'sa_relationship_kwargs': "{'lazy': 'selectin'}"}), "(back_populates='listing', sa_relationship_kwargs={'lazy':\n 'selectin'})\n", (681, 756), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((997, 1043), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""listings.id"""'}), "(default=None, foreign_key='listings.id')\n", (1002, 1043), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((1124, 1147), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (1129, 1147), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((1181, 1267), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""images"""', 'sa_relationship_kwargs': "{'lazy': 'selectin'}"}), "(back_populates='images', sa_relationship_kwargs={'lazy':\n 'selectin'})\n", (1193, 1267), False, 'from sqlmodel import SQLModel, Field, Relationship\n')] |
from typing import Optional
from sqlmodel import Field, SQLModel
__all__ = ['User']
class User(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
username: str = Field(index=False, nullable=False)
password: str = Field(index=False, nullable=False)
| [
"sqlmodel.Field"
] | [((146, 183), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (151, 183), False, 'from sqlmodel import Field, SQLModel\n'), ((204, 238), 'sqlmodel.Field', 'Field', ([], {'index': '(False)', 'nullable': '(False)'}), '(index=False, nullable=False)\n', (209, 238), False, 'from sqlmodel import Field, SQLModel\n'), ((259, 293), 'sqlmodel.Field', 'Field', ([], {'index': '(False)', 'nullable': '(False)'}), '(index=False, nullable=False)\n', (264, 293), False, 'from sqlmodel import Field, SQLModel\n')] |
from typing import List, Optional
from sqlmodel import Field, Relationship, SQLModel
class Sport(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
athletes: List["Athlete"] = Relationship(back_populates="sport")
class Athlete(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
sport_id: Optional[int] = Field(default=None, foreign_key="sport.id")
sport: Optional[Sport] = Relationship(back_populates="athletes")
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((147, 184), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (152, 184), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((231, 267), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""sport"""'}), "(back_populates='sport')\n", (243, 267), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((331, 368), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (336, 368), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((413, 456), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""sport.id"""'}), "(default=None, foreign_key='sport.id')\n", (418, 456), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((486, 525), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""athletes"""'}), "(back_populates='athletes')\n", (498, 525), False, 'from sqlmodel import Field, Relationship, SQLModel\n')] |
from typing import List, Optional
from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select
class Team(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str = Field(index=True)
headquarters: str
heroes: List["Hero"] = Relationship()
class Hero(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str = Field(index=True)
secret_name: str
age: Optional[int] = Field(default=None, index=True)
team_id: Optional[int] = Field(default=None, foreign_key="team.id")
team: Optional[Team] = Relationship()
sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"
engine = create_engine(sqlite_url, echo=True)
def create_db_and_tables():
SQLModel.metadata.create_all(engine)
def create_heroes():
with Session(engine) as session:
team_preventers = Team(name="Preventers", headquarters="Sharp Tower")
team_z_force = Team(name="Z-Force", headquarters="Sister Margaret’s Bar")
hero_deadpond = Hero(
name="Deadpond", secret_name="<NAME>", team=team_z_force
)
hero_rusty_man = Hero(
name="Rusty-Man", secret_name="<NAME>", age=48, team=team_preventers
)
hero_spider_boy = Hero(name="Spider-Boy", secret_name="<NAME>")
session.add(hero_deadpond)
session.add(hero_rusty_man)
session.add(hero_spider_boy)
session.commit()
session.refresh(hero_deadpond)
session.refresh(hero_rusty_man)
session.refresh(hero_spider_boy)
print("Created hero:", hero_deadpond)
print("Created hero:", hero_rusty_man)
print("Created hero:", hero_spider_boy)
hero_spider_boy.team = team_preventers
session.add(hero_spider_boy)
session.commit()
session.refresh(hero_spider_boy)
print("Updated hero:", hero_spider_boy)
hero_black_lion = Hero(name="<NAME>", secret_name="<NAME>", age=35)
hero_sure_e = Hero(name="<NAME>", secret_name="Sure-E")
team_wakaland = Team(
name="Wakaland",
headquarters="Wakaland Capital City",
heroes=[hero_black_lion, hero_sure_e],
)
session.add(team_wakaland)
session.commit()
session.refresh(team_wakaland)
print("Team Wakaland:", team_wakaland)
hero_tarantula = Hero(name="Tarantula", secret_name="<NAME>", age=32)
hero_dr_weird = Hero(name="<NAME>", secret_name="<NAME>", age=36)
hero_cap = Hero(
name="Captain North America", secret_name="<NAME>", age=93
)
team_preventers.heroes.append(hero_tarantula)
team_preventers.heroes.append(hero_dr_weird)
team_preventers.heroes.append(hero_cap)
session.add(team_preventers)
session.commit()
session.refresh(hero_tarantula)
session.refresh(hero_dr_weird)
session.refresh(hero_cap)
print("Preventers new hero:", hero_tarantula)
print("Preventers new hero:", hero_dr_weird)
print("Preventers new hero:", hero_cap)
def select_heroes():
with Session(engine) as session:
statement = select(Team).where(Team.name == "Preventers")
result = session.exec(statement)
team_preventers = result.one()
print("Preventers heroes:", team_preventers.heroes)
def update_heroes():
with Session(engine) as session:
hero_spider_boy = session.exec(
select(Hero).where(Hero.name == "Spider-Boy")
).one()
preventers_team = session.exec(
select(Team).where(Team.name == "Preventers")
).one()
print("Hero Spider-Boy:", hero_spider_boy)
print("Preventers Team:", preventers_team)
print("Preventers Team Heroes:", preventers_team.heroes)
hero_spider_boy.team = None
print("Spider-Boy without team:", hero_spider_boy)
print("Preventers Team Heroes again:", preventers_team.heroes)
session.add(hero_spider_boy)
session.commit()
print("After committing")
session.refresh(hero_spider_boy)
print("Spider-Boy after commit:", hero_spider_boy)
print("Preventers Team Heroes after commit:", preventers_team.heroes)
def main():
create_db_and_tables()
create_heroes()
select_heroes()
update_heroes()
if __name__ == "__main__":
main()
| [
"sqlmodel.Relationship",
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.select"
] | [((730, 766), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (743, 766), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((178, 215), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (183, 215), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((232, 249), 'sqlmodel.Field', 'Field', ([], {'index': '(True)'}), '(index=True)\n', (237, 249), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((300, 314), 'sqlmodel.Relationship', 'Relationship', ([], {}), '()\n', (312, 314), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((375, 412), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (380, 412), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((429, 446), 'sqlmodel.Field', 'Field', ([], {'index': '(True)'}), '(index=True)\n', (434, 446), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((493, 524), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'index': '(True)'}), '(default=None, index=True)\n', (498, 524), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((555, 597), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""team.id"""'}), "(default=None, foreign_key='team.id')\n", (560, 597), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((625, 639), 'sqlmodel.Relationship', 'Relationship', ([], {}), '()\n', (637, 639), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((801, 837), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (829, 837), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((870, 885), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (877, 885), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3191, 3206), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (3198, 3206), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3458, 3473), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (3465, 3473), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3239, 3251), 'sqlmodel.select', 'select', (['Team'], {}), '(Team)\n', (3245, 3251), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3538, 3550), 'sqlmodel.select', 'select', (['Hero'], {}), '(Hero)\n', (3544, 3550), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3653, 3665), 'sqlmodel.select', 'select', (['Team'], {}), '(Team)\n', (3659, 3665), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n')] |
from typing import Union
from uuid import uuid4
import inject
from sqlmodel import Session, select
from src.core.events import EventDescription
from src.core.models import Context, File
from src.core.services import Storage, Streamer
from src.utils.miscellaneous import get_file_hash
@inject.params(streamer=Streamer, storage=Storage)
def get_or_create_file(
session: Session,
preffix: str,
filename: str,
file: Union[str, bytes],
context: Context,
streamer: Streamer,
storage: Storage,
) -> File:
file_hash = get_file_hash(file)
file_obj = session.exec(select(File).where(File.hash == file_hash)).first()
extension = filename.split(".")[-1]
if not file_obj:
streamer.send_event(
EventDescription.UPLOAD_FILE, context=context, file={"filename": filename, "hash": file_hash}
)
file_obj = File(bucket_key=f"{preffix}-{uuid4()}.{extension}", hash=file_hash)
session.add(file_obj)
if not storage.check_file_exists(file_obj.bucket_key):
storage.upload_file(file, key=file_obj.bucket_key)
streamer.send_event(
EventDescription.UPLOAD_FILE,
context=context,
file={"filename": filename, "hash": file_hash, "bucket_key": file_obj.bucket_key},
)
return file_obj
@inject.params(storage=Storage)
def check_file_exists(bucket_key: str, storage: Storage) -> bool:
return storage.check_file_exists(bucket_key)
| [
"sqlmodel.select"
] | [((289, 338), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer', 'storage': 'Storage'}), '(streamer=Streamer, storage=Storage)\n', (302, 338), False, 'import inject\n'), ((1318, 1348), 'inject.params', 'inject.params', ([], {'storage': 'Storage'}), '(storage=Storage)\n', (1331, 1348), False, 'import inject\n'), ((546, 565), 'src.utils.miscellaneous.get_file_hash', 'get_file_hash', (['file'], {}), '(file)\n', (559, 565), False, 'from src.utils.miscellaneous import get_file_hash\n'), ((594, 606), 'sqlmodel.select', 'select', (['File'], {}), '(File)\n', (600, 606), False, 'from sqlmodel import Session, select\n'), ((901, 908), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (906, 908), False, 'from uuid import uuid4\n')] |
from datetime import datetime
from typing import TYPE_CHECKING, Optional
from models.base import BaseModel, BaseTableFields
from sqlmodel import Field, Relationship, Column, String
if TYPE_CHECKING:
from models.user import User
class Session(BaseModel, BaseTableFields, table=True):
__tablename__ = "sessions"
access_token: str = Field(
sa_column=Column(
String,
unique=True,
nullable=False
)
)
ip_address: Optional[str] = Field(
sa_column=Column(
String(100),
nullable=True
)
)
user_agent: Optional[str] = Field(
sa_column=Column(
String(100),
nullable=True
)
)
user_id: int = Field(foreign_key="users.id")
user: "User" = Relationship(back_populates="sessions")
class SessionRead(BaseModel):
id: int
access_token: str
ip_address: Optional[str]
user_agent: Optional[str]
created_at: datetime
updated_at: datetime
is_active: bool
class SessionCreate(BaseModel):
access_token: str
ip_address: Optional[str]
user_agent: Optional[str]
user_id: int
class SessionUpdate(BaseModel):
is_active: Optional[bool] = None
| [
"sqlmodel.String",
"sqlmodel.Relationship",
"sqlmodel.Field",
"sqlmodel.Column"
] | [((751, 780), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""users.id"""'}), "(foreign_key='users.id')\n", (756, 780), False, 'from sqlmodel import Field, Relationship, Column, String\n'), ((800, 839), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""sessions"""'}), "(back_populates='sessions')\n", (812, 839), False, 'from sqlmodel import Field, Relationship, Column, String\n'), ((371, 414), 'sqlmodel.Column', 'Column', (['String'], {'unique': '(True)', 'nullable': '(False)'}), '(String, unique=True, nullable=False)\n', (377, 414), False, 'from sqlmodel import Field, Relationship, Column, String\n'), ((544, 555), 'sqlmodel.String', 'String', (['(100)'], {}), '(100)\n', (550, 555), False, 'from sqlmodel import Field, Relationship, Column, String\n'), ((676, 687), 'sqlmodel.String', 'String', (['(100)'], {}), '(100)\n', (682, 687), False, 'from sqlmodel import Field, Relationship, Column, String\n')] |
from typing import Optional
from fastapi import FastAPI
from sqlmodel import Session, SQLModel, create_engine
from .abstractions import MultipleModels, register_endpoints
class HeroBase(SQLModel):
name: str
secret_name: str
age: Optional[int] = None
class HeroRead(HeroBase):
id: int
hero_models = MultipleModels(path="/heroes/", base=HeroBase, response=HeroRead)
Hero = hero_models.table # Shim to avoid changing tests.
sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"
connect_args = {"check_same_thread": False}
engine = create_engine(sqlite_url, echo=True, connect_args=connect_args)
def create_db_and_tables():
SQLModel.metadata.create_all(engine)
def get_session():
with Session(engine) as session:
yield session
app = FastAPI()
register_endpoints(app, models=hero_models, get_session=get_session)
| [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.create_engine"
] | [((579, 642), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)', 'connect_args': 'connect_args'}), '(sqlite_url, echo=True, connect_args=connect_args)\n', (592, 642), False, 'from sqlmodel import Session, SQLModel, create_engine\n'), ((802, 811), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (809, 811), False, 'from fastapi import FastAPI\n'), ((677, 713), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (705, 713), False, 'from sqlmodel import Session, SQLModel, create_engine\n'), ((744, 759), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (751, 759), False, 'from sqlmodel import Session, SQLModel, create_engine\n')] |
from popol.db.sqlmodel import models
from sqlmodel import Field
class Account(models.Model, table=True):
username: str = Field(max_length=255, nullable=False)
password: str = Field(max_length=255, nullable=False)
class Counter(models.Model, table=True):
value: int
| [
"sqlmodel.Field"
] | [((127, 164), 'sqlmodel.Field', 'Field', ([], {'max_length': '(255)', 'nullable': '(False)'}), '(max_length=255, nullable=False)\n', (132, 164), False, 'from sqlmodel import Field\n'), ((185, 222), 'sqlmodel.Field', 'Field', ([], {'max_length': '(255)', 'nullable': '(False)'}), '(max_length=255, nullable=False)\n', (190, 222), False, 'from sqlmodel import Field\n')] |
import requests
import logging
import us
from pydantic import validator
from sqlmodel import Field, SQLModel, Session, create_engine
import json
from os.path import exists
# Define the Store model
# The model is a SQLModel so it gets Pydantic and SQLAlchemy methods
# It will be a SQL table with the name 'store'
class Store(SQLModel, table=True):
id: str = Field(default=None, primary_key=True)
name: str
state: str
latitude: float
longitude: float
# Grab the needed fields from the data from the API
def __init__(self, source_data):
self.id = source_data['key']['id']
self.name = source_data['name']['label']
self.state = source_data['location']['address']['administrativeArea']
self.latitude = source_data['location']['geo']['latitude']
self.longitude = source_data['location']['geo']['longitude']
# Verify that the State is a valid US state or territory
@validator('state')
def validate_state(cls, v):
v = us.states.lookup(v)
if v not in us.states.STATES_AND_TERRITORIES:
raise ValueError(f'{v} is not a valid state')
return v
# Verify that the latitude is a float and between -90 and 90
@validator('latitude')
def validate_latitude(cls, v):
v = float(v)
if v < -90 or v > 90:
raise ValueError(f'{v} is not a valid latitude')
return v
# Verify that the longitude is a float and between -180 and 180
@validator('longitude')
def validate_longitude(cls, v):
v = float(v)
if v < -180 or v > 180:
raise ValueError(f'{v} is not a valid longitude')
return v
# Verify that the name is a string and not empty
@validator('name')
def validate_name(cls, v):
if len(v) < 1:
raise ValueError(f'{v} is not a valid name')
return v
# read the store data from the provided filepath or if the file does not exist pull the store data from the API
def extract(filepath: str, url: str) -> dict:
# try filepath
if exists(filepath):
with open(filepath, 'r') as f:
return json.load(f)
# try API
try:
r = requests.get(url)
r.raise_for_status()
logging.info('Successfully retrieved stores data')
return r.json()
except Exception as e:
logging.warning(f'Error getting stores data: {e}')
return None
# transform the data into a list of Store objects
def transform(data: dict) -> dict:
stores = []
if 'store' in data:
for s in data['store']:
try:
stores.append(Store(s))
except Exception as e:
logging.warning(f'Error transforming store: {e}')
return stores
return None
# load the data into the database
def load(stores: list, engine) -> None:
if not stores:
logging.warning('No stores to load')
return
try:
# Create a session to connect to the database
with Session(engine) as session:
# add the stores to the database
session.add_all(stores)
session.commit()
logging.info(f'Successfully loaded {len(stores)} stores')
except Exception as e:
logging.warning(f'Error loading stores: {e}')
# main function to be called by the pipeline
def run(filepath: str, stores_url: str, engine):
data = extract(filepath, stores_url)
logging.debug(data.keys())
stores = transform(data)
load(stores, engine) | [
"sqlmodel.Session",
"sqlmodel.Field"
] | [((363, 400), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (368, 400), False, 'from sqlmodel import Field, SQLModel, Session, create_engine\n'), ((938, 956), 'pydantic.validator', 'validator', (['"""state"""'], {}), "('state')\n", (947, 956), False, 'from pydantic import validator\n'), ((1221, 1242), 'pydantic.validator', 'validator', (['"""latitude"""'], {}), "('latitude')\n", (1230, 1242), False, 'from pydantic import validator\n'), ((1481, 1503), 'pydantic.validator', 'validator', (['"""longitude"""'], {}), "('longitude')\n", (1490, 1503), False, 'from pydantic import validator\n'), ((1731, 1748), 'pydantic.validator', 'validator', (['"""name"""'], {}), "('name')\n", (1740, 1748), False, 'from pydantic import validator\n'), ((2062, 2078), 'os.path.exists', 'exists', (['filepath'], {}), '(filepath)\n', (2068, 2078), False, 'from os.path import exists\n'), ((1001, 1020), 'us.states.lookup', 'us.states.lookup', (['v'], {}), '(v)\n', (1017, 1020), False, 'import us\n'), ((2191, 2208), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (2203, 2208), False, 'import requests\n'), ((2246, 2296), 'logging.info', 'logging.info', (['"""Successfully retrieved stores data"""'], {}), "('Successfully retrieved stores data')\n", (2258, 2296), False, 'import logging\n'), ((2883, 2919), 'logging.warning', 'logging.warning', (['"""No stores to load"""'], {}), "('No stores to load')\n", (2898, 2919), False, 'import logging\n'), ((2138, 2150), 'json.load', 'json.load', (['f'], {}), '(f)\n', (2147, 2150), False, 'import json\n'), ((2356, 2406), 'logging.warning', 'logging.warning', (['f"""Error getting stores data: {e}"""'], {}), "(f'Error getting stores data: {e}')\n", (2371, 2406), False, 'import logging\n'), ((3011, 3026), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (3018, 3026), False, 'from sqlmodel import Field, SQLModel, Session, create_engine\n'), ((3254, 3299), 'logging.warning', 'logging.warning', (['f"""Error loading stores: {e}"""'], {}), "(f'Error loading stores: {e}')\n", (3269, 3299), False, 'import logging\n'), ((2693, 2742), 'logging.warning', 'logging.warning', (['f"""Error transforming store: {e}"""'], {}), "(f'Error transforming store: {e}')\n", (2708, 2742), False, 'import logging\n')] |
from datetime import datetime
from typing import TYPE_CHECKING, Dict, List, Optional
from pydantic import root_validator
from sqlalchemy import Column
from sqlmodel import Field, Relationship, SQLModel
from .event_attendance import EventAttendance
from .types import TimeStamp
if TYPE_CHECKING:
from .feedback import Feedback, FeedbackList
from .participant import Participant, ParticipantList
class EventBase(SQLModel):
name: str
code: str
valid_from: datetime = Field(
sa_column=Column(
TimeStamp(timezone=True),
default=datetime.now,
nullable=False,
)
)
valid_until: datetime = Field(
sa_column=Column(
TimeStamp(timezone=True),
default=datetime.now,
nullable=False,
)
)
enabled: bool = Field(default=True, nullable=False)
@root_validator()
def range_is_positive(cls, values: Dict[str, datetime]):
start, end = values.get("valid_from"), values.get("valid_until")
if start is None or end is None:
return values
elif end < start:
raise ValueError("validity range cannot be negative")
return values
class Event(EventBase, table=True):
__tablename__ = "events"
id: Optional[int] = Field(default=None, primary_key=True, nullable=False)
attendees: List["Participant"] = Relationship(
back_populates="attended",
link_model=EventAttendance,
)
feedback: List["Feedback"] = Relationship(
back_populates="event",
sa_relationship_kwargs={"cascade": "all, delete, delete-orphan"},
)
class EventCreate(SQLModel):
name: str
valid_from: datetime
valid_until: datetime
class EventList(SQLModel):
id: int
name: str
code: str
enabled: bool
class EventRead(EventBase):
id: int
feedback: List["FeedbackList"]
attendees: List["ParticipantList"]
class EventUpdate(SQLModel):
name: Optional[str]
valid_from: Optional[datetime]
valid_until: Optional[datetime]
enabled: Optional[bool]
| [
"sqlmodel.Field",
"sqlmodel.Relationship"
] | [((838, 873), 'sqlmodel.Field', 'Field', ([], {'default': '(True)', 'nullable': '(False)'}), '(default=True, nullable=False)\n', (843, 873), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((880, 896), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (894, 896), False, 'from pydantic import root_validator\n'), ((1305, 1358), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)', 'nullable': '(False)'}), '(default=None, primary_key=True, nullable=False)\n', (1310, 1358), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((1397, 1464), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""attended"""', 'link_model': 'EventAttendance'}), "(back_populates='attended', link_model=EventAttendance)\n", (1409, 1464), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((1521, 1627), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""event"""', 'sa_relationship_kwargs': "{'cascade': 'all, delete, delete-orphan'}"}), "(back_populates='event', sa_relationship_kwargs={'cascade':\n 'all, delete, delete-orphan'})\n", (1533, 1627), False, 'from sqlmodel import Field, Relationship, SQLModel\n')] |
from sqlmodel import create_engine
from config import settings
engine = create_engine(settings.database_url)
| [
"sqlmodel.create_engine"
] | [((73, 109), 'sqlmodel.create_engine', 'create_engine', (['settings.database_url'], {}), '(settings.database_url)\n', (86, 109), False, 'from sqlmodel import create_engine\n')] |
from typing import Optional
import pandas as pd
import streamlit as st
import os
from sqlmodel import Field, Session, SQLModel, create_engine, select
class Hero(SQLModel, table=True):
__table_args__ = {'extend_existing': True} # required for streamlit refreshing
id: Optional[int] = Field(default=None, primary_key=True)
name: str
secret_name: str
age: Optional[int] = None
sqlite_file_name = 'database.db'
sqlite_url = f"sqlite:///{sqlite_file_name}"
engine = create_engine(sqlite_url, echo=True)
def create_db_and_tables():
SQLModel.metadata.create_all(engine)
def create_heroes():
hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36)
hero_2 = Hero(name="Tarantula", secret_name="<NAME>", age=26)
hero_3 = Hero(name="<NAME>", secret_name="<NAME>", age=33)
with Session(engine) as session:
session.add(hero_1)
session.add(hero_2)
session.add(hero_3)
session.commit()
def get_db_size():
with Session(engine) as session:
heroes = session.exec(select(Hero)).all()
return len(heroes)
def select_heros():
with Session(engine) as session:
statement = select(Hero).where(Hero.age <= 35)
results = session.exec(statement)
for hero in results:
st.text(hero)
#st.text(len(results))
def show_table():
with Session(engine) as session:
heroes = session.exec(select(Hero)).all()
st.table(pd.DataFrame([s.dict() for s in heroes[-5:]]))
def delete_db():
with Session(engine) as session:
heroes = session.exec(select(Hero)).all()
for hero in heroes:
session.delete(hero)
session.commit()
st.text("Deleted all rows")
def write_new_row():
with st.form('new_row'):
name_input = st.text_input('Name', value="<NAME>")
secret_name = st.text_input('Secret alias', value="Dr. Jon")
submitted = st.form_submit_button("Submit")
if submitted:
hero = Hero(name=name_input, secret_name=secret_name, age=23)
st.write('submitted')
hero_1 = Hero(name="Rusty-Man", secret_name="<NAME>", age=36)
with Session(engine) as session:
session.add(hero_1)
session.commit()
# ====================================== main ====================================== #
def main():
create_db_and_tables()
st.title('🦄 SQLModel Demo')
b1, b2, b3, b4= st.columns(4)
#if b1.button('Add Filter'):
# pass
#select_heros() # todo
if b4.button("♻️ Empty db"):
delete_db()
#if b2.button('Create db'):
# create_db_and_tables()
if b3.button('+ Add 3 rows'):
create_heroes()
if st.button("➡️ Insert Row"):
write_new_row()
show_table()
col0, col1, col2 = st.columns(3)
file_size = os.path.getsize('database.db')
col1.metric("💾 database.db", f"{get_db_size()}", "total rows")
col2.metric("filesize", f"{file_size/1000:0.1f}", 'kb')
if __name__ == '__main__':
st.set_page_config(
page_title="SQLModel Demo",
page_icon="🦄",
layout="centered",
initial_sidebar_state="auto")
main()
| [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.select"
] | [((487, 523), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)'}), '(sqlite_url, echo=True)\n', (500, 523), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((294, 331), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (299, 331), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((558, 594), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (586, 594), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((1703, 1730), 'streamlit.text', 'st.text', (['"""Deleted all rows"""'], {}), "('Deleted all rows')\n", (1710, 1730), True, 'import streamlit as st\n'), ((2419, 2446), 'streamlit.title', 'st.title', (['"""🦄 SQLModel Demo"""'], {}), "('🦄 SQLModel Demo')\n", (2427, 2446), True, 'import streamlit as st\n'), ((2467, 2480), 'streamlit.columns', 'st.columns', (['(4)'], {}), '(4)\n', (2477, 2480), True, 'import streamlit as st\n'), ((2745, 2771), 'streamlit.button', 'st.button', (['"""➡️ Insert Row"""'], {}), "('➡️ Insert Row')\n", (2754, 2771), True, 'import streamlit as st\n'), ((2838, 2851), 'streamlit.columns', 'st.columns', (['(3)'], {}), '(3)\n', (2848, 2851), True, 'import streamlit as st\n'), ((2868, 2898), 'os.path.getsize', 'os.path.getsize', (['"""database.db"""'], {}), "('database.db')\n", (2883, 2898), False, 'import os\n'), ((3059, 3174), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': '"""SQLModel Demo"""', 'page_icon': '"""🦄"""', 'layout': '"""centered"""', 'initial_sidebar_state': '"""auto"""'}), "(page_title='SQLModel Demo', page_icon='🦄', layout=\n 'centered', initial_sidebar_state='auto')\n", (3077, 3174), True, 'import streamlit as st\n'), ((822, 837), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (829, 837), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((989, 1004), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (996, 1004), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((1121, 1136), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1128, 1136), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((1361, 1376), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1368, 1376), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((1531, 1546), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1538, 1546), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((1766, 1784), 'streamlit.form', 'st.form', (['"""new_row"""'], {}), "('new_row')\n", (1773, 1784), True, 'import streamlit as st\n'), ((1807, 1844), 'streamlit.text_input', 'st.text_input', (['"""Name"""'], {'value': '"""<NAME>"""'}), "('Name', value='<NAME>')\n", (1820, 1844), True, 'import streamlit as st\n'), ((1867, 1913), 'streamlit.text_input', 'st.text_input', (['"""Secret alias"""'], {'value': '"""Dr. Jon"""'}), "('Secret alias', value='Dr. Jon')\n", (1880, 1913), True, 'import streamlit as st\n'), ((1935, 1966), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""Submit"""'], {}), "('Submit')\n", (1956, 1966), True, 'import streamlit as st\n'), ((1287, 1300), 'streamlit.text', 'st.text', (['hero'], {}), '(hero)\n', (1294, 1300), True, 'import streamlit as st\n'), ((2075, 2096), 'streamlit.write', 'st.write', (['"""submitted"""'], {}), "('submitted')\n", (2083, 2096), True, 'import streamlit as st\n'), ((1169, 1181), 'sqlmodel.select', 'select', (['Hero'], {}), '(Hero)\n', (1175, 1181), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((2189, 2204), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (2196, 2204), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((1047, 1059), 'sqlmodel.select', 'select', (['Hero'], {}), '(Hero)\n', (1053, 1059), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((1419, 1431), 'sqlmodel.select', 'select', (['Hero'], {}), '(Hero)\n', (1425, 1431), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n'), ((1589, 1601), 'sqlmodel.select', 'select', (['Hero'], {}), '(Hero)\n', (1595, 1601), False, 'from sqlmodel import Field, Session, SQLModel, create_engine, select\n')] |
"""
dayong.models
~~~~~~~~~~~~~
A model maps to a single database table. It contains fields and behaviors of the data
stored in the database.
"""
from typing import Optional
from sqlmodel import Field, SQLModel
class Message(SQLModel):
"""Base model class for message table models."""
message_id: str
class AnonMessage(Message, table=True):
"""Table model for anonymized guild messages."""
# pyright cannot recognize the type of SQLModel.__tablename__
# See: https://github.com/tiangolo/sqlmodel/issues/98
__tablename__ = "anon_messages" # type: ignore
id: Optional[int] = Field(default=None, primary_key=True)
user_id: str
username: str
nickname: str
message: str
| [
"sqlmodel.Field"
] | [((610, 647), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (615, 647), False, 'from sqlmodel import Field, SQLModel\n')] |
import typing as t
from sqlmodel import SQLModel, Field, Relationship
from datetime import datetime
from .discussions import DB_Discussion
class DB_Post(SQLModel, table=True):
__tablename__ = 'posts'
id: t.Optional[int] = Field(default=None, primary_key=True)
"""The ID of the post. This is handled by the database."""
discussion_id: int = Field(foreign_key='discussions.id')
discussion: t.Optional[DB_Discussion] = Relationship(back_populates='posts')
"""Discussion that this post belongs to."""
number: int = Field(default=1)
"""The number/order of the post in the discussion."""
created_at: datetime = Field(default=datetime.utcnow())
"""When was this post created. Default is now."""
type: str = Field(max_length=100, default='comment')
"""The type of the post. Can be `'comment'` for standard post."""
content: t.Text
"""The post's content, in HTML."""
edited_at: t.Optional[datetime]
"""When was the post edited at?"""
hidden_at: t.Optional[datetime]
"""When was the post hidden at?"""
ip_address: t.Optional[str] = Field(max_length=45)
"""The IP address of the user that created the post."""
is_private: bool = Field(default=False)
"""Whether or not the post is private."""
is_approved: bool = Field(default=True)
"""Whether or not the post is approved."""
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((235, 272), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (240, 272), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((362, 397), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""discussions.id"""'}), "(foreign_key='discussions.id')\n", (367, 397), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((442, 478), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""posts"""'}), "(back_populates='posts')\n", (454, 478), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((546, 562), 'sqlmodel.Field', 'Field', ([], {'default': '(1)'}), '(default=1)\n', (551, 562), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((751, 791), 'sqlmodel.Field', 'Field', ([], {'max_length': '(100)', 'default': '"""comment"""'}), "(max_length=100, default='comment')\n", (756, 791), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((1108, 1128), 'sqlmodel.Field', 'Field', ([], {'max_length': '(45)'}), '(max_length=45)\n', (1113, 1128), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((1213, 1233), 'sqlmodel.Field', 'Field', ([], {'default': '(False)'}), '(default=False)\n', (1218, 1233), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((1304, 1323), 'sqlmodel.Field', 'Field', ([], {'default': '(True)'}), '(default=True)\n', (1309, 1323), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((662, 679), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (677, 679), False, 'from datetime import datetime\n')] |
import datetime
import typing
from sqlmodel import SQLModel, Field, Relationship
import typing as tp
import ipaddress
from sqlalchemy import UniqueConstraint
if tp.TYPE_CHECKING:
from .user import User
class LoginToken(SQLModel, table=True):
__tablename__:str = "login_tokens" # type: ignore
__table_args__ = (UniqueConstraint("token"),)
id: int = Field(primary_key=True)
token: str # 校验token
expired_in: typing.Optional[datetime.datetime] # 过期时间
user_id: int = Field(foreign_key="user.id") # 关联用户
user: User = Relationship(back_populates="tokens")
class LoginLog(SQLModel, table=True):
__tablename__:str = "login_logs" # type: ignore
id: int = Field(primary_key=True)
user_id: int = Field(foreign_key="users.id", index=True) # 关联用户
user: User = Relationship(back_populates="login_logs", link_model="User")
login_time: datetime.datetime = Field(
default_factory=lambda: datetime.datetime.utcnow
) # 登录时间
custom_ip: typing.Optional[ipaddress.IPv4Address] # 登录用户IP
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((368, 391), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (373, 391), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((496, 524), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""user.id"""'}), "(foreign_key='user.id')\n", (501, 524), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((550, 587), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""tokens"""'}), "(back_populates='tokens')\n", (562, 587), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((694, 717), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (699, 717), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((737, 778), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""users.id"""', 'index': '(True)'}), "(foreign_key='users.id', index=True)\n", (742, 778), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((804, 864), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""login_logs"""', 'link_model': '"""User"""'}), "(back_populates='login_logs', link_model='User')\n", (816, 864), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((901, 957), 'sqlmodel.Field', 'Field', ([], {'default_factory': '(lambda : datetime.datetime.utcnow)'}), '(default_factory=lambda : datetime.datetime.utcnow)\n', (906, 957), False, 'from sqlmodel import SQLModel, Field, Relationship\n'), ((326, 351), 'sqlalchemy.UniqueConstraint', 'UniqueConstraint', (['"""token"""'], {}), "('token')\n", (342, 351), False, 'from sqlalchemy import UniqueConstraint\n')] |
from fastapi.encoders import jsonable_encoder
from fastapi.testclient import TestClient
from sqlmodel import Session, select
from model.item import Item
TEST_ITEM = {
"name": "aasif126",
"sku": "AASI126",
"metric": "m",
"cost": 2200
}
def test_get_items_returns_no_item_when_table_is_empty(client: TestClient):
response = client.get("/item/get_all/")
assert response.status_code == 200
assert len(response.json()) == 0
def test_get_items_returns_existing_items(client: TestClient, session: Session, item: Item):
item_2 = Item(**TEST_ITEM)
session.add(item_2)
session.commit()
session.refresh(item_2)
item_ids = [item.id, item_2.id]
response = client.get("/item/get_all/")
response_ids = list(map(lambda _item: _item['id'], response.json()))
assert response.status_code == 200
assert item_ids == response_ids
def test_get_items_csv_returns_csv(client: TestClient, session: Session, item: Item):
response = client.get("/item/get_all.csv")
assert response.status_code == 200
def test_get_items_csv_raises_error_for_when_no_items_present(
client: TestClient, session: Session):
response = client.get("/item/get_all.csv")
assert response.status_code == 404
def test_add_item_returns_inserted_row(client: TestClient, session: Session):
response = client.post("/item/", json=TEST_ITEM)
assert response.status_code == 200
item = Item(**response.json())
row = session.exec(
select(Item).where(Item.id == item.id)).one()
assert row == item
def test_add_item_returns_error_for_invalid_body(
client: TestClient, session: Session
):
data = {
"name": "aasif125",
"sku": "AASI125",
}
response = client.post("/item/", json=data)
assert response.status_code == 422
def test_add_item_returns_error_existing_item(
client: TestClient,
session: Session,
item: Item
):
response = client.post("/item/", json=jsonable_encoder(item))
assert response.status_code == 412
def test_edit_item_returns_error_for_invalid_item_id(
client: TestClient, session: Session
):
response = client.put("/item/1", json=TEST_ITEM)
assert response.status_code == 404
def test_edit_item_returns_updated_item(
client: TestClient, session: Session,
item: Item
):
item.cost = 2200
response = client.put("/item/1", data=item.json())
assert response.status_code == 200
assert response.json()['cost'] == item.cost
def test_delete_item_returns_error_for_invalid_item_id(
client: TestClient, session: Session
):
response = client.delete("/item/1")
assert response.status_code == 404
def test_delete_item_returns_success(
client: TestClient, session: Session,
item: Item
):
response = client.delete("/item/1")
assert response.status_code == 200
| [
"sqlmodel.select"
] | [((559, 576), 'model.item.Item', 'Item', ([], {}), '(**TEST_ITEM)\n', (563, 576), False, 'from model.item import Item\n'), ((1989, 2011), 'fastapi.encoders.jsonable_encoder', 'jsonable_encoder', (['item'], {}), '(item)\n', (2005, 2011), False, 'from fastapi.encoders import jsonable_encoder\n'), ((1491, 1503), 'sqlmodel.select', 'select', (['Item'], {}), '(Item)\n', (1497, 1503), False, 'from sqlmodel import Session, select\n')] |
from typing import List
from uuid import UUID
import inject
from sqlalchemy.sql.expression import desc
from sqlmodel import Session, between, select
from src.core.events import EventDescription
from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError
from src.core.models import (
Client,
Context,
CreateBalance,
CreateOrder,
Item,
Order,
OrderDetail,
QueryOrder,
UpdateOrder,
UpdateOrderStatus,
)
from src.core.services import Streamer
from . import balance
def get_all(session: Session, query_schema: QueryOrder, context: Context) -> List[Order]:
args = []
if query_schema.status is not None:
args.append(Order.status == query_schema.status)
if not context.user_is_super_user:
args.append(Order.owner_id == context.user_id)
if query_schema.start_date is not None and query_schema.end_date is not None:
args.append(between(Order.date, query_schema.start_date, query_schema.end_date))
return session.exec(select(Order).where(*args).order_by(desc(Order.date))).all()
def get_by_id(session: Session, order_id: UUID, context: Context) -> Order:
order = session.exec(select(Order).where(Order.id == order_id)).first()
if not order:
raise NotFoundError("Não foi possível localizar a venda com ID: %s" % order_id)
if not context.user_is_super_user and order.owner_id != context.user_id:
raise NotAuthorizedError(f"Você não possui permissão para consultar a Venda {order_id}")
return order
@inject.params(streamer=Streamer)
def register_sale(session: Session, schema: CreateOrder, context: Context, streamer: Streamer) -> Order:
if not session.exec(select(Client).where(Client.id == schema.client_id)).first():
raise NotFoundError(f"Não foi possível localizar o cliente com ID: {schema.client_id}")
checked_ids = []
for detail in schema.items:
if detail.item_id in checked_ids:
continue
checked_ids.append(detail.item_id)
item = session.exec(select(Item).where(Item.id == detail.item_id)).first()
if not item:
raise NotFoundError(f"Não foi possível salvar a venda, item com o ID {detail.item_id} não existe")
if not item.avaliable:
raise DataValidationError(f"O item {item.name} de ID {item.id} não está disponível!")
total_required = sum(x.item_amount for x in schema.items if x.item_id == item.id)
if item.amount < total_required:
raise DataValidationError(
"O item %(name)s não possui estoque suficiente, disponível: %(amount)s, solicitado: %(required)s"
% {"name": item.name, "amount": item.amount, "required": total_required}
)
item.amount -= total_required
session.add(item)
order = Order(**schema.dict(exclude={"details": ...}), owner_id=context.user_id)
session.add(order)
for detail in schema.items:
detail_obj = OrderDetail(**detail.dict(), order_id=order.id)
session.add(detail_obj)
balance_schema = CreateBalance(
value=sum(detail.value for detail in schema.items),
operation=schema.sale_type.value,
description=schema.description,
)
balance_obj = balance.create(session, balance_schema, context=context)
session.add(balance_obj)
session.commit()
streamer.send_event(description=EventDescription.CREATE_ORDER, context=context, order=order.dict())
return order
@inject.params(streamer=Streamer)
def delete_by_id(session: Session, order_id: UUID, context: Context, streamer: Streamer) -> Order:
order = session.exec(select(Order).where(Order.id == order_id)).first()
if not order:
raise NotFoundError(f"Não foi possível localizar a venda com o ID: {order_id}")
if not context.user_is_super_user and order.owner_id != context.user_id:
raise NotAuthorizedError(f"Você não possui permissão para excluir a Venda {order_id}")
for detail in [detail for detail in order.items]:
item = detail.item
item.amount += detail.item_amount
session.add(item)
session.delete(order)
session.commit()
streamer.send_event(EventDescription.DELETE_ORDER, context=context, order=order.dict())
return order
@inject.params(streamer=Streamer)
def update(session: Session, data: UpdateOrder, context: Context, streamer: Streamer) -> Client:
order = session.exec(select(Order).where(Order.id == data.id)).first()
if not order:
raise NotFoundError(f"Não foi possível localizar a venda com ID: {data.id}")
if not context.user_is_super_user and order.owner_id != context.user_id:
raise NotAuthorizedError(f"Você não possui permissão para excluir a venda com ID: {data.id}")
columns = order.__table__.columns.keys()
for key, value in data.dict(exclude_defaults=True).items():
if key not in columns:
continue
setattr(order, key, value)
session.add(order)
session.commit()
streamer.send_event(
description=EventDescription.UPDATE_ORDER,
context=context,
data={"order_data": order.dict(), "update_schema": data.dict()},
)
return order
@inject.params(streamer=Streamer)
def update_status(session: Session, schema: UpdateOrderStatus, context: Context, streamer: Streamer) -> None:
order = session.exec(select(Order).where(Order.id == schema.order_id)).first()
if not order:
raise NotFoundError(f"Não foi possível localizar a venda com o ID: {schema.order_id}")
if not context.user_is_super_user and order.owner_id != context.user_id:
raise NotAuthorizedError(f"Você não possui permissão para alterar o status da venda {schema.order_id}")
order.status = schema.status
session.add(order)
session.commit()
streamer.send_event(EventDescription.UPDATE_ORDER, context=context, order=order.dict(), new_status=schema.status)
| [
"sqlmodel.select",
"sqlmodel.between"
] | [((1554, 1586), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer'}), '(streamer=Streamer)\n', (1567, 1586), False, 'import inject\n'), ((3515, 3547), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer'}), '(streamer=Streamer)\n', (3528, 3547), False, 'import inject\n'), ((4315, 4347), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer'}), '(streamer=Streamer)\n', (4328, 4347), False, 'import inject\n'), ((5250, 5282), 'inject.params', 'inject.params', ([], {'streamer': 'Streamer'}), '(streamer=Streamer)\n', (5263, 5282), False, 'import inject\n'), ((1284, 1357), 'src.core.helpers.exceptions.NotFoundError', 'NotFoundError', (["('Não foi possível localizar a venda com ID: %s' % order_id)"], {}), "('Não foi possível localizar a venda com ID: %s' % order_id)\n", (1297, 1357), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((1450, 1537), 'src.core.helpers.exceptions.NotAuthorizedError', 'NotAuthorizedError', (['f"""Você não possui permissão para consultar a Venda {order_id}"""'], {}), "(\n f'Você não possui permissão para consultar a Venda {order_id}')\n", (1468, 1537), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((1792, 1878), 'src.core.helpers.exceptions.NotFoundError', 'NotFoundError', (['f"""Não foi possível localizar o cliente com ID: {schema.client_id}"""'], {}), "(\n f'Não foi possível localizar o cliente com ID: {schema.client_id}')\n", (1805, 1878), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((3756, 3829), 'src.core.helpers.exceptions.NotFoundError', 'NotFoundError', (['f"""Não foi possível localizar a venda com o ID: {order_id}"""'], {}), "(f'Não foi possível localizar a venda com o ID: {order_id}')\n", (3769, 3829), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((3922, 4007), 'src.core.helpers.exceptions.NotAuthorizedError', 'NotAuthorizedError', (['f"""Você não possui permissão para excluir a Venda {order_id}"""'], {}), "(f'Você não possui permissão para excluir a Venda {order_id}'\n )\n", (3940, 4007), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((4553, 4623), 'src.core.helpers.exceptions.NotFoundError', 'NotFoundError', (['f"""Não foi possível localizar a venda com ID: {data.id}"""'], {}), "(f'Não foi possível localizar a venda com ID: {data.id}')\n", (4566, 4623), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((4716, 4808), 'src.core.helpers.exceptions.NotAuthorizedError', 'NotAuthorizedError', (['f"""Você não possui permissão para excluir a venda com ID: {data.id}"""'], {}), "(\n f'Você não possui permissão para excluir a venda com ID: {data.id}')\n", (4734, 4808), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((5509, 5594), 'src.core.helpers.exceptions.NotFoundError', 'NotFoundError', (['f"""Não foi possível localizar a venda com o ID: {schema.order_id}"""'], {}), "(f'Não foi possível localizar a venda com o ID: {schema.order_id}'\n )\n", (5522, 5594), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((5682, 5789), 'src.core.helpers.exceptions.NotAuthorizedError', 'NotAuthorizedError', (['f"""Você não possui permissão para alterar o status da venda {schema.order_id}"""'], {}), "(\n f'Você não possui permissão para alterar o status da venda {schema.order_id}'\n )\n", (5700, 5789), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((942, 1009), 'sqlmodel.between', 'between', (['Order.date', 'query_schema.start_date', 'query_schema.end_date'], {}), '(Order.date, query_schema.start_date, query_schema.end_date)\n', (949, 1009), False, 'from sqlmodel import Session, between, select\n'), ((2159, 2261), 'src.core.helpers.exceptions.NotFoundError', 'NotFoundError', (['f"""Não foi possível salvar a venda, item com o ID {detail.item_id} não existe"""'], {}), "(\n f'Não foi possível salvar a venda, item com o ID {detail.item_id} não existe'\n )\n", (2172, 2261), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((2302, 2381), 'src.core.helpers.exceptions.DataValidationError', 'DataValidationError', (['f"""O item {item.name} de ID {item.id} não está disponível!"""'], {}), "(f'O item {item.name} de ID {item.id} não está disponível!')\n", (2321, 2381), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((2533, 2734), 'src.core.helpers.exceptions.DataValidationError', 'DataValidationError', (["('O item %(name)s não possui estoque suficiente, disponível: %(amount)s, solicitado: %(required)s'\n % {'name': item.name, 'amount': item.amount, 'required': total_required})"], {}), "(\n 'O item %(name)s não possui estoque suficiente, disponível: %(amount)s, solicitado: %(required)s'\n % {'name': item.name, 'amount': item.amount, 'required': total_required})\n", (2552, 2734), False, 'from src.core.helpers.exceptions import DataValidationError, NotAuthorizedError, NotFoundError\n'), ((1072, 1088), 'sqlalchemy.sql.expression.desc', 'desc', (['Order.date'], {}), '(Order.date)\n', (1076, 1088), False, 'from sqlalchemy.sql.expression import desc\n'), ((1200, 1213), 'sqlmodel.select', 'select', (['Order'], {}), '(Order)\n', (1206, 1213), False, 'from sqlmodel import Session, between, select\n'), ((3672, 3685), 'sqlmodel.select', 'select', (['Order'], {}), '(Order)\n', (3678, 3685), False, 'from sqlmodel import Session, between, select\n'), ((4470, 4483), 'sqlmodel.select', 'select', (['Order'], {}), '(Order)\n', (4476, 4483), False, 'from sqlmodel import Session, between, select\n'), ((5418, 5431), 'sqlmodel.select', 'select', (['Order'], {}), '(Order)\n', (5424, 5431), False, 'from sqlmodel import Session, between, select\n'), ((1716, 1730), 'sqlmodel.select', 'select', (['Client'], {}), '(Client)\n', (1722, 1730), False, 'from sqlmodel import Session, between, select\n'), ((2064, 2076), 'sqlmodel.select', 'select', (['Item'], {}), '(Item)\n', (2070, 2076), False, 'from sqlmodel import Session, between, select\n'), ((1036, 1049), 'sqlmodel.select', 'select', (['Order'], {}), '(Order)\n', (1042, 1049), False, 'from sqlmodel import Session, between, select\n')] |
from fastapi import FastAPI
from api import router
from settings.datastore import dbengine
from sqlmodel import SQLModel
app = FastAPI()
#include app api routers
router.add_routers(app)
SQLModel.metadata.create_all(dbengine)
@app.get("/")
def main():
return {
"message": "Welcome to pilot"
} | [
"sqlmodel.SQLModel.metadata.create_all"
] | [((127, 136), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (134, 136), False, 'from fastapi import FastAPI\n'), ((162, 185), 'api.router.add_routers', 'router.add_routers', (['app'], {}), '(app)\n', (180, 185), False, 'from api import router\n'), ((186, 224), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['dbengine'], {}), '(dbengine)\n', (214, 224), False, 'from sqlmodel import SQLModel\n')] |
import importlib
import pytest
from fastapi.testclient import TestClient
from sqlalchemy import inspect
from sqlalchemy.engine.reflection import Inspector
from sqlmodel import Session, create_engine
from docs_src.tutorial.fastapi.app_testing.tutorial001 import main as app_mod
from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod
from docs_src.tutorial.fastapi.app_testing.tutorial001.test_main import (
client_fixture,
session_fixture,
)
assert session_fixture, "This keeps the session fixture used below"
assert client_fixture, "This keeps the client fixture used below"
@pytest.fixture(name="prepare", autouse=True)
def prepare_fixture(clear_sqlmodel):
# Trigger side effects of registering table models in SQLModel
# This has to be called after clear_sqlmodel, but before the session_fixture
# That's why the extra custom fixture here
importlib.reload(app_mod)
importlib.reload(test_mod)
def test_create_hero(session: Session, client: TestClient):
test_mod.test_create_hero(client)
def test_create_hero_incomplete(session: Session, client: TestClient):
test_mod.test_create_hero_incomplete(client)
def test_create_hero_invalid(session: Session, client: TestClient):
test_mod.test_create_hero_invalid(client)
def test_read_heroes(session: Session, client: TestClient):
test_mod.test_read_heroes(session=session, client=client)
def test_read_hero(session: Session, client: TestClient):
test_mod.test_read_hero(session=session, client=client)
def test_update_hero(session: Session, client: TestClient):
test_mod.test_update_hero(session=session, client=client)
def test_delete_hero(session: Session, client: TestClient):
test_mod.test_delete_hero(session=session, client=client)
def test_startup():
app_mod.engine = create_engine("sqlite://")
app_mod.on_startup()
insp: Inspector = inspect(app_mod.engine)
assert insp.has_table(str(app_mod.Hero.__tablename__))
def test_get_session():
app_mod.engine = create_engine("sqlite://")
for session in app_mod.get_session():
assert isinstance(session, Session)
assert session.bind == app_mod.engine
def test_read_hero_not_found(client: TestClient):
response = client.get("/heroes/9000")
assert response.status_code == 404
def test_update_hero_not_found(client: TestClient):
response = client.patch("/heroes/9000", json={"name": "Very-Rusty-Man"})
assert response.status_code == 404
def test_delete_hero_not_found(client: TestClient):
response = client.delete("/heroes/9000")
assert response.status_code == 404
| [
"sqlmodel.create_engine"
] | [((618, 662), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""prepare"""', 'autouse': '(True)'}), "(name='prepare', autouse=True)\n", (632, 662), False, 'import pytest\n'), ((899, 924), 'importlib.reload', 'importlib.reload', (['app_mod'], {}), '(app_mod)\n', (915, 924), False, 'import importlib\n'), ((929, 955), 'importlib.reload', 'importlib.reload', (['test_mod'], {}), '(test_mod)\n', (945, 955), False, 'import importlib\n'), ((1022, 1055), 'docs_src.tutorial.fastapi.app_testing.tutorial001.test_main.test_create_hero', 'test_mod.test_create_hero', (['client'], {}), '(client)\n', (1047, 1055), True, 'from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod\n'), ((1133, 1177), 'docs_src.tutorial.fastapi.app_testing.tutorial001.test_main.test_create_hero_incomplete', 'test_mod.test_create_hero_incomplete', (['client'], {}), '(client)\n', (1169, 1177), True, 'from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod\n'), ((1252, 1293), 'docs_src.tutorial.fastapi.app_testing.tutorial001.test_main.test_create_hero_invalid', 'test_mod.test_create_hero_invalid', (['client'], {}), '(client)\n', (1285, 1293), True, 'from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod\n'), ((1360, 1417), 'docs_src.tutorial.fastapi.app_testing.tutorial001.test_main.test_read_heroes', 'test_mod.test_read_heroes', ([], {'session': 'session', 'client': 'client'}), '(session=session, client=client)\n', (1385, 1417), True, 'from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod\n'), ((1482, 1537), 'docs_src.tutorial.fastapi.app_testing.tutorial001.test_main.test_read_hero', 'test_mod.test_read_hero', ([], {'session': 'session', 'client': 'client'}), '(session=session, client=client)\n', (1505, 1537), True, 'from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod\n'), ((1604, 1661), 'docs_src.tutorial.fastapi.app_testing.tutorial001.test_main.test_update_hero', 'test_mod.test_update_hero', ([], {'session': 'session', 'client': 'client'}), '(session=session, client=client)\n', (1629, 1661), True, 'from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod\n'), ((1728, 1785), 'docs_src.tutorial.fastapi.app_testing.tutorial001.test_main.test_delete_hero', 'test_mod.test_delete_hero', ([], {'session': 'session', 'client': 'client'}), '(session=session, client=client)\n', (1753, 1785), True, 'from docs_src.tutorial.fastapi.app_testing.tutorial001 import test_main as test_mod\n'), ((1829, 1855), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite://"""'], {}), "('sqlite://')\n", (1842, 1855), False, 'from sqlmodel import Session, create_engine\n'), ((1860, 1880), 'docs_src.tutorial.fastapi.app_testing.tutorial001.main.on_startup', 'app_mod.on_startup', ([], {}), '()\n', (1878, 1880), True, 'from docs_src.tutorial.fastapi.app_testing.tutorial001 import main as app_mod\n'), ((1903, 1926), 'sqlalchemy.inspect', 'inspect', (['app_mod.engine'], {}), '(app_mod.engine)\n', (1910, 1926), False, 'from sqlalchemy import inspect\n'), ((2033, 2059), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite://"""'], {}), "('sqlite://')\n", (2046, 2059), False, 'from sqlmodel import Session, create_engine\n'), ((2079, 2100), 'docs_src.tutorial.fastapi.app_testing.tutorial001.main.get_session', 'app_mod.get_session', ([], {}), '()\n', (2098, 2100), True, 'from docs_src.tutorial.fastapi.app_testing.tutorial001 import main as app_mod\n')] |
from pydantic import BaseModel
from sqlmodel import Field, SQLModel, Relationship
from typing import Optional, List
class UserBase(SQLModel):
username: str
desc: str
class User(UserBase, table=True):
id: Optional[int] = Field(index=True, default=None, primary_key=True)
password: str
tasks: List["Task"] = Relationship(back_populates="owner")
class UserQuery(SQLModel):
id: int
class UserCreate(UserBase):
pass
class UserRead(UserBase, UserQuery):
pass
class TaskBase(SQLModel):
title: str
desc: str
owner_id: Optional[int] = Field(default=None, foreign_key="user.id")
class Task(TaskBase, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
owner: Optional[User] = Relationship(back_populates="tasks")
class TaskCreate(TaskBase):
pass
class TaskRead(TaskBase):
id: int
class TaskQuery(SQLModel):
id: int
owner_id: int
class StandardResponse(BaseModel):
success: str = "Success"
message: str = "Task completed successfully"
code: int = 200 | [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((235, 284), 'sqlmodel.Field', 'Field', ([], {'index': '(True)', 'default': 'None', 'primary_key': '(True)'}), '(index=True, default=None, primary_key=True)\n', (240, 284), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((329, 365), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""owner"""'}), "(back_populates='owner')\n", (341, 365), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((578, 620), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""user.id"""'}), "(default=None, foreign_key='user.id')\n", (583, 620), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((680, 717), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (685, 717), False, 'from sqlmodel import Field, SQLModel, Relationship\n'), ((746, 782), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""tasks"""'}), "(back_populates='tasks')\n", (758, 782), False, 'from sqlmodel import Field, SQLModel, Relationship\n')] |
from fastapi import APIRouter, Depends, HTTPException, Path
from sqlmodel import Session, select
from sqlalchemy.exc import IntegrityError
from typing import List
import datetime as dt
from app.src.common.security import get_current_user
from app.src.common.utils import profiling_api
from app.src.models.app_user import AppUser
from app.src.models.tag import Tag, TagRead, TagCreate, TagUpdate
from app.src.db.engine import get_session
router = APIRouter()
async def get_tag_or_404(
*,
session: Session = Depends(get_session),
tag_id: int = Path(..., ge=1),
current_user: AppUser = Depends(get_current_user),
):
start_time = dt.datetime.now()
try:
db_tag = session.get(Tag, tag_id)
if db_tag:
return {
"db_tag": db_tag,
"username": current_user.username,
"start_time": start_time,
}
else:
raise HTTPException(status_code=404, detail="Tag not found")
except KeyError:
raise HTTPException(status_code=400, detail="Tag not found")
async def get_tag_by_name_or_404(
*,
session: Session = Depends(get_session),
tag_name: str,
current_user: AppUser = Depends(get_current_user),
):
start_time = dt.datetime.now()
try:
db_tag = session.exec(select(Tag).where(Tag.name == tag_name)).one()
if db_tag:
return {
"db_tag": db_tag,
"username": current_user.username,
"start_time": start_time,
}
else:
raise HTTPException(status_code=404, detail="Tag not found by name")
except KeyError:
raise HTTPException(status_code=400, detail="Tag not found by name")
@router.get("/", response_model=List[TagRead])
async def read_tags(
*,
session: Session = Depends(get_session),
current_user: AppUser = Depends(get_current_user),
):
"""
Get all the existing tags
"""
start_time = dt.datetime.now()
tags = session.exec(select(Tag)).all()
profiling_api("Tags:get:all", start_time, current_user.username)
return tags
@router.get("/{tag_id}", response_model=TagRead)
async def read_tag(*, tag_id: int, db_tag: Tag = Depends(get_tag_or_404)):
"""
Get the tag by id
"""
profiling_api(
f"Tag:read:by_id:{tag_id}",
db_tag["start_time"],
db_tag["username"],
)
return db_tag["db_tag"]
@router.post("/", response_model=TagRead)
async def create_tags(
*,
session: Session = Depends(get_session),
tag: TagCreate,
current_user: AppUser = Depends(get_current_user),
):
"""
Create a tag
"""
start_time = dt.datetime.now()
try:
db_t = Tag.from_orm(tag)
session.add(db_t)
session.commit()
session.refresh(db_t)
except IntegrityError:
raise HTTPException(
status_code=404, detail="Impossible to create tag with same name"
)
profiling_api("Tag:insert:single", start_time, current_user.username)
return db_t
@router.patch("/{tag_id}", response_model=TagRead)
async def update_tag(
*,
tag_id: int,
session: Session = Depends(get_session),
tag: TagUpdate,
db_tag: Tag = Depends(get_tag_or_404),
):
"""
Modify a tag
"""
# exclude_unset=True: it would only include the values
# that were sent by the client
existing_tag = db_tag["db_tag"]
tag_data = tag.dict(exclude_unset=True)
for key, value in tag_data.items():
setattr(existing_tag, key, value)
session.add(existing_tag)
session.commit()
session.refresh(existing_tag)
profiling_api(
f"Tag:update:by_id:{tag_id}",
db_tag["start_time"],
db_tag["username"],
)
return existing_tag
@router.delete("/{tag_id}")
async def delete_tag(
*,
tag_id: int,
session: Session = Depends(get_session),
db_tag: Tag = Depends(get_tag_or_404),
):
"""
Delete and remove an existing product type by id; it must be >= 1
"""
existing_tag = db_tag["db_tag"]
session.delete(existing_tag)
session.commit()
profiling_api(
f"Tag:delete:by_id:{tag_id}",
db_tag["start_time"],
db_tag["username"],
)
return {"ok": True}
| [
"sqlmodel.select"
] | [((449, 460), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (458, 460), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((519, 539), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (526, 539), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((559, 574), 'fastapi.Path', 'Path', (['...'], {'ge': '(1)'}), '(..., ge=1)\n', (563, 574), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((604, 629), 'fastapi.Depends', 'Depends', (['get_current_user'], {}), '(get_current_user)\n', (611, 629), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((651, 668), 'datetime.datetime.now', 'dt.datetime.now', ([], {}), '()\n', (666, 668), True, 'import datetime as dt\n'), ((1144, 1164), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (1151, 1164), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((1213, 1238), 'fastapi.Depends', 'Depends', (['get_current_user'], {}), '(get_current_user)\n', (1220, 1238), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((1260, 1277), 'datetime.datetime.now', 'dt.datetime.now', ([], {}), '()\n', (1275, 1277), True, 'import datetime as dt\n'), ((1838, 1858), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (1845, 1858), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((1888, 1913), 'fastapi.Depends', 'Depends', (['get_current_user'], {}), '(get_current_user)\n', (1895, 1913), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((1981, 1998), 'datetime.datetime.now', 'dt.datetime.now', ([], {}), '()\n', (1996, 1998), True, 'import datetime as dt\n'), ((2046, 2110), 'app.src.common.utils.profiling_api', 'profiling_api', (['"""Tags:get:all"""', 'start_time', 'current_user.username'], {}), "('Tags:get:all', start_time, current_user.username)\n", (2059, 2110), False, 'from app.src.common.utils import profiling_api\n'), ((2227, 2250), 'fastapi.Depends', 'Depends', (['get_tag_or_404'], {}), '(get_tag_or_404)\n', (2234, 2250), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((2295, 2383), 'app.src.common.utils.profiling_api', 'profiling_api', (['f"""Tag:read:by_id:{tag_id}"""', "db_tag['start_time']", "db_tag['username']"], {}), "(f'Tag:read:by_id:{tag_id}', db_tag['start_time'], db_tag[\n 'username'])\n", (2308, 2383), False, 'from app.src.common.utils import profiling_api\n'), ((2535, 2555), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (2542, 2555), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((2605, 2630), 'fastapi.Depends', 'Depends', (['get_current_user'], {}), '(get_current_user)\n', (2612, 2630), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((2685, 2702), 'datetime.datetime.now', 'dt.datetime.now', ([], {}), '()\n', (2700, 2702), True, 'import datetime as dt\n'), ((2974, 3043), 'app.src.common.utils.profiling_api', 'profiling_api', (['"""Tag:insert:single"""', 'start_time', 'current_user.username'], {}), "('Tag:insert:single', start_time, current_user.username)\n", (2987, 3043), False, 'from app.src.common.utils import profiling_api\n'), ((3182, 3202), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (3189, 3202), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((3242, 3265), 'fastapi.Depends', 'Depends', (['get_tag_or_404'], {}), '(get_tag_or_404)\n', (3249, 3265), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((3648, 3738), 'app.src.common.utils.profiling_api', 'profiling_api', (['f"""Tag:update:by_id:{tag_id}"""', "db_tag['start_time']", "db_tag['username']"], {}), "(f'Tag:update:by_id:{tag_id}', db_tag['start_time'], db_tag[\n 'username'])\n", (3661, 3738), False, 'from app.src.common.utils import profiling_api\n'), ((3888, 3908), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (3895, 3908), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((3928, 3951), 'fastapi.Depends', 'Depends', (['get_tag_or_404'], {}), '(get_tag_or_404)\n', (3935, 3951), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((4136, 4226), 'app.src.common.utils.profiling_api', 'profiling_api', (['f"""Tag:delete:by_id:{tag_id}"""', "db_tag['start_time']", "db_tag['username']"], {}), "(f'Tag:delete:by_id:{tag_id}', db_tag['start_time'], db_tag[\n 'username'])\n", (4149, 4226), False, 'from app.src.common.utils import profiling_api\n'), ((2727, 2744), 'app.src.models.tag.Tag.from_orm', 'Tag.from_orm', (['tag'], {}), '(tag)\n', (2739, 2744), False, 'from app.src.models.tag import Tag, TagRead, TagCreate, TagUpdate\n'), ((933, 987), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""Tag not found"""'}), "(status_code=404, detail='Tag not found')\n", (946, 987), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((1023, 1077), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(400)', 'detail': '"""Tag not found"""'}), "(status_code=400, detail='Tag not found')\n", (1036, 1077), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((1577, 1639), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""Tag not found by name"""'}), "(status_code=404, detail='Tag not found by name')\n", (1590, 1639), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((1675, 1737), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(400)', 'detail': '"""Tag not found by name"""'}), "(status_code=400, detail='Tag not found by name')\n", (1688, 1737), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((2867, 2952), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""Impossible to create tag with same name"""'}), "(status_code=404, detail='Impossible to create tag with same name'\n )\n", (2880, 2952), False, 'from fastapi import APIRouter, Depends, HTTPException, Path\n'), ((2023, 2034), 'sqlmodel.select', 'select', (['Tag'], {}), '(Tag)\n', (2029, 2034), False, 'from sqlmodel import Session, select\n'), ((1317, 1328), 'sqlmodel.select', 'select', (['Tag'], {}), '(Tag)\n', (1323, 1328), False, 'from sqlmodel import Session, select\n')] |
from typing import Optional
from pydantic import condecimal
from sqlalchemy.orm import declared_attr
from sqlmodel import Field, SQLModel
class Reward(SQLModel, table=True):
tx_hash: Optional[str] = Field(primary_key=True)
address: Optional[str] = Field(..., index=True)
block: Optional[int]
timestamp: Optional[int]
# Come from Tx logs
value: condecimal(max_digits=10, decimal_places=3) = None
iscore: condecimal(max_digits=13, decimal_places=3) = None
@declared_attr
def __tablename__(cls) -> str: # noqa: N805
return "rewards"
| [
"sqlmodel.Field"
] | [((206, 229), 'sqlmodel.Field', 'Field', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (211, 229), False, 'from sqlmodel import Field, SQLModel\n'), ((259, 281), 'sqlmodel.Field', 'Field', (['...'], {'index': '(True)'}), '(..., index=True)\n', (264, 281), False, 'from sqlmodel import Field, SQLModel\n'), ((372, 415), 'pydantic.condecimal', 'condecimal', ([], {'max_digits': '(10)', 'decimal_places': '(3)'}), '(max_digits=10, decimal_places=3)\n', (382, 415), False, 'from pydantic import condecimal\n'), ((435, 478), 'pydantic.condecimal', 'condecimal', ([], {'max_digits': '(13)', 'decimal_places': '(3)'}), '(max_digits=13, decimal_places=3)\n', (445, 478), False, 'from pydantic import condecimal\n')] |
"""Initial model generation
Revision ID: a2ced875a244
Revises:
Create Date: 2021-10-28 09:24:53.225445
"""
from alembic import op
import sqlalchemy as sa
import sqlmodel
# revision identifiers, used by Alembic.
revision = 'a2ced875a244'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('category',
sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.Column('playlists', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.Column('id', sa.Integer(), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_category_id'), 'category', ['id'], unique=False)
op.create_index(op.f('ix_category_name'), 'category', ['name'], unique=False)
op.create_index(op.f('ix_category_playlists'), 'category', ['playlists'], unique=False)
op.create_table('user',
sa.Column('entity_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.Column('created_at', sa.DateTime(), nullable=False),
sa.Column('last_login', sa.DateTime(), nullable=True),
sa.Column('admin', sa.Boolean(), nullable=False),
sa.Column('id', sa.Integer(), nullable=True),
sa.Column('password', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_user_admin'), 'user', ['admin'], unique=False)
op.create_index(op.f('ix_user_created_at'), 'user', ['created_at'], unique=False)
op.create_index(op.f('ix_user_entity_id'), 'user', ['entity_id'], unique=False)
op.create_index(op.f('ix_user_id'), 'user', ['id'], unique=False)
op.create_index(op.f('ix_user_last_login'), 'user', ['last_login'], unique=False)
op.create_index(op.f('ix_user_name'), 'user', ['name'], unique=False)
op.create_index(op.f('ix_user_password'), 'user', ['password'], unique=False)
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_user_password'), table_name='user')
op.drop_index(op.f('ix_user_name'), table_name='user')
op.drop_index(op.f('ix_user_last_login'), table_name='user')
op.drop_index(op.f('ix_user_id'), table_name='user')
op.drop_index(op.f('ix_user_entity_id'), table_name='user')
op.drop_index(op.f('ix_user_created_at'), table_name='user')
op.drop_index(op.f('ix_user_admin'), table_name='user')
op.drop_table('user')
op.drop_index(op.f('ix_category_playlists'), table_name='category')
op.drop_index(op.f('ix_category_name'), table_name='category')
op.drop_index(op.f('ix_category_id'), table_name='category')
op.drop_table('category')
# ### end Alembic commands ###
| [
"sqlmodel.sql.sqltypes.AutoString"
] | [((2554, 2575), 'alembic.op.drop_table', 'op.drop_table', (['"""user"""'], {}), "('user')\n", (2567, 2575), False, 'from alembic import op\n'), ((2784, 2809), 'alembic.op.drop_table', 'op.drop_table', (['"""category"""'], {}), "('category')\n", (2797, 2809), False, 'from alembic import op\n'), ((626, 655), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""id"""'], {}), "('id')\n", (649, 655), True, 'import sqlalchemy as sa\n'), ((682, 704), 'alembic.op.f', 'op.f', (['"""ix_category_id"""'], {}), "('ix_category_id')\n", (686, 704), False, 'from alembic import op\n'), ((760, 784), 'alembic.op.f', 'op.f', (['"""ix_category_name"""'], {}), "('ix_category_name')\n", (764, 784), False, 'from alembic import op\n'), ((842, 871), 'alembic.op.f', 'op.f', (['"""ix_category_playlists"""'], {}), "('ix_category_playlists')\n", (846, 871), False, 'from alembic import op\n'), ((1403, 1432), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""id"""'], {}), "('id')\n", (1426, 1432), True, 'import sqlalchemy as sa\n'), ((1459, 1480), 'alembic.op.f', 'op.f', (['"""ix_user_admin"""'], {}), "('ix_user_admin')\n", (1463, 1480), False, 'from alembic import op\n'), ((1535, 1561), 'alembic.op.f', 'op.f', (['"""ix_user_created_at"""'], {}), "('ix_user_created_at')\n", (1539, 1561), False, 'from alembic import op\n'), ((1621, 1646), 'alembic.op.f', 'op.f', (['"""ix_user_entity_id"""'], {}), "('ix_user_entity_id')\n", (1625, 1646), False, 'from alembic import op\n'), ((1705, 1723), 'alembic.op.f', 'op.f', (['"""ix_user_id"""'], {}), "('ix_user_id')\n", (1709, 1723), False, 'from alembic import op\n'), ((1775, 1801), 'alembic.op.f', 'op.f', (['"""ix_user_last_login"""'], {}), "('ix_user_last_login')\n", (1779, 1801), False, 'from alembic import op\n'), ((1861, 1881), 'alembic.op.f', 'op.f', (['"""ix_user_name"""'], {}), "('ix_user_name')\n", (1865, 1881), False, 'from alembic import op\n'), ((1935, 1959), 'alembic.op.f', 'op.f', (['"""ix_user_password"""'], {}), "('ix_user_password')\n", (1939, 1959), False, 'from alembic import op\n'), ((2135, 2159), 'alembic.op.f', 'op.f', (['"""ix_user_password"""'], {}), "('ix_user_password')\n", (2139, 2159), False, 'from alembic import op\n'), ((2198, 2218), 'alembic.op.f', 'op.f', (['"""ix_user_name"""'], {}), "('ix_user_name')\n", (2202, 2218), False, 'from alembic import op\n'), ((2257, 2283), 'alembic.op.f', 'op.f', (['"""ix_user_last_login"""'], {}), "('ix_user_last_login')\n", (2261, 2283), False, 'from alembic import op\n'), ((2322, 2340), 'alembic.op.f', 'op.f', (['"""ix_user_id"""'], {}), "('ix_user_id')\n", (2326, 2340), False, 'from alembic import op\n'), ((2379, 2404), 'alembic.op.f', 'op.f', (['"""ix_user_entity_id"""'], {}), "('ix_user_entity_id')\n", (2383, 2404), False, 'from alembic import op\n'), ((2443, 2469), 'alembic.op.f', 'op.f', (['"""ix_user_created_at"""'], {}), "('ix_user_created_at')\n", (2447, 2469), False, 'from alembic import op\n'), ((2508, 2529), 'alembic.op.f', 'op.f', (['"""ix_user_admin"""'], {}), "('ix_user_admin')\n", (2512, 2529), False, 'from alembic import op\n'), ((2594, 2623), 'alembic.op.f', 'op.f', (['"""ix_category_playlists"""'], {}), "('ix_category_playlists')\n", (2598, 2623), False, 'from alembic import op\n'), ((2666, 2690), 'alembic.op.f', 'op.f', (['"""ix_category_name"""'], {}), "('ix_category_name')\n", (2670, 2690), False, 'from alembic import op\n'), ((2733, 2755), 'alembic.op.f', 'op.f', (['"""ix_category_id"""'], {}), "('ix_category_id')\n", (2737, 2755), False, 'from alembic import op\n'), ((439, 473), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (471, 473), False, 'import sqlmodel\n'), ((519, 553), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (551, 553), False, 'import sqlmodel\n'), ((592, 604), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (602, 604), True, 'import sqlalchemy as sa\n'), ((969, 1003), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1001, 1003), False, 'import sqlmodel\n'), ((1044, 1078), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1076, 1078), False, 'import sqlmodel\n'), ((1125, 1138), 'sqlalchemy.DateTime', 'sa.DateTime', ([], {}), '()\n', (1136, 1138), True, 'import sqlalchemy as sa\n'), ((1185, 1198), 'sqlalchemy.DateTime', 'sa.DateTime', ([], {}), '()\n', (1196, 1198), True, 'import sqlalchemy as sa\n'), ((1239, 1251), 'sqlalchemy.Boolean', 'sa.Boolean', ([], {}), '()\n', (1249, 1251), True, 'import sqlalchemy as sa\n'), ((1290, 1302), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (1300, 1302), True, 'import sqlalchemy as sa\n'), ((1346, 1380), 'sqlmodel.sql.sqltypes.AutoString', 'sqlmodel.sql.sqltypes.AutoString', ([], {}), '()\n', (1378, 1380), False, 'import sqlmodel\n')] |
import streamlit as st
import pandas as pd
import argparse
import datetime as dt
from sqlmodel import create_engine, Session
parser = argparse.ArgumentParser(description="A steamlit dashboard for visualising news analytics.")
parser.add_argument("--database", type=str, default="sqlite:///database.db")
class Dasboard:
def __init__(self, database) -> None:
self.engine = create_engine(database)
self.attr = {
"date_range": self.get_date_range(),
}
self.state = st.session_state
self.build()
def build(self):
# ~~~ Build Sidebar ~~~~~~~~~
st.sidebar.header("Newsreader")
with st.form(key="date_picker"):
st.sidebar.date_input(
"Period From",
key="period_from",
min_value=self.attr["date_range"][0],
max_value=self.attr["date_range"][1],
value=self.attr["date_range"][0]
)
st.sidebar.date_input(
"Period To",
key="period_to",
min_value=self.attr["date_range"][0],
max_value=self.attr["date_range"][1],
value=self.attr["date_range"][1]
)
# ~~~ Build Main UI ~~~~~~~~~~
st.text_input("Search", key="search_text")
st.write(self.state.search_text)
st.write([self.state.period_from, self.state.period_to])
st.write(self.get_total_sentiment("00375cd420e37d4084c6668975f91648"))
# ~~~ Callbacks ~~~~~~~~~~~
# ~~~ Analytics Operations ~~~~~~
def exec(self, stmt: str, params = {}):
with Session(self.engine) as session:
return session.exec(stmt, params=params).all()
def get_date_range(self):
ans = self.exec("""
SELECT MIN(date) as first_date, MAX(date) as last_date FROM document
""")
return list(map(dt.datetime.fromisoformat, ans[0]))
def get_total_sentiment(self, document_id: str):
ans = self.exec("""
WITH t1 AS (
SELECT
document.id as document_id,
paragraph.sentiment as sent,
COUNT(*) as paragraphs
FROM document
JOIN paragraph ON document.id = paragraph.document_id
WHERE document.id = :document_id
GROUP BY document.id, paragraph.sentiment
)
SELECT sent, paragraphs FROM t1
""", params={ "document_id": document_id })
return pd.DataFrame(ans, columns=["lable", "total_paragraphs"])
if __name__ == "__main__":
args = parser.parse_args()
dashboard = Dasboard(args.database)
| [
"sqlmodel.create_engine",
"sqlmodel.Session"
] | [((135, 231), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""A steamlit dashboard for visualising news analytics."""'}), "(description=\n 'A steamlit dashboard for visualising news analytics.')\n", (158, 231), False, 'import argparse\n'), ((385, 408), 'sqlmodel.create_engine', 'create_engine', (['database'], {}), '(database)\n', (398, 408), False, 'from sqlmodel import create_engine, Session\n'), ((619, 650), 'streamlit.sidebar.header', 'st.sidebar.header', (['"""Newsreader"""'], {}), "('Newsreader')\n", (636, 650), True, 'import streamlit as st\n'), ((1282, 1324), 'streamlit.text_input', 'st.text_input', (['"""Search"""'], {'key': '"""search_text"""'}), "('Search', key='search_text')\n", (1295, 1324), True, 'import streamlit as st\n'), ((1334, 1366), 'streamlit.write', 'st.write', (['self.state.search_text'], {}), '(self.state.search_text)\n', (1342, 1366), True, 'import streamlit as st\n'), ((1375, 1431), 'streamlit.write', 'st.write', (['[self.state.period_from, self.state.period_to]'], {}), '([self.state.period_from, self.state.period_to])\n', (1383, 1431), True, 'import streamlit as st\n'), ((2549, 2605), 'pandas.DataFrame', 'pd.DataFrame', (['ans'], {'columns': "['lable', 'total_paragraphs']"}), "(ans, columns=['lable', 'total_paragraphs'])\n", (2561, 2605), True, 'import pandas as pd\n'), ((665, 691), 'streamlit.form', 'st.form', ([], {'key': '"""date_picker"""'}), "(key='date_picker')\n", (672, 691), True, 'import streamlit as st\n'), ((705, 880), 'streamlit.sidebar.date_input', 'st.sidebar.date_input', (['"""Period From"""'], {'key': '"""period_from"""', 'min_value': "self.attr['date_range'][0]", 'max_value': "self.attr['date_range'][1]", 'value': "self.attr['date_range'][0]"}), "('Period From', key='period_from', min_value=self.attr\n ['date_range'][0], max_value=self.attr['date_range'][1], value=self.\n attr['date_range'][0])\n", (726, 880), True, 'import streamlit as st\n'), ((977, 1148), 'streamlit.sidebar.date_input', 'st.sidebar.date_input', (['"""Period To"""'], {'key': '"""period_to"""', 'min_value': "self.attr['date_range'][0]", 'max_value': "self.attr['date_range'][1]", 'value': "self.attr['date_range'][1]"}), "('Period To', key='period_to', min_value=self.attr[\n 'date_range'][0], max_value=self.attr['date_range'][1], value=self.attr\n ['date_range'][1])\n", (998, 1148), True, 'import streamlit as st\n'), ((1650, 1670), 'sqlmodel.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (1657, 1670), False, 'from sqlmodel import create_engine, Session\n')] |
import os
import asyncio
import subprocess
import contextlib
import contextvars
from typing import *
import wait4it
import sqlmodel
from sqlmodel import Session
from aioify import aioify
from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric
from twitterscraper.utils import Singleton
class Repository(Singleton):
# https://sqlmodel.tiangolo.com/
get: Callable[..., "Repository"]
_session_contextvar: contextvars.ContextVar[Optional[Session]]
def __init__(self, uri: str):
self._engine = sqlmodel.create_engine(uri)
self._session_contextvar = contextvars.ContextVar("session", default=None)
# TODO implement pool_pre_ping & pool_recycle_time
# Fix for https://github.com/tiangolo/sqlmodel/issues/189#issuecomment-1025190094
from sqlmodel.sql.expression import Select, SelectOfScalar
SelectOfScalar.inherit_cache = True # type: ignore
Select.inherit_cache = True # type: ignore
def _new_session(self) -> Session:
session = Session(bind=self._engine)
self._session_contextvar.set(session)
return session
def _get_context_session(self) -> Optional[Session]:
return self._session_contextvar.get()
def _clear_context_session(self):
self._session_contextvar.set(None)
@contextlib.contextmanager
def session(self) -> Session:
"""Contextmanager that wraps code behind a database transaction (session).
Any error during the execution rolls back the transaction, so any data saved is not persisted."""
session = self._get_context_session()
if session is not None:
# Another session() contextmanager is already running; let it handle the commit/rollback
yield session
return
session = self._new_session()
print("New session")
try:
yield session
print("Session Commit")
session.commit()
except Exception as ex:
print("Session Rollback")
session.rollback()
raise ex
finally:
print("Session Close")
session.close()
self._clear_context_session()
@contextlib.asynccontextmanager
async def session_async(self) -> Session:
"""Contextmanager that wraps code behind a database transaction (session).
Any error during the execution rolls back the transaction, so any data saved is not persisted."""
session = self._get_context_session()
if session is not None:
# Another session() contextmanager is already running; let it handle the commit/rollback
yield session
return
session = self._new_session()
print("New session")
try:
yield session
print("Session Commit")
await aioify(session.commit)()
except Exception as ex:
print("Session Rollback")
await aioify(session.rollback)()
raise ex
finally:
print("Session Close")
await aioify(session.close)()
self._clear_context_session()
def save_object(self, obj: sqlmodel.SQLModel, flush: bool = False):
"""Save or update any SQLModel object instance"""
with self.session() as session:
session.add(obj)
if flush:
session.flush([obj])
async def save_object_async(self, *obj: sqlmodel.SQLModel, flush: bool = False):
# return await aioify(self.save_object)(obj, flush)
async with self.session_async() as session:
await asyncio.gather(*[aioify(session.add)(_obj) for _obj in obj])
if flush:
await aioify(session.flush)(obj)
def delete_object(self, obj: sqlmodel.SQLModel, flush: bool = False):
with self.session() as session:
session.delete(obj)
if flush:
session.flush([obj])
async def delete_object_async(self, obj: sqlmodel.SQLModel, flush: bool = False):
async with self.session_async() as session:
await aioify(session.delete)(obj)
if flush:
await aioify(session.flush)([obj])
def list_profiles(self) -> List[TwitterProfile]:
with self.session() as session:
query = sqlmodel.select(TwitterProfile)
return session.exec(query).all()
async def list_profiles_async(self, filter_active_profiles: Optional[bool] = None) -> List[TwitterProfile]:
async with self.session_async() as session:
query = sqlmodel.select(TwitterProfile)
if filter_active_profiles is not None:
query = query.where(TwitterProfile.active == filter_active_profiles)
result = await aioify(session.exec)(query)
return await aioify(result.all)()
def get_profile_by_userid(self, userid: str) -> TwitterProfile:
# TODO Deprecate
with self.session() as session:
query = sqlmodel.select(TwitterProfile).where(TwitterProfile.userid == userid)
return session.exec(query).one()
async def get_profile_by_userid_async(self, userid: str) -> TwitterProfile:
# TODO Deprecate
async with self.session_async() as session:
query = sqlmodel.select(TwitterProfile).where(TwitterProfile.userid == userid)
result = await aioify(session.exec)(query)
return await aioify(result.one)()
async def get_profile_by(self, userid: Optional[str] = None, username: Optional[str] = None) -> TwitterProfile:
async with self.session_async() as session:
query = sqlmodel.select(TwitterProfile)
if userid:
query = query.where(TwitterProfile.userid == userid)
if username:
query = query.where(TwitterProfile.username == username)
result = await aioify(session.exec)(query)
return await aioify(result.one)()
# noinspection PyComparisonWithNone
async def tweets_iterator(
self,
batch_size: int,
userid: Optional[str] = None,
username: Optional[str] = None,
from_ts: Optional[int] = None,
to_ts: Optional[int] = None,
filter_active_profiles: Optional[bool] = None,
filter_active_tweets: Optional[bool] = None,
tweets_ids: Optional[List[str]] = None,
) -> AsyncIterable[List[TwitterTweet]]:
# TODO Deprecate, iterator seems like no longer needed
# TODO Any way for making the generator async?
async with self.session_async() as session:
query = sqlmodel.select(TwitterTweet).join(TwitterProfile)
if filter_active_profiles is not None:
query = query.where(TwitterProfile.active == filter_active_profiles)
if filter_active_tweets is True:
query = query.where(TwitterTweet.deletion_detected_timestamp == None)
elif filter_active_tweets is False:
query = query.where(TwitterTweet.deletion_detected_timestamp != None)
if userid is not None:
query = query.where(TwitterProfile.userid == userid)
if username is not None:
query = query.where(TwitterProfile.username == username)
if from_ts is not None:
query = query.where(TwitterTweet.timestamp >= from_ts)
if to_ts is not None:
query = query.where(TwitterTweet.timestamp < to_ts)
if tweets_ids is not None:
# noinspection PyUnresolvedReferences
query = query.filter(TwitterTweet.tweet_id.in_(tweets_ids))
query = query.execution_options(stream_results=True)
result = session.exec(query)
for partition in result.partitions(batch_size):
yield partition
async def get_tweets(
self,
**kwargs
) -> List[TwitterTweet]:
tweets = list()
async for tweets_batch in self.tweets_iterator(batch_size=50, **kwargs):
tweets.extend(tweets_batch)
return tweets
async def get_job_historic(self, job_id: str) -> Optional[JobHistoric]:
async with self.session_async() as session:
query = sqlmodel.select(JobHistoric).where(JobHistoric.job_id == job_id)
return session.exec(query).one_or_none()
# TODO remove "with self.session..." from everything, since we're returning ORM models, it's always needed on the outside
async def close(self):
# TODO implement
print("Closing Repository...")
print("Closed Repository")
@staticmethod
def run_migrations():
subprocess.check_output(("alembic", "upgrade", "head"), cwd=os.getcwd())
@staticmethod
def generate_migration(name: str):
subprocess.check_output(("alembic", "revision", "--autogenerate", "-m", name))
def tcp_wait(self):
# TODO configurable timeout
url = self._engine.url
print("Waiting for TCP port", url)
wait4it.wait_for(host=url.host, port=url.port, timeout=5)
print("TCP port ready", url)
async def tcp_wait_async(self):
await aioify(self.tcp_wait)()
| [
"sqlmodel.Session",
"sqlmodel.create_engine",
"sqlmodel.select"
] | [((545, 572), 'sqlmodel.create_engine', 'sqlmodel.create_engine', (['uri'], {}), '(uri)\n', (567, 572), False, 'import sqlmodel\n'), ((608, 655), 'contextvars.ContextVar', 'contextvars.ContextVar', (['"""session"""'], {'default': 'None'}), "('session', default=None)\n", (630, 655), False, 'import contextvars\n'), ((1043, 1069), 'sqlmodel.Session', 'Session', ([], {'bind': 'self._engine'}), '(bind=self._engine)\n', (1050, 1069), False, 'from sqlmodel import Session\n'), ((8932, 9010), 'subprocess.check_output', 'subprocess.check_output', (["('alembic', 'revision', '--autogenerate', '-m', name)"], {}), "(('alembic', 'revision', '--autogenerate', '-m', name))\n", (8955, 9010), False, 'import subprocess\n'), ((9154, 9211), 'wait4it.wait_for', 'wait4it.wait_for', ([], {'host': 'url.host', 'port': 'url.port', 'timeout': '(5)'}), '(host=url.host, port=url.port, timeout=5)\n', (9170, 9211), False, 'import wait4it\n'), ((4359, 4390), 'sqlmodel.select', 'sqlmodel.select', (['TwitterProfile'], {}), '(TwitterProfile)\n', (4374, 4390), False, 'import sqlmodel\n'), ((4621, 4652), 'sqlmodel.select', 'sqlmodel.select', (['TwitterProfile'], {}), '(TwitterProfile)\n', (4636, 4652), False, 'import sqlmodel\n'), ((5700, 5731), 'sqlmodel.select', 'sqlmodel.select', (['TwitterProfile'], {}), '(TwitterProfile)\n', (5715, 5731), False, 'import sqlmodel\n'), ((8853, 8864), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (8862, 8864), False, 'import os\n'), ((9300, 9321), 'aioify.aioify', 'aioify', (['self.tcp_wait'], {}), '(self.tcp_wait)\n', (9306, 9321), False, 'from aioify import aioify\n'), ((2877, 2899), 'aioify.aioify', 'aioify', (['session.commit'], {}), '(session.commit)\n', (2883, 2899), False, 'from aioify import aioify\n'), ((3108, 3129), 'aioify.aioify', 'aioify', (['session.close'], {}), '(session.close)\n', (3114, 3129), False, 'from aioify import aioify\n'), ((4144, 4166), 'aioify.aioify', 'aioify', (['session.delete'], {}), '(session.delete)\n', (4150, 4166), False, 'from aioify import aioify\n'), ((4817, 4837), 'aioify.aioify', 'aioify', (['session.exec'], {}), '(session.exec)\n', (4823, 4837), False, 'from aioify import aioify\n'), ((4870, 4888), 'aioify.aioify', 'aioify', (['result.all'], {}), '(result.all)\n', (4876, 4888), False, 'from aioify import aioify\n'), ((5045, 5076), 'sqlmodel.select', 'sqlmodel.select', (['TwitterProfile'], {}), '(TwitterProfile)\n', (5060, 5076), False, 'import sqlmodel\n'), ((5339, 5370), 'sqlmodel.select', 'sqlmodel.select', (['TwitterProfile'], {}), '(TwitterProfile)\n', (5354, 5370), False, 'import sqlmodel\n'), ((5437, 5457), 'aioify.aioify', 'aioify', (['session.exec'], {}), '(session.exec)\n', (5443, 5457), False, 'from aioify import aioify\n'), ((5490, 5508), 'aioify.aioify', 'aioify', (['result.one'], {}), '(result.one)\n', (5496, 5508), False, 'from aioify import aioify\n'), ((5949, 5969), 'aioify.aioify', 'aioify', (['session.exec'], {}), '(session.exec)\n', (5955, 5969), False, 'from aioify import aioify\n'), ((6002, 6020), 'aioify.aioify', 'aioify', (['result.one'], {}), '(result.one)\n', (6008, 6020), False, 'from aioify import aioify\n'), ((6714, 6743), 'sqlmodel.select', 'sqlmodel.select', (['TwitterTweet'], {}), '(TwitterTweet)\n', (6729, 6743), False, 'import sqlmodel\n'), ((7719, 7756), 'twitterscraper.models.domain.TwitterTweet.tweet_id.in_', 'TwitterTweet.tweet_id.in_', (['tweets_ids'], {}), '(tweets_ids)\n', (7744, 7756), False, 'from twitterscraper.models.domain import TwitterProfile, TwitterTweet, JobHistoric\n'), ((8368, 8396), 'sqlmodel.select', 'sqlmodel.select', (['JobHistoric'], {}), '(JobHistoric)\n', (8383, 8396), False, 'import sqlmodel\n'), ((2990, 3014), 'aioify.aioify', 'aioify', (['session.rollback'], {}), '(session.rollback)\n', (2996, 3014), False, 'from aioify import aioify\n'), ((3754, 3775), 'aioify.aioify', 'aioify', (['session.flush'], {}), '(session.flush)\n', (3760, 3775), False, 'from aioify import aioify\n'), ((4216, 4237), 'aioify.aioify', 'aioify', (['session.flush'], {}), '(session.flush)\n', (4222, 4237), False, 'from aioify import aioify\n'), ((3666, 3685), 'aioify.aioify', 'aioify', (['session.add'], {}), '(session.add)\n', (3672, 3685), False, 'from aioify import aioify\n')] |
import typer
import uvicorn
from sqlmodel import Session, select
from .app import app
from .config import settings
from .db import create_db_and_tables, engine
from .models.content import Content
from .security import User
cli = typer.Typer(name="pythontasks API")
@cli.command()
def run(
port: int = settings.server.port,
host: str = settings.server.host,
log_level: str = settings.server.log_level,
reload: bool = settings.server.reload,
): # pragma: no cover
"""Run the API server."""
uvicorn.run(
"pythontasks.app:app",
host=host,
port=port,
log_level=log_level,
reload=reload,
)
@cli.command()
def create_user(username: str, password: str, superuser: bool = False):
"""Create user"""
create_db_and_tables(engine)
with Session(engine) as session:
user = User(username=username, password=password, superuser=superuser)
session.add(user)
session.commit()
session.refresh(user)
typer.echo(f"created {username} user")
return user
@cli.command()
def shell(): # pragma: no cover
"""Opens an interactive shell with objects auto imported"""
_vars = {
"app": app,
"settings": settings,
"User": User,
"engine": engine,
"cli": cli,
"create_user": create_user,
"select": select,
"session": Session(engine),
"Content": Content,
}
typer.echo(f"Auto imports: {list(_vars.keys())}")
try:
from IPython import start_ipython
start_ipython(argv=[], user_ns=_vars)
except ImportError:
import code
code.InteractiveConsole(_vars).interact()
| [
"sqlmodel.Session"
] | [((231, 266), 'typer.Typer', 'typer.Typer', ([], {'name': '"""pythontasks API"""'}), "(name='pythontasks API')\n", (242, 266), False, 'import typer\n'), ((517, 614), 'uvicorn.run', 'uvicorn.run', (['"""pythontasks.app:app"""'], {'host': 'host', 'port': 'port', 'log_level': 'log_level', 'reload': 'reload'}), "('pythontasks.app:app', host=host, port=port, log_level=\n log_level, reload=reload)\n", (528, 614), False, 'import uvicorn\n'), ((810, 825), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (817, 825), False, 'from sqlmodel import Session, select\n'), ((1006, 1044), 'typer.echo', 'typer.echo', (['f"""created {username} user"""'], {}), "(f'created {username} user')\n", (1016, 1044), False, 'import typer\n'), ((1392, 1407), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1399, 1407), False, 'from sqlmodel import Session, select\n'), ((1557, 1594), 'IPython.start_ipython', 'start_ipython', ([], {'argv': '[]', 'user_ns': '_vars'}), '(argv=[], user_ns=_vars)\n', (1570, 1594), False, 'from IPython import start_ipython\n'), ((1648, 1678), 'code.InteractiveConsole', 'code.InteractiveConsole', (['_vars'], {}), '(_vars)\n', (1671, 1678), False, 'import code\n')] |
from datetime import datetime, timezone
from typing import List, Optional
from sqlmodel import Field, Relationship, SQLModel, Session, select
from sqlalchemy.engine import Engine
class Post(SQLModel, table=True):
__tablename__ = "ig_posts"
id: Optional[int] = Field(default=None, primary_key=True)
ig_account_id: int = Field(foreign_key="ig_accounts.id")
ig_pk: int
webhook_message_id: Optional[int] = None
ig_account: "IGAccount" = Relationship(back_populates="ig_posts")
class IGAccount(SQLModel, table=True):
__tablename__ = "ig_accounts"
id: Optional[int] = Field(default=None, primary_key=True)
ig_pk: int
ig_hint_username: Optional[str] = None
webhook_id: int
min_time: datetime = Field(default_factory=datetime.utcnow)
@property
def aware_min_time(self) -> datetime:
return self.min_time.replace(tzinfo=timezone.utc)
@aware_min_time.setter
def aware_min_time(self, value: datetime) -> None:
assert value.tzinfo is not None
delta = value.tzinfo.utcoffset(value)
assert delta is not None
self.min_time = value - delta
ig_posts: List["Post"] = Relationship(back_populates="ig_account")
@classmethod
def get(cls, session: Session, pk: int | str, webhook_id: int):
pk_i = int(pk)
query = select(cls).where(cls.ig_pk == pk_i, cls.webhook_id == webhook_id)
acc = session.exec(query).one_or_none()
if acc is None:
acc = cls(ig_pk=pk_i, webhook_id=webhook_id)
session.add(acc)
return acc
def make_post(self, session: Session, pk: int | str) -> Post:
pk_i = int(pk)
# use ig_account_id=-1 to remove type errors (overwritten by ig_account=self)
post = Post(ig_account_id=-1, ig_account=self, ig_pk=pk_i)
session.add(post)
return post
class DB:
engine: Engine
def __init__(self, engine: Engine) -> None:
self.engine = engine
SQLModel.metadata.create_all(engine)
def session(self) -> Session:
return Session(self.engine)
def get_ig_account(
self, session: Session, pk: int | str, webhook_id: int
) -> IGAccount:
return IGAccount.get(session, pk=pk, webhook_id=webhook_id)
def make_ig_post(self, session: Session, pk: int | str, account: IGAccount) -> Post:
return account.make_post(session, pk)
| [
"sqlmodel.Relationship",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.select"
] | [((271, 308), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (276, 308), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n'), ((335, 370), 'sqlmodel.Field', 'Field', ([], {'foreign_key': '"""ig_accounts.id"""'}), "(foreign_key='ig_accounts.id')\n", (340, 370), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n'), ((462, 501), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""ig_posts"""'}), "(back_populates='ig_posts')\n", (474, 501), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n'), ((602, 639), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (607, 639), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n'), ((744, 782), 'sqlmodel.Field', 'Field', ([], {'default_factory': 'datetime.utcnow'}), '(default_factory=datetime.utcnow)\n', (749, 782), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n'), ((1168, 1209), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""ig_account"""'}), "(back_populates='ig_account')\n", (1180, 1209), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n'), ((1985, 2021), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (2013, 2021), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n'), ((2072, 2092), 'sqlmodel.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (2079, 2092), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n'), ((1335, 1346), 'sqlmodel.select', 'select', (['cls'], {}), '(cls)\n', (1341, 1346), False, 'from sqlmodel import Field, Relationship, SQLModel, Session, select\n')] |
from unittest.mock import patch
from sqlmodel import create_engine
from ....conftest import get_testing_print_function
expected_calls = [
[
"Created hero:",
{
"age": None,
"id": 1,
"secret_name": "<NAME>",
"team_id": 1,
"name": "Deadpond",
},
],
[
"Created hero:",
{
"age": 48,
"id": 2,
"secret_name": "<NAME>",
"team_id": 2,
"name": "Rusty-Man",
},
],
[
"Created hero:",
{
"age": None,
"id": 3,
"secret_name": "<NAME>",
"team_id": None,
"name": "Spider-Boy",
},
],
[
"Updated hero:",
{
"age": None,
"id": 3,
"secret_name": "<NAME>",
"team_id": 2,
"name": "Spider-Boy",
},
],
[
"Team Wakaland:",
{"id": 3, "headquarters": "Wakaland Capital City", "name": "Wakaland"},
],
[
"Preventers new hero:",
{
"age": 32,
"id": 6,
"secret_name": "<NAME>",
"team_id": 2,
"name": "Tarantula",
},
],
[
"Preventers new hero:",
{
"age": 36,
"id": 7,
"secret_name": "<NAME>",
"team_id": 2,
"name": "Dr. Weird",
},
],
[
"Preventers new hero:",
{
"age": 93,
"id": 8,
"secret_name": "<NAME>",
"team_id": 2,
"name": "Captain North America",
},
],
]
def test_tutorial(clear_sqlmodel):
from docs_src.tutorial.relationship_attributes.create_and_update_relationships import (
tutorial001 as mod,
)
mod.sqlite_url = "sqlite://"
mod.engine = create_engine(mod.sqlite_url)
calls = []
new_print = get_testing_print_function(calls)
with patch("builtins.print", new=new_print):
mod.main()
assert calls == expected_calls
| [
"sqlmodel.create_engine"
] | [((1912, 1941), 'sqlmodel.create_engine', 'create_engine', (['mod.sqlite_url'], {}), '(mod.sqlite_url)\n', (1925, 1941), False, 'from sqlmodel import create_engine\n'), ((2018, 2056), 'unittest.mock.patch', 'patch', (['"""builtins.print"""'], {'new': 'new_print'}), "('builtins.print', new=new_print)\n", (2023, 2056), False, 'from unittest.mock import patch\n'), ((2066, 2076), 'docs_src.tutorial.relationship_attributes.create_and_update_relationships.tutorial001.main', 'mod.main', ([], {}), '()\n', (2074, 2076), True, 'from docs_src.tutorial.relationship_attributes.create_and_update_relationships import tutorial001 as mod\n')] |
import datetime
from typing import Optional
from pydantic import PositiveInt
from sqlalchemy import Integer, ForeignKey
from sqlmodel import Field, Column, DateTime, Relationship, SQLModel
from sqlalchemy import UniqueConstraint
from sb_backend.app.models.base.base_model import TimeStampMixin
from sb_backend.app.models.fields import SeriesCode
from .noseries import NoSeries
class NoSeriesLineBase(SQLModel):
"""«No. Series Line» («Серия Номеров Строка»)"""
starting_date: datetime.datetime = Field(
sa_column=Column(
DateTime(timezone=True),
nullable=False
)
)
starting_no: SeriesCode
ending_no: SeriesCode
# starting_no: str = Field(max_length=20, nullable=False)
# ending_no: str = Field(max_length=20, nullable=True, default='')
last_date_used: datetime.datetime = Field(
sa_column=Column(
DateTime(timezone=True),
nullable=True
)
)
warning_no: str = Field(max_length=20, nullable=True, default='')
last_no_used: str = Field(max_length=20, nullable=True, default='')
increment_by: PositiveInt = Field(default=1)
blocked: bool = False
# series_no_id: int = Field(
# sa_column=Column(
# Integer,
# ForeignKey(NoSeries.id, ondelete="CASCADE"),
# ),
# nullable = False
# )
# ForeignKey(NoSeries.id, ondelete="RESTRICT"),
# series_no_id: int = Field(default=None, foreign_key="no_series.id")
series_no_id: int
series_no: Optional[NoSeries] = Relationship(back_populates = "noserieslines")
class NoSeriesLine(NoSeriesLineBase, TimeStampMixin, table=True):
"""«No. Series Line» («Серия Номеров Строка»)"""
__tablename__ = "no_series_line"
__table_args__ = (UniqueConstraint("series_no_id", "starting_date"),)
id: Optional[int] = Field(default=None, primary_key=True)
series_no_id: int = Field(
sa_column=Column(
Integer,
ForeignKey(NoSeries.id, ondelete="RESTRICT"),
),
nullable = False
)
class NoSeriesLineCreate(NoSeriesLineBase):
"""«No. Series Line» («Серия Номеров Строка»)"""
pass
class NoSeriesLineRead(NoSeriesLineBase):
"""«No. Series Line» («Серия Номеров Строка»)"""
id: int
class NoSeriesLineUpdate(SQLModel):
"""«No. Series Line» («Серия Номеров Строка»)"""
starting_date: datetime.datetime
starting_no: SeriesCode
ending_no: Optional[SeriesCode]
last_date_used: datetime.datetime
warning_no: Optional[SeriesCode]
increment_by: Optional[PositiveInt] = 1
blocked: Optional[bool] = False
series_no_id: PositiveInt
# series_no_id: Optional[int] = None | [
"sqlmodel.Relationship",
"sqlmodel.Field",
"sqlmodel.DateTime"
] | [((967, 1014), 'sqlmodel.Field', 'Field', ([], {'max_length': '(20)', 'nullable': '(True)', 'default': '""""""'}), "(max_length=20, nullable=True, default='')\n", (972, 1014), False, 'from sqlmodel import Field, Column, DateTime, Relationship, SQLModel\n'), ((1039, 1086), 'sqlmodel.Field', 'Field', ([], {'max_length': '(20)', 'nullable': '(True)', 'default': '""""""'}), "(max_length=20, nullable=True, default='')\n", (1044, 1086), False, 'from sqlmodel import Field, Column, DateTime, Relationship, SQLModel\n'), ((1119, 1135), 'sqlmodel.Field', 'Field', ([], {'default': '(1)'}), '(default=1)\n', (1124, 1135), False, 'from sqlmodel import Field, Column, DateTime, Relationship, SQLModel\n'), ((1529, 1573), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""noserieslines"""'}), "(back_populates='noserieslines')\n", (1541, 1573), False, 'from sqlmodel import Field, Column, DateTime, Relationship, SQLModel\n'), ((1831, 1868), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (1836, 1868), False, 'from sqlmodel import Field, Column, DateTime, Relationship, SQLModel\n'), ((1755, 1804), 'sqlalchemy.UniqueConstraint', 'UniqueConstraint', (['"""series_no_id"""', '"""starting_date"""'], {}), "('series_no_id', 'starting_date')\n", (1771, 1804), False, 'from sqlalchemy import UniqueConstraint\n'), ((548, 571), 'sqlmodel.DateTime', 'DateTime', ([], {'timezone': '(True)'}), '(timezone=True)\n', (556, 571), False, 'from sqlmodel import Field, Column, DateTime, Relationship, SQLModel\n'), ((882, 905), 'sqlmodel.DateTime', 'DateTime', ([], {'timezone': '(True)'}), '(timezone=True)\n', (890, 905), False, 'from sqlmodel import Field, Column, DateTime, Relationship, SQLModel\n'), ((1954, 1998), 'sqlalchemy.ForeignKey', 'ForeignKey', (['NoSeries.id'], {'ondelete': '"""RESTRICT"""'}), "(NoSeries.id, ondelete='RESTRICT')\n", (1964, 1998), False, 'from sqlalchemy import Integer, ForeignKey\n')] |
from typing import List, Optional
from fastapi import Depends, FastAPI, HTTPException, Query
from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select
class TeamBase(SQLModel):
name: str = Field(index=True)
headquarters: str
class Team(TeamBase, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
heroes: List["Hero"] = Relationship(back_populates="team")
class TeamCreate(TeamBase):
pass
class TeamRead(TeamBase):
id: int
class TeamUpdate(SQLModel):
id: Optional[int] = None
name: Optional[str] = None
headquarters: Optional[str] = None
class HeroBase(SQLModel):
name: str = Field(index=True)
secret_name: str
age: Optional[int] = Field(default=None, index=True)
team_id: Optional[int] = Field(default=None, foreign_key="team.id")
class Hero(HeroBase, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
team: Optional[Team] = Relationship(back_populates="heroes")
class HeroRead(HeroBase):
id: int
class HeroCreate(HeroBase):
pass
class HeroUpdate(SQLModel):
name: Optional[str] = None
secret_name: Optional[str] = None
age: Optional[int] = None
team_id: Optional[int] = None
sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"
connect_args = {"check_same_thread": False}
engine = create_engine(sqlite_url, echo=True, connect_args=connect_args)
def create_db_and_tables():
SQLModel.metadata.create_all(engine)
def get_session():
with Session(engine) as session:
yield session
app = FastAPI()
@app.on_event("startup")
def on_startup():
create_db_and_tables()
@app.post("/heroes/", response_model=HeroRead)
def create_hero(*, session: Session = Depends(get_session), hero: HeroCreate):
db_hero = Hero.from_orm(hero)
session.add(db_hero)
session.commit()
session.refresh(db_hero)
return db_hero
@app.get("/heroes/", response_model=List[HeroRead])
def read_heroes(
*,
session: Session = Depends(get_session),
offset: int = 0,
limit: int = Query(default=100, lte=100),
):
heroes = session.exec(select(Hero).offset(offset).limit(limit)).all()
return heroes
@app.get("/heroes/{hero_id}", response_model=HeroRead)
def read_hero(*, session: Session = Depends(get_session), hero_id: int):
hero = session.get(Hero, hero_id)
if not hero:
raise HTTPException(status_code=404, detail="Hero not found")
return hero
@app.patch("/heroes/{hero_id}", response_model=HeroRead)
def update_hero(
*, session: Session = Depends(get_session), hero_id: int, hero: HeroUpdate
):
db_hero = session.get(Hero, hero_id)
if not db_hero:
raise HTTPException(status_code=404, detail="Hero not found")
hero_data = hero.dict(exclude_unset=True)
for key, value in hero_data.items():
setattr(db_hero, key, value)
session.add(db_hero)
session.commit()
session.refresh(db_hero)
return db_hero
@app.delete("/heroes/{hero_id}")
def delete_hero(*, session: Session = Depends(get_session), hero_id: int):
hero = session.get(Hero, hero_id)
if not hero:
raise HTTPException(status_code=404, detail="Hero not found")
session.delete(hero)
session.commit()
return {"ok": True}
@app.post("/teams/", response_model=TeamRead)
def create_team(*, session: Session = Depends(get_session), team: TeamCreate):
db_team = Team.from_orm(team)
session.add(db_team)
session.commit()
session.refresh(db_team)
return db_team
@app.get("/teams/", response_model=List[TeamRead])
def read_teams(
*,
session: Session = Depends(get_session),
offset: int = 0,
limit: int = Query(default=100, lte=100),
):
teams = session.exec(select(Team).offset(offset).limit(limit)).all()
return teams
@app.get("/teams/{team_id}", response_model=TeamRead)
def read_team(*, team_id: int, session: Session = Depends(get_session)):
team = session.get(Team, team_id)
if not team:
raise HTTPException(status_code=404, detail="Team not found")
return team
@app.patch("/teams/{team_id}", response_model=TeamRead)
def update_team(
*,
session: Session = Depends(get_session),
team_id: int,
team: TeamUpdate,
):
db_team = session.get(Team, team_id)
if not db_team:
raise HTTPException(status_code=404, detail="Team not found")
team_data = team.dict(exclude_unset=True)
for key, value in team_data.items():
setattr(db_team, key, value)
session.add(db_team)
session.commit()
session.refresh(db_team)
return db_team
@app.delete("/teams/{team_id}")
def delete_team(*, session: Session = Depends(get_session), team_id: int):
team = session.get(Team, team_id)
if not team:
raise HTTPException(status_code=404, detail="Team not found")
session.delete(team)
session.commit()
return {"ok": True}
| [
"sqlmodel.Relationship",
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field",
"sqlmodel.select"
] | [((1384, 1447), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'echo': '(True)', 'connect_args': 'connect_args'}), '(sqlite_url, echo=True, connect_args=connect_args)\n', (1397, 1447), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((1607, 1616), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (1614, 1616), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((221, 238), 'sqlmodel.Field', 'Field', ([], {'index': '(True)'}), '(index=True)\n', (226, 238), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((321, 358), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (326, 358), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((387, 422), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""team"""'}), "(back_populates='team')\n", (399, 422), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((675, 692), 'sqlmodel.Field', 'Field', ([], {'index': '(True)'}), '(index=True)\n', (680, 692), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((739, 770), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'index': '(True)'}), '(default=None, index=True)\n', (744, 770), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((801, 843), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""team.id"""'}), "(default=None, foreign_key='team.id')\n", (806, 843), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((904, 941), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (909, 941), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((970, 1007), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""heroes"""'}), "(back_populates='heroes')\n", (982, 1007), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((1482, 1518), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (1510, 1518), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((1776, 1796), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (1783, 1796), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((2046, 2066), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (2053, 2066), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((2106, 2133), 'fastapi.Query', 'Query', ([], {'default': '(100)', 'lte': '(100)'}), '(default=100, lte=100)\n', (2111, 2133), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((2323, 2343), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (2330, 2343), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((2603, 2623), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (2610, 2623), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((3081, 3101), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (3088, 3101), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((3400, 3420), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (3407, 3420), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((3668, 3688), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (3675, 3688), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((3728, 3755), 'fastapi.Query', 'Query', ([], {'default': '(100)', 'lte': '(100)'}), '(default=100, lte=100)\n', (3733, 3755), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((3956, 3976), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (3963, 3976), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((4225, 4245), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (4232, 4245), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((4711, 4731), 'fastapi.Depends', 'Depends', (['get_session'], {}), '(get_session)\n', (4718, 4731), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((1549, 1564), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1556, 1564), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((2429, 2484), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""Hero not found"""'}), "(status_code=404, detail='Hero not found')\n", (2442, 2484), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((2734, 2789), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""Hero not found"""'}), "(status_code=404, detail='Hero not found')\n", (2747, 2789), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((3188, 3243), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""Hero not found"""'}), "(status_code=404, detail='Hero not found')\n", (3201, 3243), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((4048, 4103), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""Team not found"""'}), "(status_code=404, detail='Team not found')\n", (4061, 4103), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((4365, 4420), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""Team not found"""'}), "(status_code=404, detail='Team not found')\n", (4378, 4420), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((4817, 4872), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': '(404)', 'detail': '"""Team not found"""'}), "(status_code=404, detail='Team not found')\n", (4830, 4872), False, 'from fastapi import Depends, FastAPI, HTTPException, Query\n'), ((2164, 2176), 'sqlmodel.select', 'select', (['Hero'], {}), '(Hero)\n', (2170, 2176), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n'), ((3785, 3797), 'sqlmodel.select', 'select', (['Team'], {}), '(Team)\n', (3791, 3797), False, 'from sqlmodel import Field, Relationship, Session, SQLModel, create_engine, select\n')] |
"""All database connection information is defined here"""
from sqlmodel import SQLModel, create_engine
from sqlalchemy.engine import Engine
from sqlalchemy import event
DB_FILE = "devices.db"
sqlite_url = f"sqlite:///{DB_FILE}"
connect_args = {"check_same_thread": False}
engine = create_engine(
sqlite_url, connect_args=connect_args, echo=True
) # set echo=True to view output
# From SQLAlchemy docs to allow foreign Key support
# https://docs.sqlalchemy.org/en/14/dialects/sqlite.html#foreign-key-support
@event.listens_for(Engine, "connect")
def set_sqlite_pragma(dbapi_connection, connection_record):
"""Used to enable foreign keys in sqlite"""
cursor = dbapi_connection.cursor()
cursor.execute("PRAGMA foreign_keys=ON")
cursor.close()
def create_db_and_tables():
"""Used to create and initialize DB"""
SQLModel.metadata.create_all(engine)
| [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.create_engine"
] | [((284, 347), 'sqlmodel.create_engine', 'create_engine', (['sqlite_url'], {'connect_args': 'connect_args', 'echo': '(True)'}), '(sqlite_url, connect_args=connect_args, echo=True)\n', (297, 347), False, 'from sqlmodel import SQLModel, create_engine\n'), ((518, 554), 'sqlalchemy.event.listens_for', 'event.listens_for', (['Engine', '"""connect"""'], {}), "(Engine, 'connect')\n", (535, 554), False, 'from sqlalchemy import event\n'), ((843, 879), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (871, 879), False, 'from sqlmodel import SQLModel, create_engine\n')] |
"""Contact Database Tables/Models.
Models of the Endorser tables for Contacts (Authors) and related data.
"""
import uuid
from datetime import datetime
from typing import List
from sqlmodel import Field
from sqlalchemy import Column, func, text, String
from sqlalchemy.dialects.postgresql import UUID, TIMESTAMP, ARRAY
from api.db.models.base import BaseModel
class Contact(BaseModel, table=True):
"""Contact.
This is the model for the Contact table (postgresql specific dialects in use).
Attributes:
contact_id: Endorser's Contact ID
author_status: Whether they are an approved author or not
endorse_status: Whether endorsements are auto-approved or not
tags: Set by endorser for arbitrary grouping of Contacts
connection_id: Underlying AcaPy connection id
connection_alias: Underlying AcaPy connection alias
public_did: Represents the Contact's agent's Public DID (if any)
state: The underlying AcaPy connection state
created_at: Timestamp when record was created
updated_at: Timestamp when record was last modified
"""
contact_id: uuid.UUID = Field(
sa_column=Column(
UUID(as_uuid=True),
primary_key=True,
server_default=text("gen_random_uuid()"),
)
)
author_status: str = Field(nullable=False)
endorse_status: str = Field(nullable=False)
tags: List[str] = Field(sa_column=Column(ARRAY(String)))
# acapy data ---
connection_id: uuid.UUID = Field(nullable=False)
connection_protocol: str = Field(nullable=False)
connection_alias: str = Field(nullable=True, default=False)
public_did: str = Field(nullable=True, default=False)
state: str = Field(nullable=False)
# --- acapy data
created_at: datetime = Field(
sa_column=Column(TIMESTAMP, nullable=False, server_default=func.now())
)
updated_at: datetime = Field(
sa_column=Column(
TIMESTAMP, nullable=False, server_default=func.now(), onupdate=func.now()
)
)
| [
"sqlmodel.Field"
] | [((1326, 1347), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (1331, 1347), False, 'from sqlmodel import Field\n'), ((1374, 1395), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (1379, 1395), False, 'from sqlmodel import Field\n'), ((1510, 1531), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (1515, 1531), False, 'from sqlmodel import Field\n'), ((1563, 1584), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (1568, 1584), False, 'from sqlmodel import Field\n'), ((1613, 1648), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)', 'default': '(False)'}), '(nullable=True, default=False)\n', (1618, 1648), False, 'from sqlmodel import Field\n'), ((1671, 1706), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)', 'default': '(False)'}), '(nullable=True, default=False)\n', (1676, 1706), False, 'from sqlmodel import Field\n'), ((1724, 1745), 'sqlmodel.Field', 'Field', ([], {'nullable': '(False)'}), '(nullable=False)\n', (1729, 1745), False, 'from sqlmodel import Field\n'), ((1180, 1198), 'sqlalchemy.dialects.postgresql.UUID', 'UUID', ([], {'as_uuid': '(True)'}), '(as_uuid=True)\n', (1184, 1198), False, 'from sqlalchemy.dialects.postgresql import UUID, TIMESTAMP, ARRAY\n'), ((1441, 1454), 'sqlalchemy.dialects.postgresql.ARRAY', 'ARRAY', (['String'], {}), '(String)\n', (1446, 1454), False, 'from sqlalchemy.dialects.postgresql import UUID, TIMESTAMP, ARRAY\n'), ((1257, 1282), 'sqlalchemy.text', 'text', (['"""gen_random_uuid()"""'], {}), "('gen_random_uuid()')\n", (1261, 1282), False, 'from sqlalchemy import Column, func, text, String\n'), ((1869, 1879), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (1877, 1879), False, 'from sqlalchemy import Column, func, text, String\n'), ((2001, 2011), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (2009, 2011), False, 'from sqlalchemy import Column, func, text, String\n'), ((2022, 2032), 'sqlalchemy.func.now', 'func.now', ([], {}), '()\n', (2030, 2032), False, 'from sqlalchemy import Column, func, text, String\n')] |
from pydantic.types import Optional
from sqlmodel import Field, Relationship, SQLModel
from api.public.team.models import Team
class HeroBase(SQLModel):
name: str
secret_name: str
age: Optional[int] = None
team_id: Optional[int] = Field(default=None, foreign_key="team.id")
class Config:
schema_extra = {
"example": {
"id": 1,
"name": "<NAME>",
"secret_name": "<NAME>",
"age": 27,
"team_id": 1,
}
}
class Hero(HeroBase, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
team: Optional[Team] = Relationship(back_populates="heroes")
class HeroCreate(HeroBase):
pass
class HeroRead(HeroBase):
id: int
class HeroUpdate(HeroBase):
name: Optional[str] = None
secret_name: Optional[str] = None
age: Optional[int] = None
team_id: Optional[int] = None
class Config:
schema_extra = {
"example": {
"name": "<NAME>",
"secret_name": "<NAME>",
"age": 27,
"team_id": 1,
}
}
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((251, 293), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'foreign_key': '"""team.id"""'}), "(default=None, foreign_key='team.id')\n", (256, 293), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((604, 641), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (609, 641), False, 'from sqlmodel import Field, Relationship, SQLModel\n'), ((670, 707), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""heroes"""'}), "(back_populates='heroes')\n", (682, 707), False, 'from sqlmodel import Field, Relationship, SQLModel\n')] |
import pytest
from typing import Optional
from sqlmodel import Field, Session, SQLModel, create_engine
from sqlalchemy.exc import IntegrityError
def test_should_allow_duplicate_row_if_unique_constraint_is_not_passed(clear_sqlmodel):
class Hero(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
secret_name: str
age: Optional[int] = None
hero_1 = Hero(name="Deadpond", secret_name="<NAME>")
hero_2 = Hero(name="Deadpond", secret_name="<NAME>")
engine = create_engine("sqlite://")
SQLModel.metadata.create_all(engine)
with Session(engine) as session:
session.add(hero_1)
session.commit()
session.refresh(hero_1)
with Session(engine) as session:
session.add(hero_2)
session.commit()
session.refresh(hero_2)
with Session(engine) as session:
heroes = session.query(Hero).all()
assert len(heroes) == 2
assert heroes[0].name == heroes[1].name
def test_should_allow_duplicate_row_if_unique_constraint_is_false(clear_sqlmodel):
class Hero(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
secret_name: str = Field(unique=False)
age: Optional[int] = None
hero_1 = Hero(name="Deadpond", secret_name="<NAME>")
hero_2 = Hero(name="Deadpond", secret_name="<NAME>")
engine = create_engine("sqlite://")
SQLModel.metadata.create_all(engine)
with Session(engine) as session:
session.add(hero_1)
session.commit()
session.refresh(hero_1)
with Session(engine) as session:
session.add(hero_2)
session.commit()
session.refresh(hero_2)
with Session(engine) as session:
heroes = session.query(Hero).all()
assert len(heroes) == 2
assert heroes[0].name == heroes[1].name
def test_should_raise_exception_when_try_to_duplicate_row_if_unique_constraint_is_true(clear_sqlmodel):
class Hero(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str
secret_name: str = Field(unique=True)
age: Optional[int] = None
hero_1 = Hero(name="Deadpond", secret_name="<NAME>")
hero_2 = Hero(name="Deadpond", secret_name="<NAME>")
engine = create_engine("sqlite://")
SQLModel.metadata.create_all(engine)
with Session(engine) as session:
session.add(hero_1)
session.commit()
session.refresh(hero_1)
with pytest.raises(IntegrityError):
with Session(engine) as session:
session.add(hero_2)
session.commit()
session.refresh(hero_2)
| [
"sqlmodel.create_engine",
"sqlmodel.Session",
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Field"
] | [((563, 589), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite://"""'], {}), "('sqlite://')\n", (576, 589), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((597, 633), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (625, 633), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((1486, 1512), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite://"""'], {}), "('sqlite://')\n", (1499, 1512), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((1520, 1556), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (1548, 1556), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((2429, 2455), 'sqlmodel.create_engine', 'create_engine', (['"""sqlite://"""'], {}), "('sqlite://')\n", (2442, 2455), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((2463, 2499), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (2491, 2499), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((311, 348), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (316, 348), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((646, 661), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (653, 661), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((774, 789), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (781, 789), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((902, 917), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (909, 917), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((1212, 1249), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (1217, 1249), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((1297, 1316), 'sqlmodel.Field', 'Field', ([], {'unique': '(False)'}), '(unique=False)\n', (1302, 1316), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((1569, 1584), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1576, 1584), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((1697, 1712), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1704, 1712), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((1825, 1840), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (1832, 1840), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((2156, 2193), 'sqlmodel.Field', 'Field', ([], {'default': 'None', 'primary_key': '(True)'}), '(default=None, primary_key=True)\n', (2161, 2193), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((2241, 2259), 'sqlmodel.Field', 'Field', ([], {'unique': '(True)'}), '(unique=True)\n', (2246, 2259), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((2512, 2527), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (2519, 2527), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n'), ((2640, 2669), 'pytest.raises', 'pytest.raises', (['IntegrityError'], {}), '(IntegrityError)\n', (2653, 2669), False, 'import pytest\n'), ((2685, 2700), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (2692, 2700), False, 'from sqlmodel import Field, Session, SQLModel, create_engine\n')] |
from decouple import config
from sqlmodel import Session, SQLModel, create_engine
DATABASE_URL = config("DATABASE_URL")
DEBUG = config("DEBUG", default=False, cast=bool)
engine = create_engine(DATABASE_URL, echo=DEBUG)
def get_session():
with Session(engine) as session:
yield session
def create_db_and_tables():
SQLModel.metadata.create_all(engine)
| [
"sqlmodel.SQLModel.metadata.create_all",
"sqlmodel.Session",
"sqlmodel.create_engine"
] | [((98, 120), 'decouple.config', 'config', (['"""DATABASE_URL"""'], {}), "('DATABASE_URL')\n", (104, 120), False, 'from decouple import config\n'), ((129, 170), 'decouple.config', 'config', (['"""DEBUG"""'], {'default': '(False)', 'cast': 'bool'}), "('DEBUG', default=False, cast=bool)\n", (135, 170), False, 'from decouple import config\n'), ((182, 221), 'sqlmodel.create_engine', 'create_engine', (['DATABASE_URL'], {'echo': 'DEBUG'}), '(DATABASE_URL, echo=DEBUG)\n', (195, 221), False, 'from sqlmodel import Session, SQLModel, create_engine\n'), ((336, 372), 'sqlmodel.SQLModel.metadata.create_all', 'SQLModel.metadata.create_all', (['engine'], {}), '(engine)\n', (364, 372), False, 'from sqlmodel import Session, SQLModel, create_engine\n'), ((252, 267), 'sqlmodel.Session', 'Session', (['engine'], {}), '(engine)\n', (259, 267), False, 'from sqlmodel import Session, SQLModel, create_engine\n')] |
import uuid
from datetime import datetime
from typing import Optional, List
import pydantic
from sqlalchemy import Column, JSON
from sqlmodel import Field, Relationship
from api.db.models.base import BaseModel, BaseTable
class SchemaDef(pydantic.BaseModel):
id: Optional[str] = None
name: Optional[str] = None
version: Optional[str] = None
attributes: Optional[List[str]] = []
class Governance(pydantic.BaseModel):
schema_def: Optional[SchemaDef] = None
cred_def_id: Optional[str] = None
cred_def_tag: Optional[str] = None
class SandboxBase(BaseModel):
tag: Optional[str] = Field(nullable=True)
governance: dict = Field(default={}, sa_column=Column(JSON))
governance_cas: dict = Field(default={}, sa_column=Column(JSON))
class Sandbox(SandboxBase, BaseTable, table=True):
lobs: List["Lob"] = Relationship(back_populates="sandbox") # noqa: F821
students: List["Student"] = Relationship(back_populates="sandbox") # noqa: F821
applicants: List["Applicant"] = Relationship(back_populates="sandbox") # noqa: F821
class SandboxCreate(SandboxBase):
tag: Optional[str] = None
governance: Optional[Governance] = None
governance_cas: Optional[Governance] = None
class SandboxUpdate(SandboxBase):
id: uuid.UUID
tag: Optional[str] = None
governance: Optional[Governance] = None
governance_cas: Optional[Governance] = None
class SandboxRead(SandboxBase):
id: uuid.UUID
created_at: datetime
updated_at: datetime
tag: Optional[str] = None
governance: Optional[Governance] = None
governance_cas: Optional[Governance] = None
| [
"sqlmodel.Relationship",
"sqlmodel.Field"
] | [((614, 634), 'sqlmodel.Field', 'Field', ([], {'nullable': '(True)'}), '(nullable=True)\n', (619, 634), False, 'from sqlmodel import Field, Relationship\n'), ((846, 884), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""sandbox"""'}), "(back_populates='sandbox')\n", (858, 884), False, 'from sqlmodel import Field, Relationship\n'), ((931, 969), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""sandbox"""'}), "(back_populates='sandbox')\n", (943, 969), False, 'from sqlmodel import Field, Relationship\n'), ((1020, 1058), 'sqlmodel.Relationship', 'Relationship', ([], {'back_populates': '"""sandbox"""'}), "(back_populates='sandbox')\n", (1032, 1058), False, 'from sqlmodel import Field, Relationship\n'), ((686, 698), 'sqlalchemy.Column', 'Column', (['JSON'], {}), '(JSON)\n', (692, 698), False, 'from sqlalchemy import Column, JSON\n'), ((755, 767), 'sqlalchemy.Column', 'Column', (['JSON'], {}), '(JSON)\n', (761, 767), False, 'from sqlalchemy import Column, JSON\n')] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.