datasette-libfec 0.0.1a4__py3-none-any.whl → 0.0.1a6__py3-none-any.whl

datasette_libfec/manifest.json

@@ -1,11 +1,93 @@
 {
+  "_class-C5DDKbJD.js": {
+    "file": "static/gen/class-C5DDKbJD.js",
+    "name": "class"
+  },
+  "_each-DkfQbqzj.js": {
+    "file": "static/gen/each-DkfQbqzj.js",
+    "name": "each",
+    "imports": [
+      "_load-AXKAVXVj.js"
+    ]
+  },
+  "_index-client-CDwZ_Ixa.js": {
+    "file": "static/gen/index-client-CDwZ_Ixa.js",
+    "name": "index-client",
+    "imports": [
+      "_load-AXKAVXVj.js"
+    ]
+  },
+  "_load-AXKAVXVj.js": {
+    "file": "static/gen/load-AXKAVXVj.js",
+    "name": "load"
+  },
+  "src/candidate_view.ts": {
+    "file": "static/gen/candidate-tqxa29G-.js",
+    "name": "candidate",
+    "src": "src/candidate_view.ts",
+    "isEntry": true,
+    "imports": [
+      "_load-AXKAVXVj.js",
+      "_each-DkfQbqzj.js",
+      "_class-C5DDKbJD.js"
+    ],
+    "css": [
+      "static/gen/candidate-BEqDafKu.css"
+    ]
+  },
+  "src/committee_view.ts": {
+    "file": "static/gen/committee-DY1GmylW.js",
+    "name": "committee",
+    "src": "src/committee_view.ts",
+    "isEntry": true,
+    "imports": [
+      "_load-AXKAVXVj.js",
+      "_each-DkfQbqzj.js"
+    ],
+    "css": [
+      "static/gen/committee-Bmki9iKb.css"
+    ]
+  },
+  "src/contest_view.ts": {
+    "file": "static/gen/contest-BbYrzKRg.js",
+    "name": "contest",
+    "src": "src/contest_view.ts",
+    "isEntry": true,
+    "imports": [
+      "_load-AXKAVXVj.js",
+      "_each-DkfQbqzj.js",
+      "_class-C5DDKbJD.js"
+    ],
+    "css": [
+      "static/gen/contest-D4Fj7kGA.css"
+    ]
+  },
+  "src/filing_detail_view.ts": {
+    "file": "static/gen/filing_detail-D2ib3OM6.js",
+    "name": "filing_detail",
+    "src": "src/filing_detail_view.ts",
+    "isEntry": true,
+    "imports": [
+      "_load-AXKAVXVj.js",
+      "_index-client-CDwZ_Ixa.js"
+    ],
+    "css": [
+      "static/gen/filing_detail-Ba6_iQwV.css"
+    ]
+  },
   "src/index_view.ts": {
-    "file": "static/gen/index-CaTQMY-X.js",
+    "file": "static/gen/index-AHqus2fd.js",
     "name": "index",
     "src": "src/index_view.ts",
     "isEntry": true,
+    "imports": [
+      "_load-AXKAVXVj.js",
+      "_index-client-CDwZ_Ixa.js",
+      "_each-DkfQbqzj.js",
+      "_class-C5DDKbJD.js"
+    ],
     "css": [
-      "static/gen/index-6cjSv2YC.css"
+      "static/gen/index-jv9_YIKt.css"
     ]
   }
 }

datasette_libfec/page_data.py

