initial commit

.gitignore

@@ -0,0 +1,12 @@
+__pycache__/  
+*.pyc  
+*.pyo  
+*.egg-info/  
+dist/  
+build/  
+.env  
+.idea/  
+.vscode/  
+*.log  
+*.swp  
+.DS_Store

Dockerfile

@@ -0,0 +1,11 @@
+FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8
+
+COPY ./app /app/app
+
+COPY ./requirements.txt /app
+
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+EXPOSE 80
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]

Pipfile

@@ -0,0 +1,20 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+fastapi = "*"
+uvicorn = {extras = ["standard"], version = "*"}
+python-dotenv = "*"
+sqlalchemy = "*"
+psycopg2-binary = "*"
+pytest = "*"
+pytest-cov = "*"
+faker = "*"
+requests-mock = "*"
+
+[dev-packages]
+
+[requires]
+python_version = "3.9"

README.md

@@ -0,0 +1,70 @@
+# my-fastapi-project
+
+This is a production level project structure for a Python FastAPI project.
+
+## Project Structure
+
+```
+my-fastapi-project
+├── app
+│   ├── __init__.py
+│   ├── api
+│   │   ├── __init__.py
+│   │   ├── endpoints
+│   │   │   ├── __init__.py
+│   │   │   ├── items.py
+│   │   │   └── users.py
+│   │   └── models
+│   │       ├── __init__.py
+│   │       ├── item.py
+│   │       └── user.py
+│   ├── core
+│   │   ├── __init__.py
+│   │   ├── config.py
+│   │   ├── security.py
+│   │   └── database.py
+│   ├── tests
+│   │   ├── __init__.py
+│   │   ├── conftest.py
+│   │   ├── test_api
+│   │   │   ├── __init__.py
+│   │   │   ├── test_items.py
+│   │   │   └── test_users.py
+│   │   └── test_core
+│   │       ├── __init__.py
+│   │       ├── test_config.py
+│   │       ├── test_security.py
+│   │       └── test_database.py
+│   └── main.py
+├── .env
+├── .gitignore
+├── Dockerfile
+├── requirements.txt
+├── README.md
+└── .vscode
+    ├── settings.json
+    └── launch.json
+```
+
+## Description
+
+The project structure is organized as follows:
+
+- `app`: contains the main application code.
+- `app/api`: contains the API endpoints.
+- `app/api/endpoints`: contains the endpoint functions.
+- `app/api/models`: contains the data models.
+- `app/core`: contains the core application code.
+- `app/core/config.py`: contains the application configuration.
+- `app/core/security.py`: contains the security functions.
+- `app/core/database.py`: contains the database connection code.
+- `app/tests`: contains the test code.
+- `app/tests/test_api`: contains the API endpoint tests.
+- `app/tests/test_core`: contains the core application tests.
+- `app/main.py`: contains the main application entry point.
+- `.env`: contains environment variables.
+- `.gitignore`: specifies files and directories to ignore in Git.
+- `Dockerfile`: specifies the Docker image configuration.
+- `requirements.txt`: specifies the Python dependencies.
+- `README.md`: this file.
+- `.vscode`: contains Visual Studio Code configuration files.

app/__init__.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+
+from app.api.api import api_router
+from app.core.config import settings
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(title=settings.PROJECT_NAME, version=settings.PROJECT_VERSION)
+    app.include_router(api_router, prefix=settings.API_V1_STR)
+    return app
+
+
+app = create_app()

app/api/__init__.py

@@ -0,0 +1,10 @@
+# File: my-fastapi-project/app/api/__init__.py
+
+from fastapi import FastAPI
+from .endpoints import items, users
+from .models import item, user
+
+app = FastAPI()
+
+app.include_router(items.router)
+app.include_router(users.router)

app/api/endpoints/__init__.py

@@ -0,0 +1,10 @@
+# File: my-fastapi-project/app/api/endpoints/__init__.py
+
+from fastapi import APIRouter
+
+from . import items, users
+
+router = APIRouter()
+
+router.include_router(items.router, prefix="/items", tags=["items"])
+router.include_router(users.router, prefix="/users", tags=["users"])

app/api/endpoints/items.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/")
+async def read_items():
+    return [{"name": "Item Foo"}, {"name": "item Bar"}]
+
+
+@router.get("/{item_id}")
+async def read_item(item_id: int, q: str = None):
+    return {"item_id": item_id, "q": q}

app/api/endpoints/users.py

