Create app.py

app.py

@@ -0,0 +1,239 @@
+import os
+import io
+import time
+import tempfile
+from typing import Optional, Tuple, List
+
+import matplotlib.pyplot as plt
+import gradio as gr
+
+# Google Drive (service account)
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaIoBaseUpload
+from google.oauth2.service_account import Credentials
+
+
+# --------- Config ---------
+DEFAULT_EXTENT = (119.0, 123.5, 21.5, 25.5)  # (min_lon, max_lon, min_lat, max_lat) ~ Taiwan region
+SCOPES = ["https://www.googleapis.com/auth/drive.file"]  # minimal scope to create files you own
+
+
+def _parse_points(csv_text: str) -> List[Tuple[float, float]]:
+    """
+    Accepts lines like:
+        121.5,25.0
+        120.9,24.5
+        121.0,23.9
+    (lon,lat). Ignores blank/comment lines.
+    """
+    pts = []
+    if not csv_text:
+        return pts
+    for ln in csv_text.strip().splitlines():
+        ln = ln.strip()
+        if not ln or ln.startswith("#"):
+            continue
+        # allow "lon,lat" or "lat,lon" if user toggles a flag later (we keep lon,lat only here for simplicity)
+        parts = [p.strip() for p in ln.replace("\t", ",").split(",")]
+        if len(parts) < 2:
+            continue
+        try:
+            lon = float(parts[0])
+            lat = float(parts[1])
+            pts.append((lon, lat))
+        except ValueError:
+            # skip invalid rows
+            continue
+    return pts
+
+
+def _make_figure(
+    points: List[Tuple[float, float]],
+    title: str,
+    extent: Tuple[float, float, float, float] = DEFAULT_EXTENT,
+    dpi: int = 150,
+) -> str:
+    """
+    Draw a simple lon/lat scatter within the extent.
+    Returns path to the saved PNG.
+    """
+    min_lon, max_lon, min_lat, max_lat = extent
+    fig, ax = plt.subplots(figsize=(6.5, 6.5), dpi=dpi)
+    ax.set_title(title or "Map Plot", pad=10)
+    ax.set_xlabel("Longitude")
+    ax.set_ylabel("Latitude")
+
+    # Axes extent
+    ax.set_xlim(min_lon, max_lon)
+    ax.set_ylim(min_lat, max_lat)
+    ax.grid(True, linestyle=":", linewidth=0.8)
+
+    # Light background box suggesting region
+    rect = plt.Rectangle(
+        (min_lon, min_lat),
+        max_lon - min_lon,
+        max_lat - min_lat,
+        fill=False,
+        linestyle="--",
+        linewidth=1.0,
+    )
+    ax.add_patch(rect)
+
+    # Plot points
+    if points:
+        xs = [p[0] for p in points]
+        ys = [p[1] for p in points]
+        ax.scatter(xs, ys, s=60, marker="*", label="Input points")
+        ax.legend(loc="upper right")
+
+    # Save to a temporary PNG
+    tmpdir = tempfile.gettempdir()
+    ts = int(time.time())
+    filename = f"map_{ts}.png"
+    out_path = os.path.join(tmpdir, filename)
+    fig.tight_layout()
+    fig.savefig(out_path)
+    plt.close(fig)
+    return out_path
+
+
+def _drive_service_from_env() -> Optional[object]:
+    """
+    Build a Google Drive service using a service account JSON
+    provided via the Hugging Face Space secret `SERVICE_ACCOUNT_JSON`.
+    """
+    sa_json = os.environ.get("SERVICE_ACCOUNT_JSON", "").strip()
+    if not sa_json:
+        return None
+
+    # In Spaces secrets, you typically paste the **full** JSON string of the service account.
+    # Load it into Credentials directly via from_service_account_info.
+    import json
+    try:
+        info = json.loads(sa_json)
+    except Exception:
+        return None
+
+    creds = Credentials.from_service_account_info(info, scopes=SCOPES)
+    service = build("drive", "v3", credentials=creds, cache_discovery=False)
+    return service
+
+
+def _upload_to_drive(
+    local_path: str,
+    service,
+    folder_id: Optional[str] = None,
+) -> Tuple[str, str]:
+    """
+    Uploads local file to Google Drive.
+    Returns (file_id, webViewLink)
+    """
+    fname = os.path.basename(local_path)
+    file_metadata = {"name": fname}
+    if folder_id:
+        file_metadata["parents"] = [folder_id]
+
+    with open(local_path, "rb") as f:
+        media = MediaIoBaseUpload(f, mimetype="image/png", resumable=False)
+        created = (
+            service.files()
+            .create(body=file_metadata, media_body=media, fields="id, webViewLink, webContentLink")
+            .execute()
+        )
+
+    file_id = created.get("id", "")
+    web_view_link = created.get("webViewLink", "")
+    return file_id, web_view_link
+
+
+def generate_and_upload(
+    points_text: str,
+    title: str,
+    min_lon: float,
+    max_lon: float,
+    min_lat: float,
+    max_lat: float,
+    drive_folder_id_input: str,
+):
+    """
+    Gradio handler:
+      1) parse points
+      2) make figure
+      3) upload to Drive (if configured)
+      4) return preview image and link
+    """
+    points = _parse_points(points_text)
+    extent = (min_lon, max_lon, min_lat, max_lat)
+    local_png = _make_figure(points, title, extent=extent)
+
+    # Build Drive service from env
+    service = _drive_service_from_env()
+    if service is None:
+        # Tell user how to set up secrets
+        msg = (
+            "⚠️ Google Drive upload is not configured. "
+            "Please add a Hugging Face Space secret named `SERVICE_ACCOUNT_JSON` "
+            "with your service account JSON. Optionally add `DRIVE_FOLDER_ID`."
+        )
+        # Return just the preview, no link
+        return local_png, msg
+
+    # Determine folder ID (priority: user input > env)
+    folder_id_env = os.environ.get("DRIVE_FOLDER_ID", "").strip()
+    folder_id = (drive_folder_id_input or folder_id_env or "").strip() or None
+
+    try:
+        file_id, view_link = _upload_to_drive(local_png, service, folder_id=folder_id)
+        link_text = f"✅ Uploaded to Google Drive.\n• File ID: `{file_id}`\n• Open: {view_link}"
+        return local_png, link_text
+    except Exception as e:
+        return local_png, f"❌ Upload failed: {e}"
+
+
+# ----------------- Gradio UI -----------------
+with gr.Blocks(title="Map → Google Drive Uploader") as demo:
+    gr.Markdown(
+        """
+# 🗺️ Map → Google Drive Uploader
+Paste lon,lat pairs (one per line), set the extent, and click **Generate & Upload**.
+
+**Note:** To enable Google Drive upload in this Space, add the secret `SERVICE_ACCOUNT_JSON` (full service account JSON)  
+and optionally `DRIVE_FOLDER_ID` in the Space settings.
+        """
+    )
+
+    with gr.Row():
+        with gr.Column():
+            points_in = gr.Textbox(
+                label="Points (lon,lat per line)",
+                value="121.5,25.0\n120.9,24.5\n121.0,23.9",
+                lines=8,
+                placeholder="e.g.\n121.5,25.0\n120.9,24.5",
+            )
+            title_in = gr.Textbox(label="Map title", value="Taiwan Points Example")
+
+            with gr.Accordion("Map extent (lon/lat bounds)", open=False):
+                min_lon_in = gr.Number(label="min_lon", value=DEFAULT_EXTENT[0])
+                max_lon_in = gr.Number(label="max_lon", value=DEFAULT_EXTENT[1])
+                min_lat_in = gr.Number(label="min_lat", value=DEFAULT_EXTENT[2])
+                max_lat_in = gr.Number(label="max_lat", value=DEFAULT_EXTENT[3])
+
+            folder_id_in = gr.Textbox(
+                label="Google Drive Folder ID (optional — overrides Space secret)",
+                placeholder="e.g. 1AbCdEfGhIJKlmnopQRstuVWxyz",
+            )
+
+            run_btn = gr.Button("🚀 Generate & Upload")
+
+        with gr.Column():
+            out_image = gr.Image(label="Preview", type="filepath")
+            out_msg = gr.Markdown(label="Result / Link")
+
+    run_btn.click(
+        fn=generate_and_upload,
+        inputs=[points_in, title_in, min_lon_in, max_lon_in, min_lat_in, max_lat_in, folder_id_in],
+        outputs=[out_image, out_msg],
+    )
+
+if __name__ == "__main__":
+    demo.launch()