c1groupy 0.3.0__py3-none-any.whl

c1gpy/fastapi_project_files/.gitignore

@@ -0,0 +1,82 @@
+# Project-specific
+*secret*
+*secret*/
+*.json
+*.xlsx
+*.xml
+*.csv
+*cache*
+*.zip
+input/
+data_files/
+duckdb
+.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Distribution / packaging
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv/
+
+# Testing
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+.nox/
+*.cover
+.hypothesis/
+
+# Type checking
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.pytype/
+.pyre/
+
+# IDEs
+.DS_Store
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.project
+.pydevproject
+.settings/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Documentation
+docs/_build/
+site/
+
+# Streamlit
+.streamlit/

c1gpy/fastapi_project_files/.pre-commit-config.yaml

@@ -0,0 +1,43 @@
+# pre commit hook config
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+    - id: check-yaml
+      stages: [pre-commit]
+    - id: end-of-file-fixer
+      stages: [pre-commit]
+    - id: trailing-whitespace
+      stages: [pre-commit]
+    - id: detect-private-key
+      stages: [pre-commit]
+    - id: check-added-large-files
+      stages: [pre-commit]
+
+-   repo: https://github.com/python-poetry/poetry
+    rev: 2.1.1
+    hooks:
+    - id: poetry-check
+      stages: [pre-commit]
+    - id: poetry-lock
+      stages: [pre-commit]
+
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  # Ruff version.
+  rev: v0.11.2
+  hooks:
+    # Run the linter.
+    - id: ruff
+      args: [ --fix]
+    # Run the formatter.
+    - id: ruff-format
+
+# pre push needs install of podman & podman-compose
+-   repo: local
+    hooks:
+    - id: run-unit-tests
+      name: Run unit tests in container
+      entry:  bash -c 'PYTEST=TRUE  podman-compose up --build --force-recreate --remove-orphans'
+      language: system
+      stages: [pre-push]
+      verbose: true

c1gpy/fastapi_project_files/Dockerfile

@@ -0,0 +1,47 @@
+FROM python:3.12-slim AS builder
+
+WORKDIR /app
+
+# Install uv
+RUN pip install --no-cache-dir uv
+
+# Copy only dependency files first
+COPY pyproject.toml ./
+
+# Install dependencies using uv
+RUN uv pip install --system -e .
+
+# use multi stage for smaller image size
+FROM python:3.12-slim
+
+LABEL author="{author_email}"
+
+WORKDIR /app
+
+# Copy uv and installed packages from builder
+COPY --from=builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
+COPY --from=builder /usr/local/bin /usr/local/bin
+
+# Create non-root user
+RUN useradd -m -u 1000 appuser
+
+# Copy project files
+COPY pyproject.toml ./
+COPY src/ ./src/
+COPY tests/ ./tests/
+
+# Change ownership of src and tests to appuser
+RUN chown -R appuser:appuser /app/src /app/tests
+
+# Make entrypoint executable
+RUN chmod +x /app/src/entrypoint.sh
+
+# Switch to non-root user
+USER appuser
+
+# Set default environment variables
+ENV LOCALRUN=FALSE
+ENV PYTEST=FALSE
+
+#needs $PORT $LOCALRUN $PYTEST
+ENTRYPOINT ["/app/src/entrypoint.sh"]

c1gpy/fastapi_project_files/README.md.template

