Upload 18 files

app/auth.py

@@ -0,0 +1,53 @@
+# fastapi_crud/app/auth.py
+
+from fastapi import Depends, HTTPException, status
+from jose import JWTError, jwt
+from sqlalchemy.orm import Session
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from passlib.context import CryptContext
+from datetime import timedelta, datetime
+from . import crud, models, schemas, database
+
+# Generate your secret key using the script above and replace it here
+SECRET_KEY = "a12f6578e42b1e1e4f48d4d4c8482e92f00a1de8eb5290a4f7a6b42a51220b29"
+ALGORITHM = "HS256"
+# Set a very long expiration time, e.g., 365 days
+ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24 * 365
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+def authenticate_user(db: Session, username: str, password: str):
+    user = crud.get_user_by_username(db, username)
+    if not user:
+        return False
+    if not pwd_context.verify(password, user.hashed_password):
+        return False
+    return user
+
+def create_access_token(data: dict, expires_delta: timedelta = None):
+    to_encode = data.copy()
+    if expires_delta:
+        to_encode.update({"exp": datetime.utcnow() + expires_delta})
+    else:
+        to_encode.update({"exp": datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(database.get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+    user = crud.get_user_by_username(db, username=username)
+    if user is None:
+        raise credentials_exception
+    return user

app/crud.py

@@ -0,0 +1,62 @@
+# fastapi_crud/app/crud.py
+from sqlalchemy.orm import Session
+from . import models, schemas
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# User CRUD operations
+def get_user(db: Session, user_id: int):
+    return db.query(models.User).filter(models.User.id == user_id).first()
+
+def get_user_by_username(db: Session, username: str):
+    return db.query(models.User).filter(models.User.username == username).first()
+
+def create_user(db: Session, user: schemas.UserCreate):
+    hashed_password = pwd_context.hash(user.password)
+    db_user = models.User(username=user.username, hashed_password=hashed_password)
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+# Device CRUD operations
+def get_device(db: Session, device_id: int):
+    return db.query(models.Device).filter(models.Device.id == device_id).first()
+
+def get_devices(db: Session, skip: int = 0, limit: int = 10):
+    return db.query(models.Device).offset(skip).limit(limit).all()
+
+def create_device(db: Session, device: schemas.DeviceCreate):
+    db_device = models.Device(**device.dict())
+    db.add(db_device)
+    db.commit()
+    db.refresh(db_device)
+    return db_device
+
+def update_device(db: Session, device_id: int, device: schemas.DeviceUpdate):
+    db_device = db.query(models.Device).filter(models.Device.id == device_id).first()
+    if db_device is None:
+        return None
+    for key, value in device.dict().items():
+        setattr(db_device, key, value)
+    db.commit()
+    db.refresh(db_device)
+    return db_device
+
+def delete_device(db: Session, device_id: int):
+    db_device = db.query(models.Device).filter(models.Device.id == device_id).first()
+    if db_device is None:
+        return None
+    db.delete(db_device)
+    db.commit()
+    return db_device
+
+def set_device_active(db: Session, device_id: int, active: bool):
+    db_device = db.query(models.Device).filter(models.Device.id == device_id).first()
+    if db_device is None:
+        return None
+    db_device.active = active
+    db.commit()
+    db.refresh(db_device)
+    return db_device

app/database.py

@@ -0,0 +1,18 @@
+# fastapi_crud/app/database.py
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+DATABASE_URL = "sqlite:///./test.db"
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/main.py

@@ -0,0 +1,114 @@
+# fastapi_crud/app/main.py
+from fastapi import FastAPI, File, UploadFile, HTTPException, Form, Depends
+from fastapi.responses import JSONResponse
+from sqlalchemy.orm import Session
+from pydub import AudioSegment
+import io
+import spacy
+import speech_recognition as sr
+
+from app.database import engine, Base, get_db
+from app.routers import user, device
+from app import crud, schemas, auth, models
+
+# Create the database tables
+Base.metadata.create_all(bind=engine)
+
+app = FastAPI()
+
+app.include_router(user.router)
+app.include_router(device.router)
+
+# Load spaCy models
+nlp = spacy.load("custom_nlp_model")
+nlp2 = spacy.load("text_categorizer_model")
+
+def convert_audio_to_text(audio_file: UploadFile):
+    try:
+        audio_format = audio_file.filename.split(".")[-1]
+        if audio_format not in ["wav", "mp3", "ogg", "flac"]:
+            raise HTTPException(status_code=400, detail="Unsupported audio format. Please upload a wav, mp3, ogg, or flac file.")
+        
+        audio = AudioSegment.from_file(io.BytesIO(audio_file.file.read()), format=audio_format)
+        audio = audio.set_channels(1).set_frame_rate(16000)
+        wav_io = io.BytesIO()
+        audio.export(wav_io, format="wav")
+        wav_io.seek(0)
+        
+        recognizer = sr.Recognizer()
+        with sr.AudioFile(wav_io) as source:
+            audio_data = recognizer.record(source)
+        
+        text = recognizer.recognize_google(audio_data)
+        return text
+    except sr.UnknownValueError:
+        raise HTTPException(status_code=400, detail="Speech recognition could not understand the audio.")
+    except sr.RequestError as e:
+        raise HTTPException(status_code=500, detail=f"Speech recognition service error: {e}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Audio processing error: {e}")
+
+def update_device_status(db: Session, device_name: str, location: str, status: str):
+    db_device = db.query(models.Device).filter(models.Device.name == device_name, models.Device.location == location).first()
+    active_status = True if status.lower() == "on" else False
+    if db_device:
+        crud.set_device_active(db, db_device.id, active_status)
+        return {"device": db_device.name, "location": db_device.location, "status": "turned " + status}
+    return {"device": device_name, "location": location, "status": "not found"}
+
+def find_location(db: Session, text: str):
+    words = text.split()
+    for word in words:
+        db_location = db.query(models.Device).filter(models.Device.location == word).first()
+        if db_location:
+            return db_location.location
+    return ''
+
+def process_entities_and_update(db: Session, doc, text, status):
+    updates = []
+    location_entity = next((ent for ent in doc.ents if ent.label_.lower() == 'location'), None)
+    location = location_entity.text if location_entity else find_location(db, text)
+    
+    for ent in doc.ents:
+        if ent.label_ == 'device':
+            update = update_device_status(db, ent.text, location, status)
+            updates.append(update)
+
+    if not updates:  # No device entities found, process all words as potential device names
+        words = text.split()
+        for word in words:
+            update = update_device_status(db, word, location, status)
+            updates.append(update)
+
+    return updates
+
+@app.post("/predict/")
+async def predict(audio_file: UploadFile = File(...), db: Session = Depends(get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    try:
+        text = convert_audio_to_text(audio_file)
+        doc = nlp(text)
+        doc2 = nlp2(text)
+
+        predictions = {"category": max(doc2.cats, key=doc2.cats.get)}
+        entities = [{"text": ent.text, "label": ent.label_} for ent in doc.ents]
+
+        updates = process_entities_and_update(db, doc, text, predictions['category'])
+
+        return JSONResponse(content={"text": text, "predictions": predictions, "entities": entities, "updates": updates})
+    except HTTPException as e:
+        return JSONResponse(status_code=e.status_code, content={"detail": e.detail})
+
+@app.post("/predict_text/")
+async def predict_text(text: str = Form(...), db: Session = Depends(get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    try:
+        doc = nlp(text)
+        doc2 = nlp2(text)
+
+        predictions = {"category": max(doc2.cats, key=doc2.cats.get)}
+        entities = [{"text": ent.text, "label": ent.label_} for ent in doc.ents]
+
+        updates = process_entities_and_update(db, doc, text, predictions['category'])
+
+        return JSONResponse(content={"text": text, "predictions": predictions, "entities": entities, "updates": updates})
+    except HTTPException as e:
+        return JSONResponse(status_code=e.status_code, content={"detail": e.detail})

app/models.py

@@ -0,0 +1,21 @@
+# fastapi_crud/app/models.py
+from sqlalchemy import Column, Integer, String, Boolean
+from .database import Base
+
+class User(Base):
+    __tablename__ = "users"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+    is_active = Column(Boolean, default=True)
+
+class Device(Base):
+    __tablename__ = "devices"
+    
+    id = Column(Integer, primary_key=True, index=True)
+    channel = Column(Integer, unique=True, index=True)
+    name = Column(String, index=True)
+    rating = Column(Integer)
+    location = Column(String)
+    active = Column(Boolean, default=False)

app/routers/device.py

@@ -0,0 +1,51 @@
+# fastapi_crud/app/routers/device.py
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List
+from app import crud, schemas, database, auth
+
+router = APIRouter()
+
+@router.post("/devices/", response_model=schemas.Device)
+def create_device(device: schemas.DeviceCreate, db: Session = Depends(database.get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    return crud.create_device(db=db, device=device)
+
+@router.get("/devices/", response_model=List[schemas.Device])
+def read_devices(skip: int = 0, limit: int = 10, db: Session = Depends(database.get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    devices = crud.get_devices(db, skip=skip, limit=limit)
+    return devices
+
+@router.get("/devices/{device_id}", response_model=schemas.Device)
+def read_device(device_id: int, db: Session = Depends(database.get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    db_device = crud.get_device(db, device_id=device_id)
+    if db_device is None:
+        raise HTTPException(status_code=404, detail="Device not found")
+    return db_device
+
+@router.post("/devices/{device_id}/update", response_model=schemas.Device)
+def update_device(device_id: int, device: schemas.DeviceUpdate, db: Session = Depends(database.get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    db_device = crud.update_device(db, device_id=device_id, device=device)
+    if db_device is None:
+        raise HTTPException(status_code=404, detail="Device not found")
+    return db_device
+
+@router.delete("/devices/{device_id}", response_model=schemas.Device)
+def delete_device(device_id: int, db: Session = Depends(database.get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    db_device = crud.delete_device(db, device_id=device_id)
+    if db_device is None:
+        raise HTTPException(status_code=404, detail="Device not found")
+    return db_device
+
+@router.post("/devices/{device_id}/on", response_model=schemas.Device)
+def set_device_on(device_id: int, db: Session = Depends(database.get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    db_device = crud.set_device_active(db, device_id=device_id, active=True)
+    if db_device is None:
+        raise HTTPException(status_code=404, detail="Device not found")
+    return db_device
+
+@router.post("/devices/{device_id}/off", response_model=schemas.Device)
+def set_device_off(device_id: int, db: Session = Depends(database.get_db), current_user: schemas.User = Depends(auth.get_current_user)):
+    db_device = crud.set_device_active(db, device_id=device_id, active=False)
+    if db_device is None:
+        raise HTTPException(status_code=404, detail="Device not found")
+    return db_device

app/routers/user.py

@@ -0,0 +1,30 @@
+# fastapi_crud/app/routers/user.py
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from fastapi.security import OAuth2PasswordRequestForm
+from app import crud, schemas, database, auth
+router = APIRouter()
+
+@router.post("/users/", response_model=schemas.User)
+def create_user(user: schemas.UserCreate, db: Session = Depends(database.get_db)):
+    db_user = crud.get_user_by_username(db, username=user.username)
+    if db_user:
+        raise HTTPException(status_code=400, detail="Username already registered")
+    return crud.create_user(db=db, user=user)
+
+# status_code=status.HTTP_401_UNAUTHORIZED
+@router.post("/token", response_model=dict)
+async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(database.get_db)):
+    user = auth.authenticate_user(db, form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=401,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token = auth.create_access_token(data={"sub": user.username})
+    return {"access_token": access_token, "token_type": "bearer"}
+
+@router.get("/users/me/", response_model=schemas.User)
+async def read_users_me(current_user: schemas.User = Depends(auth.get_current_user)):
+    return current_user

app/schemas.py

@@ -0,0 +1,34 @@
+# fastapi_crud/app/schemas.py
+from pydantic import BaseModel
+
+class UserBase(BaseModel):
+    username: str
+
+class UserCreate(UserBase):
+    password: str
+
+class User(UserBase):
+    id: int
+    is_active: bool
+
+    class Config:
+        orm_mode = True
+
+class DeviceBase(BaseModel):
+    channel: int
+    name: str
+    rating: int
+    location: str
+    active: bool = False
+
+class DeviceCreate(DeviceBase):
+    pass
+
+class DeviceUpdate(DeviceBase):
+    pass
+
+class Device(DeviceBase):
+    id: int
+
+    class Config:
+        orm_mode = True