migrations/env.py
import asyncio
from logging.config import fileConfig

from sqlalchemy import pool
from sqlalchemy.engine import Connection
from sqlalchemy.ext.asyncio import async_engine_from_config

from alembic import context

from src.core.database import Base
from src.core.settings import settings

from auth.models import User
from event.models import Event
from account.models import Account
from src.associations import AccountEventAssociation, AccountRatingAssociation
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
section = config.config_ini_section
config.set_section_option(section, "POSTGRES_USER", settings.db.POSTGRES_USER)
config.set_section_option(section, "POSTGRES_HOST", settings.db.POSTGRES_HOST)
config.set_section_option(section, "POSTGRES_DB", settings.db.POSTGRES_DB)
config.set_section_option(section, "POSTGRES_PASSWORD", settings.db.POSTGRES_PASSWORD)


# 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 do_run_migrations(connection: Connection) -> None:
    context.configure(connection=connection, target_metadata=target_metadata)

    with context.begin_transaction():
        context.run_migrations()


async def run_async_migrations() -> None:
    """In this scenario we need to create an Engine
    and associate a connection with the context.

    """

    connectable = async_engine_from_config(
        config.get_section(config.config_ini_section, {}),
        prefix="sqlalchemy.",
        poolclass=pool.NullPool,
    )

    async with connectable.connect() as connection:
        await connection.run_sync(do_run_migrations)

    await connectable.dispose()


def run_migrations_online() -> None:
    """Run migrations in 'online' mode."""

    asyncio.run(run_async_migrations())


if context.is_offline_mode():
    run_migrations_offline()
else:
    run_migrations_online()


src/core/__init__
from .celery import celery as celery_app

__all__ = ['celery_app']


event/__init__
from fastapi import APIRouter

from .api import router as api_router

router = APIRouter(prefix='/event', tags=['Event'])
router.include_router(api_router)

event/api
from typing import List

from fastapi import APIRouter, Depends, status
from sqlalchemy.ext.asyncio import AsyncSession

from src import utils
from src.core.database import get_session

from .permissions import event_owner_permission
from .schemas import (EventInSchema, EventOutListSchema, EventOutSchema,
                      EventSchema, EventUpdateSchema)
from .services import EventService

router = APIRouter()


@router.post(
    '/create-event',
    response_model=EventOutSchema,
    status_code=status.HTTP_201_CREATED
)
async def create_event(
        event_data: EventInSchema,
        session: AsyncSession = Depends(get_session),
        service: EventService = Depends(),
        account: dict = Depends(utils.get_account_from_user)
):
    event = await service.create_event(
        session,
        account,
        event_data
    )
    return event


@router.get(
    '/event-list',
    status_code=status.HTTP_200_OK,
    response_model=List[EventOutListSchema]
)
async def event_list(
    session: AsyncSession = Depends(get_session),
    service: EventService = Depends(),
    account: dict = Depends(utils.get_account_from_user)
):
    res = await service.event_list(session)
    return res


@router.get(
    '/{event_id}',
    status_code=status.HTTP_200_OK,
    response_model=EventSchema
)
async def get_event(
    event_id: int,
    session: AsyncSession = Depends(get_session),
    service: EventService = Depends(),
    account: dict = Depends(utils.get_account_from_user)
):
    event, event_instance = await service.get_event(session, event_id)
    return event


@router.put(
    '/{event_id}',
    status_code=status.HTTP_200_OK,
    response_model=EventSchema
)
@event_owner_permission()
async def update_event(
        event_id: int,
        event_data: EventUpdateSchema,
        account: dict = Depends(utils.get_account_from_user),
        session: AsyncSession = Depends(get_session),
        service: EventService = Depends(),
):
    return await service.update_event(session, event_id, event_data)


@router.delete(
    '/{event_id}',
    status_code=status.HTTP_204_NO_CONTENT
)
@event_owner_permission()
async def delete_event(
        event_id: int,
        account: dict = Depends(utils.get_account_from_user),
        session: AsyncSession = Depends(get_session),
        service: EventService = Depends()
):
    await service.delete_event(session, event_id)


@router.post('/{event_id}/go-to-event')
async def go_to_event(
    event_id: int,
    account: dict = Depends(utils.get_account_from_user),
    session: AsyncSession = Depends(get_session),
    service: EventService = Depends()
):
    return await service.go_to_event(session, event_id, account)

src/utils
from fastapi import Cookie, Depends, Header, HTTPException, status
from jose import JWTError, jwt
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from account import models as acc_model
from auth import crud
from auth import models as auth_model
from auth import schemas