@@ -0,0 +1,87 @@
+from pydantic import BaseModel
+
+
+class Candidate(BaseModel):
+    candidate_id: str
+    name: str | None = None
+    party_affiliation: str | None = None
+    state: str | None = None
+    office: str | None = None
+    district: str | None = None
+    incumbent_challenger_status: str | None = None
+    principal_campaign_committee: str | None = None
+    address_street1: str | None = None
+    address_street2: str | None = None
+    address_city: str | None = None
+    address_state: str | None = None
+    address_zip: str | None = None
+    cycle: int | None = None
+
+
+class Committee(BaseModel):
+    committee_id: str
+    name: str | None = None
+    committee_type: str | None = None
+    designation: str | None = None
+    candidate_id: str | None = None
+    party_affiliation: str | None = None
+    filing_frequency: str | None = None
+    address_street1: str | None = None
+    address_street2: str | None = None
+    address_city: str | None = None
+    address_state: str | None = None
+    address_zip: str | None = None
+    treasurer_name: str | None = None
+    cycle: int | None = None
+
+
+class Filing(BaseModel):
+    filing_id: str
+    cover_record_form: str | None = None
+    filer_id: str | None = None
+    filer_name: str | None = None
+    coverage_from_date: str | None = None
+    coverage_through_date: str | None = None
+
+
+class CandidatePageData(BaseModel):
+    candidate_id: str
+    cycle: int
+    candidate: Candidate | None = None
+    committee: Committee | None = None
+    filings: list[Filing] = []
+    error: str | None = None
+
+
+class CommitteePageData(BaseModel):
+    committee_id: str
+    cycle: int
+    committee: Committee | None = None
+    candidate: Candidate | None = None
+    filings: list[Filing] = []
+    error: str | None = None
+
+
+class ContestPageData(BaseModel):
+    state: str
+    office: str
+    district: str | None = None
+    cycle: int
+    contest_description: str
+    candidates: list[Candidate] = []
+    error: str | None = None
+
+
+class FilingDetailPageData(BaseModel):
+    filing_id: str
+    filing: Filing | None = None
+    form_data: dict | None = None
+    database_name: str
+    error: str | None = None
+
+
+class IndexPageData(BaseModel):
+    database_name: str
+
+
+__exports__ = [CandidatePageData, CommitteePageData, ContestPageData, FilingDetailPageData, IndexPageData]

datasette_libfec/router.py

@@ -0,0 +1,24 @@
+from datasette import Forbidden
+from datasette_plugin_router import Router
+from functools import wraps
+
+router = Router()
+
+LIBFEC_ACCESS_NAME = "datasette_libfec_access"
+
+# decorator for routes, to ensure the proper permissions are checked
+def check_permission():
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(datasette, request, **kwargs):
+            result = await datasette.allowed(
+                action=LIBFEC_ACCESS_NAME, actor=request.actor
+            )
+            if not result:
+                raise Forbidden("Permission denied for datasette-libfec access")
+            return await func(datasette=datasette, request=request, **kwargs)
+
+        return wrapper
+
+    return decorator
+

datasette_libfec/routes_export.py