@@ -0,0 +1,48 @@
+from fastapi import APIRouter
+
+from app.api.models.user import UserInDB
+from app.api.db import database
+
+users_router = r = APIRouter()
+
+
+@r.post("/", response_model=UserInDB, status_code=201)
+async def create_user(user: UserInDB):
+    query = UserInDB.insert().values(
+        username=user.username,
+        email=user.email,
+        hashed_password=user.hashed_password
+    )
+    user_id = await database.execute(query)
+    return {**user.dict(), "id": user_id}
+
+
+@r.get("/{id}/", response_model=UserInDB)
+async def read_user(id: int):
+    query = UserInDB.select().where(UserInDB.c.id == id)
+    user = await database.fetch_one(query)
+    return user
+
+
+@r.put("/{id}/", response_model=UserInDB)
+async def update_user(id: int, user: UserInDB):
+    query = (
+        UserInDB
+        .update()
+        .where(UserInDB.c.id == id)
+        .values(
+            username=user.username,
+            email=user.email,
+            hashed_password=user.hashed_password
+        )
+        .returning(UserInDB.c.id)
+    )
+    user_id = await database.execute(query)
+    return {**user.dict(), "id": user_id}
+
+
+@r.delete("/{id}/", response_model=int)
+async def delete_user(id: int):
+    query = UserInDB.delete().where(UserInDB.c.id == id)
+    user_id = await database.execute(query)
+    return user_id

app/api/models/__init__.py

@@ -0,0 +1,2 @@
+from .item import Item
+from .user import User

app/api/models/item.py

@@ -0,0 +1,19 @@
+from typing import Optional
+from pydantic import BaseModel
+
+
+class ItemBase(BaseModel):
+    title: str
+    description: Optional[str] = None
+
+
+class ItemCreate(ItemBase):
+    pass
+
+
+class Item(ItemBase):
+    id: int
+    owner_id: int
+
+    class Config:
+        orm_mode = True

app/api/models/user.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+class UserBase(BaseModel):
+    email: str
+
+class UserCreate(UserBase):
+    password: str
+
+class User(UserBase):
+    id: int
+    is_active: bool
+
+    class Config:
+        orm_mode = True

app/core/__init__.py

@@ -0,0 +1,5 @@
+from .config import settings
+from .database import Base, engine, SessionLocal
+from .security import get_password_hash, verify_password
+
+__all__ = ["settings", "Base", "engine", "SessionLocal", "get_password_hash", "verify_password"]

app/core/config.py

@@ -0,0 +1,60 @@
+from typing import Any, Dict, List, Optional, Union
+from pydantic import AnyHttpUrl, BaseSettings, validator
+
+
+class Settings(BaseSettings):
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "Whisper API"
+    SECRET_KEY: str
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 60
+    SERVER_NAME: str
+    SERVER_HOST: AnyHttpUrl
+    POSTGRES_SERVER: str
+    POSTGRES_USER: str
+    POSTGRES_PASSWORD: str
+    POSTGRES_DB: str
+
+    @validator("SECRET_KEY", pre=True)
+    def secret_key_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
+        if not v:
+            raise ValueError("SECRET_KEY must be set")
+        return v
+
+    @validator("SERVER_NAME", pre=True)
+    def server_name_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
+        if not v:
+            raise ValueError("SERVER_NAME must be set")
+        return v
+
+    @validator("SERVER_HOST", pre=True)
+    def server_host_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> AnyHttpUrl:
+        if not v:
+            raise ValueError("SERVER_HOST must be set")
+        return v
+
+    @validator("POSTGRES_SERVER", pre=True)
+    def postgres_server_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
+        if not v:
+            raise ValueError("POSTGRES_SERVER must be set")
+        return v
+
+    @validator("POSTGRES_USER", pre=True)
+    def postgres_user_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
+        if not v:
+            raise ValueError("POSTGRES_USER must be set")
+        return v
+
+    @validator("POSTGRES_PASSWORD", pre=True)
+    def postgres_password_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
+        if not v:
+            raise ValueError("POSTGRES_PASSWORD must be set")
+        return v
+
+    @validator("POSTGRES_DB", pre=True)
+    def postgres_db_must_be_set(cls, v: Optional[str], values: Dict[str, Any]) -> str:
+        if not v:
+            raise ValueError("POSTGRES_DB must be set")
+        return v
+
+
+settings = Settings()

app/core/database.py

