hinbert-fastapi 0.1.0__py3-none-any.whl

app/services/social_auth_service.py

@@ -0,0 +1,47 @@
+"""Social-login provider adapters for Google and Facebook."""
+
+import httpx
+
+from app.core.config.settings import get_settings
+
+
+async def exchange_provider_code(provider: str, code: str) -> dict[str, str]:
+    """Exchange an authorization code for normalized provider user information."""
+    if provider not in {"google", "facebook"}:
+        raise ValueError("Unsupported provider")
+    settings = get_settings()
+    async with httpx.AsyncClient(timeout=10) as client:
+        if provider == "google":
+            token_response = await client.post(
+                "https://oauth2.googleapis.com/token",
+                data={
+                    "code": code,
+                    "client_id": settings.google_client_id,
+                    "client_secret": settings.google_client_secret.get_secret_value(),
+                    "grant_type": "authorization_code",
+                },
+            )
+            token_response.raise_for_status()
+            profile = await client.get(
+                "https://openidconnect.googleapis.com/v1/userinfo",
+                headers={"Authorization": f"Bearer {token_response.json()['access_token']}"},
+            )
+        else:
+            token_response = await client.get(
+                "https://graph.facebook.com/v19.0/oauth/access_token",
+                params={
+                    "client_id": settings.facebook_client_id,
+                    "client_secret": settings.facebook_client_secret.get_secret_value(),
+                    "code": code,
+                },
+            )
+            token_response.raise_for_status()
+            profile = await client.get(
+                "https://graph.facebook.com/me",
+                params={"fields": "id,name,email", "access_token": token_response.json()["access_token"]},
+            )
+        profile.raise_for_status()
+    data = profile.json()
+    if not data.get("email"):
+        raise ValueError("OAuth provider did not return an email address")
+    return {"email": data["email"], "full_name": data.get("name") or data.get("given_name") or "OAuth User"}

app/services/totp_service.py

@@ -0,0 +1,13 @@
+"""Two-factor orchestration kept separate from HTTP handlers."""
+
+from app.core.security.totp import new_secret, verify_code
+
+
+def setup_totp() -> str:
+    """Return a new secret to encrypt and associate with a user."""
+    return new_secret()
+
+
+def verify_totp(secret: str, code: str) -> bool:
+    """Verify a user-provided current code."""
+    return verify_code(secret, code)

app/services/user_service.py

@@ -0,0 +1,27 @@
+"""User business rules and safe profile operations."""
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.security.password import hash_password
+from app.models.domain.user import User
+from app.models.schemas.user import UserCreate, UserUpdate
+
+
+async def create_user(session: AsyncSession, payload: UserCreate) -> User:
+    """Create a user with a bcrypt hash and commit the transaction."""
+    user = User(
+        email=str(payload.email).lower(), full_name=payload.full_name, password_hash=hash_password(payload.password)
+    )
+    session.add(user)
+    await session.commit()
+    await session.refresh(user)
+    return user
+
+
+async def update_user(session: AsyncSession, user: User, payload: UserUpdate) -> User:
+    """Apply allowed profile fields and persist them."""
+    if payload.full_name is not None:
+        user.full_name = payload.full_name
+    await session.commit()
+    await session.refresh(user)
+    return user

app/tests/__init__.py

@@ -0,0 +1 @@
+"""Test package for unit and integration coverage."""

app/tests/conftest.py

@@ -0,0 +1,36 @@
+"""Shared asynchronous database and HTTP fixtures for isolated application tests."""
+
+import pytest_asyncio
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+
+from app.db.base import Base
+from app.db.session import get_db
+from app.main import app
+
+
+@pytest_asyncio.fixture
+async def database_session():
+    """Create an in-memory schema and roll back all test data after each test."""
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:", pool_pre_ping=True)
+    async with engine.begin() as connection:
+        await connection.run_sync(Base.metadata.create_all)
+    session_factory = async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)
+    async with session_factory() as session:
+        yield session
+        await session.rollback()
+    await engine.dispose()
+
+
+@pytest_asyncio.fixture
+async def client(database_session: AsyncSession):
+    """Yield an HTTP client whose database dependency uses the isolated session."""
+
+    async def override_get_db():
+        """Yield the current test transaction to FastAPI dependencies."""
+        yield database_session
+
+    app.dependency_overrides[get_db] = override_get_db
+    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as test_client:
+        yield test_client
+    app.dependency_overrides.clear()

app/tests/integration/test_auth_api.py

