adjusted users

README

@@ -0,0 +1,80 @@
+# FastAPI Databases
+
+Create a basic FastAPI application with a SQLAlchemy database backend. This can be used to access and update a client database with the option to add new clients, items, or transactions.
+
+The project is structured with the following components:
+
+```
+my_super_project/
+│
+└── sql_app/
+    ├── __init__.py
+    ├── crud.py
+    ├── database.py
+    ├── main.py
+    ├── models.py
+    └── schemas.py
+```
+
+## Getting Started
+
+First, you need to install SQLAlchemy, a powerful SQL toolkit and Object-Relational Mapping (ORM) library for Python. You can do this by running the following command:
+
+```bash
+pip install sqlalchemy
+```
+
+### Database Configuration
+
+In the `/database.py` file, you can configure your database connection. The example provided uses SQLite, but you can easily change the connection URL to your preferred database system (e.g., PostgreSQL, MySQL).
+
+
+### Creating a Database Session
+
+In the same file, a `SessionLocal` class is created, which represents a database session. This class should be used to interact with the database. The provided `Base` class is used for creating SQLAlchemy models.
+
+### SQLAlchemy Models
+
+In the `/models.py` file, you'll define your database models. For example, the project includes two models: `User` and `Item`. You can customize these models or add more models as needed.
+
+You can create your own models and define their attributes as needed.
+
+### Pydantic Models
+
+In the `/schemas.py` file, you'll find Pydantic models that define the request and response data structures for your API. For instance, you have `UserBase`, `UserCreate`, `User`, `ItemBase`, `ItemCreate`, and `Item` Pydantic models.
+
+These Pydantic models define the structure of data being sent to and received from your API endpoints.
+
+### CRUD Operations
+
+The `sql_app/crud.py` file contains utility functions for performing CRUD (Create, Read, Update, Delete) operations on the database. You can see functions to get users, create users, and get items, among others. You can modify or extend these functions to suit your needs.
+
+### Main FastAPI Application
+
+The `/main.py` file is where the FastAPI application is defined. It integrates all the components mentioned above, creating API endpoints to perform operations on the database.
+
+This is just a simple example of a FastAPI application with SQLAlchemy integration. You can extend this application by adding more routes, CRUD operations, and custom business logic as per your project requirements.
+
+## Running the Application
+
+To run the FastAPI application, navigate to the directory and use the `uvicorn` command:
+
+```bash
+uvicorn main:app --reload
+```
+
+This will start the FastAPI development server, and you can access your API at http://localhost:8000.
+
+## API Documentation
+
+FastAPI automatically generates interactive API documentation for your application. You can access it at http://localhost:8000/docs, and you'll be able to test your API endpoints from there.
+
+## Conclusion
+
+This project is a basic example of a FastAPI application with SQLAlchemy integration, showcasing how to structure your project and perform common database operations. You can extend it to build more complex and feature-rich applications.
+
+Contact Information
+For questions, please contact [email protected].
+
+Acknowledgments
+We acknowledge the use of third-party libraries and frameworks that have contributed to the success of this project. Thank you to the open-source community for their invaluable contributions.

app.py

@@ -7,7 +7,7 @@ import logging
 import llama_cpp
 import llama_cpp.llama_tokenizer
 from pydantic import BaseModel
-
+from fastapi import APIRouter
 
 class GenModel(BaseModel):
     question: str