@@ -0,0 +1,13 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+from app.core.config import settings
+
+SQLALCHEMY_DATABASE_URL = settings.database_url
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()

app/core/security.py

@@ -0,0 +1,7 @@
+from passlib.context import CryptContext
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+SECRET_KEY = "mysecretkey"

app/main.py

@@ -0,0 +1,25 @@
+from fastapi import FastAPI
+from app.api.api_v1.api import router as api_router
+from app.core.config import settings
+from app.core.errors import http_error_handler
+from app.core.errors import http422_error_handler
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI(title=settings.PROJECT_NAME, openapi_url=f"{settings.API_V1_STR}/openapi.json")
+
+# Set all CORS enabled origins
+if settings.BACKEND_CORS_ORIGINS:
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[str(origin) for origin in settings.BACKEND_CORS_ORIGINS],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+# Include routers
+app.include_router(api_router, prefix=settings.API_V1_STR)
+
+# Error handlers
+app.add_exception_handler(422, http422_error_handler)
+app.add_exception_handler(500, http_error_handler)

app/tests/__init__.py

@@ -0,0 +1,34 @@
+# File: my-fastapi-project/app/tests/__init__.py
+
+# Import necessary modules
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from app.core.config import settings
+from app.main import app
+from app.tests.utils.utils import override_get_db
+
+# Create test database
+SQLALCHEMY_DATABASE_URL = settings.TEST_DATABASE_URL
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Define test client
+@pytest.fixture(scope="module")
+def test_client():
+    with TestClient(app) as client:
+        yield client
+
+# Define test database
+@pytest.fixture(scope="module")
+def test_db():
+    db = TestingSessionLocal()
+    yield db
+    db.close()
+
+# Override get_db function for testing
+@pytest.fixture(autouse=True)
+def override_get_db(monkeypatch):
+    monkeypatch.setattr("app.api.dependencies.get_db", override_get_db)

app/tests/conftest.py

@@ -0,0 +1,36 @@
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from app.core.config import settings
+from app.db.base import Base
+from app.db.session import SessionLocal
+
+
+@pytest.fixture(scope="module")
+def test_app():
+    # set up test app with client
+    from app.main import app
+    client = TestClient(app)
+    # set up test database
+    SQLALCHEMY_DATABASE_URL = settings.SQLALCHEMY_DATABASE_TEST_URL
+    engine = create_engine(SQLALCHEMY_DATABASE_URL)
+    TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    Base.metadata.create_all(bind=engine)
+    # yield the app and database session to the test
+    try:
+        yield client, TestingSessionLocal()
+    finally:
+        # clean up test database
+        Base.metadata.drop_all(bind=engine)
+
+
+@pytest.fixture(scope="function")
+def db_session():
+    # set up a new database session for each test
+    session = SessionLocal()
+    try:
+        yield session
+    finally:
+        session.close()

app/tests/test_api/__init__.py

@@ -0,0 +1,11 @@
+# File: my-fastapi-project/app/tests/test_api/__init__.py
+
+from fastapi.testclient import TestClient
+from my_fastapi_project.app.api import app
+
+client = TestClient(app)
+
+def test_read_main():
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == {"msg": "Hello World"}

app/tests/test_api/test_items.py

@@ -0,0 +1,34 @@
+from fastapi.testclient import TestClient
+from app.main import app
+
+client = TestClient(app)
+
+def test_create_item():
+    data = {"name": "test", "description": "test description"}
+    response = client.post("/items/", json=data)
+    assert response.status_code == 200
+    assert response.json()["name"] == "test"
+    assert response.json()["description"] == "test description"
+
+def test_read_item():
+    response = client.get("/items/1")
+    assert response.status_code == 200
+    assert response.json()["name"] == "test"
+    assert response.json()["description"] == "test description"
+
+def test_read_all_items():
+    response = client.get("/items/")
+    assert response.status_code == 200
+    assert len(response.json()) == 1
+
+def test_update_item():
+    data = {"name": "updated test", "description": "updated test description"}
+    response = client.put("/items/1", json=data)
+    assert response.status_code == 200
+    assert response.json()["name"] == "updated test"
+    assert response.json()["description"] == "updated test description"
+
+def test_delete_item():
+    response = client.delete("/items/1")
+    assert response.status_code == 200
+    assert response.json() == {"detail": "Item deleted successfully"}

app/tests/test_api/test_users.py

