Add files via upload

Author: ProFastCode

README.md

@@ -0,0 +1,21 @@
+# FastAPI Template
+
+### app - Backend FastAPI
+
+# Настройка
+
+### Настройка происходит в файле .env его нет в репозитории, т.к. он конфиденциален, но я предоставил файл .env-dist создайте на его основе файл .env и проведите все необходимые настройки.
+
+# Установка зависимостей
+
+### В основе проекта лежит пакетный менеджер poetry, но я так же предоставил файл зависимостей requirements.txt, что бы вы могли установить зависимости через пакетный менеджер pip.
+
+`poetry install` - Вариант с использованием poetry.
+
+`pip install -r requirements.txt` - Вариант с использованием pip.
+
+# Запуск
+
+### Для запуска воспользуйтесь ниже приведёнными командами.
+
+`python -m app` - Команда для запуска backend'а.

alembic.ini

@@ -0,0 +1,39 @@
+[alembic]
+script_location = migrations
+prepend_sys_path = . app
+version_path_separator = os
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+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

app/__main__.py

@@ -0,0 +1,33 @@
+import uvicorn
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.api.api_v1 import api
+from app.core.config import settings
+from app.database import Database
+from app.database.database import engine
+
+app = FastAPI(openapi_url=f"{settings.API_V1_STR}/openapi.json")
+
+
+@app.middleware("http")
+async def session_db(request: Request, call_next):
+    async with AsyncSession(bind=engine, expire_on_commit=False) as session:
+        request.state.db = Database(session)
+        response = await call_next(request)
+    return response
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_credentials=True,
+    allow_origins=[settings.APP_HOST],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(api.api_router, prefix=settings.API_V1_STR)
+
+if __name__ == "__main__":
+    uvicorn.run(app, host=settings.APP_HOST, port=settings.APP_PORT)

app/__pycache__/__main__.cpython-311.pyc

@@ -0,0 +1,3 @@
+"""
+API Проекта
+"""

app/api/__init__.py

@@ -0,0 +1,3 @@
+"""
+Первая версия API
+"""

app/api/__pycache__/__init__.cpython-311.pyc

@@ -0,0 +1,10 @@
+"""
+Модуль где подключаются все endpoints
+"""
+
+from fastapi import APIRouter
+
+from app.api.api_v1.endpoints import users
+
+api_router = APIRouter()
+api_router.include_router(users.router, prefix="/users", tags=["users"])

app/api/__pycache__/depends.cpython-311.pyc

@@ -0,0 +1,3 @@
+"""
+Endpoints module
+"""

app/api/api_v1/__init__.py

@@ -0,0 +1,49 @@
+"""
+User endpoints
+"""
+
+from fastapi import APIRouter, Depends, HTTPException
+from starlette import status
+
+from app.api import depends
+from app.core.oauth import OAuth2PasswordRequestForm
+from app.core.security import create_access_token, get_password_hash, verify_password
+from app.database import Database
+from app.schemas import UserScheme, UserSchemeAdd, UserTokenScheme
+
+router = APIRouter()
+
+
+@router.get("/get", response_model=UserScheme)
+async def get(current_user=Depends(depends.get_current_user)):
+    return UserScheme(**current_user.__dict__)
+
+
+@router.post("/new", response_model=UserTokenScheme)
+async def new(user: UserSchemeAdd, db: Database = Depends(depends.get_db)):
+    user_exists = await db.user.get_by_email(user.email)
+    if user_exists:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Такой пользователь уже зарегистрирован.",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    hash_password = get_password_hash(user.password)
+    await db.user.new(user.email, hash_password)
+    await db.session.commit()
+    access_token = create_access_token(user.email)
+    return UserTokenScheme(access_token=access_token)
+
+
+@router.post("/token", response_model=UserTokenScheme)
+async def token(form_data: OAuth2PasswordRequestForm = Depends(), db: Database = Depends(depends.get_db)):
+    user = await db.user.get_by_email(form_data.email)
+    if not user or not verify_password(form_data.password, user.password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Неверное имя пользователя или пароль",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token = create_access_token(user.email)
+    return UserTokenScheme(access_token=access_token)

app/api/api_v1/__pycache__/__init__.cpython-311.pyc

@@ -0,0 +1,45 @@
+"""
+Зависимости
+"""
+
+from fastapi import Depends, HTTPException, status, Request
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.config import settings
+from app.database import Database
+from app.database.database import engine
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.API_V1_STR}/users/token")
+
+
+async def get_db(request: Request = None) -> Database:
+    if request:
+        return request.state.db
+    else:
+        async with AsyncSession(bind=engine, expire_on_commit=False) as session:
+            return Database(session)
+
+
+async def authorization(token: str, db: Database, credentials_exception):
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        email: str = payload.get("email")
+        if not email:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    user = await db.user.get_by_email(email)
+    if not user:
+        raise credentials_exception
+    return user
+
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Database = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Не удалось проверить учетные данные",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    return await authorization(token, db, credentials_exception)

