uv add fastapi["standard"]
uv add fastapi-users["sqlalchemy"]
uv add aiosqlite

import uvicorn


if __name__ == "__main__":
    uvicorn.run(app = "app.app:app", reload = True) 

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello World"}

@app.get("/order/{amount}")
async def get_pizza(amount):
    return f"You ordered {amount} pizza(s), and that would be {amount *399}$"

menu = [
    {"name": "Americano", "category": "cafe", "is_iced": False, "price": 50},
    {"name": "Iced Americano", "category": "cafe", "is_iced": True, "price": 50},
    {"name": "Latte", "category": "cafe", "is_iced": False, "price": 60},
    {"name": "Iced Latte", "category": "cafe", "is_iced": True, "price": 60},
    {"name": "Mocha", "category": "cafe", "is_iced": False, "price": 75},
    {"name": "Matcha Latte", "category": "tea", "is_iced": False, "price": 70},
    {"name": "Iced Matcha", "category": "tea", "is_iced": True, "price": 70},
    {"name": "Oolong Tea", "category": "tea", "is_iced": False, "price": 40},
    {"name": "Iced Peach Tea", "category": "tea", "is_iced": True, "price": 45},
    {"name": "Mango Smoothie", "category": "smoothie", "is_iced": True, "price": 90},
]

@app.get("/menu/{category}")
async def find_wanted_item(
    category: str, 
    is_iced: bool = False, 
    max_price: int = 70
):
    match_items = []
    for i in menu:
        if i["category"] == category and i["is_iced"] == is_iced and i["price"] <= max_price:
            match_items.append(i["name"])
    return match_items

from typing import Annotated
from fastapi import Query


@app.get("/find_pizza")
async def get_pizza(
    flavor: Annotated[str, Query(max_length = 50)], 
    size: str = "big", 
    price: Annotated[int, Query(ge = 0)] = 399
):
    my_pizza = {
        "flavor": flavor,
        "size": size,
        "price": price
    }
    return my_pizza

@app.get("/items/{item_id}")
async def read_items(
    item_id: Annotated[
        int,
        Path(
            title = "ID of item",
            ge = 0,
            le = 1000
        )
    ],
    q: Annotated[
        str | None,
        Query(
            alias="item-query",
            title="Query string",
            description="Query string for the items to search for",
            min_length=3,
            max_length=50,
            pattern="^fixedquery$",
            deprecated=True,
        ),
    ] = None,
):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})
    return results

app.get("/menu_better/{category}")
async def find_wanted_item(
    category: Annotated[str, Path(max_length = 15)], 
    is_iced: bool = False, 
    max_price: Annotated[
        int, 
        Query(
            ge = 1,
            le = 200,
            description="Filter by price. Must end with a dollar sign (e.g., '50$'). Price range: 1-200"
        )
    ] = 70
):
    match_items = []
    for i in menu:
        if i["category"] == category and i["is_iced"] == is_iced and i["price"] <= int(max_price[:-1]):
            match_items.append(i["name"])
    return match_items

@app.get("/menu_better/{category}")
async def find_wanted_item(
    category: Annotated[str, Path(max_length = 15)], 
    is_iced: bool = False, 
    max_price: Annotated[
        str, 
        Query(
            pattern="^\d+\$$", 
            description="Filter by price. Must end with a dollar sign (e.g., '50$'). Price range: 1-200"
        )
        ] = "70$"
):
    if int(max_price[:-1]) > 200 or int(max_price[:-1]) < 1:
        return "Out of price range for max_price parameter"
    match_items = []
    for i in menu:
        if i["category"] == category and i["is_iced"] == is_iced and i["price"] <= int(max_price[:-1]):
            match_items.append(i["name"])
    return match_items

from pydantic import BaseModel
class NewPizza(BaseModel):
    special_name: str | None = None
    flavor: str 
    price: int
    size: str = "12 inch"

pizza_list = []
@app.post("/pizzas")
async def create_pizza(pizza: NewPizza):
    my_pizza = pizza.model_dump()
    pizza_id = len(pizza_list) + 1
    my_pizza["id"] = pizza_id
    pizza_list.append(my_pizza)
    return my_pizza

@app.get("/pizzas")
async def get_all_pizzas():
    return pizza_list

@app.put("/pizzas/{id}")
async def update_pizza(id: int, pizza: NewPizza):
    for index, current_pizza in enumerate(pizza_list):
        if current_pizza["id"] == id:
            updated_pizza = pizza.model_dump()
            updated_pizza["id"] = id
            pizza_list[index] = updated_pizza

            return updated_pizza
    return "pizza not found"   