@@ -0,0 +1,128 @@
+from pydantic import BaseModel
+from datasette import Response
+from datasette_plugin_router import Body
+from typing import Optional, List
+import asyncio
+import uuid
+
+from .router import router, check_permission
+from .state import libfec_client, export_state
+
+
+class ExportStartParams(BaseModel):
+    filings: Optional[List[str]] = None
+    cycle: Optional[int] = None
+    cover_only: bool = False
+    clobber: bool = False
+
+
+class ExportResponse(BaseModel):
+    status: str
+    message: str
+    export_id: Optional[str] = None
+    phase: Optional[str] = None
+
+
+@router.POST("/-/api/libfec/export/start", output=ExportResponse)
+@check_permission()
+async def export_start(datasette, request, params: Body[ExportStartParams]):
+    if export_state.running:
+        return Response.json({
+            "status": "error",
+            "message": "Export already in progress",
+            "phase": export_state.phase
+        }, status=400)
+
+    # Get output database
+    output_db = None
+    for name, db in datasette.databases.items():
+        if not db.is_memory:
+            output_db = db
+            break
+    if output_db is None:
+        return Response.json({
+            "status": "error",
+            "message": "No writable database found."
+        }, status=500)
+
+    # Start export in background task
+    async def run_export():
+        await libfec_client.export_with_progress(
+            output_db=output_db.path,
+            filings=params.filings,
+            cycle=params.cycle,
+            cover_only=params.cover_only,
+            clobber=params.clobber,
+            export_state=export_state
+        )
+
+    export_state.export_id = f"export-{uuid.uuid4()}"
+    asyncio.create_task(run_export())
+
+    # Give it a moment to start
+    await asyncio.sleep(0.1)
+
+    return Response.json(
+        ExportResponse(
+            status="success",
+            message="Export started",
+            export_id=export_state.export_id,
+            phase=export_state.phase
+        ).model_dump()
+    )
+
+
+@router.GET("/-/api/libfec/export/status", output=ExportResponse)
+@check_permission()
+async def export_status(datasette, request):
+    response_data = {
+        "status": "success",
+        "message": "Export status",
+        "export_id": export_state.export_id,
+        "phase": export_state.phase,
+    }
+
+    # Add additional fields based on phase
+    if export_state.phase in ("sourcing", "downloading_bulk", "exporting"):
+        response_data["completed"] = export_state.completed
+        response_data["total"] = export_state.total
+
+        if export_state.phase == "downloading_bulk" and export_state.current:
+            response_data["current"] = export_state.current
+        elif export_state.phase == "exporting" and export_state.current_filing_id:
+            response_data["current_filing_id"] = export_state.current_filing_id
+
+    elif export_state.phase == "complete":
+        response_data["total_exported"] = export_state.total_exported
+        response_data["warnings"] = export_state.warnings
+
+    elif export_state.phase == "error":
+        response_data["error_message"] = export_state.error_message
+
+    return Response.json(response_data)
+
+
+@router.POST("/-/api/libfec/export/cancel", output=ExportResponse)
+@check_permission()
+async def export_cancel(datasette, request):
+    if not export_state.running:
+        return Response.json({
+            "status": "error",
+            "message": "No export in progress"
+        }, status=400)
+
+    # Cancel RPC export if in progress
+    if export_state.rpc_client:
+        try:
+            await export_state.rpc_client.export_cancel()
+        except Exception as e:
+            print(f"Error canceling RPC export: {e}")
+
+    return Response.json(
+        ExportResponse(
+            status="success",
+            message="Export canceled",
+            export_id=export_state.export_id,
+            phase="canceled"
+        ).model_dump()
+    )

datasette_libfec/routes_exports.py

