from typing import List
from sqlalchemy import ForeignKey, String
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship

class Base(DeclarativeBase):
    pass

# 1. USER (Bir)
class User(Base):
    __tablename__ = "users"

    id: Mapped[int] = mapped_column(primary_key=True)
    username: Mapped[str] = mapped_column(String(50))
    
    # Python darajasidagi bog'lanish (Ko'p bo'lgani uchun List olinadi)
    posts: Mapped[List["Post"]] = relationship(back_populates="author")

# 2. POST (Ko'p)
class Post(Base):
    __tablename__ = "posts"

    id: Mapped[int] = mapped_column(primary_key=True)
    title: Mapped[str] = mapped_column(String(100))
    
    # Baza darajasida bog'lanish (Foreign Key)
    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
    
    # Python darajasidagi bog'lanish (Faqat bitta obyekt)
    author: Mapped["User"] = relationship(back_populates="posts")

class Profile(Base):
    __tablename__ = "profiles"

    id: Mapped[int] = mapped_column(primary_key=True)
    bio: Mapped[str] = mapped_column(String(255))
    
    # Foreign Key unikal (unique=True) bo'lishi shart!
    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"), unique=True)
    
    # Har ikki tomonda ham List ishlatilmaydi, chunki munosabat 1:1
    user: Mapped["User"] = relationship(back_populates="profile")

# 💡 Diqqat: Yuqoridagi User modeliga quyidagi qatorni qo'shib qo'yish kerak:
# profile: Mapped["Profile"] = relationship(back_populates="user")

from sqlalchemy import Table, Column

# 1. ORALIQ JADVAL (Faqat ID'larni saqlaydi)
post_tag_m2m = Table(
    "post_tag_association",
    Base.metadata,
    Column("post_id", ForeignKey("posts.id"), primary_key=True),
    Column("tag_id", ForeignKey("tags.id"), primary_key=True),
)

# 2. TAG JADVALI
class Tag(Base):
    __tablename__ = "tags"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(50))
    
    # secondary orqali oraliq jadval ko'rsatiladi
    posts: Mapped[List["Post"]] = relationship(secondary=post_tag_m2m, back_populates="tags")

# 3. POST JADVALI (Yuqoridagi Post modelini kengaytiramiz)
class Post(Base):
    __tablename__ = "posts"

    id: Mapped[int] = mapped_column(primary_key=True)
    title: Mapped[str] = mapped_column(String(100))
    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
    author: Mapped["User"] = relationship(back_populates="posts")
    
    # Teglar bilan Many-to-Many bog'lanish
    tags: Mapped[List[Tag]] = relationship(secondary=post_tag_m2m, back_populates="posts")

from datetime import datetime
from sqlalchemy import func

# 1. KENGAYTIRILGAN ORALIQ MODEL
class Enrollment(Base):
    __tablename__ = "enrollments"

    student_id: Mapped[int] = mapped_column(ForeignKey("students.id"), primary_key=True)
    course_id: Mapped[int] = mapped_column(ForeignKey("courses.id"), primary_key=True)
    
    # Qo'shimcha ustun (Masalan: yozilgan vaqti)
    enrolled_at: Mapped[datetime] = mapped_column(default=func.now())

    # Har ikki modelga munosabat (relationship)
    student: Mapped["Student"] = relationship(back_populates="course_associations")
    course: Mapped["Course"] = relationship(back_populates="student_associations")

# 2. STUDENT MODELI
class Student(Base):
    __tablename__ = "students"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(100))
    
    # Kurslarga oraliq model orqali boriladi
    course_associations: Mapped[List["Enrollment"]] = relationship(back_populates="student")

# 3. COURSE MODELI
class Course(Base):
    __tablename__ = "courses"

    id: Mapped[int] = mapped_column(primary_key=True)
    title: Mapped[str] = mapped_column(String(100))
    
    # Talabalarga oraliq model orqali boriladi
    student_associations: Mapped[List["Enrollment"]] = relationship(back_populates="course")

from sqlalchemy.orm import selectinload
from sqlalchemy.future import select

# API endpoint ichida ishlatilishi:
stmt = select(Post).options(selectinload(Post.author)).where(Post.id == 1)
result = await db.execute(stmt)
post = result.scalar_one()
print(post.author.username) # Muammosiz ishlaydi

from __future__ import annotations
import asyncio
from logging.config import fileConfig
from alembic import context
from sqlalchemy import pool
from sqlalchemy.ext.asyncio import create_async_engine
from database import Base
# Import all model modules so metadata is populated before autogenerate.
# Replace this import with your project package if needed.
import models  # noqa: F401

config = context.config

if config.config_file_name is not None:
    fileConfig(config.config_file_name)

target_metadata = Base.metadata

def run_migrations_offline() -> None:
    """Run migrations without DB connection."""
    url = config.get_main_option("sqlalchemy.url")
    context.configure(
        url=url,
        target_metadata=target_metadata,
        literal_binds=True,
        dialect_opts={"paramstyle": "named"},
        compare_type=True,
        compare_server_default=True,
    )

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

def do_run_migrations(connection) -> None:
    context.configure(
        connection=connection,
        target_metadata=target_metadata,
        compare_type=True,
        compare_server_default=True,
    )

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

async def run_migrations_online() -> None:
    """Run migrations through async engine, but execute Alembic sync core via run_sync."""
    connectable = create_async_engine(
        config.get_main_option("sqlalchemy.url"),
        poolclass=pool.NullPool,
    )

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

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

class RoleChoice(str, Enum):
    # (backend_value, frontend_label)
    ADMIN = ("admin", "Admin Administrator")
    EDITOR = ("editor", "Redaktor / Muharrir")
    USER = ("user", "Oddiy foydalanuvchi")

    def __new__(cls, value, label):
        obj = str.__new__(cls, value)
        obj._value_ = value
        obj.label = label
        return obj

@app.get("/roles")
async def get_roles():
    return [
        {"value": role.value, "label": role.label} 
        for role in RoleChoice
    ]

uv run fastapi deploy

uv run fastapi deploy

uvx fastapi-new
uv run fastapi deploy

fastapi cloud setup-ci