from .core.database import get_session
from .core.settings import jwt_settings


async def validate_token(token: str):
    try:
        payload = jwt.decode(
            token=token,
            key=jwt_settings.SECRET_KEY,
            algorithms=[jwt_settings.ALGORITHM]
        )
        email = payload.get('email')
        if email is None:
            raise
        return payload
    except JWTError as e:
        print(e)
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            headers={'WWW-Authenticate': 'Bearer'},
            detail='Token is invalid'
        )


async def cookie_header_validation(
    access_token: str = Cookie(None),
    refresh_token: str = Cookie(None),
    Authorization: str = Header(None),
    refresh: bool = False
) -> str:
    exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        headers={'WWW-Authenticate': 'Bearer'},
        detail='Not Authenticated'
    )

    if not refresh:
        if not any([access_token, Authorization]):
            raise exception
        token = (
            Authorization
            .replace("Bearer ", "")
            if Authorization else access_token
        )
    else:
        if not any([refresh_token, Authorization]):
            raise exception
        token = (
            Authorization
            .replace("Bearer ", "")
            if Authorization else refresh_token
        )
    return token


async def get_current_user(
        access_token: str = Cookie(None),
        Authorization: str = Header(None),
) -> dict:
    token = await cookie_header_validation(
        access_token=access_token,
        Authorization=Authorization
    )
    payload = await validate_token(token)
    return payload


async def get_current_verified_user(
        payload: dict = Depends(get_current_user)
) -> dict:
    if payload['is_email_verified']:
        return payload
    raise HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        headers={'WWW-Authenticate': 'Bearer'},
        detail='User email is not verified'
    )


async def is_user_exists(
        session: AsyncSession,
        user_data: schemas.UserCreateSchema
) -> None:
    subq = (
        select(auth_model.User)
        .where(auth_model.User.email == user_data.email)
        .exists()
    )
    stmt = select(subq)
    result = await session.execute(stmt)
    if result.scalar():
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail='User with such credentials already exists',
            headers={'WWW-Authenticate': 'Bearer'}
        )
    return None


async def get_account_from_user(
        session: AsyncSession = Depends(get_session),
        payload: dict = Depends(get_current_verified_user)
) -> acc_model.Account:

    email = payload['email']
    user = await crud.retrieve_user_by_email(session, email)
    smt = select(acc_model.Account).where(
        acc_model.Account.user_id == user.id
    )
    result = await session.execute(smt)
    account_instance = result.scalar()
    await session.refresh(account_instance, attribute_names=["events"])
    return account_instance

auth/__init__
from fastapi import APIRouter

from .api import router as api_router

router = APIRouter(prefix='/auth', tags=['Authentication'])
router.include_router(api_router)

auth/api
from urllib.parse import urlparse

from fastapi import (APIRouter, Cookie, Depends, HTTPException, Request,
                     Response, status)
from sqlalchemy.ext.asyncio import AsyncSession

from account.services import AccountService
from src import utils
from src.core.database import get_session

from .schemas import (RefreshTokenSchema, UserCreateSchema, UserInSchema,
                      UserSchema)
from .services import AuthService

router = APIRouter()


@router.post(
    '/token',
    status_code=status.HTTP_200_OK,
    response_model=RefreshTokenSchema
)
async def login(
        response: Response,
        user_data: UserInSchema,
        service: AuthService = Depends(),
        session: AsyncSession = Depends(get_session)
):
    user = await service.validate_user(
        session,
        user_data.email,
        user_data.password
    )
    tokens = await service.create_token(user, refresh=True)
    response.set_cookie(
        key='access_token',
        value=tokens.access_token,
    )
    response.set_cookie(
        key='refresh_token',
        value=tokens.refresh_token,
    )
    return tokens


@router.post(
    '/sign-up',
    status_code=status.HTTP_201_CREATED,
    response_model=UserSchema
)
async def signup(
        user_data: UserCreateSchema,
        request: Request,
        service: AuthService = Depends(),
        account_service: AccountService = Depends(),
        session: AsyncSession = Depends(get_session)
):
    await service.user_exists(session, user_data)
    domain = urlparse(str(request.url)).netloc  # localhost:8000
    user = await service.create_user(
        session,
        user_data,
        domain=domain
    )
    while True:
        username = await account_service.generate_username(
            user_data=user_data
        )
        exists = await account_service.is_username_exists(
            session,
            username
        )
        if exists is None:
            await account_service.create_account(
                session,
                username=username,
                user_data=user
            )
            break
    return user