@@ -63,17 +63,18 @@ app.add_middleware(
     allow_headers=["*"]
 )
 """
-@app.get("/")
+llm_router = APIRouter()
+@llm_router.get("/")
 def index():
     return fastapi.responses.RedirectResponse(url="/docs")
 
 
-@app.get("/health")
+@llm_router.get("/health")
 def health():
     return {"status": "ok"}
     
 # Chat Completion API
-@app.post("/chat/")
+@llm_router.post("/chat/")
 async def chat(chatm:ChatModel):
     try:
         st = time()
@@ -96,7 +97,7 @@ async def chat(chatm:ChatModel):
         )
 
 # Chat Completion API
-@app.post("/generate")
+@llm_router.post("/generate")
 async def generate(gen:GenModel):
     gen.system = "You are an helpful medical AI assistant."
     gen.temperature = 0.5
@@ -132,7 +133,3 @@ async def generate(gen:GenModel):
         )
 
 
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)

app/auth.py

@@ -1,40 +0,0 @@
-from datetime import datetime, timedelta
-from typing import Optional
-
-import jwt
-from fastapi import HTTPException, Depends, status
-from fastapi.security import OAuth2PasswordBearer
-from sqlalchemy.orm import Session
-from app.db.database import get_db
-from app.models.user import User
-from app.schemas.user import UserOut
-
-SECRET_KEY = "supersecretkey"
-ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
-
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
-
-def create_access_token(data: dict):
-    to_encode = data.copy()
-    expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
-    to_encode.update({"exp": expire})
-    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return encoded_jwt
-
-def verify_access_token(token: str, db: Session):
-    try:
-        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-        user_id: str = payload.get("sub")
-        if user_id is None:
-            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
-        user = db.query(User).filter(User.id == user_id).first()
-        if user is None:
-            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,
-                                 detail="User not found")
-        return user
-    except jwt.PyJWTError:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
-
-def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
-    return verify_access_token(token, db)

app/config.py

@@ -1,7 +0,0 @@
-#from pydantic import BaseSettings
-from pydantic_settings import BaseSettings
-class Settings(BaseSettings):
-    SECRET_KEY: str = "your_secret_key"
-    DATABASE_URL: str = "sqlite:///./app.db"
-
-settings = Settings()

app/db/database.py

@@ -1,19 +0,0 @@
-from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker, declarative_base
-from app.config import settings
-
-DATABASE_URL = settings.DATABASE_URL
-
-engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-Base = declarative_base()
-
-def create_tables():
-    Base.metadata.create_all(bind=engine)
-
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()

app/fapp.py

@@ -1,62 +0,0 @@
-import os
-import urllib.request
-from llama_cpp import Llama
-from fastapi import FastAPI
-
-app = FastAPI(docs_url="/")
-
-def download_file(file_link, filename):
-    # Checks if the file already exists before downloading
-    if not os.path.isfile(filename):
-        urllib.request.urlretrieve(file_link, filename)
-        print("File downloaded successfully.")
-    else:
-        print("File already exists.")
-
-
-# Dowloading GGML model from HuggingFace
-ggml_model_path = "https://huggingface.co/TheBloke/zephyr-7B-beta-GGUF/resolve/main/zephyr-7b-beta.Q4_0.gguf"
-filename = "zephyr-7b-beta.Q4_0.gguf"
-
-#download_file(ggml_model_path, filename)
-
-
-
-llm = Llama(model_path="/home/mo/Desktop/web/oGBackend/qwen1_5-0_5b-chat-q2_k.gguf", n_ctx=512, n_batch=126, chat_format="llama")
-
-
-def generate_text(
-    prompt="Who is the COlor of Apple?",
-    max_tokens=256,
-    temperature=0.7,
-    top_p=0.5,
-    echo=False,
-    stop=["#"],
-):
-    output = llm(
-        prompt,
-        max_tokens=max_tokens,
-        temperature=temperature,
-        top_p=top_p,
-        echo=echo,
-        stop=stop,
-    )
-    output_text = output["choices"][0]["text"]
-    return output_text
-
-
-def generate_prompt_from_template(input):
-    chat_prompt_template = f"""<|im_start|>system
-You are a helpful chatbot.<|im_end|>
-<|im_start|>user
-{input}<|im_end|>"""
-    return chat_prompt_template
-
-@app.get("/generate")
-def generate(text: str):
-    prompt = generate_prompt_from_template(text) 
-
-    generate_text(
-        prompt,
-        max_tokens=356,
-    )

app/gtts.py

@@ -1,119 +0,0 @@
-import random
-import time
-
-import speech_recognition as sr
-
-
-def recognize_speech_from_mic(recognizer, microphone):
-    """Transcribe speech from recorded from `microphone`.
-
-    Returns a dictionary with three keys:
-    "success": a boolean indicating whether or not the API request was
-               successful
-    "error":   `None` if no error occured, otherwise a string containing
-               an error message if the API could not be reached or
-               speech was unrecognizable
-    "transcription": `None` if speech could not be transcribed,
-               otherwise a string containing the transcribed text
-    """
-    # check that recognizer and microphone arguments are appropriate type
-    if not isinstance(recognizer, sr.Recognizer):
-        raise TypeError("`recognizer` must be `Recognizer` instance")
-
-    if not isinstance(microphone, sr.Microphone):
-        raise TypeError("`microphone` must be `Microphone` instance")
-
-    # adjust the recognizer sensitivity to ambient noise and record audio
-    # from the microphone
-    with microphone as source:
-        recognizer.adjust_for_ambient_noise(source)
-        audio = recognizer.listen(source)
-
-    # set up the response object
-    response = {
-        "success": True,
-        "error": None,
-        "transcription": None
-    }
-
-    # try recognizing the speech in the recording
-    # if a RequestError or UnknownValueError exception is caught,
-    #     update the response object accordingly
-    try:
-        response["transcription"] = recognizer.recognize_google(audio)
-    except sr.RequestError:
-        # API was unreachable or unresponsive
-        response["success"] = False
-        response["error"] = "API unavailable"
-    except sr.UnknownValueError:
-        # speech was unintelligible
-        response["error"] = "Unable to recognize speech"
-
-    return response
-
-
-if __name__ == "__main__":
-    # set the list of words, maxnumber of guesses, and prompt limit
-    WORDS = ["apple", "banana", "grape", "orange", "mango", "lemon"]
-    NUM_GUESSES = 3
-    PROMPT_LIMIT = 5
-
-    # create recognizer and mic instances
-    recognizer = sr.Recognizer()
-    microphone = sr.Microphone()
-
-    # get a random word from the list
-    word = random.choice(WORDS)
-
-    # format the instructions string
-    instructions = (
-        "I'm thinking of one of these words:\n"
-        "{words}\n"
-        "You have {n} tries to guess which one.\n"
-    ).format(words=', '.join(WORDS), n=NUM_GUESSES)
-
-    # show instructions and wait 3 seconds before starting the game
-    print(instructions)
-    time.sleep(3)
-
-    for i in range(NUM_GUESSES):
-        # get the guess from the user
-        # if a transcription is returned, break out of the loop and
-        #     continue
-        # if no transcription returned and API request failed, break
-        #     loop and continue
-        # if API request succeeded but no transcription was returned,
-        #     re-prompt the user to say their guess again. Do this up
-        #     to PROMPT_LIMIT times
-        for j in range(PROMPT_LIMIT):
-            print('Guess {}. Speak!'.format(i+1))
-            guess = recognize_speech_from_mic(recognizer, microphone)
-            if guess["transcription"]:
-                break
-            if not guess["success"]:
-                break
-            print("I didn't catch that. What did you say?\n")
-
-        # if there was an error, stop the game
-        if guess["error"]:
-            print("ERROR: {}".format(guess["error"]))
-            break
-
-        # show the user the transcription
-        print("You said: {}".format(guess["transcription"]))
-
-        # determine if guess is correct and if any attempts remain
-        guess_is_correct = guess["transcription"].lower() == word.lower()
-        user_has_more_attempts = i < NUM_GUESSES - 1
-
-        # determine if the user has won the game
-        # if not, repeat the loop if user has more attempts
-        # if no attempts left, the user loses the game
-        if guess_is_correct:
-            print("Correct! You win!".format(word))
-            break
-        elif user_has_more_attempts:
-            print("Incorrect. Try again.\n")
-        else:
-            print("Sorry, you lose!\nI was thinking of '{}'.".format(word))
-            break

app/hello.py

@@ -1,7 +0,0 @@
-import llama_cpp
-model = llama_cpp.Llama(
-     model_path="/home/mo/Desktop/web/oGBackend/qwen1_5-0_5b-chat-q2_k.gguf",
-     chat_format="llama-2",
- )
-x = model.create_completion("Write a story about robotics?")
-print(x)

app/models/user.py

@@ -1,9 +0,0 @@
-from sqlalchemy import Column, Integer, String
-from app.db.database import Base
-
-class User(Base):
-    __tablename__ = "users"
-
-    id = Column(Integer, primary_key=True, index=True)
-    username = Column(String, unique=True, index=True)
-    password = Column(String)

app/routers/llm.py

@@ -1,136 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.orm import Session
-from app.db.database import get_db
-from app.models.user import User
-from app.schemas.user import UserCreate, UserOut
-from app.auth import create_access_token, get_current_user
-
-
-
-import fastapi
-from fastapi.responses import JSONResponse
-from time import time
-#from fastapi.middleware.cors import CORSMiddleware
-import logging
-import llama_cpp
-import llama_cpp.llama_tokenizer
-from pydantic import BaseModel
-
-
-
-
-
-router = APIRouter(prefix="/llm", tags=["llm"])
-
-
-class GenModel(BaseModel):
-    question: str
-    system: str = "You are a helpful medical AI chat assistant. Help as much as you can.Also continuously ask for possible symptoms in order to atat a conclusive ailment or sickness and possible solutions.Remember, response in English."
-    temperature: float = 0.8
-    seed: int = 101
-    mirostat_mode: int=2
-    mirostat_tau: float=4.0
-    mirostat_eta: float=1.1
-
-class ChatModel(BaseModel):
-    question: list
-    system: str = "You are a helpful medical AI chat assistant. Help as much as you can.Also continuously ask for possible symptoms in order to atat a conclusive ailment or sickness and possible solutions.Remember, response in English."
-    temperature: float = 0.8
-    seed: int = 101
-    mirostat_mode: int=2
-    mirostat_tau: float=4.0
-    mirostat_eta: float=1.1
-llm_chat = llama_cpp.Llama.from_pretrained(
-    repo_id="Qwen/Qwen1.5-0.5B-Chat-GGUF",
-    filename="*q4_0.gguf",
-    tokenizer=llama_cpp.llama_tokenizer.LlamaHFTokenizer.from_pretrained("Qwen/Qwen1.5-0.5B"),
-    verbose=False,
-     n_ctx=1024,
-     n_gpu_layers=0,
-    #chat_format="llama-2"
-)
-llm_generate = llama_cpp.Llama.from_pretrained(
-    repo_id="Qwen/Qwen1.5-0.5B-Chat-GGUF",
-    filename="*q4_0.gguf",
-    tokenizer=llama_cpp.llama_tokenizer.LlamaHFTokenizer.from_pretrained("Qwen/Qwen1.5-0.5B"),
-    verbose=False,
-     n_ctx=4096,
-     n_gpu_layers=0,
-    mirostat_mode=2,
-    mirostat_tau=4.0,
-    mirostat_eta=1.1
-    #chat_format="llama-2"
-)
-# Logger setup
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-
-
-@router.get("/")
-def index():
-    return fastapi.responses.RedirectResponse(url="/docs")
-
-@router.get("/health")
-def health():
-    return {"status": "ok"}
-    
-# Chat Completion API
-@router.post("/chat/")
-async def chat(chatm:ChatModel):
-    try:
-        st = time()
-        output = llm_chat.create_chat_completion(
-            messages = chatm.question,
-            temperature = chatm.temperature,
-            seed = chatm.seed,
-            #stream=True
-        )
-        #print(output)
-        et = time()
-        output["time"] = et - st
-        #messages.append({'role': "assistant", "content": output['choices'][0]['message']['content']})
-        #print(messages)
-        return output
-    except Exception as e:
-        logger.error(f"Error in /complete endpoint: {e}")
-        return JSONResponse(
-            status_code=500, content={"message": "Internal Server Error"}
-        )
-
-# Chat Completion API
-@router.post("/generate")
-async def generate(gen:GenModel):
-    gen.system = "You are an helpful medical AI assistant."
-    gen.temperature = 0.5
-    gen.seed = 42
-    try:
-        st = time()
-        output = llm_generate.create_chat_completion(
-            messages=[
-                {"role": "system", "content": gen.system},
-                {"role": "user", "content": gen.question},
-            ],
-            temperature = gen.temperature,
-            seed= gen.seed,
-            #stream=True,
-            #echo=True
-        )
-        """
-        for chunk in output:
-            delta = chunk['choices'][0]['delta']
-            if 'role' in delta:
-                print(delta['role'], end=': ')
-            elif 'content' in delta:
-                print(delta['content'], end='')
-            #print(chunk)
-        """
-        et = time()
-        output["time"] = et - st
-        return output
-    except Exception as e:
-        logger.error(f"Error in /generate endpoint: {e}")
-        return JSONResponse(
-            status_code=500, content={"message": "Internal Server Error"}
-        )

app/routers/user.py

@@ -1,38 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.orm import Session
-from app.db.database import get_db
-from app.models.user import User
-from app.schemas.user import UserCreate, UserOut
-from app.auth import create_access_token, get_current_user
-
-router = APIRouter(prefix="/user", tags=["user"])
-
-@router.post("/register", response_model=UserOut)
-def register(user: UserCreate, db: Session = Depends(get_db)):
-    existing_user = db.query(User).filter(User.username == user.username).first()
-    if existing_user:
-        raise HTTPException(status_code=400,
-                            #status.HTTP_400_BAD_REQUEST, 
-                            detail="Username already taken")
-
-    hashed_password = user.password  # Hashing is needed here
-    db_user = User(username=user.username, password=hashed_password)
-    db.add(db_user)
-    db.commit()
-    db.refresh(db_user)
-    return db_user
-
-@router.post("/login")
-def login(user: UserCreate, db: Session = Depends(get_db)):
-    db_user = db.query(User).filter(User.username == user.username).first()
-    if not db_user or db_user.password != user.password:
-        raise HTTPException(status_code=400,
-                            #status.HTTP.400_BAD_REQUEST, 
-                            detail="Invalid credentials")
-
-    access_token = create_access_token(data={"sub": str(db_user.id)})
-    return {"access_token": access_token, "token_type": "bearer"}
-
-@router.get("/me", response_model=UserOut)
-def read_users_me(current_user: User = Depends(get_current_user)):
-    return current_user

app/schemas/user.py

@@ -1,17 +0,0 @@
-from pydantic import BaseModel
-
-class UserInDB(BaseModel):
-    id: int
-    username: str
-    password: str
-
-class UserCreate(BaseModel):
-    username: str
-    password: str
-
-class UserOut(BaseModel):
-    id: int
-    username: str
-
-    class Config:
-        orm_mode = True

app/security.py

@@ -1,9 +0,0 @@
-from passlib.context import CryptContext
-
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-def hash_password(password: str):
-    return pwd_context.hash(password)
-
-def verify_password(plain_password: str, hashed_password: str):
-    return pwd_context.verify(plain_password, hashed_password)

crud.py

@@ -0,0 +1,37 @@
+from sqlalchemy.orm import Session
+
+import models
+import schemas
+
+
+def get_user(db: Session, user_id: int):
+    return db.query(models.User).filter(models.User.id == user_id).first()
+
+
+def get_user_by_email(db: Session, email: str):
+    return db.query(models.User).filter(models.User.email == email).first()
+
+
+def get_users(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.User).offset(skip).limit(limit).all()
+
+
+def create_user(db: Session, user: schemas.UserCreate):
+    fake_hashed_password = user.password + "notreallyhashed"
+    db_user = models.User(email=user.email, hashed_password=fake_hashed_password)
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+
+def get_items(db: Session, skip: int = 0, limit: int = 100):
+    return db.query(models.Item).offset(skip).limit(limit).all()
+
+
+def create_user_item(db: Session, item: schemas.ItemCreate, user_id: int):
+    db_item = models.Item(**item.model_dump(), owner_id=user_id)
+    db.add(db_item)
+    db.commit()
+    db.refresh(db_item)
+    return db_item

database.py

@@ -0,0 +1,13 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+SQLALCHEMY_DATABASE_URL = "sqlite:///./sql_app.db"
+# SQLALCHEMY_DATABASE_URL = "postgresql://user:password@postgresserver/db"
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()

main.py

@@ -1,29 +1,66 @@
-"""
-from fastapi import FastAPI
-from app.routers import user
-from app.db import database
+from fastapi import Depends, FastAPI, HTTPException
+from sqlalchemy.orm import Session
+import crud
+import models
+import schemas
+from database import SessionLocal, engine
+from app import llm_router
+from fastapi import APIRouter, FastAPI
+models.Base.metadata.create_all(bind=engine)
 
