fastapi-spawn 0.4.6__tar.gz → 0.4.9__tar.gz

{fastapi_spawn-0.4.6 → fastapi_spawn-0.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-spawn
-Version: 0.4.6
+Version: 0.4.9
 Summary: A powerful CLI tool to scaffold production-ready FastAPI projects with flexible database, auth, broker, and deployment options.
 Project-URL: Homepage, https://github.com/Bishwajitgarai/fastapi-spawn
 Project-URL: Documentation, https://github.com/Bishwajitgarai/fastapi-spawn#readme

{fastapi_spawn-0.4.6 → fastapi_spawn-0.4.9}/fastapi_spawn/__init__.py

@@ -1,6 +1,6 @@
 """fastapi-spawn — Production-ready FastAPI project scaffolding CLI."""
 
-__version__ = "0.4.6"
+__version__ = "0.4.9"
 __author__ = "Bishwajit Garai"
 __email__ = "bishwajitgarai@gmail.com"
 __license__ = "MIT"

{fastapi_spawn-0.4.6 → fastapi_spawn-0.4.9}/fastapi_spawn/cli.py

@@ -98,6 +98,7 @@ def new(
     no_tests: bool = typer.Option(False, "--no-tests", help="Skip test suite"),
     dry_run: bool = typer.Option(False, "--dry-run", help="Preview structure without writing files"),
     force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing directory"),
+    extra: Optional[list[str]] = typer.Option(None, "--extra", help="Extra integrations (e.g. stripe, sso, sse, seed, ocr, meilisearch)"),
     output: Path = typer.Option(Path("."), "--output", "-o", help="Output directory"),
     version: Optional[bool] = typer.Option(
         None, "--version", "-v", callback=version_callback, is_eager=True, help="Show version"
@@ -192,6 +193,7 @@ def new(
         include_tests=include_tests,
         dry_run=dry_run,
         force=force,
+        extras=extra or [],
     )
 
     _print_summary(config)

{fastapi_spawn-0.4.6 → fastapi_spawn-0.4.9}/fastapi_spawn/config.py

@@ -47,6 +47,7 @@ class ProjectConfig:
     include_makefile: bool = True
     dry_run: bool = False
     force: bool = False
+    extras: list[str] = field(default_factory=list)
     # Derived (post-init)
     package_name: str = field(default="", init=False)
     slug: str = field(default="", init=False)
@@ -194,6 +195,7 @@ class ProjectConfig:
             "has_log_file": self.has_log_file,
             "include_tests": self.include_tests,
             "include_makefile": self.include_makefile,
+            "extras": self.extras,
         }
 
     def summary_lines(self) -> list[tuple[str, str]]:
@@ -219,5 +221,6 @@ class ProjectConfig:
             ("API extras",   self.api_extra.value),
             ("Docker",       "yes" if self.has_docker else "no"),
             ("Tests",        "yes" if self.include_tests else "no"),
+            ("Extras",       ", ".join(self.extras) if self.extras else "none"),
             ("Dry-run",      "yes" if self.dry_run else "no"),
         ]

{fastapi_spawn-0.4.6 → fastapi_spawn-0.4.9}/fastapi_spawn/constants.py

@@ -93,6 +93,7 @@ class EmailProvider(str, Enum):
     sendgrid = "sendgrid"
     smtp     = "smtp"
     ses      = "ses"
+    resend   = "resend"
     none     = "none"
 
 
@@ -234,6 +235,7 @@ EMAIL_LABELS = {
     EmailProvider.sendgrid: "SendGrid",
     EmailProvider.smtp:     "SMTP (fastapi-mail)",
     EmailProvider.ses:      "AWS SES",
+    EmailProvider.resend:   "Resend",
     EmailProvider.none:     "No email",
 }
 

{fastapi_spawn-0.4.6 → fastapi_spawn-0.4.9}/fastapi_spawn/generator.py

@@ -209,6 +209,32 @@ class ProjectGenerator:
             (root / "logs").mkdir(exist_ok=True)
             (root / "logs" / ".gitkeep").write_text("", encoding="utf-8")
 
+        # Extras rendering
+        extras = self.config.extras
+        if "stripe" in extras:
+            (v1 / "payments").mkdir(parents=True, exist_ok=True)
+            self._render_to(v1 / "payments" / "router.py", "app/api/v1/payments/router.py.j2")
+            self._render_to(v1 / "payments" / "__init__.py", "app/__init__.py.j2")
+        
+        if "sso" in extras:
+            (v1 / "auth").mkdir(parents=True, exist_ok=True)
+            self._render_to(v1 / "auth" / "sso.py", "app/api/v1/auth/sso.py.j2")
+            
+        if "sse" in extras:
+            (v1 / "streaming").mkdir(parents=True, exist_ok=True)
+            self._render_to(v1 / "streaming" / "router.py", "app/api/v1/streaming/router.py.j2")
+            self._render_to(v1 / "streaming" / "__init__.py", "app/__init__.py.j2")
+
+        if "seed" in extras:
+            (root / "db").mkdir(parents=True, exist_ok=True)
+            self._render_to(root / "db" / "seed.py", "db/seed.py.j2")
+
+        if "ocr" in extras:
+            self._render_to(core / "ocr.py", "app/core/ocr.py.j2")
+
+        if "meilisearch" in extras:
+            self._render_to(core / "search.py", "app/core/search.py.j2")
+
 
     def _generate_tasks(self, root: Path) -> None:
         """Root-level tasks/ directory."""

fastapi_spawn-0.4.9/fastapi_spawn/templates/app/api/v1/auth/sso.py.j2

@@ -0,0 +1,71 @@
+from fastapi import APIRouter, Request, HTTPException
+from fastapi_sso.sso.google import GoogleSSO
+from fastapi_sso.sso.github import GithubSSO
+from app.core.config import settings
+
+router = APIRouter(prefix="/sso", tags=["auth"])
+
+# Requires GOOGLE_CLIENT_ID and GOOGLE_CLIENT_SECRET in .env
+google_sso = GoogleSSO(
+    client_id=getattr(settings, "GOOGLE_CLIENT_ID", "placeholder"),
+    client_secret=getattr(settings, "GOOGLE_CLIENT_SECRET", "placeholder"),
+    redirect_uri="http://localhost:8000/api/v1/auth/sso/google/callback",
+    allow_insecure_http=True, # Set to False in production
+)
+
+@router.get("/google/login")
+async def google_login():
+    """Redirects the user to the Google login page."""
+    with google_sso:
+        return await google_sso.get_login_redirect()
+
+@router.get("/google/callback")
+async def google_callback(request: Request):
+    """Process login response from Google and return user info."""
+    with google_sso:
+        user = await google_sso.verify_and_process(request)
+    if not user:
+        raise HTTPException(status_code=400, detail="Failed to login via Google")
+    
+    # TODO: Create or update user in database, then generate and return JWT
+    return {
+        "id": user.id,
+        "email": user.email,
+        "first_name": user.first_name,
+        "last_name": user.last_name,
+        "picture": user.picture,
+        "provider": "google"
+    }
+
+# --- GitHub SSO ---
+
+# Requires GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET in .env
+github_sso = GithubSSO(
+    client_id=getattr(settings, "GITHUB_CLIENT_ID", "placeholder"),
+    client_secret=getattr(settings, "GITHUB_CLIENT_SECRET", "placeholder"),
+    redirect_uri="http://localhost:8000/api/v1/auth/sso/github/callback",
+    allow_insecure_http=True, # Set to False in production
+)
+
+@router.get("/github/login")
+async def github_login():
+    """Redirects the user to the GitHub login page."""
+    with github_sso:
+        return await github_sso.get_login_redirect()
+
+@router.get("/github/callback")
+async def github_callback(request: Request):
+    """Process login response from GitHub and return user info."""
+    with github_sso:
+        user = await github_sso.verify_and_process(request)
+    if not user:
+        raise HTTPException(status_code=400, detail="Failed to login via GitHub")
+    
+    return {
+        "id": user.id,
+        "email": user.email,
+        "first_name": getattr(user, "first_name", None),
+        "last_name": getattr(user, "last_name", None),
+        "picture": getattr(user, "picture", None),
+        "provider": "github"
+    }

fastapi_spawn-0.4.9/fastapi_spawn/templates/app/api/v1/payments/router.py.j2

@@ -0,0 +1,58 @@
+from fastapi import APIRouter, Request, HTTPException, Depends
+import stripe
+from app.core.config import settings
+from app.core.logger import logger
+
+router = APIRouter(prefix="/payments", tags=["payments"])
+
+stripe.api_key = getattr(settings, "STRIPE_API_KEY", "sk_test_placeholder")
+webhook_secret = getattr(settings, "STRIPE_WEBHOOK_SECRET", "whsec_placeholder")
+
+@router.post("/webhook")
+async def stripe_webhook(request: Request):
+    payload = await request.body()
+    sig_header = request.headers.get("stripe-signature")
+
+    if not sig_header:
+        raise HTTPException(status_code=400, detail="Missing signature")
+
+    try:
+        event = stripe.Webhook.construct_event(
+            payload, sig_header, webhook_secret
+        )
+    except ValueError as e:
+        logger.error(f"Invalid payload: {e}")
+        raise HTTPException(status_code=400, detail="Invalid payload")
+    except stripe.error.SignatureVerificationError as e:
+        logger.error(f"Invalid signature: {e}")
+        raise HTTPException(status_code=400, detail="Invalid signature")
+
+    # Handle the event
+    if event.type == "checkout.session.completed":
+        session = event.data.object
+        logger.info(f"Payment successful for session {session.id}")
+        # TODO: Fulfill the purchase...
+
+    return {"status": "success"}
+
+@router.post("/create-checkout-session")
+async def create_checkout_session():
+    try:
+        checkout_session = stripe.checkout.Session.create(
+            line_items=[
+                {
+                    "price_data": {
+                        "currency": "usd",
+                        "product_data": {"name": "Pro Subscription"},
+                        "unit_amount": 2000,
+                    },
+                    "quantity": 1,
+                },
+            ],
+            mode="payment",
+            success_url="http://localhost:3000/success",
+            cancel_url="http://localhost:3000/cancel",
+        )
+        return {"url": checkout_session.url}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

fastapi_spawn-0.4.9/fastapi_spawn/templates/app/api/v1/streaming/router.py.j2

@@ -0,0 +1,26 @@
+from fastapi import APIRouter, Request, HTTPException
+from sse_starlette.sse import EventSourceResponse
+import asyncio
+
+router = APIRouter(prefix="/streaming", tags=["streaming"])
+
+async def message_generator():
+    """Simulates a stream of LLM tokens."""
+    tokens = ["Hello", " ", "there", "!", " ", "This", " ", "is", " ", "a", " ", "stream", "."]
+    for token in tokens:
+        await asyncio.sleep(0.1)  # Simulate processing delay
+        yield {
+            "event": "message",
+            "id": "message_id",
+            "retry": 15000,
+            "data": token
+        }
+    yield {"event": "done", "data": "[DONE]"}
+
+@router.get("/chat")
+async def stream_chat(request: Request):
+    """
+    Server-Sent Events endpoint for streaming chat responses.
+    Client can consume this using EventSource API in JS.
+    """
+    return EventSourceResponse(message_generator())

{fastapi_spawn-0.4.6 → fastapi_spawn-0.4.9}/fastapi_spawn/templates/app/core/email.py.j2

@@ -84,4 +84,27 @@ async def send_email(
     except ClientError:
         return False
 
+{% elif email == "resend" %}
+import resend
+
+
+async def send_email(
+    to: str,
+    subject: str,
+    html_content: str,
+    from_email: str | None = None,
+) -> bool:
+    """Send an email via Resend. Returns True on success."""
+    resend.api_key = settings.RESEND_API_KEY
+    try:
+        resend.Emails.send({
+            "from": from_email or settings.RESEND_FROM_EMAIL,
+            "to": to,
+            "subject": subject,
+            "html": html_content
+        })
+        return True
+    except Exception:
+        return False
+
 {% endif %}

fastapi_spawn-0.4.9/fastapi_spawn/templates/app/core/ocr.py.j2

@@ -0,0 +1,40 @@
+import io
+from typing import Optional
+try:
+    import fitz  # PyMuPDF
+except ImportError:
+    fitz = None
+
+try:
+    import pytesseract
+    from PIL import Image
+except ImportError:
+    pytesseract = None
+
+class OCRService:
+    """
+    Handles PDF parsing and Optical Character Recognition.
+    Requires `pymupdf` and `pytesseract` to be installed.
+    System requirement: `sudo apt install tesseract-ocr`
+    """
+    
+    @staticmethod
+    def extract_text_from_pdf(pdf_bytes: bytes) -> str:
+        """Extract text from a native PDF."""
+        if fitz is None:
+            raise RuntimeError("PyMuPDF is not installed. Run: pip install pymupdf")
+            
+        doc = fitz.open(stream=pdf_bytes, filetype="pdf")
+        text_chunks = []
+        for page in doc:
+            text_chunks.append(page.get_text())
+        return "\n".join(text_chunks)
+
+    @staticmethod
+    def extract_text_from_image(image_bytes: bytes) -> str:
+        """Perform OCR on an image."""
+        if pytesseract is None:
+            raise RuntimeError("pytesseract is not installed. Run: pip install pytesseract pillow")
+            
+        img = Image.open(io.BytesIO(image_bytes))
+        return pytesseract.image_to_string(img)

fastapi_spawn-0.4.9/fastapi_spawn/templates/app/core/search.py.j2

@@ -0,0 +1,23 @@
+import meilisearch
+from app.core.config import settings
+
+class MeilisearchService:
+    """
+    Client for Meilisearch — an open-source, lightning-fast, and hyper-relevant search engine.
+    """
+    def __init__(self):
+        host = getattr(settings, "MEILISEARCH_HOST", "http://localhost:7700")
+        api_key = getattr(settings, "MEILISEARCH_API_KEY", "masterKey")
+        self.client = meilisearch.Client(host, api_key)
+
+    def add_documents(self, index_name: str, documents: list[dict]):
+        """Add or update documents in an index."""
+        index = self.client.index(index_name)
+        return index.add_documents(documents)
+
+    def search(self, index_name: str, query: str, limit: int = 20):
+        """Perform a typo-tolerant search."""
+        index = self.client.index(index_name)
+        return index.search(query, {"limit": limit})
+
+search_client = MeilisearchService()

{fastapi_spawn-0.4.6 → fastapi_spawn-0.4.9}/fastapi_spawn/templates/base/pyproject.toml.j2

@@ -93,6 +93,8 @@ dependencies = [
 {% elif email == "ses" %}
     # Uses boto3 (already included above if has_s3, else add it)
     "boto3>=1.34.0",
+{% elif email == "resend" %}
+    "resend>=2.1.0",
 {% endif %}
 
 {% if has_notify %}
@@ -150,6 +152,28 @@ dependencies = [
 {% elif log_dest == "datadog" %}
     "datadog-lambda>=6.0.0",
 {% endif %}
+
+{% if extras %}
+{% if "stripe" in extras %}
+    "stripe>=9.0.0",
+{% endif %}
+{% if "sso" in extras %}
+    "fastapi-sso>=0.14.0",
+{% endif %}
+{% if "sse" in extras %}
+    "sse-starlette>=2.1.0",
+{% endif %}
+{% if "seed" in extras %}
+    "faker>=25.0.0",
+{% endif %}
+{% if "ocr" in extras %}
+    "pymupdf>=1.24.0",
+    "pytesseract>=0.3.10",
+{% endif %}
+{% if "meilisearch" in extras %}
+    "meilisearch>=0.30.0",
+{% endif %}
+{% endif %}
 ]
 
 [project.optional-dependencies]

fastapi_spawn-0.4.9/fastapi_spawn/templates/db/seed.py.j2

@@ -0,0 +1,61 @@
+import asyncio
+import logging
+from faker import Faker
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+fake = Faker()
+
+async def seed_database():
+    """
+    Seed the database with mock data.
+    Replace the stubs below with your actual database models and sessions.
+    """
+    logger.info("Seeding database...")
+    
+    # Example for SQLAlchemy:
+    # from app.db.session import async_session_maker
+    # from app.models.user import User
+    # from app.models.post import Post
+    # from app.models.comment import Comment
+    
+    # async with async_session_maker() as session:
+    #     users = []
+    #     # 1. Create Users
+    #     for _ in range(50):
+    #         user = User(
+    #             email=fake.email(),
+    #             full_name=fake.name(),
+    #             is_active=True
+    #         )
+    #         session.add(user)
+    #         users.append(user)
+    #     await session.commit()
+    #     
+    #     # 2. Create Posts
+    #     posts = []
+    #     for _ in range(200):
+    #         post = Post(
+    #             title=fake.sentence(),
+    #             content=fake.text(),
+    #             author_id=fake.random_element(elements=users).id
+    #         )
+    #         session.add(post)
+    #         posts.append(post)
+    #     await session.commit()
+    #
+    #     # 3. Create Comments
+    #     for _ in range(500):
+    #         comment = Comment(
+    #             text=fake.paragraph(),
+    #             post_id=fake.random_element(elements=posts).id,
+    #             user_id=fake.random_element(elements=users).id
+    #         )
+    #         session.add(comment)
+    #     await session.commit()
+
+    logger.info("Generated 50 mock users, 200 posts, and 500 comments (Stub)")
+    logger.info("Database seeding complete!")
+
+if __name__ == "__main__":
+    asyncio.run(seed_database())

{fastapi_spawn-0.4.6 → fastapi_spawn-0.4.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "fastapi-spawn"
-version = "0.4.6"
+version = "0.4.9"
 description = "A powerful CLI tool to scaffold production-ready FastAPI projects with flexible database, auth, broker, and deployment options."
 readme = "README.md"
 license = { text = "MIT" }