class NewDrink(BaseModel):
    name: str
    category: str
    is_iced: bool
    price: int    

@app.post("/menu_better")
async def create_drink(drink: NewDrink):
    new_drink = drink.model_dump()
    menu.append(new_drink)
    return new_drink

@app.put("/menu_better/{name}")
async def update_drink(name: str, drink: NewDrink):
    for index, current_drink in enumerate(menu):
        if current_drink["name"] == name:
            updated_drink = drink.model_dump()
            menu[index] = updated_drink

            return updated_drink
    return "drink not found"

from pydantic import Field
class NewPizza(BaseModel):
    flavor: str 
    special_name: str | None = Field(
        default = None, 
        max_length = 20, 
        description = "A cooler name for the pizza"
    )
    price: int = Field(
        default = 399,
        ge = 0,
        description = "price must be postivie"
    )
    size: str = "12 inch"

class Image(BaseModel):
    name: str
    url: str

class NewPizza(BaseModel):
    flavor: str 
    special_name: str | None = Field(
        default = None, 
        max_length = 20, 
        description = "A cooler name for the pizza"
    )
    price: int = Field(
        default = 399,
        ge = 0,
        description = "price must be postivie"
    )
    size: str = "12 inch"
    image: Image | None = None

@app.post("/pizzas_with_example")
async def create_pizza_with_example(
    pizza: Annotated[
        NewPizza, 
        Body(
            examples = [
                    {
                        "flavor": "mushroom", 
                        "price": 499
                    }
                ]
            )
        ]
    ):
    my_pizza = pizza.model_dump()
    pizza_id = len(pizza_list) + 1
    my_pizza["id"] = pizza_id
    pizza_list.append(my_pizza)
    return my_pizza

@app.post("pizza_with_multiple_examples")
async def create_pizza_with_multiple_examples(
    pizza: Annotated[
        NewPizza, 
        Body(
            openapi_examples = {
                "normal": {
                    "value": {
                        "flavor": "mushroom", 
                        "price": 499           
                    }
                },
                "complete": {
                    "value":{                        
                        "flavor": "margheritta",
                        "special_name": "The Classic",
                        "price": 399,
                        "size": "16 inch",
                        "image": {
                            "name": "pizza",
                            "url": "https://cdn.loveandlemons.com/wp-content/uploads/2023/07/margherita-pizza-recipe.jpg"
                        }
                    }
                },
                "invalid":{
                    "value":{                        
                        "flavor": 299,
                        "price": "three hundred ninety nine"
                    }
                }
            }
        )
    ]
):
    my_pizza = pizza.model_dump()
    pizza_id = len(pizza_list) + 1
    my_pizza["id"] = pizza_id
    pizza_list.append(my_pizza)
    return my_pizza

lass Image(BaseModel):
    name: str
    url: str

class NewDrink2(BaseModel):
    name: str = Field(max_length = 20)
    category: str = Field(max_length = 20)
    is_iced: bool
    price: int = Field(ge = 1)
    image: Image | None = None

@app.post("/menu_better_with_example/")
async def create_drink(
    drink: Annotated[
        NewDrink2,
        Body(
            openapi_examples ={
                "normal":{
                    "value":{
                        "name": "four season spring",
                        "category": "tea",
                        "is_iced": True,
                        "price": 50,
                        "image": {
                            "name": "just a picture",
                            "url": "https://i1.sndcdn.com/artworks-000101694590-cuxerh-t500x500.jpg"
                        }
                    }
                },
                "invalid":{
                    "value":{
                        "name": 231293801289,
                        "is_iced": "yes",
                        "price": "fifty"
                    }
                }
            }
        )
    ]
):
    new_drink = drink.model_dump()
    menu.append(new_drink)
    return new_drink

from pydantic import ConfigDict

class NewDrink(BaseModel):
    name: str = Field(max_length = 20)
    category: str = Field(max_length = 20)
    is_iced: bool
    price: int = Field(ge = 1)
    image: Image | None
    
    model_config = ConfigDict(
        extra = "forbid",
        str_strip_whitespace = True,
        json_schema_extra = {
            "example": {
                "name": "Caramel Macchiato",
                "category": "cafe",
                "is_iced": True,
                "price": 70
            }
        }
    )

from app.routers import menu
app = FastAPI()
app.include_router(menu.router)

from collections.abc import AsyncGenerator
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession

SQLALCHEMY_DATABASE_URL = "sqlite+aiosqlite:///./test.db"

engine = create_async_engine(SQLALCHEMY_DATABASE_URL, echo = True)
async_session_local = async_sessionmaker(engine, expire_on_commit = False)