app/api/api_v1/__pycache__/api.cpython-311.pyc

@@ -0,0 +1,3 @@
+"""
+Ядро FastAPI приложения.
+"""

app/api/api_v1/api.py

@@ -0,0 +1,30 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env", env_file_encoding="utf-8", case_sensitive=True
+    )
+
+    # APP
+    APP_HOST: str
+    APP_PORT: int
+    API_V1_STR: str
+
+    # Secret
+    SECRET_KEY: str
+    ALGORITHM: str
+
+    # DATABASE
+    POSTGRES_HOST: str
+    POSTGRES_PORT: int
+    POSTGRES_USER: str
+    POSTGRES_PASSWORD: str
+    POSTGRES_DATABASE: str
+
+    @property
+    def pg_dns(self):
+        return f"postgresql+asyncpg://{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@{self.POSTGRES_HOST}:{self.POSTGRES_PORT}/{self.POSTGRES_DATABASE}"
+
+
+settings = Settings()

app/api/api_v1/endpoints/__init__.py

@@ -0,0 +1,22 @@
+from typing import Annotated, Union
+
+from fastapi import Form
+
+
+class OAuth2PasswordRequestForm:
+    def __init__(
+        self,
+        *,
+        grant_type: Annotated[Union[str, None], Form(pattern="password")] = None,
+        email: Annotated[str, Form()] = None,
+        password: Annotated[str, Form()],
+        scope: Annotated[str, Form()] = "",
+        client_id: Annotated[Union[str, None], Form()] = None,
+        client_secret: Annotated[Union[str, None], Form()] = None,
+    ):
+        self.grant_type = grant_type
+        self.email = email
+        self.password = password
+        self.scopes = scope.split()
+        self.client_id = client_id
+        self.client_secret = client_secret

app/api/api_v1/endpoints/__pycache__/__init__.cpython-311.pyc

@@ -0,0 +1,25 @@
+from datetime import datetime, timedelta
+
+from jose import jwt
+from passlib.context import CryptContext
+
+from app.core.config import settings
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+
+def create_access_token(email: str):
+    data = dict(
+        email=email,
+        exp=datetime.utcnow() + timedelta(minutes=120)
+    )
+    encoded_jwt = jwt.encode(data, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encoded_jwt

app/api/api_v1/endpoints/__pycache__/users.cpython-311.pyc

@@ -0,0 +1,8 @@
+"""
+Модуль для взаимодействия с базой данных.
+"""
+
+from .database import Database
+from .models import Base
+
+__all__ = ('Database', 'Base')

app/api/api_v1/endpoints/users.py

@@ -0,0 +1,27 @@
+from sqlalchemy.engine.url import URL
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+from sqlalchemy.ext.asyncio import create_async_engine as _create_async_engine
+
+from app.core.config import settings
+from .repositories import UserRepo
+
+
+def create_async_engine(url: URL | str) -> AsyncEngine:
+    return _create_async_engine(url=url, echo=False, pool_pre_ping=True)
+
+
+engine = create_async_engine(settings.pg_dns)
+
+
+class Database:
+    session: AsyncSession
+
+    user: UserRepo
+
+    def __init__(
+            self,
+            session: AsyncSession,
+            user: UserRepo = None,
+    ):
+        self.session = session
+        self.user = user or UserRepo(session=session)

app/api/depends.py

@@ -0,0 +1,11 @@
+"""
+Модели базы данных.
+"""
+
+from .base import Base
+from .user import User
+
+__all__ = (
+    'Base',
+    'User',
+)

app/core/__init__.py

@@ -0,0 +1,31 @@
+"""
+Базовая модель от которой наследуются остальные модели.
+"""
+
+from sqlalchemy import Integer, MetaData
+from sqlalchemy.ext.declarative import as_declarative
+from sqlalchemy.orm import Mapped, declared_attr, mapped_column
+
+metadata = MetaData(
+    naming_convention={
+        'ix': 'ix_%(column_0_label)s',
+        'uq': 'uq_%(table_name)s_%(column_0_name)s',
+        'ck': 'ck_%(table_name)s_%(constraint_name)s',
+        'fk': 'fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s',
+        'pk': 'pk_%(table_name)s',
+    }
+)
+
+
+@as_declarative(metadata=metadata)
+class Base:
+    @classmethod
+    @declared_attr
+    def __tablename__(cls):
+        return cls.__name__.lower()
+
+    __allow_unmapped__ = False
+
+    id: Mapped[int] = mapped_column(
+        Integer, autoincrement=True, primary_key=True
+    )

app/core/__pycache__/__init__.cpython-311.pyc

@@ -0,0 +1,16 @@
+"""
+Модель пользователя.
+"""
+
+import sqlalchemy as sa
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import Base
+
+
+class User(Base):
+    email: Mapped[str] = mapped_column(sa.String, unique=False, nullable=False)
+    password: Mapped[str] = mapped_column(sa.String, unique=False, nullable=False)
+
+    def __repr__(self):
+        return f"User:{self.id=}"