@@ -0,0 +1,63 @@
+from fastapi.testclient import TestClient
+from app.core.config import settings
+
+client = TestClient(settings.app)
+
+
+def test_create_user():
+    data = {"email": "test@example.com", "password": "password"}
+    response = client.post("/users/", json=data)
+    assert response.status_code == 200
+    assert response.json()["email"] == "test@example.com"
+
+
+def test_create_user_invalid_email():
+    data = {"email": "invalid_email", "password": "password"}
+    response = client.post("/users/", json=data)
+    assert response.status_code == 422
+    assert "value_error.email" in response.json()["detail"][0]["type"]
+
+
+def test_create_user_invalid_password():
+    data = {"email": "test@example.com", "password": "short"}
+    response = client.post("/users/", json=data)
+    assert response.status_code == 422
+    assert "ensure this value has at least 6 characters" in response.json()["detail"][0]["msg"]
+
+
+def test_read_user():
+    response = client.get("/users/1")
+    assert response.status_code == 200
+    assert response.json()["email"] == "test@example.com"
+
+
+def test_read_user_not_found():
+    response = client.get("/users/999")
+    assert response.status_code == 404
+    assert response.json()["detail"] == "User not found"
+
+
+def test_update_user():
+    data = {"email": "new_email@example.com", "password": "new_password"}
+    response = client.put("/users/1", json=data)
+    assert response.status_code == 200
+    assert response.json()["email"] == "new_email@example.com"
+
+
+def test_update_user_not_found():
+    data = {"email": "new_email@example.com", "password": "new_password"}
+    response = client.put("/users/999", json=data)
+    assert response.status_code == 404
+    assert response.json()["detail"] == "User not found"
+
+
+def test_delete_user():
+    response = client.delete("/users/1")
+    assert response.status_code == 200
+    assert response.json() == {"msg": "User deleted"}
+
+
+def test_delete_user_not_found():
+    response = client.delete("/users/999")
+    assert response.status_code == 404
+    assert response.json()["detail"] == "User not found"

app/tests/test_core/__init__.py

@@ -0,0 +1,16 @@
+from fastapi.testclient import TestClient
+from app.core.config import settings
+
+
+def test_app():
+    from app.main import app
+    client = TestClient(app)
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == {"message": "Hello World"}
+
+
+def test_config():
+    assert settings.app_name == "My FastAPI Project"
+    assert settings.log_level == "debug"
+    assert settings.max_connection_count == 10

app/tests/test_core/test_config.py

@@ -0,0 +1,8 @@
+from app.core.config import settings
+
+
+def test_settings():
+    assert settings.API_V1_STR == "/api/v1"
+    assert settings.PROJECT_NAME == "My FastAPI Project"
+    assert settings.SQLALCHEMY_DATABASE_URI == "sqlite:///./test.db"
+    assert settings.ACCESS_TOKEN_EXPIRE_MINUTES == 30

app/tests/test_core/test_database.py

@@ -0,0 +1,24 @@
+from sqlalchemy.orm import Session
+from app.core.database import Base
+from app.models.user import User
+from app.models.item import Item
+
+
+def test_create_user(db: Session):
+    user = User(email="test@example.com", password="password123")
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    assert user.id is not None
+    assert user.email == "test@example.com"
+    assert user.is_active is True
+
+
+def test_create_item(db: Session):
+    item = Item(name="test item", description="test description")
+    db.add(item)
+    db.commit()
+    db.refresh(item)
+    assert item.id is not None
+    assert item.name == "test item"
+    assert item.description == "test description"

app/tests/test_core/test_security.py

@@ -0,0 +1,22 @@
+from fastapi import HTTPException
+from app.core.security import verify_password, get_password_hash
+
+def test_password_hashing():
+    password = "testpassword"
+    hashed_password = get_password_hash(password)
+    assert hashed_password != password
+
+def test_password_verification():
+    password = "testpassword"
+    hashed_password = get_password_hash(password)
+    assert verify_password(password, hashed_password)
+    assert not verify_password("wrongpassword", hashed_password)
+
+def test_password_verification_exception():
+    password = "testpassword"
+    hashed_password = get_password_hash(password)
+    try:
+        verify_password("wrongpassword", hashed_password)
+    except HTTPException as e:
+        assert e.status_code == 401
+        assert e.detail == "Incorrect email or password"

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn[standard]
+python-dotenv
+sqlalchemy
+psycopg2-binary
+pytest
+pytest-cov
+faker
+requests-mock