async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
    async with async_session_local() as session:
        yield session

from sqlalchemy.orm import DeclarativeBase

class Base(DeclarativeBase):
    pass        
        
async def create_db_and_tables():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)

from sqlalchemy import Column, Integer, String, Boolean
from db.db import Base

class Pizza(Base):
    __tablename__ = "pizza"
    
    id = Column(Integer, primary_key = True, index = True)
    flavor = Column(String, index = True)
    price = Column(Integer)
    size = Column(String)

from fastapi import Depends
from db.db import get_async_session
from sqlalchemy.ext.asyncio import AsyncSession
from db.models import Pizza


@app.post("/pizza_with_db")
async def create_pizza(
    pizza: NewPizza, 
    session: AsyncSession = Depends(get_async_session)
):
    new_pizza = Pizza(
        flavor = pizza.flavor,
        price = pizza.price,
        size = pizza.size,
    )
    session.add(new_pizza)
    await session.commit()
    await session.refresh(new_pizza)
    
    return new_pizza

from fastapi import Depends
from db.db import get_async_session
from sqlalchemy.ext.asyncio import AsyncSession
from db.models import Pizza


@app.post("/pizza_with_db")
async def create_pizza(
    pizza: NewPizza, 
    session: AsyncSession = Depends(get_async_session)
):
    new_pizza = Pizza(
        flavor = pizza.flavor,
        price = pizza.price,
        size = pizza.size,
    )
    session.add(new_pizza)
    await session.commit()
    await session.refresh(new_pizza)
    
    return new_pizza

async def common_parameters(q: str | None = None, skip: int = 0, limit: int = 100):
    return {"q": q, "skip": skip, "limit": limit}


@app.get("/items/")
async def read_items(commons: Annotated[dict, Depends(common_parameters)]):
    return commons

@app.post("/pizza_with_db")
async def create_pizza(
    pizza: NewPizza, 
    session: AsyncSession = Depends(get_async_session)
):

@app.get("/pizza_with_db/{pizza_id}")
async def get_pizza(
    pizza_id: int,
    session: AsyncSession = Depends(get_async_session)
):
    result = await session.execute(select(Pizza).where(Pizza.id == pizza_id))
    pizza = result.scalar_one_or_none()
    
    if not pizza:
        return "post not found"
     
    return pizza

malicious_query = text(f"SELECT * FROM drinks WHERE name = '{user_input}'")
result = await db.execute(malicious_query)

query = select(DrinkDB).where(DrinkDB.name == user_input)
result = await db.execute(query)

from fastapi import APIRouter, Path, Query, Body
from pydantic import BaseModel, Field, ConfigDict
from typing import Annotated

router = APIRouter(
    prefix = "/menu",
    tags = ["cafe"]
)

menu = [
    {"name": "Americano", "category": "cafe", "is_iced": False, "price": 50},
    {"name": "Iced Americano", "category": "cafe", "is_iced": True, "price": 50},
    {"name": "Latte", "category": "cafe", "is_iced": False, "price": 60},
    {"name": "Iced Latte", "category": "cafe", "is_iced": True, "price": 60},
    {"name": "Mocha", "category": "cafe", "is_iced": False, "price": 75},
    {"name": "Matcha Latte", "category": "tea", "is_iced": False, "price": 70},
    {"name": "Iced Matcha", "category": "tea", "is_iced": True, "price": 70},
    {"name": "Oolong Tea", "category": "tea", "is_iced": False, "price": 40},
    {"name": "Iced Peach Tea", "category": "tea", "is_iced": True, "price": 45},
    {"name": "Mango Smoothie", "category": "smoothie", "is_iced": True, "price": 90},
]

class Image(BaseModel):
    name: str
    url: str

class NewDrink(BaseModel):
    name: str = Field(max_length = 20)
    category: str = Field(max_length = 20)
    is_iced: bool
    price: int = Field(ge = 1)
    image: Image | None
    
    model_config = ConfigDict(
        extra = "forbid",
        str_strip_whitespace = True,
        json_schema_extra = {
            "example": {
                "name": "Caramel Macchiato",
                "category": "cafe",
                "is_iced": True,
                "price": 70
            }
        }
    )

@router.get("/{category}")
async def find_wanted_item(
    category: Annotated[str, Path(max_length = 15, description = "The category to search for")], 
    is_iced: bool = False, 
    max_price: Annotated[
        str, 
        Query(
            pattern="^\d+\$$", 
            description="Filter by price. Must end with a dollar sign (e.g., '50$'). Price range: 1-200")
        ] = "70$"
):
    if int(max_price[:-1]) > 200 or int(max_price[:-1]) < 1:
        return "Out of price range for max_price parameter"
    match_items = []
    for i in menu:
        if i["category"] == category and i["is_iced"] == is_iced and i["price"] <= int(max_price[:-1]):
            match_items.append(i["name"])
    return match_items