@router.get(
    '/email-verify',
    status_code=status.HTTP_200_OK
)
async def verify_email(
        service: AuthService = Depends(),
        session: AsyncSession = Depends(get_session),
        token: str | None = None
):
    if token is None:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail='Token was not provided'
        )
    payload = await utils.validate_token(token)
    await service.verify_user_email(session, payload)
    return {"message": "Email successfully verified"}


@router.post('/restore-password', status_code=status.HTTP_200_OK)
async def restore_password():
    pass


@router.post('/logout', status_code=status.HTTP_204_NO_CONTENT)
async def logout(
        response: Response,
        current_user: dict = Depends(utils.get_current_verified_user),
):
    response.delete_cookie(key='access_token')
    response.delete_cookie(key='refresh_token')
    return current_user


@router.post(
    '/refresh',
    status_code=status.HTTP_200_OK,
    response_model=RefreshTokenSchema
)
async def refresh(
        response: Response,
        refresh_token: str = Cookie(None),
        Authorization: str = Cookie(None),
        service: AuthService = Depends(),
        session: AsyncSession = Depends(get_session),
):
    tokens = await service.refresh(
        session=session,
        token=refresh_token,
        Authorization=Authorization
    )
    response.set_cookie(
        key='access_token',
        value=tokens.access_token
    )
    response.set_cookie(
        key='refresh_token',
        value=tokens.refresh_token
    )
    return tokens
вот все мои файлы и вот трейсбек
worker         | Usage: celery [OPTIONS] COMMAND [ARGS]...
worker         | Try 'celery --help' for help.
worker         |
worker         | Error: Invalid value for '-A' / '--app':
worker         | Unable to load celery application.
worker         | Partially initialized module 'src.utils' has no attribute 'get_current_verified_user' (most likely due to a circular import)
web            | Traceback (most recent call last):
web            |   File "/usr/local/bin/alembic", line 8, in <module>
web            |     sys.exit(main())
web            |              ^^^^^^
web            |   File "/usr/local/lib/python3.11/site-packages/alembic/config.py", line 632, in main
web            |     CommandLine(prog=prog).main(argv=argv)
web            |   File "/usr/local/lib/python3.11/site-packages/alembic/config.py", line 626, in main
web            |     self.run_cmd(cfg, options)
web            |   File "/usr/local/lib/python3.11/site-packages/alembic/config.py", line 603, in run_cmd
web            |     fn(
web            |   File "/usr/local/lib/python3.11/site-packages/alembic/command.py", line 385, in upgrade
web            |     script.run_env()
web            |   File "/usr/local/lib/python3.11/site-packages/alembic/script/base.py", line 582, in run_env
web            |     util.load_python_file(self.dir, "env.py")
web            |   File "/usr/local/lib/python3.11/site-packages/alembic/util/pyfiles.py", line 94, in load_python_file
web            |     module = load_module_py(module_id, path)
web            |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
web            |   File "/usr/local/lib/python3.11/site-packages/alembic/util/pyfiles.py", line 110, in load_module_py
web            |     spec.loader.exec_module(module)  # type: ignore
web            |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
web            |   File "<frozen importlib._bootstrap_external>", line 940, in exec_module
web            |   File "<frozen importlib._bootstrap>", line 241, in _call_with_frames_removed
web            |   File "/usr/src/app/migrations/env.py", line 10, in <module>
web            |     from src.core.database import Base
web            |   File "/usr/src/app/src/core/__init__.py", line 1, in <module>
web            |     from .celery import celery as celery_app
web            |   File "/usr/src/app/src/core/celery.py", line 10, in <module>
web            |     import event
web            |   File "/usr/src/app/event/__init__.py", line 3, in <module>
web            |     from .api import router as api_router
web            |   File "/usr/src/app/event/api.py", line 6, in <module>
web            |     from src import utils
web            |   File "/usr/src/app/src/utils.py", line 7, in <module>
web            |     from auth import crud
web            |   File "/usr/src/app/auth/__init__.py", line 3, in <module>
web            |     from .api import router as api_router
web            |   File "/usr/src/app/auth/api.py", line 110, in <module>
web            |     current_user: dict = Depends(utils.get_current_verified_user),
web            |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
web            | AttributeError: partially initialized module 'src.utils' has no attribute 'get_current_verified_user' (most likely due to a circular import)

в чем здесь дело и что нужно исправить?