From cf404cb2503c076d9d289947082f6fd8e33ae70e Mon Sep 17 00:00:00 2001 From: artem Date: Fri, 15 May 2026 14:44:00 +0300 Subject: [PATCH 1/3] Solution --- alembic.ini | 149 ++++++++++++++++++ db/__init__.py | 0 db/crud.py | 48 ++++++ db/database.py | 12 ++ db/main.py | 59 +++++++ db/models.py | 23 +++ db/schemas.py | 31 ++++ migrations/README | 1 + migrations/env.py | 78 +++++++++ migrations/script.py.mako | 28 ++++ .../versions/34475c2473d0_create_users.py | 32 ++++ .../versions/c56309a35b48_add_users_table.py | 50 ++++++ requirements.txt | Bin 0 -> 802 bytes 13 files changed, 511 insertions(+) create mode 100644 alembic.ini create mode 100644 db/__init__.py create mode 100644 db/crud.py create mode 100644 db/database.py create mode 100644 db/main.py create mode 100644 db/models.py create mode 100644 db/schemas.py create mode 100644 migrations/README create mode 100644 migrations/env.py create mode 100644 migrations/script.py.mako create mode 100644 migrations/versions/34475c2473d0_create_users.py create mode 100644 migrations/versions/c56309a35b48_add_users_table.py create mode 100644 requirements.txt diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 00000000..7ee05b69 --- /dev/null +++ b/alembic.ini @@ -0,0 +1,149 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts. +# this is typically a path given in POSIX (e.g. forward slashes) +# format, relative to the token %(here)s which refers to the location of this +# ini file +script_location = %(here)s/migrations + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s +# Or organize into date-based subdirectories (requires recursive_version_locations = true) +# file_template = %%(year)d/%%(month).2d/%%(day).2d_%%(hour).2d%%(minute).2d_%%(second).2d_%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. for multiple paths, the path separator +# is defined by "path_separator" below. +prepend_sys_path = . + + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the tzdata library which can be installed by adding +# `alembic[tz]` to the pip requirements. +# string value is passed to ZoneInfo() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to /versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "path_separator" +# below. +# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions + +# path_separator; This indicates what character is used to split lists of file +# paths, including version_locations and prepend_sys_path within configparser +# files such as alembic.ini. +# The default rendered in new alembic.ini files is "os", which uses os.pathsep +# to provide os-dependent path splitting. +# +# Note that in order to support legacy alembic.ini files, this default does NOT +# take place if path_separator is not present in alembic.ini. If this +# option is omitted entirely, fallback logic is as follows: +# +# 1. Parsing of the version_locations option falls back to using the legacy +# "version_path_separator" key, which if absent then falls back to the legacy +# behavior of splitting on spaces and/or commas. +# 2. Parsing of the prepend_sys_path option falls back to the legacy +# behavior of splitting on spaces, commas, or colons. +# +# Valid values for path_separator are: +# +# path_separator = : +# path_separator = ; +# path_separator = space +# path_separator = newline +# +# Use os.pathsep. Default configuration used for new projects. +path_separator = os + +# set to 'true' to search source files recursively +# in each "version_locations" directory +# new in Alembic version 1.10 +# recursive_version_locations = false + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +# database URL. This is consumed by the user-maintained env.py script only. +# other means of configuring database URLs may be customized within the env.py +# file. +sqlalchemy.url = sqlite:///db.sqlite3 + + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module +# hooks = ruff +# ruff.type = module +# ruff.module = ruff +# ruff.options = check --fix REVISION_SCRIPT_FILENAME + +# Alternatively, use the exec runner to execute a binary found on your PATH +# hooks = ruff +# ruff.type = exec +# ruff.executable = ruff +# ruff.options = check --fix REVISION_SCRIPT_FILENAME + +# Logging configuration. This is also consumed by the user-maintained +# env.py script only. +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARNING +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARNING +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/db/__init__.py b/db/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/db/crud.py b/db/crud.py new file mode 100644 index 00000000..ce22b02d --- /dev/null +++ b/db/crud.py @@ -0,0 +1,48 @@ +from sqlalchemy.orm import Session +from db import models, schemas + + +def get_books(db: Session, skip: int = 0, limit: int = 100): + return db.query(models.Book).offset(skip).limit(limit).all() + + +def create_book(db: Session, book_type: schemas.BookBase): + db_book = models.Book( + title=book_type.title, + summary=book_type.summary, + publication_date=book_type.publication_date, + author_id=book_type.author_id, + ) + db.add(db_book) + db.commit() + db.refresh(db_book) + return db_book + + +def get_authors(db: Session, skip: int = 0, limit: int = 100): + return db.query(models.Author).offset(skip).limit(limit).all() + + +def create_author(db: Session, author_type: schemas.AuthorBase): + db_author = models.Author( + name=author_type.name, + bio=author_type.bio, + ) + db.add(db_author) + db.commit() + db.refresh(db_author) + return db_author + + +def get_author(db: Session, author_id: int): + return db.query(models.Author).filter(models.Author.id == author_id).first() + + +def get_books_by_author(db: Session, author_id: int, skip: int = 0, limit: int = 100): + return ( + db.query(models.Book) + .filter(models.Book.author_id == author_id) + .offset(skip) + .limit(limit) + .all() + ) diff --git a/db/database.py b/db/database.py new file mode 100644 index 00000000..83686457 --- /dev/null +++ b/db/database.py @@ -0,0 +1,12 @@ +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker, declarative_base + +SQLALCHEMY_DATABASE_URL = "sqlite:///db.sqlite3" + + +engine = create_engine( + SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False} +) +SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) + +Base = declarative_base() diff --git a/db/main.py b/db/main.py new file mode 100644 index 00000000..505f0c58 --- /dev/null +++ b/db/main.py @@ -0,0 +1,59 @@ +from fastapi import FastAPI, Depends, HTTPException +from sqlalchemy.orm import Session +from database import SessionLocal, engine, Base +import crud +import schemas + +Base.metadata.create_all(bind=engine) + +app = FastAPI(title="Library Management API") + + +def get_db(): + db = SessionLocal() + try: + yield db + finally: + db.close() + + +@app.post("/authors/", response_model=schemas.Author) +def create_author_endpoint(author: schemas.AuthorBase, db: Session = Depends(get_db)): + return crud.create_author(db, author) + + +@app.get("/authors/", response_model=list[schemas.Author]) +def get_authors_endpoint( + skip: int = 0, limit: int = 100, db: Session = Depends(get_db) +): + return crud.get_authors(db, skip, limit) + + +@app.get("/authors/{author_id}", response_model=schemas.Author) +def get_author_endpoint(author_id: int, db: Session = Depends(get_db)): + author = crud.get_author(db, author_id) + if not author: + raise HTTPException(status_code=404, detail="Author not found") + return author + + +@app.post("/authors/{author_id}/books/", response_model=schemas.Book) +def create_book_endpoint( + author_id: int, book: schemas.BookBase, db: Session = Depends(get_db) +): + author = crud.get_author(db, author_id) + if not author: + raise HTTPException(status_code=404, detail="Author not found") + return crud.create_book(db, book, author_id) + + +@app.get("/books/", response_model=list[schemas.Book]) +def get_books_endpoint(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): + return crud.get_books(db, skip, limit) + + +@app.get("/books/by-author/{author_id}", response_model=list[schemas.Book]) +def get_books_by_author_endpoint( + author_id: int, skip: int = 0, limit: int = 100, db: Session = Depends(get_db) +): + return crud.get_books_by_author(db, author_id, skip, limit) diff --git a/db/models.py b/db/models.py new file mode 100644 index 00000000..6f0f2a1b --- /dev/null +++ b/db/models.py @@ -0,0 +1,23 @@ +from sqlalchemy import Integer, Column, String, Date, ForeignKey +from sqlalchemy.orm import relationship + +from db.database import Base + + +class Author(Base): + __tablename__ = "authors" + + id = Column(Integer, primary_key=True, index=True) + name = Column(String(255), nullable=False, unique=True) + bio = Column(String(255)) + books = relationship("Book", back_populates="author") + + +class Book(Base): + __tablename__ = "books" + id = Column(Integer, primary_key=True) + title = Column(String(255), nullable=False) + summary = Column(String(255)) + publication_date = Column(Date) + author_id = Column(Integer, ForeignKey("authors.id")) + author = relationship("Author", back_populates="books") diff --git a/db/schemas.py b/db/schemas.py new file mode 100644 index 00000000..aa52e043 --- /dev/null +++ b/db/schemas.py @@ -0,0 +1,31 @@ +from datetime import date +from typing import Optional + +from pydantic import BaseModel + + +class BookBase(BaseModel): + title: str + summary: Optional[str] + publication_date: Optional[date] + author_id: int + + +class Book(BookBase): + id: int + + class Config: + orm_mode = True + + +class AuthorBase(BaseModel): + name: str + bio: str + + +class Author(AuthorBase): + id: int + books: list[Book] = [] + + class Config: + orm_mode = True diff --git a/migrations/README b/migrations/README new file mode 100644 index 00000000..98e4f9c4 --- /dev/null +++ b/migrations/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 00000000..0f2b0760 --- /dev/null +++ b/migrations/env.py @@ -0,0 +1,78 @@ +from logging.config import fileConfig + +from sqlalchemy import engine_from_config +from sqlalchemy import pool + +from alembic import context + +from db.models import Base + +# this is the Alembic Config object, which provides +# access to the values within the .ini file in use. +config = context.config + +# Interpret the config file for Python logging. +# This line sets up loggers basically. +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +# add your model's MetaData object here +# for 'autogenerate' support +# from myapp import mymodel +# target_metadata = mymodel.Base.metadata +target_metadata = [Base.metadata] + +# other values from the config, defined by the needs of env.py, +# can be acquired: +# my_important_option = config.get_main_option("my_important_option") +# ... etc. + + +def run_migrations_offline() -> None: + """Run migrations in 'offline' mode. + + This configures the context with just a URL + and not an Engine, though an Engine is acceptable + here as well. By skipping the Engine creation + we don't even need a DBAPI to be available. + + Calls to context.execute() here emit the given string to the + script output. + + """ + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + + with context.begin_transaction(): + context.run_migrations() + + +def run_migrations_online() -> None: + """Run migrations in 'online' mode. + + In this scenario we need to create an Engine + and associate a connection with the context. + + """ + connectable = engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + + with connectable.connect() as connection: + context.configure(connection=connection, target_metadata=target_metadata) + + with context.begin_transaction(): + context.run_migrations() + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 00000000..11016301 --- /dev/null +++ b/migrations/script.py.mako @@ -0,0 +1,28 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + """Upgrade schema.""" + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + """Downgrade schema.""" + ${downgrades if downgrades else "pass"} diff --git a/migrations/versions/34475c2473d0_create_users.py b/migrations/versions/34475c2473d0_create_users.py new file mode 100644 index 00000000..410b7b83 --- /dev/null +++ b/migrations/versions/34475c2473d0_create_users.py @@ -0,0 +1,32 @@ +"""create users + +Revision ID: 34475c2473d0 +Revises: +Create Date: 2026-05-15 13:10:35.287682 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = '34475c2473d0' +down_revision: Union[str, Sequence[str], None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + """Upgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + pass + # ### end Alembic commands ### + + +def downgrade() -> None: + """Downgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + pass + # ### end Alembic commands ### diff --git a/migrations/versions/c56309a35b48_add_users_table.py b/migrations/versions/c56309a35b48_add_users_table.py new file mode 100644 index 00000000..a749f51a --- /dev/null +++ b/migrations/versions/c56309a35b48_add_users_table.py @@ -0,0 +1,50 @@ +"""add users table + +Revision ID: c56309a35b48 +Revises: 34475c2473d0 +Create Date: 2026-05-15 13:16:13.117424 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = 'c56309a35b48' +down_revision: Union[str, Sequence[str], None] = '34475c2473d0' +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + """Upgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('authors', + sa.Column('id', sa.Integer(), nullable=False), + sa.Column('name', sa.String(length=255), nullable=False), + sa.Column('bio', sa.String(length=255), nullable=True), + sa.PrimaryKeyConstraint('id'), + sa.UniqueConstraint('name') + ) + op.create_index(op.f('ix_authors_id'), 'authors', ['id'], unique=False) + op.create_table('books', + sa.Column('id', sa.Integer(), nullable=False), + sa.Column('title', sa.String(length=255), nullable=False), + sa.Column('summary', sa.String(length=255), nullable=True), + sa.Column('publication_date', sa.Date(), nullable=True), + sa.Column('author_id', sa.Integer(), nullable=True), + sa.ForeignKeyConstraint(['author_id'], ['authors.id'], ), + sa.PrimaryKeyConstraint('id') + ) + # ### end Alembic commands ### + + +def downgrade() -> None: + """Downgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + op.drop_table('books') + op.drop_index(op.f('ix_authors_id'), table_name='authors') + op.drop_table('authors') + # ### end Alembic commands ### diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..2455897db28d1024de507d95090da256becf4ff7 GIT binary patch literal 802 zcmZ`%!A^rv5S+7#pHfo_t?j{scQ3{dXb@;6Ee|Xl2gma-Iq$7CbEqJn&oM&Q69~+>r5?J77e|x_;*0TTSGTsHrBcjQ0uB8GXf>iUm%F zuCO5@G_hU<(RxO=6P8X`OSHv>^$ky)R2??PIPkVNPaRbvuI}pM9geK8_yuZJ=$`r*I@WyIo z>DfmOpSH8K1{} Date: Fri, 15 May 2026 14:53:30 +0300 Subject: [PATCH 2/3] Solution --- db/database.py | 1 - db/main.py | 42 ++++++++++++++++++++---------------------- db/models.py | 2 +- db/schemas.py | 4 ++-- migrations/env.py | 33 --------------------------------- 5 files changed, 23 insertions(+), 59 deletions(-) diff --git a/db/database.py b/db/database.py index 83686457..30dd1d9d 100644 --- a/db/database.py +++ b/db/database.py @@ -3,7 +3,6 @@ SQLALCHEMY_DATABASE_URL = "sqlite:///db.sqlite3" - engine = create_engine( SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False} ) diff --git a/db/main.py b/db/main.py index 505f0c58..e57a9ecd 100644 --- a/db/main.py +++ b/db/main.py @@ -1,12 +1,11 @@ from fastapi import FastAPI, Depends, HTTPException from sqlalchemy.orm import Session -from database import SessionLocal, engine, Base -import crud -import schemas +from db.database import SessionLocal, engine, Base +from db import crud, schemas Base.metadata.create_all(bind=engine) -app = FastAPI(title="Library Management API") +app = FastAPI() def get_db(): @@ -18,42 +17,41 @@ def get_db(): @app.post("/authors/", response_model=schemas.Author) -def create_author_endpoint(author: schemas.AuthorBase, db: Session = Depends(get_db)): - return crud.create_author(db, author) +def create_author(author: schemas.AuthorBase, db: Session = Depends(get_db)): + return crud.create_author(db=db, author_type=author) @app.get("/authors/", response_model=list[schemas.Author]) -def get_authors_endpoint( - skip: int = 0, limit: int = 100, db: Session = Depends(get_db) -): - return crud.get_authors(db, skip, limit) +def read_authors(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): + return crud.get_authors(db, skip=skip, limit=limit) @app.get("/authors/{author_id}", response_model=schemas.Author) -def get_author_endpoint(author_id: int, db: Session = Depends(get_db)): - author = crud.get_author(db, author_id) - if not author: +def read_author(author_id: int, db: Session = Depends(get_db)): + db_author = crud.get_author(db, author_id=author_id) + if db_author is None: raise HTTPException(status_code=404, detail="Author not found") - return author + return db_author @app.post("/authors/{author_id}/books/", response_model=schemas.Book) -def create_book_endpoint( +def create_book_for_author( author_id: int, book: schemas.BookBase, db: Session = Depends(get_db) ): - author = crud.get_author(db, author_id) + author = crud.get_author(db, author_id=author_id) if not author: raise HTTPException(status_code=404, detail="Author not found") - return crud.create_book(db, book, author_id) + book.author_id = author_id + return crud.create_book(db=db, book_type=book) @app.get("/books/", response_model=list[schemas.Book]) -def get_books_endpoint(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): - return crud.get_books(db, skip, limit) +def read_books(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): + return crud.get_books(db, skip=skip, limit=limit) -@app.get("/books/by-author/{author_id}", response_model=list[schemas.Book]) -def get_books_by_author_endpoint( +@app.get("/authors/{author_id}/books/", response_model=list[schemas.Book]) +def read_books_by_author( author_id: int, skip: int = 0, limit: int = 100, db: Session = Depends(get_db) ): - return crud.get_books_by_author(db, author_id, skip, limit) + return crud.get_books_by_author(db, author_id=author_id, skip=skip, limit=limit) diff --git a/db/models.py b/db/models.py index 6f0f2a1b..f13b14b1 100644 --- a/db/models.py +++ b/db/models.py @@ -1,6 +1,5 @@ from sqlalchemy import Integer, Column, String, Date, ForeignKey from sqlalchemy.orm import relationship - from db.database import Base @@ -15,6 +14,7 @@ class Author(Base): class Book(Base): __tablename__ = "books" + id = Column(Integer, primary_key=True) title = Column(String(255), nullable=False) summary = Column(String(255)) diff --git a/db/schemas.py b/db/schemas.py index aa52e043..fd1add57 100644 --- a/db/schemas.py +++ b/db/schemas.py @@ -1,6 +1,5 @@ from datetime import date from typing import Optional - from pydantic import BaseModel @@ -20,7 +19,8 @@ class Config: class AuthorBase(BaseModel): name: str - bio: str + bio: Optional[str] = None + books: list = [] class Author(AuthorBase): diff --git a/migrations/env.py b/migrations/env.py index 0f2b0760..a932b27c 100644 --- a/migrations/env.py +++ b/migrations/env.py @@ -1,45 +1,18 @@ from logging.config import fileConfig - from sqlalchemy import engine_from_config from sqlalchemy import pool - from alembic import context - from db.models import Base -# this is the Alembic Config object, which provides -# access to the values within the .ini file in use. config = context.config -# Interpret the config file for Python logging. -# This line sets up loggers basically. if config.config_file_name is not None: fileConfig(config.config_file_name) -# add your model's MetaData object here -# for 'autogenerate' support -# from myapp import mymodel -# target_metadata = mymodel.Base.metadata target_metadata = [Base.metadata] -# other values from the config, defined by the needs of env.py, -# can be acquired: -# my_important_option = config.get_main_option("my_important_option") -# ... etc. - def run_migrations_offline() -> None: - """Run migrations in 'offline' mode. - - This configures the context with just a URL - and not an Engine, though an Engine is acceptable - here as well. By skipping the Engine creation - we don't even need a DBAPI to be available. - - Calls to context.execute() here emit the given string to the - script output. - - """ url = config.get_main_option("sqlalchemy.url") context.configure( url=url, @@ -53,12 +26,6 @@ def run_migrations_offline() -> None: def run_migrations_online() -> None: - """Run migrations in 'online' mode. - - In this scenario we need to create an Engine - and associate a connection with the context. - - """ connectable = engine_from_config( config.get_section(config.config_ini_section, {}), prefix="sqlalchemy.", From da28dddea5fab121432ccfac07ee4abc7a1dad9a Mon Sep 17 00:00:00 2001 From: artem Date: Fri, 15 May 2026 15:05:30 +0300 Subject: [PATCH 3/3] Solution --- db/crud.py => crud.py | 3 ++- db/database.py => database.py | 0 db/__init__.py | 0 db/main.py => main.py | 5 +++-- migrations/env.py | 2 +- db/models.py => models.py | 2 +- db/schemas.py => schemas.py | 0 7 files changed, 7 insertions(+), 5 deletions(-) rename db/crud.py => crud.py (97%) rename db/database.py => database.py (100%) delete mode 100644 db/__init__.py rename db/main.py => main.py (95%) rename db/models.py => models.py (95%) rename db/schemas.py => schemas.py (100%) diff --git a/db/crud.py b/crud.py similarity index 97% rename from db/crud.py rename to crud.py index ce22b02d..5151b83a 100644 --- a/db/crud.py +++ b/crud.py @@ -1,5 +1,6 @@ from sqlalchemy.orm import Session -from db import models, schemas +import models +import schemas def get_books(db: Session, skip: int = 0, limit: int = 100): diff --git a/db/database.py b/database.py similarity index 100% rename from db/database.py rename to database.py diff --git a/db/__init__.py b/db/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/db/main.py b/main.py similarity index 95% rename from db/main.py rename to main.py index e57a9ecd..0149d314 100644 --- a/db/main.py +++ b/main.py @@ -1,7 +1,8 @@ from fastapi import FastAPI, Depends, HTTPException from sqlalchemy.orm import Session -from db.database import SessionLocal, engine, Base -from db import crud, schemas +from database import SessionLocal, engine, Base +import crud +import schemas Base.metadata.create_all(bind=engine) diff --git a/migrations/env.py b/migrations/env.py index a932b27c..7f5e1a03 100644 --- a/migrations/env.py +++ b/migrations/env.py @@ -2,7 +2,7 @@ from sqlalchemy import engine_from_config from sqlalchemy import pool from alembic import context -from db.models import Base +from models import Base config = context.config diff --git a/db/models.py b/models.py similarity index 95% rename from db/models.py rename to models.py index f13b14b1..ca62e8f4 100644 --- a/db/models.py +++ b/models.py @@ -1,6 +1,6 @@ from sqlalchemy import Integer, Column, String, Date, ForeignKey from sqlalchemy.orm import relationship -from db.database import Base +from database import Base class Author(Base): diff --git a/db/schemas.py b/schemas.py similarity index 100% rename from db/schemas.py rename to schemas.py