@@ -0,0 +1,161 @@
+# {project_name}
+
+A FastAPI application with organized router structure.
+
+## Project Structure
+
+```
+{project_name}/
+├── src/
+│   ├── api_interface.py    # Main FastAPI app
+│   ├── routers/            # API routers
+│   │   ├── router1.py
+│   │   └── router2.py
+│   ├── endpoints/          # Endpoint logic
+│   │   ├── router1/
+│   │   │   └── example_endpoint.py
+│   │   └── router2/
+│   │       └── example_endpoint.py
+│   └── entrypoint.sh       # Container entrypoint script
+├── tests/                  # Test files
+├── Dockerfile              # Docker configuration
+├── docker-compose.yml      # Docker Compose configuration
+├── pyproject.toml          # Project dependencies
+├── .pre-commit-config.yaml # Pre-commit hooks
+└── .gitignore              # Git ignore rules
+```
+
+## Getting Started
+
+### Local Development (with uv)
+
+1. Install dependencies:
+```bash
+uv sync
+```
+
+2. Run the application:
+```bash
+uv run hypercorn src.api_interface:rest_api --bind :8000 --reload
+```
+
+The API will be available at:
+- **API**: http://localhost:8000
+- **Interactive Docs**: http://localhost:8000/docs
+- **ReDoc**: http://localhost:8000/redoc
+
+### Docker Development
+
+1. Build and run with Docker Compose:
+```bash
+docker-compose up --build --force-recreate --remove-orphans
+```
+
+The application will be available at http://localhost:8000
+
+The `LOCALRUN=TRUE` environment variable enables hot-reloading for development.
+
+### Production Deployment
+
+For production, set `LOCALRUN=FALSE` in the docker-compose.yml or use the Dockerfile directly:
+
+```bash
+docker build -t {project_name} .
+docker run -p 8000:8000 -e LOCALRUN=FALSE -e PORT=8000 {project_name}
+```
+
+## Running Tests
+
+### Locally
+```bash
+uv run pytest tests/
+```
+
+### In Docker
+```bash
+docker-compose run -e PYTEST=TRUE fastapi-app
+```
+
+## API Structure
+
+### Routers
+
+Routers are defined in `src/routers/` and organize related endpoints:
+
+- **router1.py**: Example router with basic CRUD operations
+- **router2.py**: Example router with data processing endpoints
+
+### Endpoints
+
+Endpoint logic is separated into `src/endpoints/` for better organization:
+
+- **router1/**: Business logic for router1 endpoints
+- **router2/**: Business logic for router2 endpoints
+
+### Adding New Endpoints
+
+1. Create endpoint logic in `src/endpoints/router_name/`:
+```python
+# src/endpoints/router1/new_endpoint.py
+async def get_data() -> dict:
+    return {{"data": "example"}}
+```
+
+2. Add route in `src/routers/router1.py`:
+```python
+from endpoints.router1 import new_endpoint
+
+@router.get("/data")
+async def get_data():
+    return await new_endpoint.get_data()
+```
+
+### Adding New Routers
+
+1. Create router file in `src/routers/router3.py`:
+```python
+from fastapi import APIRouter
+
+router = APIRouter(prefix="/router3", tags=["router3"])
+
+@router.get("/example")
+async def example():
+    return {{"message": "Hello from router3"}}
+```
+
+2. Register in `src/api_interface.py`:
+```python
+from routers import router1, router2, router3
+
+rest_api.include_router(router3.router)
+```
+
+## API Security
+
+The template includes commented-out API key authentication:
+
+```python
+# Uncomment in routers to enable
+from fastapi.security import APIKeyHeader
+api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+@router.get("/secure")
+async def secure_endpoint(api_key: str = Security(api_key_header)):
+    # Validate api_key
+    return {{"secure": "data"}}
+```
+
+## Environment Variables
+
+- `PORT`: Port for the API server (default: 8000)
+- `LOCALRUN`: Set to `TRUE` for development mode with hot-reloading (default: `FALSE`)
+- `PYTEST`: Set to `TRUE` to run tests instead of the app (default: `FALSE`)
+
+## Pre-commit Hooks
+
+Install pre-commit hooks:
+```bash
+pre-commit install
+```
+
+This will run linting and formatting checks before each commit.

c1gpy/fastapi_project_files/docker-compose.yml

@@ -0,0 +1,12 @@
+services:
+  fastapi-app:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - LOCALRUN=TRUE
+      - PYTEST=FALSE
+      - PORT=8000
+    volumes:
+      - ./src:/app/src
+    restart: unless-stopped

c1gpy/fastapi_project_files/pyproject.toml.template

@@ -0,0 +1,21 @@
+[project]
+name = "{project_name}"
+version = "0.1.0"
+description = "A FastAPI application"
+authors = [
+    {{email = "{author_email}"}},
+]
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi>=0.115.0",
+    "hypercorn[uvloop]>=0.17.0",
+    "pytest>=8.0.0",
+    "httpx>=0.27.0",
+]
+
+[tool.uv]
+dev-dependencies = []
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

c1gpy/fastapi_project_files/src/api_interface.py

@@ -0,0 +1,55 @@
+"""Main FastAPI application interface."""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from routers import router1, router2
+
+# Initialize FastAPI app
+rest_api = FastAPI(
+    title="{project_name}",
+    description="FastAPI application with multiple routers",
+    version="0.1.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    contact={
+        {
+            "email": "{author_email}",
+        }
+    },
+)
+
+# Configure CORS
+rest_api.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+rest_api.include_router(router1.router)
+rest_api.include_router(router2.router)
+
+
+@rest_api.get("/")
+async def root() -> dict:
+    """
+    Root endpoint.
+
+    Returns:
+        dict: Welcome message
+    """
+    return {{"message": "Welcome to {{project_name}}", "docs": "/docs"}}
+
+
+@rest_api.get("/health")
+async def health_check() -> dict:
+    """
+    Health check endpoint.
+
+    Returns:
+        dict: Health status
+    """
+    return {{"status": "healthy", "service": "{{project_name}}"}}

c1gpy/fastapi_project_files/src/endpoints/router1/example_endpoint.py

@@ -0,0 +1,24 @@
+"""Example endpoint for router1."""
+
+
+async def get_example_data() -> dict:
+    """
+    Example async endpoint function.
+
+    Returns:
+        dict: Example data
+    """
+    return {"message": "Hello from router1", "status": "success"}
+
+
+async def create_example_item(item_data: dict) -> dict:
+    """
+    Example async POST endpoint function.
+
+    Args:
+        item_data: Data for the new item
+
+    Returns:
+        dict: Created item with ID
+    """
+    return {"id": 1, "data": item_data, "status": "created"}

c1gpy/fastapi_project_files/src/endpoints/router2/example_endpoint.py

@@ -0,0 +1,24 @@
+"""Example endpoint for router2."""
+
+
+async def get_status() -> dict:
+    """
+    Example async endpoint function.
+
+    Returns:
+        dict: Status information
+    """
+    return {"status": "healthy", "service": "router2"}
+
+
+async def process_data(data: dict) -> dict:
+    """
+    Example async data processing endpoint.
+
+    Args:
+        data: Input data to process
+
+    Returns:
+        dict: Processed result
+    """
+    return {"processed": True, "input": data, "result": "processed successfully"}

c1gpy/fastapi_project_files/src/entrypoint.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+## Main script for starting up FastAPI WSGI server or tests in a container
+
+# Redirect stderr to stdout for better logging
+exec 2>&1
+
+if [ "${PYTEST}" = 'TRUE' ]
+then
+    python -m pytest -v tests/  # run Pytest framework
+else # run FastAPI
+    if [ "${LOCALRUN}" = 'TRUE' ]
+    then
+        python -m hypercorn api_interface:rest_api --bind :$PORT --reload --workers 4 --worker-class uvloop # run with reload for local dev
+    else
+          python -m hypercorn api_interface:rest_api --bind :$PORT --workers 4 --worker-class uvloop
+    fi
+fi

c1gpy/fastapi_project_files/src/routers/router1.py

@@ -0,0 +1,53 @@
+"""Router1 - Example API routes."""
+
+from fastapi import APIRouter  # , Security
+# from fastapi.security import APIKeyHeader
+
+from endpoints.router1 import example_endpoint
+
+router = APIRouter(prefix="/router1", tags=["router1"])
+
+# Uncomment to enable API key authentication
+# api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+
+@router.get("/example")
+async def get_example() -> dict:
+    """
+    Get example data.
+
+    Returns:
+        dict: Example response
+    """
+    return await example_endpoint.get_example_data()
+
+
+@router.post("/items")
+async def create_item(item_data: dict) -> dict:
+    """
+    Create a new item.
+
+    Args:
+        item_data: Item data to create
+
+    Returns:
+        dict: Created item
+    """
+    return await example_endpoint.create_example_item(item_data)
+
+
+# Example with API key security (commented out)
+# @router.get("/secure")
+# async def secure_endpoint(api_key: str = Security(api_key_header)):
+#     """
+#     Secure endpoint requiring API key.
+#
+#     Args:
+#         api_key: API key from header
+#
+#     Returns:
+#         dict: Secure data
+#     """
+#     if api_key != "your-secret-key":
+#         raise HTTPException(status_code=403, detail="Invalid API key")
+#     return {"message": "Access granted", "secure_data": "sensitive information"}

c1gpy/fastapi_project_files/src/routers/router2.py

@@ -0,0 +1,36 @@
+"""Router2 - Example API routes."""
+
+from fastapi import APIRouter  # , Security
+# from fastapi.security import APIKeyHeader
+
+from endpoints.router2 import example_endpoint
+
+router = APIRouter(prefix="/router2", tags=["router2"])
+
+# Uncomment to enable API key authentication
+# api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+
+@router.get("/status")
+async def get_status() -> dict:
+    """
+    Get service status.
+
+    Returns:
+        dict: Status information
+    """
+    return await example_endpoint.get_status()
+
+
+@router.post("/process")
+async def process_data(data: dict) -> dict:
+    """
+    Process input data.
+
+    Args:
+        data: Data to process
+
+    Returns:
+        dict: Processing result
+    """
+    return await example_endpoint.process_data(data)

c1gpy/fastapi_project_files/tests/test_example.py

@@ -0,0 +1,33 @@
+from fastapi.testclient import TestClient
+
+from api_interface import rest_api
+
+client = TestClient(rest_api)
+
+
+def test_root():
+    """Test root endpoint."""
+    response = client.get("/")
+    assert response.status_code == 200
+    assert "message" in response.json()
+
+
+def test_health_check():
+    """Test health check endpoint."""
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json()["status"] == "healthy"
+
+
+def test_router1_example():
+    """Test router1 example endpoint."""
+    response = client.get("/router1/example")
+    assert response.status_code == 200
+    assert response.json()["status"] == "success"
+
+
+def test_router2_status():
+    """Test router2 status endpoint."""
+    response = client.get("/router2/status")
+    assert response.status_code == 200
+    assert response.json()["status"] == "healthy"