@@ -0,0 +1,115 @@
+"""Integration tests for credential, token, and TOTP authentication flows."""
+
+import pyotp
+import pytest
+from httpx import AsyncClient
+
+from app.api.v1.endpoints import auth as auth_endpoint
+
+
+@pytest.mark.asyncio
+async def test_signup_and_login(client: AsyncClient):
+    """Signup returns a safe user and login returns both token types."""
+    signup = await client.post(
+        "/api/v1/auth/signup",
+        json={"email": "user@example.com", "full_name": "Test User", "password": "StrongPassword!123"},
+    )
+    assert signup.status_code == 201
+    assert "password_hash" not in signup.text
+    login = await client.post(
+        "/api/v1/auth/login", json={"email": "user@example.com", "password": "StrongPassword!123"}
+    )
+    assert login.status_code == 200
+    assert login.json()["data"]["access_token"]
+    assert login.json()["data"]["refresh_token"]
+
+
+@pytest.mark.asyncio
+async def test_refresh_rotation_and_logout(client: AsyncClient):
+    """A refresh token rotates once and logout revokes its replacement."""
+    await client.post(
+        "/api/v1/auth/signup",
+        json={"email": "rotate@example.com", "full_name": "Rotate User", "password": "StrongPassword!123"},
+    )
+    login = await client.post(
+        "/api/v1/auth/login", json={"email": "rotate@example.com", "password": "StrongPassword!123"}
+    )
+    first_refresh = login.json()["data"]["refresh_token"]
+    refreshed = await client.post("/api/v1/auth/refresh", json={"refresh_token": first_refresh})
+    assert refreshed.status_code == 200
+    second_refresh = refreshed.json()["data"]["refresh_token"]
+    assert second_refresh != first_refresh
+    assert (await client.post("/api/v1/auth/refresh", json={"refresh_token": first_refresh})).status_code == 401
+    assert (await client.post("/api/v1/auth/logout", json={"refresh_token": second_refresh})).status_code == 200
+    assert (await client.post("/api/v1/auth/refresh", json={"refresh_token": second_refresh})).status_code == 401
+
+
+@pytest.mark.asyncio
+async def test_invalid_login_returns_401(client: AsyncClient):
+    """Invalid credentials are rejected without account detail leakage."""
+    response = await client.post(
+        "/api/v1/auth/login", json={"email": "missing@example.com", "password": "WrongPassword!123"}
+    )
+    assert response.status_code == 401
+
+
+@pytest.mark.asyncio
+async def test_totp_setup_and_verify(client: AsyncClient):
+    """TOTP setup returns a provisioning URI and accepts a current code."""
+    await client.post(
+        "/api/v1/auth/signup",
+        json={"email": "totp@example.com", "full_name": "TOTP User", "password": "StrongPassword!123"},
+    )
+    login = await client.post(
+        "/api/v1/auth/login", json={"email": "totp@example.com", "password": "StrongPassword!123"}
+    )
+    headers = {"Authorization": f"Bearer {login.json()['data']['access_token']}"}
+    setup = await client.post("/api/v1/auth/totp/setup", headers=headers)
+    assert setup.status_code == 200
+    secret = setup.json()["data"]["secret"]
+    verify = await client.post("/api/v1/auth/totp/verify", headers=headers, json={"code": pyotp.TOTP(secret).now()})
+    assert verify.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_email_verification_activates_account(client: AsyncClient, monkeypatch):
+    """Signup creates a token that activates the account when consumed."""
+    sent = {}
+    monkeypatch.setattr(auth_endpoint, "send_verification_email", lambda user, token: sent.setdefault("token", token))
+    response = await client.post(
+        "/api/v1/auth/signup",
+        json={"email": "verify@example.com", "full_name": "Verify", "password": "StrongPassword!123"},
+    )
+    assert response.status_code == 201
+    verified = await client.post("/api/v1/auth/verify-email", json={"token": sent["token"]})
+    assert verified.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_forgot_and_reset_password(client: AsyncClient, monkeypatch):
+    """Forgot-password creates a reset token that changes the login credential."""
+    sent = {}
+    monkeypatch.setattr(auth_endpoint, "send_reset_email", lambda user, token: sent.setdefault("token", token))
+    await client.post(
+        "/api/v1/auth/signup",
+        json={"email": "reset@example.com", "full_name": "Reset", "password": "StrongPassword!123"},
+    )
+    forgotten = await client.post("/api/v1/auth/forgot-password", json={"email": "reset@example.com"})
+    assert forgotten.status_code == 200
+    reset = await client.post(
+        "/api/v1/auth/reset-password", json={"token": sent["token"], "password": "NewStrongPassword!123"}
+    )
+    assert reset.status_code == 200
+    assert (
+        await client.post(
+            "/api/v1/auth/login", json={"email": "reset@example.com", "password": "NewStrongPassword!123"}
+        )
+    ).status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_health_endpoint(client: AsyncClient):
+    """The liveness endpoint is available without database access."""
+    response = await client.get("/health")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}

