implement clustering, recommendation system, improve algorithm

Author: batreller

.gitignore

@@ -0,0 +1,4 @@
+.idea
+.venv
+src/fuel_forecast
+csv

.idea/hackathon.iml

@@ -24,6 +24,7 @@ def upgrade() -> None:
     sa.Column('id', sa.Integer(), nullable=False),
     sa.Column('email', sa.String(), nullable=True),
     sa.Column('promotions', sa.Boolean(), nullable=True),
+    sa.Column('guest', sa.Boolean(), nullable=False),
     sa.Column('password', sa.String(), nullable=True),
     sa.PrimaryKeyConstraint('id'),
     sa.UniqueConstraint('email')

alembic/versions/481d2b9416cd_add_users_table.py

@@ -1,7 +1,7 @@
 """add fuel table
 
 Revision ID: 4ba0c3464647
-Revises: e4222f79264a
+Revises: ca72df19df31
 Create Date: 2024-02-25 07:53:03.178722
 
 """
@@ -13,7 +13,7 @@
 
 # revision identifiers, used by Alembic.
 revision: str = '4ba0c3464647'
-down_revision: Union[str, None] = 'e4222f79264a'
+down_revision: Union[str, None] = 'ca72df19df31'
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 

alembic/versions/4ba0c3464647_add_fuel_table.py

@@ -32,6 +32,8 @@ def upgrade() -> None:
     sa.Column('tax', sa.Integer(), nullable=True),
     sa.Column('mpg', sa.Float(), nullable=True),
     sa.Column('engine_size', sa.Float(), nullable=True),
+    sa.Column('satisfaction', sa.Float(), nullable=True),
+    sa.Column('class_prediction', sa.Integer(), nullable=True),
     sa.PrimaryKeyConstraint('id')
     )
     op.create_table('logs',

alembic/versions/c3104d14e561_add_cars_and_logs_table.py

@@ -16,6 +16,10 @@ passlib = "^1.7.4"
 pyjwt = "^2.8.0"
 bcrypt = "^4.1.2"
 python-jose = "^3.3.0"
+pandas = "^2.2.1"
+prophet = "^1.1.5"
+scikit-learn = "^1.4.1.post1"
+jwt = "^1.3.1"
 
 
 [build-system]

alembic/versions/e4222f79264a_add_satisfaction_field.py

@@ -1,10 +1,8 @@
 from typing import Annotated
 
 from fastapi import Depends
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from src.auth.service import get_current_user
-from src.database import get_db_session
 from src.models import UserModel
 
 # DBSessionDep = Annotated[AsyncSession, Depends(get_db_session)]

poetry.lock

@@ -1,4 +1,4 @@
-from sqlalchemy import Integer, Column, Boolean, String, Float, ForeignKey, DateTime
+from sqlalchemy import Integer, Column, ForeignKey, DateTime
 from sqlalchemy.orm import relationship
 
 from src.database import Base

pyproject.toml

@@ -1,9 +1,10 @@
 from fastapi import APIRouter
 
-from src.auth import service
 from src.auth.dependencies import CurrentUserDep
-from src.auth.schemas import RegisterData, UserSchemeDetailed, LoginData, Token
+from src.auth.schemas import RegisterData, LoginData, Token, UserScheme
 from src.auth.exceptions import UserAlreadyExists
+from src import config
+from src.auth import service
 from src.database import DBSessionDep
 from src.exceptions import InvalidCredentials
 
@@ -44,12 +45,23 @@ async def register(
     return Token(access_token=jwt_token, token_type="Bearer")
 
 
-
 @router.get(
     "/me",
-    response_model=UserSchemeDetailed
+    response_model=UserScheme
 )
 async def get_me(
         user: CurrentUserDep
 ):
-    return UserSchemeDetailed.from_orm(user)
+    return UserScheme.from_orm(user)
+
+
+@router.post(
+    "/guest",
+    response_model=Token
+)
+async def get_me(
+        db_session: DBSessionDep
+):
+    user_model = await service.create_guest_user(db_session)
+    jwt_token = service.create_access_token(user_model.id, expiry_time=config.GUEST_JWT_EXPIRY_TIME)
+    return Token(access_token=jwt_token, token_type="Bearer")

src/auth/dependencies.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from pydantic import BaseModel
 
 
@@ -19,19 +21,22 @@ class LoginData(BaseModel):
 
 class UserScheme(BaseModel):
     id: int
-    email: str
-    promotions: bool
+    email: Optional[str]
+    promotions: Optional[bool]
+    guest: Optional[bool]
 
     class Config:
         from_attributes = True
 
 
 class UserSchemeDetailed(BaseModel):
     id: int
-    email: str
-    promotions: bool
-    _password: str
+    email: Optional[str]
+    promotions: Optional[bool]
+    guest: Optional[bool]
+    password: Optional[str]
 
     class Config:
         from_attributes = True
-        underscore_attrs_are_private = True
+    #     underscore_attrs_are_private = True
+    # todo make sure its ok

src/auth/models.py

@@ -1,20 +1,17 @@
 from datetime import datetime, timedelta
-from typing import Optional
 
 import jwt
 from fastapi import Depends
 from fastapi.security import OAuth2PasswordBearer
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import Session
 from jose import JWTError
-from src.auth import models, schemas
+from src import config
 from src.auth.exceptions import UserDoesntExist, InvalidPassword
-from src.auth.schemas import RegisterData, LoginData
+from src.auth.schemas import RegisterData
 from src.database import get_db_session
 from src.exceptions import InvalidCredentials
 from src.models import UserModel
-from src import config
 from passlib.context import CryptContext
 from typing import Annotated
 
@@ -23,7 +20,6 @@
     scheme_name="JWT"
 )
 
-
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
 
@@ -61,32 +57,38 @@ async def get_user_by_email(db_session: AsyncSession, user_email: str) -> UserMo
     return user
 
 
-def create_access_token(user_id: int) -> str:
+def create_access_token(user_id: int, expiry_time: int = config.JWT_EXPIRY_TIME) -> str:
     to_encode = {"sub": user_id}
-    expire = datetime.utcnow() + timedelta(minutes=config.JWT_EXPIRY_TIME)
+    expire = datetime.utcnow() + timedelta(minutes=expiry_time)
     to_encode.update({"exp": expire})
     encoded_jwt = jwt.encode(to_encode, config.SECRET_KEY, algorithm=config.JWT_ALGORITHM)
     return encoded_jwt
 
 
-async def get_current_user(token: Annotated[str, Depends(oauth2_bearer)], db_session: AsyncSession = Depends(get_db_session), fatal: bool = False) -> UserModel:
+async def get_current_user(token: Annotated[str, Depends(oauth2_bearer)],
+                           db_session: AsyncSession = Depends(get_db_session), fatal: bool = False) -> UserModel:
     try:
         payload = jwt.decode(token, config.SECRET_KEY, algorithms=[config.JWT_ALGORITHM])
         user_id = int(payload.get("sub"))  # todo add exception for this
         if user_id is None:
             raise InvalidCredentials()
     except JWTError:
         raise InvalidCredentials()
-    user = await get_user_by_id(db_session, user_id)
-    # todo prob dont need that expcetion cuz get_user_by_id will cause exception if it needs to
-    if user is None:
-        raise InvalidCredentials()
-    return user
+    return await get_user_by_id(db_session, user_id)
 
 
 async def create_user(db_session: AsyncSession, register_data: RegisterData) -> UserModel:
     db_user = UserModel(email=register_data.email, password=pwd_context.hash(register_data.password),
-                        promotions=register_data.promotions)
+                        guest=False, promotions=register_data.promotions)
+    db_session.add(db_user)
+    await db_session.commit()
+    await db_session.refresh(db_user)
+    return db_user
+
+
+async def create_guest_user(db_session: AsyncSession) -> UserModel:
+    db_user = UserModel(email=None, password=None,
+                        guest=True, promotions=False)
     db_session.add(db_user)
     await db_session.commit()
     await db_session.refresh(db_user)

