Making migrations to code after removing huggingface secrets

alembic.ini

@@ -0,0 +1,116 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+# Use forward slashes (/) also on windows to provide an os agnostic path
+script_location = alembic
+
+# 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
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library.
+# Any required deps can 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 alembic/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 "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# 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
+
+sqlalchemy.url = postgresql://snapfeast_db_owner:4fLiupkCsN5E@ep-fancy-glade-a57hqsn3-pooler.us-east-2.aws.neon.tech/snapdb?sslmode=require
+
+
+[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 exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[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

alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

alembic/env.py

@@ -0,0 +1,81 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+from core.database 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
+from users.models import User, UserEmbeddings
+from orders.models import Meal, Order
+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()

alembic/script.py.mako

@@ -0,0 +1,26 @@
+"""${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, 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:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

alembic/versions/5dceb6aede3b_initiate_database_migration.py

@@ -0,0 +1,91 @@
+"""Initiate Database Migration
+
+Revision ID: 5dceb6aede3b
+Revises: 
+Create Date: 2024-08-20 17:33:42.696641
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '5dceb6aede3b'
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('meals',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('name', sa.String(), nullable=False),
+    sa.Column('description', sa.String(), nullable=False),
+    sa.Column('price', sa.Float(), nullable=False),
+    sa.Column('category', sa.String(), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_meals_id'), 'meals', ['id'], unique=False)
+    op.create_index(op.f('ix_meals_name'), 'meals', ['name'], unique=True)
+    op.create_table('users',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('email', sa.String(), nullable=False),
+    sa.Column('username', sa.String(), nullable=False),
+    sa.Column('hashed_password', sa.String(), nullable=False),
+    sa.Column('first_name', sa.String(), nullable=True),
+    sa.Column('last_name', sa.String(), nullable=True),
+    sa.Column('age', sa.Integer(), nullable=True),
+    sa.Column('preferences', sa.ARRAY(sa.String()), nullable=True),
+    sa.Column('is_active', sa.Boolean(), nullable=True),
+    sa.Column('is_admin', sa.Boolean(), nullable=True),
+    sa.Column('updated_at', sa.DateTime(), nullable=True),
+    sa.Column('created_at', sa.DateTime(), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_users_email'), 'users', ['email'], unique=True)
+    op.create_index(op.f('ix_users_id'), 'users', ['id'], unique=False)
+    op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
+    op.create_table('orders',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('user_id', sa.Integer(), nullable=False),
+    sa.Column('meal_id', sa.Integer(), nullable=False),
+    sa.Column('quantity', sa.Integer(), nullable=False),
+    sa.Column('timestamp', sa.DateTime(), nullable=True),
+    sa.ForeignKeyConstraint(['meal_id'], ['meals.id'], ),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_orders_id'), 'orders', ['id'], unique=False)
+    op.create_index(op.f('ix_orders_meal_id'), 'orders', ['meal_id'], unique=False)
+    op.create_index(op.f('ix_orders_user_id'), 'orders', ['user_id'], unique=False)
+    op.create_table('user_embeddings',
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('user_id', sa.Integer(), nullable=False),
+    sa.Column('embeddings', sa.ARRAY(sa.Float()), nullable=False),
+    sa.ForeignKeyConstraint(['user_id'], ['users.id'], ),
+    sa.PrimaryKeyConstraint('id'),
+    sa.UniqueConstraint('user_id')
+    )
+    op.create_index(op.f('ix_user_embeddings_id'), 'user_embeddings', ['id'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_user_embeddings_id'), table_name='user_embeddings')
+    op.drop_table('user_embeddings')
+    op.drop_index(op.f('ix_orders_user_id'), table_name='orders')
+    op.drop_index(op.f('ix_orders_meal_id'), table_name='orders')
+    op.drop_index(op.f('ix_orders_id'), table_name='orders')
+    op.drop_table('orders')
+    op.drop_index(op.f('ix_users_username'), table_name='users')
+    op.drop_index(op.f('ix_users_id'), table_name='users')
+    op.drop_index(op.f('ix_users_email'), table_name='users')
+    op.drop_table('users')
+    op.drop_index(op.f('ix_meals_name'), table_name='meals')
+    op.drop_index(op.f('ix_meals_id'), table_name='meals')
+    op.drop_table('meals')
+    # ### end Alembic commands ###

auth/responses.py

@@ -4,4 +4,4 @@ class TokenResponse(BaseModel):
     access_token: str
     refresh_token: str
     token_type: str = "Bearer"
-    expires_in: int
+    expires_in: int

core/config.py

@@ -8,14 +8,14 @@ load_dotenv()
 
 class Settings(BaseSettings):
     # Database settings
-    DATABASE_USER: str = os.getenv("PG_USER")
-    DATABASE_PASSWORD: str = os.getenv("PG_PASSWORD")
-    DATABASE_HOST: str = os.getenv("PG_HOST")
-    DATABASE_PORT: str = os.getenv("PG_PORT")
-    DATABASE_NAME: str = os.getenv("PG_NAME")
+    DATABASE_USER: str = os.getenv("PG_USER", "snapfeast_db_owner")
+    DATABASE_PASSWORD: str = os.getenv("PG_PASSWORD", "4fLiupkCsN5E")
+    DATABASE_HOST: str = os.getenv("PG_HOST", "ep-fancy-glade-a57hqsn3-pooler.us-east-2.aws.neon.tech")
+    DATABASE_PORT: int = os.getenv("PG_PORT", 5432)
+    DATABASE_NAME: str = os.getenv("PG_DATABASE", "snapdb")
+    JWT_SECRET_KEY: str = os.getenv("JWT_SECRET", "EjQFIgOWHqrzjZc23CfcY6RWi2F2yUMr67DRJlpkjSU")
     
     # JWT settings
-    JWT_SECRET_KEY: str = os.getenv("JWT_SECRET")
     JWT_ALGORITHM: str = "HS256"
     ACCESS_TOKEN_EXPIRE_MINUTES: int = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "30"))
     REFRESH_TOKEN_EXPIRE_DAYS: int = int(os.getenv("REFRESH_TOKEN_EXPIRE_DAYS", "7"))

core/database.py

@@ -11,8 +11,7 @@ engine = create_engine(
     pool_size=5,
     pool_pre_ping=True,
     pool_recycle=300,
-    max_overflow=0
-                       
+    max_overflow=0     
                        )
 
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

orders/models.py

@@ -1,25 +1,28 @@
 # models.py
-from sqlalchemy import Column, ForeignKey, Integer, String, Float, JSON, ARRAY
+from sqlalchemy import Column, ForeignKey, Integer, String, Float, DateTime
 from sqlalchemy.orm import relationship
 from core.database import Base
+from datetime import datetime
 
 class Meal(Base):
     __tablename__ = "meals"
 
     id = Column(Integer, primary_key=True, index=True)
-    name = Column(String, index=True)
-    description = Column(String)
-    price = Column(Float)
-
-    orders = relationship("Order", back_populates="meal")
+    name = Column(String, unique=True, nullable=False, index=True)
+    description = Column(String, nullable=False)
+    price = Column(Float, nullable=False)
+    category = Column(String, nullable=True)  # Optional: To classify meals
+    
+    orders = relationship("Order", back_populates="meal", cascade="all, delete-orphan")
 
 class Order(Base):
     __tablename__ = "orders"
 
     id = Column(Integer, primary_key=True, index=True)
-    user_id = Column(Integer, ForeignKey("users.id"))
-    meal_id = Column(Integer, ForeignKey("meals.id"))
-    quantity = Column(Integer)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False, index=True)
+    meal_id = Column(Integer, ForeignKey("meals.id"), nullable=False, index=True)
+    quantity = Column(Integer, nullable=False)
+    timestamp = Column(DateTime, default=datetime.utcnow)  # To track when the order was made
 
     user = relationship("User", back_populates="orders")
     meal = relationship("Meal", back_populates="orders")

orders/routes.py

@@ -25,33 +25,50 @@ meal_router = APIRouter(
 def health_check():
     return {"status": "ok"}
 
-@meal_router.get("/", response_model=MealBase)
+
+@meal_router.post("/", response_model=MealBase, status_code=status.HTTP_201_CREATED)
 async def meal_create(data: MealCreate, db: Session = Depends(get_db)):
     return create_meal(db, data)
 
+
 @meal_router.get("/", response_model=List[MealBase])
 def meals_get(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
     return get_meals(db, skip=skip, limit=limit)
 
+
 @meal_router.get("/{meal_id}", response_model=MealBase)
 def meal_get(meal_id: int, db: Session = Depends(get_db)):
-    return get_meal(db, meal_id)
+    meal = get_meal(db, meal_id)
+    if not meal:
+        raise HTTPException(status_code=404, detail="Meal not found")
+    return meal
+
 
 @meal_router.put("/{meal_id}", response_model=MealBase)
 def meal_update(meal_id: int, data: MealUpdate, db: Session = Depends(get_db)):
-    return update_meal(db, meal_id, data)
+    meal = update_meal(db, meal_id, data)
+    if not meal:
+        raise HTTPException(status_code=404, detail="Meal not found")
+    return meal
+
 
 @meal_router.delete("/{meal_id}", response_model=MealBase)
 def meal_delete(meal_id: int, db: Session = Depends(get_db)):
-    return delete_meal(db, meal_id)
+    meal = delete_meal(db, meal_id)
+    if not meal:
+        raise HTTPException(status_code=404, detail="Meal not found")
+    return meal
+
 
-@order_router.post("/", response_model=OrderBase)
+@order_router.post("/", response_model=OrderBase, status_code=status.HTTP_201_CREATED)
 def create_order(order: OrderCreate, current_user: OrderBase = Depends(get_current_user), db: Session = Depends(get_db)):
     return create_user_order(db, order, current_user.id)
 
+
 @order_router.get("/", response_model=List[OrderBase])
-def read_user_orders(skip: int = 0, limit: int = 100, current_user: OrderBase = Depends(get_current_user), db: Session = Depends(get_db)):
-    return get_user_orders(db, user_id=current_user.id, skip=skip, limit=limit)
+def get_orders(current_user: OrderBase = Depends(get_current_user), skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    return get_user_orders(db, current_user.id, skip=skip, limit=limit)
+
 
 @meal_router.get("/recommendations/", response_model=List[MealBase])
 async def get_recommendations(current_user: OrderBase = Depends(get_current_user), db: Session = Depends(get_db)):

orders/schemas.py

@@ -1,9 +1,9 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 class MealBase(BaseModel):
     name: str
     description: str
-    price: float
+    price: float = Field(..., gt=0, description="Price must be greater than zero")
 
 class MealCreate(MealBase):
     pass
@@ -18,15 +18,15 @@ class Meal(MealBase):
         orm_mode = True
 
 class OrderBase(BaseModel):
-    quantity: int
+    quantity: int = Field(..., gt=0, description="Quantity must be greater than zero")
 
 class OrderCreate(OrderBase):
     meal_id: int
 
 class Order(OrderBase):
     id: int
-    user_id: int  # Corrected type annotation
-    meal_id: int  # Corrected type annotation
+    user_id: int
+    meal_id: int
 
     class Config:
         orm_mode = True

orders/services.py

@@ -1,44 +1,46 @@
 from sqlalchemy.orm import Session
-from typing import List
+from typing import List, Optional
 from orders.schemas import MealCreate, MealUpdate, OrderCreate
 from orders.models import Meal, Order
 
-def get_meals(db: Session, skip: int = 0, limit: int = 100):
+def get_meals(db: Session, skip: int = 0, limit: int = 100) -> List[Meal]:
     return db.query(Meal).offset(skip).limit(limit).all()
 
-def create_meal(db: Session, meal: MealCreate):
+def create_meal(db: Session, meal: MealCreate) -> Meal:
     db_meal = Meal(**meal.dict())
     db.add(db_meal)
     db.commit()
     db.refresh(db_meal)
     return db_meal
 
-def get_meal(db: Session, meal_id: int):
+def get_meal(db: Session, meal_id: int) -> Optional[Meal]:
     return db.query(Meal).filter(Meal.id == meal_id).first()
 
-def update_meal(db: Session, meal_id: int, meal: MealUpdate):
+def update_meal(db: Session, meal_id: int, meal: MealUpdate) -> Optional[Meal]:
     db_meal = db.query(Meal).filter(Meal.id == meal_id).first()
-    if db_meal:
-        update_data = meal.dict(exclude_unset=True)
-        for key, value in update_data.items():
-            setattr(db_meal, key, value)
-        db.commit()
-        db.refresh(db_meal)
+    if not db_meal:
+        return None  # Or raise an exception
+    update_data = meal.dict(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(db_meal, key, value)
+    db.commit()
+    db.refresh(db_meal)
     return db_meal
 
-def delete_meal(db: Session, meal_id: int):
+def delete_meal(db: Session, meal_id: int) -> Optional[Meal]:
     db_meal = db.query(Meal).filter(Meal.id == meal_id).first()
-    if db_meal:
-        db.delete(db_meal)
-        db.commit()
+    if not db_meal:
+        return None  # Or raise an exception
+    db.delete(db_meal)
+    db.commit()
     return db_meal
 
-def create_user_order(db: Session, order: OrderCreate, user_id: int):
+def create_user_order(db: Session, order: OrderCreate, user_id: int) -> Order:
     db_order = Order(**order.dict(), user_id=user_id)
     db.add(db_order)
     db.commit()
     db.refresh(db_order)
     return db_order
 
-def get_user_orders(db: Session, user_id: int, skip: int = 0, limit: int = 100):
+def get_user_orders(db: Session, user_id: int, skip: int = 0, limit: int = 100) -> List[Order]:
     return db.query(Order).filter(Order.user_id == user_id).offset(skip).limit(limit).all()

users/models.py

@@ -10,10 +10,10 @@ class User(Base):
     email = Column(String, unique=True, index=True, nullable=False)
     username = Column(String, unique=True, index=True, nullable=False)
     hashed_password = Column(String, nullable=False)
-    first_name = Column(String)
-    last_name = Column(String)
-    age = Column(Integer)
-    preferences = Column(ARRAY(String))
+    first_name = Column(String, nullable=True) 
+    last_name = Column(String, nullable=True)   
+    age = Column(Integer, nullable=True)        
+    preferences = Column(ARRAY(String), nullable=True)
     is_active = Column(Boolean, default=True)
     is_admin = Column(Boolean, default=False)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
@@ -29,4 +29,4 @@ class UserEmbeddings(Base):
     user_id = Column(Integer, ForeignKey("users.id"), unique=True, nullable=False)
     embeddings = Column(ARRAY(Float), nullable=False)
 
-    user = relationship("User", back_populates="embeddings")
+    user = relationship("User", back_populates="embeddings")

users/schemas.py

@@ -9,7 +9,6 @@ class UserBase(BaseModel):
     email: EmailStr
     age: Optional[int] = Field(None, ge=0, le=120)
     preferences: Optional[List[str]] = None
-    is_active: bool = True
 
 class UserCreate(UserBase):
     password: str = Field(..., min_length=8)
@@ -44,4 +43,4 @@ class UserEmbeddings(UserEmbeddingsBase):
     user_id: int
 
     class Config:
-        orm_mode = True
+        orm_mode = True