app/tests/integration/test_product_api.py

@@ -0,0 +1,58 @@
+"""Integration tests for product CRUD, ownership, and query controls."""
+
+import pytest
+from httpx import AsyncClient
+
+
+async def product_token(client: AsyncClient) -> str:
+    """Create a test user and return its access token."""
+    await client.post(
+        "/api/v1/auth/signup",
+        json={"email": "products@example.com", "full_name": "Products", "password": "StrongPassword!123"},
+    )
+    response = await client.post(
+        "/api/v1/auth/login", json={"email": "products@example.com", "password": "StrongPassword!123"}
+    )
+    return response.json()["data"]["access_token"]
+
+
+@pytest.mark.asyncio
+async def test_product_crud(client: AsyncClient):
+    """An owner can create, read, update, and delete a product."""
+    token = await product_token(client)
+    headers = {"Authorization": f"Bearer {token}"}
+    created = await client.post(
+        "/api/v1/products",
+        headers=headers,
+        json={"name": "Widget", "description": "A widget", "price": "12.50", "category": "tools"},
+    )
+    assert created.status_code == 201
+    product_id = created.json()["data"]["id"]
+    assert (await client.get(f"/api/v1/products/{product_id}")).status_code == 200
+    updated = await client.put(
+        f"/api/v1/products/{product_id}",
+        headers=headers,
+        json={"name": "Better Widget", "description": "Updated", "price": "15.00", "category": "tools"},
+    )
+    assert updated.status_code == 200
+    assert updated.json()["data"]["name"] == "Better Widget"
+    assert (await client.delete(f"/api/v1/products/{product_id}", headers=headers)).status_code == 200
+    assert (await client.get(f"/api/v1/products/{product_id}")).status_code == 404
+
+
+@pytest.mark.asyncio
+async def test_product_filter_sort_and_pagination(client: AsyncClient):
+    """The collection endpoint applies category, price, sort, and page controls."""
+    token = await product_token(client)
+    headers = {"Authorization": f"Bearer {token}"}
+    for name, price in (("Cheap", "5.00"), ("Expensive", "50.00")):
+        response = await client.post(
+            "/api/v1/products", headers=headers, json={"name": name, "price": price, "category": "tools"}
+        )
+        assert response.status_code == 201
+    response = await client.get("/api/v1/products?page=1&page_size=1&category=tools&min_price=10&sort_by=price")
+    data = response.json()["data"]
+    assert data["total_count"] == 2
+    assert data["page"] == 1
+    assert data["limit"] == 1
+    assert data["items"][0]["name"] == "Expensive"

app/tests/integration/test_user_api.py

@@ -0,0 +1,68 @@
+"""Integration tests for profile and administrator user management."""
+
+import pytest
+from httpx import AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.security.password import hash_password
+from app.models.domain.user import User
+
+
+async def login(client: AsyncClient, email: str, password: str) -> str:
+    """Return an access token from the credential login endpoint."""
+    response = await client.post("/api/v1/auth/login", json={"email": email, "password": password})
+    return response.json()["data"]["access_token"]
+
+
+@pytest.mark.asyncio
+async def test_current_user_can_update_profile(client: AsyncClient):
+    """Authenticated users can update their own display name."""
+    await client.post(
+        "/api/v1/auth/signup",
+        json={"email": "profile@example.com", "full_name": "Original", "password": "StrongPassword!123"},
+    )
+    token = await login(client, "profile@example.com", "StrongPassword!123")
+    response = await client.patch(
+        "/api/v1/users/me", headers={"Authorization": f"Bearer {token}"}, json={"full_name": "Updated"}
+    )
+    assert response.status_code == 200
+    assert response.json()["data"]["full_name"] == "Updated"
+
+
+@pytest.mark.asyncio
+async def test_non_admin_cannot_list_users(client: AsyncClient):
+    """Regular accounts cannot access administrator user listings."""
+    await client.post(
+        "/api/v1/auth/signup",
+        json={"email": "member@example.com", "full_name": "Member", "password": "StrongPassword!123"},
+    )
+    token = await login(client, "member@example.com", "StrongPassword!123")
+    response = await client.get("/api/v1/users", headers={"Authorization": f"Bearer {token}"})
+    assert response.status_code == 401
+
+
+@pytest.mark.asyncio
+async def test_admin_can_list_and_update_users(client: AsyncClient, database_session: AsyncSession):
+    """Administrators can list users and change a user's active state."""
+    admin = User(
+        email="admin@example.com",
+        full_name="Admin",
+        password_hash=hash_password("AdminPassword!123"),
+        is_admin=True,
+        is_verified=True,
+    )
+    database_session.add(admin)
+    await database_session.commit()
+    await client.post(
+        "/api/v1/auth/signup",
+        json={"email": "managed@example.com", "full_name": "Managed", "password": "StrongPassword!123"},
+    )
+    token = await login(client, "admin@example.com", "AdminPassword!123")
+    listing = await client.get("/api/v1/users", headers={"Authorization": f"Bearer {token}"})
+    assert listing.status_code == 200
+    managed = next(item for item in listing.json()["data"] if item["email"] == "managed@example.com")
+    updated = await client.patch(
+        f"/api/v1/users/{managed['id']}", headers={"Authorization": f"Bearer {token}"}, json={"is_active": False}
+    )
+    assert updated.status_code == 200
+    assert updated.json()["data"]["is_active"] is False