@router.post("/")
async def create_drink(
    drink: Annotated[
        NewDrink,
        Body(
            openapi_examples ={
                "normal":{
                    "value":{
                        "name": "four season spring",
                        "category": "tea",
                        "is_iced": True,
                        "price": 50
                    }
                },
                "invalid":{
                    "value":{
                        "name": 231293801289,
                        "is_iced": "yes",
                        "price": "fifty"
                    }
                }
            }
        )
    ]
):
    new_drink = drink.model_dump()
    menu.append(new_drink)
    return new_drink


@router.put("/{name}")
async def update_drink(name: str, drink: NewDrink):
    for index, current_drink in enumerate(menu):
        if current_drink["name"] == name:
            updated_drink = drink.model_dump()
            updated_drink["id"] = id
            menu[index] = updated_drink

            return updated_drink
    return "drink not found"

from fastapi_users.db import SQLAlchemyUserDatabase, SQLAlchemyBaseUserTableUUID
from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship
import uuid
from fastapi import Depends
from sqlalchemy.ext.asyncio import AsyncSession
from db.db import get_async_session


class User(SQLAlchemyBaseUserTableUUID, Base):
    pizzas = relationship("Pizza", back_populates = "creator")
    
class Pizza(Base):
    __tablename__ = "pizza"
    
    id:     Mapped[int] = mapped_column(primary_key = True, index = True)
    creator_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("user.id"), nullable = False)
    flavor: Mapped[str] = mapped_column(index = True)
    price:  Mapped[int]
    size:   Mapped[str]
    
    creator = relationship("User", back_populates = "pizzas")
    
 async def get_user_db(session: AsyncSession = Depends(get_async_session)):
    yield SQLAlchemyUserDatabase(session, User)

import uuid
from fastapi import Depends
from fastapi_users import BaseUserManager, FastAPIUsers, UUIDIDMixin, models
from fastapi_users.authentication import (
    AuthenticationBackend,
    BearerTransport,
    JWTStrategy
)
from fastapi_users.db import SQLAlchemyUserDatabase
from db.models import User, get_user_db

SECRET = "fiasjdihuhagur932u841ij"

class UserManager(UUIDIDMixin, BaseUserManager[User, uuid.UUID]):
    reset_password_token_secret = SECRET
    verification_token_secret = SECRET
    

async def get_user_manager(user_db: SQLAlchemyUserDatabase = Depends(get_user_db)):
    yield UserManager(user_db)
    
bearer_transport = BearerTransport(tokenUrl = "auth/jwt/login")

def get_jwt_strategy():
    return JWTStrategy(secret = SECRET, lifetime_seconds = 3600)

auth_backend  = AuthenticationBackend(
    name = "jwt",
    transport = bearer_transport,
    get_strategy = get_jwt_strategy
)

fastapi_users = FastAPIUsers[User, uuid.UUID](get_user_manager, [auth_backend])
current_active_user = fastapi_users.current_user(active = True)

from user import auth_backend, current_active_user, fastapi_users
from fastapi_users import schemas
import uuid
from db.models import User

class UserRead(schemas.BaseUser[uuid.UUID]):
    pass

class UserCreate(schemas.BaseUserCreate):
    pass

class UserUpdate(schemas.BaseUserUpdate):
    pass
  
app.include_router(fastapi_users.get_auth_router(auth_backend), prefix = "/auth/jwt", tags = ["auth"])
app.include_router(fastapi_users.get_register_router(UserRead, UserCreate), prefix = "/auth", tags = ["auth"])
app.include_router(fastapi_users.get_reset_password_router(), prefix = "/auth", tags = ["auth"])
app.include_router(fastapi_users.get_verify_router(UserRead), prefix = "/auth", tags = ["auth"])
app.include_router(fastapi_users.get_users_router(UserRead, UserUpdate), prefix = "/users", tags = ["users"])

@app.post("/pizza_with_db")
async def create_pizza(
    pizza: NewPizza, 
    session: AsyncSession = Depends(get_async_session),
    user: User = Depends(current_active_user)
):
    new_pizza = Pizza(
        creator_id = user.id,
        flavor = pizza.flavor,
        price = pizza.price,
        size = pizza.size,
    )
    session.add(new_pizza)
    await session.commit()
    await session.refresh(new_pizza)
    
    return new_pizza