@@ -0,0 +1,222 @@
+from pydantic import BaseModel
+from datasette import Response
+from typing import Optional, List, Literal
+
+from .router import router, check_permission
+
+
+class ExportRecord(BaseModel):
+    export_id: int
+    export_uuid: str
+    created_at: str
+    filings_count: int
+    cover_only: bool
+    status: str
+    error_message: Optional[str] = None
+
+
+class ExportFilingRecord(BaseModel):
+    filing_id: str
+    success: bool
+    message: Optional[str] = None
+
+
+class ExportInputRecord(BaseModel):
+    id: int
+    input_type: str
+    input_value: str
+    cycle: Optional[int] = None
+    office: Optional[str] = None
+    state: Optional[str] = None
+    district: Optional[str] = None
+    filing_ids: List[str] = []
+
+
+class ExportDetailResponse(BaseModel):
+    export: ExportRecord
+    inputs: List[ExportInputRecord]
+    filings: List[ExportFilingRecord]
+
+
+class ApiExportsListResponse(BaseModel):
+    status: Literal['success']
+    exports: List[ExportRecord]
+    message: Optional[str] = None
+
+@router.GET("/-/api/libfec/exports$", output=ApiExportsListResponse)
+@check_permission()
+async def list_exports(datasette, request):
+    """List all export operations from the metadata tables"""
+    db = datasette.get_database()
+
+    # Check if the table exists
+    try:
+        tables = await db.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='libfec_exports'")
+        if not tables.first():
+            return Response.json({
+                "status": "success",
+                "exports": [],
+                "message": "No exports yet"
+            })
+    except Exception as e:
+        return Response.json({
+            "status": "error",
+            "message": f"Database error: {str(e)}"
+        }, status=500)
+
+    try:
+        exports_result = await db.execute("""
+            SELECT
+                export_id,
+                export_uuid,
+                created_at,
+                filings_count,
+                cover_only,
+                status,
+                error_message
+            FROM libfec_exports
+            ORDER BY created_at DESC
+            LIMIT 50
+        """)
+
+        exports = []
+        for row in exports_result.rows:
+            exports.append({
+                "export_id": row[0],
+                "export_uuid": row[1],
+                "created_at": row[2],
+                "filings_count": row[3],
+                "cover_only": bool(row[4]),
+                "status": row[5],
+                "error_message": row[6]
+            })
+        return Response.json(ApiExportsListResponse(
+            status="success",
+            exports=exports
+        ).model_dump_json())
+
+
+    except Exception as e:
+        return Response.json({
+            "status": "error",
+            "message": f"Failed to fetch exports: {str(e)}"
+        }, status=500)
+
+
+@router.GET("/-/api/libfec/exports/(?P<export_id>\\d+)")
+@check_permission()
+async def get_export_detail(datasette, request, export_id: str):
+    """Get detailed information about a specific export"""
+    db = datasette.get_database()
+    export_id_int = int(export_id)
+
+    try:
+        # Get export record
+        export_result = await db.execute("""
+            SELECT
+                export_id,
+                export_uuid,
+                created_at,
+                filings_count,
+                cover_only,
+                status,
+                error_message
+            FROM libfec_exports
+            WHERE export_id = ?
+        """, [export_id_int])
+
+        export_row = export_result.first()
+        if not export_row:
+            return Response.json({
+                "status": "error",
+                "message": "Export not found"
+            }, status=404)
+
+        export = {
+            "export_id": export_row[0],
+            "export_uuid": export_row[1],
+            "created_at": export_row[2],
+            "filings_count": export_row[3],
+            "cover_only": bool(export_row[4]),
+            "status": export_row[5],
+            "error_message": export_row[6]
+        }
+
+        # Get inputs with their resolved filing IDs
+        inputs = []
+        try:
+            inputs_result = await db.execute("""
+                SELECT
+                    i.id,
+                    i.input_type,
+                    i.input_value,
+                    i.cycle,
+                    i.office,
+                    i.state,
+                    i.district
+                FROM libfec_export_inputs i
+                WHERE i.export_id = ?
+                ORDER BY i.id
+            """, [export_id_int])
+
+            for row in inputs_result.rows:
+                input_record = {
+                    "id": row[0],
+                    "input_type": row[1],
+                    "input_value": row[2],
+                    "cycle": row[3],
+                    "office": row[4],
+                    "state": row[5],
+                    "district": row[6],
+                    "filing_ids": []
+                }
+
+                # Get filing IDs for this input
+                filings_for_input = await db.execute("""
+                    SELECT filing_id
+                    FROM libfec_export_input_filings
+                    WHERE input_id = ?
+                """, [row[0]])
+
+                input_record["filing_ids"] = [f[0] for f in filings_for_input.rows]
+                inputs.append(input_record)
+
+        except Exception:
+            # Table might not exist
+            pass
+
+        # Get filings with their success/failure status
+        filings = []
+        try:
+            filings_result = await db.execute("""
+                SELECT
+                    filing_id,
+                    success,
+                    message
+                FROM libfec_export_filings
+                WHERE export_id = ?
+                ORDER BY filing_id
+            """, [export_id_int])
+
+            for row in filings_result.rows:
+                filings.append({
+                    "filing_id": row[0],
+                    "success": bool(row[1]),
+                    "message": row[2]
+                })
+        except Exception:
+            # Table might not exist
+            pass
+
+        return Response.json({
+            "status": "success",
+            "export": export,
+            "inputs": inputs,
+            "filings": filings
+        })
+
+    except Exception as e:
+        return Response.json({
+            "status": "error",
+            "message": f"Failed to fetch export detail: {str(e)}"
+        }, status=500)