app/tests/unit/test_auth_service.py

@@ -0,0 +1,48 @@
+"""Unit tests for authentication and credential primitives."""
+
+from datetime import UTC, datetime, timedelta
+from uuid import uuid4
+
+import pytest
+
+from app.core.security.jwt import create_token, decode_token
+from app.core.security.password import hash_password, verify_password
+from app.services.auth_service import hash_refresh_token, issue_tokens
+
+
+def test_refresh_hash_is_deterministic_and_not_plaintext():
+    """The database representation is fixed-length SHA-256, never the bearer value."""
+    assert hash_refresh_token("secret") == hash_refresh_token("secret")
+    assert hash_refresh_token("secret") != "secret"
+
+
+def test_issue_tokens_returns_matching_refresh_digest():
+    """Token issuance returns independently usable values and a matching digest."""
+    access, refresh, digest, expiry = issue_tokens(uuid4())
+    assert access and refresh and digest and expiry > datetime.now(UTC)
+    assert digest == hash_refresh_token(refresh)
+
+
+def test_access_token_contains_subject_and_type():
+    """JWT claims identify the subject and prevent refresh-token confusion."""
+    subject = uuid4()
+    token = create_token(subject, "access", timedelta(minutes=5))
+    claims = decode_token(token)
+    assert claims["sub"] == str(subject)
+    assert claims["type"] == "access"
+
+
+def test_wrong_token_type_is_rejected():
+    """A token issued for one purpose cannot be used for another purpose."""
+    token = create_token(uuid4(), "refresh", timedelta(minutes=5))
+    with pytest.raises(ValueError):
+        decode_token(token)
+
+
+def test_password_hash_is_salted_and_verifiable():
+    """Two hashes differ because bcrypt salts each password independently."""
+    first = hash_password("StrongPassword!123")
+    second = hash_password("StrongPassword!123")
+    assert first != second
+    assert verify_password("StrongPassword!123", first)
+    assert not verify_password("wrong", first)

app/tests/unit/test_product_service.py

@@ -0,0 +1,33 @@
+"""Unit tests for product service business operations."""
+
+from decimal import Decimal
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from app.models.domain.product import Product
+from app.models.schemas.product import ProductCreate
+from app.services.product_service import create_product, update_product
+
+
+@pytest.mark.asyncio
+async def test_create_product_persists_payload():
+    """Product creation maps validated schema fields to the model."""
+    session = AsyncMock()
+    session.add = MagicMock()
+    session.refresh = AsyncMock()
+    product = await create_product(session, ProductCreate(name="Widget", price=Decimal("2.50")))
+    assert product.name == "Widget"
+    assert product.price == Decimal("2.50")
+
+
+@pytest.mark.asyncio
+async def test_update_product_replaces_editable_fields():
+    """Product updates modify name, category, description, and price."""
+    session = AsyncMock()
+    product = Product(name="Old", description="old", price=Decimal("1.00"))
+    await update_product(
+        session, product, ProductCreate(name="New", description="new", price=Decimal("2.00"), category="tools")
+    )
+    assert product.name == "New"
+    assert product.category == "tools"

app/tests/unit/test_user_service.py