-app = FastAPI()
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
 
-# Include user router
-app.include_router(user.router)
+user_router = APIRouter()
 
-# Create tables
-database.create_tables()
-"""
-from fastapi import FastAPI
-from app.db import database # Base, engine
-from app.routers import user, llm
+@user_router.post("/users/", response_model=schemas.User)
+def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
+    db_user = crud.get_user_by_email(db, email=user.email)
+    if db_user:
+        raise HTTPException(status_code=400, detail="Email already registered")
+    return crud.create_user(db=db, user=user)
 
-#Base.metadata.create_all(bind=engine)
 
-app = FastAPI(title="OpenGenAI",
-    description="Your Excellect AI Physician", docs_url="/")
+@user_router.get("/users/", response_model=list[schemas.User])
+def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    users = crud.get_users(db, skip=skip, limit=limit)
+    return users
 
 
-@app.on_event("startup")
-async def startup():
-    await database.create_tables()
-    
-app.include_router(llm.router)
-app.include_router(user.router)
+@user_router.get("/users/{user_id}", response_model=schemas.User)
+def read_user(user_id: int, db: Session = Depends(get_db)):
+    db_user = crud.get_user(db, user_id=user_id)
+    if db_user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return db_user
+
+
+@user_router.post("/users/{user_id}/items/", response_model=schemas.Item)
+def create_item_for_user(
+        user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)
+):
+    return crud.create_user_item(db=db, item=item, user_id=user_id)
+
+
+@user_router.get("/items/", response_model=list[schemas.Item])
+def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
+    items = crud.get_items(db, skip=skip, limit=limit)
+    return items
+
+
+@user_router.get("/")
+async def root():
+    return {"message": "Hello World"}
+
+
+app = FastAPI(
+    title="OpenGenAI",
+    description="Your Excellect AI Physician")
+
+app.include_router(user_router)
+app.include_router(llm_router)

models.py

@@ -0,0 +1,26 @@
+from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
+from sqlalchemy.orm import relationship
+
+from database import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String, unique=True, index=True)
+    hashed_password = Column(String)
+    is_active = Column(Boolean, default=True)
+
+    items = relationship("Item", back_populates="owner")
+
+
+class Item(Base):
+    __tablename__ = "items"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String, index=True)
+    description = Column(String, index=True)
+    owner_id = Column(Integer, ForeignKey("users.id"))
+
+    owner = relationship("User", back_populates="items")

schemas.py

@@ -0,0 +1,36 @@
+from typing import Union
+from pydantic import BaseModel
+
+
+class ItemBase(BaseModel):
+    title: str
+    description: Union[str, None] = None
+
+
+class ItemCreate(ItemBase):
+    pass
+
+
+class Item(ItemBase):
+    id: int
+    owner_id: int
+
+    class Config:
+        from_attributes = True
+
+
+class UserBase(BaseModel):
+    email: str
+
+
+class UserCreate(UserBase):
+    password: str
+
+
+class User(UserBase):
+    id: int
+    is_active: bool
+    items: list[Item] = []
+
+    class Config:
+        from_attributes = True