src/auth/router.py

@@ -21,6 +21,7 @@ class CarModel(Base):
     mpg = Column(Float)
     engine_size = Column(Float)
     satisfaction = Column(Float)
+    class_prediction = Column(Integer)
 
     @property
     def maintenance(self):

src/auth/schemas.py

@@ -1,14 +1,9 @@
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter
 
-from src.auth import service
-from src.auth.dependencies import CurrentUserDep
-from src.auth.schemas import RegisterData, UserSchemeDetailed, LoginData, Token
-from src.auth.exceptions import UserAlreadyExists
 from src.cars.schemas import CarsFiltersSchema
-from src.cars.service import get_cars_makes, get_cars_models, get_cars
-from src.database import get_db_session, DBSessionDep
-from src.exceptions import InvalidCredentials, TokenParseError
-from src.models import UserModel
+from src.cars.service import get_cars_makes, get_cars_models, get_cars, add_log, get_recommended_car
+from src.auth.dependencies import CurrentUserDep
+from src.database import DBSessionDep
 
 router = APIRouter()
 
@@ -25,9 +20,21 @@ async def get_models(car_make: str, db_session: DBSessionDep):
 
 
 @router.post("/find")
-async def find_cars(filters: CarsFiltersSchema,
-                    db_session: DBSessionDep
-                    ):
-    car = await get_cars(db_session, filters)
-    # await add_log()
-    return car
+async def find_cars(
+        user: CurrentUserDep,
+        filters: CarsFiltersSchema,
+        db_session: DBSessionDep
+):
+    cars = await get_cars(db_session, filters)
+
+    for car in cars:
+        await add_log(db_session, user, car.CarModel)
+    return cars
+
+
+@router.get("/recommended")
+async def recommended_car(
+        user: CurrentUserDep,
+        db_session: DBSessionDep
+):
+    return await get_recommended_car(db_session, user)

src/auth/service.py

@@ -1,6 +1,6 @@
 from typing import Optional, List
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 
 class CarsFiltersSchema(BaseModel):