@@ -0,0 +1,32 @@
+"""Unit tests for user service business operations."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from app.models.domain.user import User
+from app.models.schemas.user import UserCreate, UserUpdate
+from app.services.user_service import create_user, update_user
+
+
+@pytest.mark.asyncio
+async def test_create_user_hashes_password():
+    """User creation persists a bcrypt hash rather than plaintext."""
+    session = AsyncMock()
+    session.add = MagicMock()
+    session.refresh = AsyncMock()
+    user = await create_user(
+        session, UserCreate(email="new@example.com", full_name="New", password="StrongPassword!123")
+    )
+    assert user.password_hash != "StrongPassword!123"
+    session.commit.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_update_user_changes_only_allowed_profile_field():
+    """Profile updates do not alter role or credential fields."""
+    session = AsyncMock()
+    user = User(email="user@example.com", full_name="Before", password_hash="hash", is_admin=False)
+    await update_user(session, user, UserUpdate(full_name="After"))
+    assert user.full_name == "After"
+    assert user.is_admin is False

app/utils/__init__.py

@@ -0,0 +1 @@
+"""Small pure helpers with no business or HTTP dependencies."""

app/utils/date_utils.py

@@ -0,0 +1,8 @@
+"""Timezone-aware date formatting helpers."""
+
+from datetime import UTC, datetime
+
+
+def utc_iso(value: datetime | None = None) -> str:
+    """Format a datetime as an explicit UTC ISO-8601 string."""
+    return (value or datetime.now(UTC)).astimezone(UTC).isoformat()

app/utils/file_utils.py

@@ -0,0 +1,8 @@
+"""Safe file helper boundaries for future object-storage integration."""
+
+from pathlib import Path
+
+
+def safe_filename(filename: str) -> str:
+    """Strip path components so user input cannot select arbitrary directories."""
+    return Path(filename).name

app/utils/logger.py

@@ -0,0 +1,11 @@
+"""Central Loguru configuration with rotation and retention.
+
+Applications may replace the sink in one place to integrate with a managed
+logging platform. Never log passwords, bearer tokens, or reset links.
+"""
+
+from loguru import logger
+
+logger.remove()
+logger.add("logs/app.log", rotation="10 MB", retention="30 days", serialize=True, enqueue=True)
+logger.add(lambda message: print(message, end=""), level="INFO")

app/utils/validators.py

@@ -0,0 +1,13 @@
+"""Reusable validation functions for values not covered by Pydantic fields."""
+
+import re
+
+
+def is_strong_password(password: str) -> bool:
+    """Require upper, lower, digit, symbol, and a twelve-character minimum."""
+    return len(password) >= 12 and bool(
+        re.search(r"[A-Z]", password)
+        and re.search(r"[a-z]", password)
+        and re.search(r"\d", password)
+        and re.search(r"[^A-Za-z0-9]", password)
+    )

hinbert_fastapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,96 @@
+app/__init__.py,sha256=ITWqSHnty47G8bzwU0xhOf4DE9qvmDGAUi9njoX866k,318
+app/main.py,sha256=QRBOaROPI8EpvnQQkkEG4EaMkTivryiSYh1xnX0YSpg,1926
+app/api/__init__.py,sha256=KodSsSkjyFZ1wrOEYuXH_OOhOFwZzZ1GdHWLXAzgNe8,26
+app/api/deps/__init__.py,sha256=Wcx5dlMLPfRRMqiG2rZCttzWAvJ9pNgICeJklLZ_3qU,37
+app/api/deps/auth.py,sha256=m0Q00JSNl-q2NPG54Kx-copSLo-fT2wCqkXJWfqr_Hc,1480
+app/api/deps/pagination.py,sha256=P6gyIBF-nSajbwsb8PoimH-uUQQkyAgaWbmAKvAPjOs,308
+app/api/v1/__init__.py,sha256=NSwukK-n6wMt-5QZwyZNkvu0jbKtX9Bk1vHEH8_Nkvk,33
+app/api/v1/endpoints/__init__.py,sha256=KvQACxGWS4udvDyAFYVIfhbrxr3CXjZAwUIR2xFLlnk,36
+app/api/v1/endpoints/auth.py,sha256=B4WRk6S2ajVL33NdVW8UqB8e9lIfNpZmL2rXmbWhCxk,11983
+app/api/v1/endpoints/dashboard.py,sha256=tWipV9U7whKblF0ul1-rLahI9MLH3CRSo-6JEVsnukA,1093
+app/api/v1/endpoints/products.py,sha256=6xJhz9_TrV6QtE1PvEol-b3KqAjQqW4WBut4LICC5XY,4277
+app/api/v1/endpoints/users.py,sha256=KgLgCtdfCc_JNhyO52pvhKaNopAVkP2I7vNGKVDgj_A,3417
+app/api/v1/routers/__init__.py,sha256=NqHDFG1hmdTh0wH_XaKt9D32m7s3iOe604F1kLndS5U,37
+app/api/v1/routers/api_router.py,sha256=zO__zUFJSgfgNCV726dZZm1Or-i8JpAx_zuoVu9oAYg,342
+app/core/__init__.py,sha256=FIk5KtRzI5uDeCmCFxr-z_ldX5hkaiu8KBhqoZMZI1k,80
+app/core/config/__init__.py,sha256=aOGV1j12RPh2DgAweCVAMbtqDe_dhkbkATgWOJ2zK18,50
+app/core/config/database.py,sha256=_VyZ5pu0Ea4hmbGDmQ9yaD7pmhA9TwS8C7qXMZ7eQOY,553
+app/core/config/settings.py,sha256=auo_aT8khtXQQ9kWTSRtLkhMFzkEi9dXDn-lUyidvGw,4218
+app/core/exceptions/__init__.py,sha256=seTrkfNqRMfcWUr6oWzo73Ccr02CtcfuwnC9-vZNMCg,42
+app/core/exceptions/base_exception.py,sha256=FIIpbgngcUv10cEV4j50HdM_UmycV-QFt19FFkff1yU,404
+app/core/exceptions/custom_exceptions.py,sha256=L3TPvdZXtr0OwpWZ7ligcK3B5z6XTK0H_K_gjTq1fmY,541
+app/core/middleware/__init__.py,sha256=N1ezjt2INhnh5nIdG46hQUHU7sX-2Q6ScOeSM2Yh-WI,57
+app/core/middleware/cors.py,sha256=-9K0FQWunNPkwNekIU4drdroFd6PlmUS-ITTc9aiCPo,216
+app/core/middleware/error_handler.py,sha256=Y2D6b1pDBZDNgwgmq8BeHZ4qiCznGbpcfcYo7rzV7jc,820
+app/core/middleware/logging.py,sha256=5wokekqERtb5_7gk6Pc2BQiT_RtuydEviofCTIFc6uc,1167
+app/core/middleware/rate_limit.py,sha256=GOJP2XfeZoVDZjsdZQAxhs2_Lslb50BW1DSja8jrcbU,927
+app/core/security/__init__.py,sha256=uMwPaSb7JxuFAzF5qRBOMBkC_18hkH21WcMYgfOEUdE,64
+app/core/security/auth.py,sha256=Cy5Z4neOPRO1ByGdWziM0aNisI2xLqOdbxPymF7NFEs,341
+app/core/security/jwt.py,sha256=M6Apv0vu8J9I0H6refBp6ojQs5cUF82fyTmfOLOuZhQ,1400
+app/core/security/oauth.py,sha256=1sYkl5l4KI8lL0nIVY5pr3WKWARSkfo0_mfgCflnxcs,325
+app/core/security/password.py,sha256=xyPf6YyYXw1v3AGlCz5UG_tFpvPy4SHIE8-AbXJmHjY,710
+app/core/security/totp.py,sha256=x0iVHA5Y8hM5zdNggVQD9pX_1U80eQySdCl98ntkTV8,402
+app/db/__init__.py,sha256=-5YRLYVpvPbEWDjUxyBKu5zEwikMV4StqpEskMTP3OM,46
+app/db/base.py,sha256=lVrpob0gI-DFBGYJchJcEC5vOjZ8JdNMrIUciug7fI4,204
+app/db/session.py,sha256=Gd2VyuJu1-p2fXlO558U3zNDij5G7Ydm2t3NnaSFfJs,353
+app/db/migrations/env.py,sha256=93BySoir11StMvMWra3Jh0cjCJmBgtRlKJ5TwKGXq6Y,1427
+app/db/migrations/versions/97ed1bc05f4a_complete_product_and_totp_fields.py,sha256=54v3xWqwb2jOZvLSPIXIK2xyVCiT9b9vEmGzcKb-0e0,2240
+app/db/migrations/versions/f8b632aa11da_initial_migration.py,sha256=bSLNgP0x8wwGrJkT75XRGSNkV_-6-VtMf0j88G09U0I,5385
+app/models/__init__.py,sha256=brUa_brdi2sWbVh9A7nkEVTGtcj1Sv3KLtWneEeApEE,518
+app/models/domain/__init__.py,sha256=it9kNQEgkbXUGmrwAP92wLpGqaePowae0KWTSWU62W0,41
+app/models/domain/base.py,sha256=j8ynMqabOz5N_1ykfGn2PDnCaNpju4EMjFm3_3ygXrE,724
+app/models/domain/email_verification.py,sha256=c6mw1Pp7l3PlVX7SQzalLWG0X_ng7Az9C7dE_tg8Tc4,938
+app/models/domain/password_reset.py,sha256=FHsH87Nrcd6CI_N1ABq_YoQHdI0SStDDEi8HGfJz53I,949
+app/models/domain/product.py,sha256=-fOujqws6Qllcc3h7LVMhP2ZAfch1rnRgwNdSJmeuFE,831
+app/models/domain/refresh_token.py,sha256=Wihy0SRA3WI7RO2w1v9JG6C2TEYd_yn9nfnSgDf8irg,983
+app/models/domain/totp_secret.py,sha256=XOABus9AXJ9Ddn0XYBX5ZincbXbF9Bf3VaVJ9fbGoME,1669
+app/models/domain/user.py,sha256=DvDHGCIuPGXejDsyOzAF3Z5SEOjyXDOkJnTyOwdvR3U,1625
+app/models/schemas/__init__.py,sha256=GSkoAMgiZLeQKOAQwaBDSvLwValEUwJqBU6gPLffx_o,45
+app/models/schemas/auth.py,sha256=-2NQ5SqeERoyYpYE2FSgcrRIh43K5n4gN5eMNCG5V7Q,738
+app/models/schemas/password.py,sha256=BFApbSmUqzHRTm1yPkrWBe4PmH8qUv13Wef8Op7SV1o,374
+app/models/schemas/product.py,sha256=GSZB71Xo0cgpvorXma02VjvOlk6cUPkWDR25hrOPXbE,775
+app/models/schemas/response.py,sha256=Ypfw4j90WNxi_WqqIuFyE9VE9N-yo-Dsr7t5Oo8y2AQ,473
+app/models/schemas/token.py,sha256=drHEH2QErm2vfiHEAW2X8giVfhuLoGf5SvtbWNF7KEQ,358
+app/models/schemas/totp.py,sha256=RfdV2lt0XhoYkjnD93na-t1WzXIScuL1QF_RYjKmmzE,374
+app/models/schemas/user.py,sha256=fj5rnYiAtBsMOE78Dma-IVRM8jbFBYVc-yrzuc_E24U,922
+app/repositories/__init__.py,sha256=jE_Lwi9eoISFCA_NW2lSyqBD_SfuE5vU6kxNvQ0jrg4,58
+app/repositories/email_verification_repository.py,sha256=NMs3OsJHMcmJLb-B8ajfz80VGg3LFMQK-CySMKpZFlQ,1294
+app/repositories/password_reset_repository.py,sha256=UhmyTDz6vABhZ76epZn87zgOZ1EgDfQ1iBO_R9GEWEI,1121
+app/repositories/product_repository.py,sha256=WJkvhnkvtSDSbRAXiNWGmlJpD4ap-ZvnDrBBZhWPYU8,1474
+app/repositories/refresh_token_repository.py,sha256=mKUTXEtppz1Jfo5Hz6LzI8Fvi44Hb2BuRXffjZG7tek,1407
+app/repositories/totp_secret_repository.py,sha256=g3K2SfTEfcO7D9uvh3xbPYsX7DVxCPsqQBa2MwK7UBc,776
+app/repositories/user_repository.py,sha256=Sc9kPj-3zcCXjeGQw1oDxyYOgdLV4vjm-5n-nXaGxE4,1479
+app/repositories/base/__init__.py,sha256=SRqlheoVnRx-7TMgwEONcB9e97cSGW_3GPN2MIGHs5I,40
+app/repositories/base/base_repository.py,sha256=5eHZXDvXf3AndG7ozNNPT1pKp60Y5-cvpgpDyQVoWD4,2025
+app/services/__init__.py,sha256=g8HzLkrQpvwcDJWdfu4fnAWOCMZqRnvCXvDaKoO07U4,74
+app/services/auth_service.py,sha256=gdSPUOcMXk8nkXX7rrk8ZSPiD36m7TbHLUCRhn5Yuf8,1235
+app/services/email_service.py,sha256=hbZ2qqji51iTn8SWIeHLskCNvKEQlt_ITk_WnmOgocw,1391
+app/services/product_service.py,sha256=TshhMqseRUU5GLRF738R3qXeEhkO1BjJ1p6Y6zIJr60,859
+app/services/social_auth_service.py,sha256=sbuaYcLRb819cekjJG3767QKCwTjMMDezaIBitTXkNQ,2116
+app/services/totp_service.py,sha256=WTqIg-WL6iv6RQTRWOtozWJvV_x1FVBPFqK1KASBa_I,392
+app/services/user_service.py,sha256=V63V2fhL86fryLY2g345wAgYXUy_EA8nLr9CGgCWC20,971
+app/services/base/__init__.py,sha256=xmy_RDDZmTxrwMTAZoxcgyrvkV6Zn7QSajbQmkdv1No,37
+app/services/base/base_service.py,sha256=kNfET76erQSZyPh93LavpwWYJ4UAcTRHDtwF-jHmEI8,673
+app/tests/__init__.py,sha256=RMe_6_k55X9JooxiaFDBfi6hc9BI-y1EJHRW6mWdP40,54
+app/tests/conftest.py,sha256=INyg0Phm-FIkTfYEezKMW6m2Tl8XdhUdQlZETLaBdUg,1435
+app/tests/integration/test_auth_api.py,sha256=Hoc8zRLsu1h53tdchiDZxIOQv_q0FrPrJeREfcbQEqg,5192
+app/tests/integration/test_product_api.py,sha256=3vCkxuzbDpuGIVkAWIc5M4uVVeWEqs0QX1zLiRxbg0E,2563
+app/tests/integration/test_user_api.py,sha256=lwcZ4krqxAd9rdLncThM8CeyqkAv8Wm3SllnQQvR09Q,2976
+app/tests/unit/test_auth_service.py,sha256=QhAL9YQ9MrYJPYoNpIPB7KHK6uqjTw7MJpF06r4VnBo,1937
+app/tests/unit/test_product_service.py,sha256=secvzUcPclYXtCyOinftfmQf0MdIVlPHDS_axjACsNg,1236
+app/tests/unit/test_user_service.py,sha256=M7SWq7hy5_FwffBR217A86vJUD4AR4WJqjl2B3d9TNs,1193
+app/utils/__init__.py,sha256=o8f2P1oHPwNyJPjCNyEG16TR3y4D0Ivq55GBARsp-Jw,64
+app/utils/date_utils.py,sha256=JURJXd7IUpgBE2_NyW-jp4UapfAXaI923UAWOw4sHkE,275
+app/utils/file_utils.py,sha256=jKJ2UMvJjh9s-10Z4JizJR79Ee7tzVdjFjgC6ukw-Dc,264
+app/utils/logger.py,sha256=DGqMTLSWP8y7ST3-TjMtfKYPX2HPmzv_7Mlr0_zX2z4,427
+app/utils/validators.py,sha256=6S-olI1YEar1TXsrDIdKxuUjSimXxPjA5lABZ0p_6gk,446
+hinbert_fastapi-0.1.0.dist-info/licenses/LICENSE,sha256=u2u91B7zuvQyx2ACdQULyh0YMb_yr2SjiqIR4gLEGIA,1097
+scripts/__init__.py,sha256=zzoqX63YF4xYySgy4TPgQkNAV_FeE68kcIv7RJwTL6c,78
+scripts/create_admin.py,sha256=JG3V1RNIgXM7k1GxXkPxkO5EsC-J40NAUouAU0W91Aw,1468
+scripts/run_migrations.py,sha256=Fy_LN5xtNK0zsRE05BWbUhIjXIxJQzQlEmjwsRLZS3I,312
+scripts/seed_data.py,sha256=Pgr0Z9aUFjrtkvL1i_1f4a7B2FqdJ19XRf2-aDg2K7o,1665
+hinbert_fastapi-0.1.0.dist-info/METADATA,sha256=RfTUkP1vnOjlxgrnMgvtThl4zb2D5An50d4GQP-0-UU,7537
+hinbert_fastapi-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+hinbert_fastapi-0.1.0.dist-info/entry_points.txt,sha256=db2SvdTODpwyBDNX-f9TFW9U-XzPJH0Bizcr86Wz5iU,183
+hinbert_fastapi-0.1.0.dist-info/top_level.txt,sha256=0TlswQcp1e2_wFmkaFYptXRuV0X6QpkLpMINHMa_iPI,12
+hinbert_fastapi-0.1.0.dist-info/RECORD,,

hinbert_fastapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+