Made the intial files ready for the hf workflow

.env.example

@@ -0,0 +1,12 @@
+# Hugging Face Spaces Environment Variables
+# Copy this file to .env for local testing
+# On HF Spaces, set these as Space secrets
+
+# Full JSON content of config.json (paste the entire JSON as one line or use multiline)
+HF_CONFIG_JSON='{"google_sheets":{"enabled":true,"sync_interval_minutes":5,"credentials_file":"credentials.json","spreadsheets":[{"id":"YOUR_SPREADSHEET_ID_1","sheet_name":"processed_dialects","output_file":"sheets_output/processed_dialects.csv"},{"id":"YOUR_SPREADSHEET_ID_2","sheet_name":"digiwords_grouped","output_file":"sheets_output/digiwords_grouped.csv"}]},"file_watcher":{"enabled":true,"watch_directory":"sheets_output","file_patterns":["*.csv"]},"output":{"json_directory":"data/processed"}}'
+
+# Full JSON content of credentials.json (paste the entire service account JSON)
+HF_CREDENTIALS_JSON='{"type":"service_account","project_id":"your-project","private_key_id":"...","private_key":"-----BEGIN PRIVATE KEY-----\n...\n-----END PRIVATE KEY-----\n","client_email":"...@...iam.gserviceaccount.com","client_id":"...","auth_uri":"https://accounts.google.com/o/oauth2/auth","token_uri":"https://oauth2.googleapis.com/token","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs","client_x509_cert_url":"..."}'
+
+# Optional: Port for local development (HF Spaces uses 7860 by default)
+PORT=7860

.gitignore

@@ -31,6 +31,7 @@ token.json
 
 # Environment variables
 .env
+.env.local
 
 # IDE
 .vscode/

QUICKSTART.md

@@ -0,0 +1,109 @@
+# Quick Start Guide
+
+## For Local Development
+
+### 1. Install Dependencies
+
+```bash
+cd /home/kashikuldeep/Desktop/dialect-map
+
+# Install Python dependencies
+pip install -r requirements.txt
+# OR if you have externally managed Python:
+pipx install -r requirements.txt
+```
+
+### 2. Configure Secrets
+
+Choose ONE of these methods:
+
+#### Method A: Using actual config files (easier for local dev)
+
+```bash
+# Copy templates
+cp config.json.example config.json
+cp credentials.json.example credentials.json
+
+# Edit with your actual Google Cloud credentials
+nano config.json        # Update spreadsheet IDs
+nano credentials.json   # Paste your service account JSON
+```
+
+#### Method B: Using environment variables (simulates HF Spaces)
+
+```bash
+# Copy .env template
+cp .env.example .env
+
+# Edit .env with your actual JSON content
+nano .env
+
+# Set your actual spreadsheet IDs and credentials
+```
+
+### 3. Run the Application
+
+```bash
+# Start the app
+python3 app.py
+
+# Open your browser to:
+# http://localhost:7860/index.html
+```
+
+The app will:
+- ✅ Load secrets from environment or files
+- ✅ Start Google Sheets sync automation (every 5 minutes)
+- ✅ Serve the interactive map on port 7860
+
+---
+
+## For Hugging Face Spaces Deployment
+
+See **[SECRETS_SETUP.md](SECRETS_SETUP.md)** for complete deployment instructions.
+
+**Quick summary:**
+1. Create a new Space on Hugging Face
+2. Add two secrets in Space settings:
+   - `HF_CONFIG_JSON` - your entire config.json content
+   - `HF_CREDENTIALS_JSON` - your entire credentials.json content
+3. Push your code to the Space
+4. Access your live app!
+
+---
+
+## Files You Need
+
+| File | Purpose | How to Get |
+|------|---------|------------|
+| `config.json` | App configuration with spreadsheet IDs | Copy from `config.json.example` and edit |
+| `credentials.json` | Google service account credentials | Download from Google Cloud Console |
+
+**Important:** These files are in `.gitignore` - never commit them!
+
+---
+
+## Troubleshooting
+
+**"ModuleNotFoundError: No module named 'google'"**
+- Install dependencies: `pip install -r requirements.txt`
+
+**"HF_CONFIG_JSON not found"**
+- You need to either:
+  - Create `config.json` file locally, OR
+  - Set `HF_CONFIG_JSON` environment variable
+
+**"Credentials file not found"**
+- Follow [SECRETS_SETUP.md](SECRETS_SETUP.md) steps 1.1-1.4 to get credentials
+
+---
+
+## What Gets Created
+
+When you run `app.py`:
+- `config.json` - Created from `HF_CONFIG_JSON` env var (if set)
+- `credentials.json` - Created from `HF_CREDENTIALS_JSON` env var (if set)
+- `sheets_output/*.csv` - Downloaded from Google Sheets
+- `data/processed/*.json` - Converted from CSV files
+
+All of these are in `.gitignore` and safe to regenerate.

README.md

@@ -9,6 +9,22 @@
 - **Interactive Map**: Click districts to explore local vocabulary, meanings, and sources
 - **Rich Content**: 3000+ verified dialect terms from crowdsourced and JSONL data
 - **Zero Build Required**: Pure static site with automatic data loading
+- **Google Sheets Integration**: Automated synchronization with Google Sheets
+
+## 🚀 Deployment Options
+
+### Option 1: Hugging Face Spaces (Recommended for Public Access)
+
+Deploy to Hugging Face Spaces with continuous automation:
+
+1. **Create a Space** on [Hugging Face](https://huggingface.co/spaces)
+2. **Configure secrets** for `config.json` and `credentials.json`
+3. **Push your code** to the Space repository
+4. **Access your app** at `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE`
+
+📖 **[Complete HF Spaces Setup Guide →](SECRETS_SETUP.md)**
+
+### Option 2: Local Development
 
 ## 🚀 How to Run
 

SECRETS_SETUP.md

@@ -0,0 +1,361 @@
+# Hugging Face Spaces Secrets Setup Guide
+
+This guide explains how to configure and deploy your Telugu Dialect Map to Hugging Face Spaces with secure secrets management.
+
+## Overview
+
+Your application requires two secret files:
+- **`config.json`**: Configuration for Google Sheets sync and automation
+- **`credentials.json`**: Google Cloud service account credentials
+
+These files contain sensitive information and should NEVER be committed to git. Instead, we'll use Hugging Face Spaces **secrets** (environment variables) to store them securely.
+
+---
+
+## Step 1: Obtain Google Service Account Credentials
+
+### 1.1 Create a Google Cloud Project
+
+1. Go to [Google Cloud Console](https://console.cloud.google.com/)
+2. Create a new project or select an existing one
+3. Note your project ID
+
+### 1.2 Enable Google Sheets API
+
+1. In your project, go to **APIs & Services** → **Library**
+2. Search for "Google Sheets API"
+3. Click **Enable**
+
+### 1.3 Create a Service Account
+
+1. Go to **APIs & Services** → **Credentials**
+2. Click **Create Credentials** → **Service Account**
+3. Fill in the details:
+   - **Service account name**: `dialect-map-automation`
+   - **Service account ID**: (auto-generated)
+   - **Description**: "Service account for dialect map Google Sheets automation"
+4. Click **Create and Continue**
+5. Skip the optional steps (roles and user access)
+6. Click **Done**
+
+### 1.4 Create and Download Service Account Key
+
+1. Click on the service account you just created
+2. Go to the **Keys** tab
+3. Click **Add Key** → **Create new key**
+4. Select **JSON** format
+5. Click **Create**
+6. A JSON file will be downloaded - this is your `credentials.json`
+7. **Keep this file secure!** It provides full access to your Google Sheets
+
+### 1.5 Share Your Google Sheets with the Service Account
+
+1. Open your `credentials.json` file
+2. Find the `client_email` field (e.g., `dialect-map-automation@your-project.iam.gserviceaccount.com`)
+3. Copy this email address
+4. Open each Google Sheet you want to sync
+5. Click **Share** button
+6. Paste the service account email
+7. Give it **Editor** or **Viewer** access (Editor if you want to write data back)
+8. Click **Send**
+
+---
+
+## Step 2: Configure config.json
+
+Create your `config.json` file with your specific settings:
+
+```json
+{
+  "google_sheets": {
+    "enabled": true,
+    "sync_interval_minutes": 5,
+    "credentials_file": "credentials.json",
+    "spreadsheets": [
+      {
+        "id": "YOUR_ACTUAL_SPREADSHEET_ID_HERE",
+        "sheet_name": "processed_dialects",
+        "output_file": "sheets_output/processed_dialects.csv"
+      },
+      {
+        "id": "YOUR_ACTUAL_SPREADSHEET_ID_HERE",
+        "sheet_name": "digiwords_grouped",
+        "output_file": "sheets_output/digiwords_grouped.csv"
+      }
+    ]
+  },
+  "file_watcher": {
+    "enabled": true,
+    "watch_directory": "sheets_output",
+    "file_patterns": ["*.csv"]
+  },
+  "output": {
+    "json_directory": "data/processed"
+  }
+}
+```
+
+### Finding Your Spreadsheet ID
+
+Your Google Sheets URL looks like:
+```
+https://docs.google.com/spreadsheets/d/1AbC123XyZ456_Example_ID/edit#gid=0
+                                    ^^^^^^^^^^^^^^^^^^^^^^^^^
+                                    This is your spreadsheet ID
+```
+
+Copy the ID from your URL and replace `YOUR_ACTUAL_SPREADSHEET_ID_HERE` in the config.
+
+---
+
+## Step 3: Deploy to Hugging Face Spaces
+
+### 3.1 Create a New Space
+
+1. Go to [Hugging Face](https://huggingface.co/)
+2. Click your profile → **New Space**
+3. Fill in the details:
+   - **Space name**: `telugu-dialect-map` (or your choice)
+   - **License**: Choose appropriate license
+   - **Space SDK**: Select **Static** (we'll use a custom Python app)
+   - **Visibility**: Public or Private
+4. Click **Create Space**
+
+### 3.2 Push Your Code to the Space
+
+You can either:
+
+**Option A: Use Git**
+```bash
+# Clone the Space repository
+git clone https://huggingface.co/spaces/YOUR_USERNAME/telugu-dialect-map
+cd telugu-dialect-map
+
+# Copy your project files (excluding secrets!)
+cp -r /path/to/dialect-map/* .
+
+# Make sure .gitignore is in place
+cat .gitignore  # Should include config.json and credentials.json
+
+# Commit and push
+git add .
+git commit -m "Initial commit"
+git push
+```
+
+**Option B: Upload via Web Interface**
+1. In your Space, click **Files** tab
+2. Click **Add file** → **Upload files**
+3. Select all your project files (EXCEPT `config.json` and `credentials.json`)
+4. Click **Commit changes**
+
+### 3.3 Add Secrets to Your Space
+
+This is the **critical step** - we'll add your sensitive credentials as secrets.
+
+1. In your Space, click the **Settings** tab
+2. Scroll down to **Repository secrets**
+3. Add the following secrets:
+
+#### Secret 1: HF_CONFIG_JSON
+
+- **Name**: `HF_CONFIG_JSON`
+- **Value**: Paste the **entire contents** of your `config.json` file
+  
+  Example (all on one line):
+  ```
+  {"google_sheets":{"enabled":true,"sync_interval_minutes":5,"credentials_file":"credentials.json","spreadsheets":[{"id":"1AbC123XyZ456_Example","sheet_name":"processed_dialects","output_file":"sheets_output/processed_dialects.csv"}]},"file_watcher":{"enabled":true,"watch_directory":"sheets_output","file_patterns":["*.csv"]},"output":{"json_directory":"data/processed"}}
+  ```
+
+#### Secret 2: HF_CREDENTIALS_JSON
+
+- **Name**: `HF_CREDENTIALS_JSON`
+- **Value**: Paste the **entire contents** of your `credentials.json` file
+
+  Example (all on one line, with escaped newlines in private key):
+  ```
+  {"type":"service_account","project_id":"your-project","private_key_id":"abc123...","private_key":"-----BEGIN PRIVATE KEY-----\\nMIIEvQIB...\\n-----END PRIVATE KEY-----\\n","client_email":"name@project.iam.gserviceaccount.com",...}
+  ```
+
+4. Click **Add secret** for each one
+
+**Important Notes:**
+- The entire JSON must be on one line (no newlines except in the `private_key` field where `\n` should be `\\n`)
+- Make sure to escape special characters if needed
+- You can use a JSON minifier tool to compact your JSON
+
+### 3.4 Rebuild Your Space
+
+After adding secrets:
+1. Your Space should automatically rebuild
+2. Watch the **Logs** tab for any errors
+3. Once built, click **App** tab to view your running application
+
+---
+
+## Step 4: Verify Deployment
+
+### 4.1 Check Space Logs
+
+1. Go to your Space's **Logs** tab
+2. You should see:
+   ```
+   🔐 Loading secrets from environment variables...
+   ✅ Created config.json from HF_CONFIG_JSON secret
+   ✅ Created credentials.json from HF_CREDENTIALS_JSON secret
+   🚀 Starting automation runner...
+   ✅ Automation runner started
+   🌐 Starting web server on port 7860...
+   ```
+
+3. If you see errors, check:
+   - JSON formatting in your secrets
+   - Spreadsheet IDs are correct
+   - Service account has access to sheets
+
+### 4.2 Access Your Application
+
+1. Click the **App** tab
+2. You should see your Telugu Dialect Map interface
+3. The map should load with data from your Google Sheets
+
+### 4.3 Verify Automation
+
+1. Edit your Google Sheet (add/modify some dialect data)
+2. Wait 5 minutes (or your configured interval)
+3. Check the Space logs - you should see sync messages
+4. Refresh your app - changes should appear
+
+---
+
+## Troubleshooting
+
+### "HF_CONFIG_JSON not found in environment"
+
+**Problem**: The secret wasn't added or has the wrong name.
+
+**Solution**:
+1. Go to Space Settings → Repository secrets
+2. Verify the secret name is exactly `HF_CONFIG_JSON` (case-sensitive)
+3. Add it if missing
+4. Rebuild the Space
+
+### "Error parsing HF_CONFIG_JSON"
+
+**Problem**: The JSON is malformed.
+
+**Solution**:
+1. Copy your `config.json` content
+2. Use a JSON validator (e.g., [jsonlint.com](https://jsonlint.com/))
+3. Make sure it's valid JSON
+4. Remove all newlines (except `\n` in strings should become `\\n`)
+5. Update the secret with the corrected value
+
+### "Connection refused" or "Credentials invalid"
+
+**Problem**: Google service account credentials are wrong or not shared.
+
+**Solution**:
+1. Verify `credentials.json` content is correct
+2. Check that you shared your Google Sheets with the service account email
+3. Verify the Sheets API is enabled in Google Cloud Console
+4. Regenerate service account key if needed
+
+### "Automation not syncing"
+
+**Problem**: Automation runner isn't working.
+
+**Solution**:
+1. Check Space logs for error messages
+2. Verify `spreadsheets.id` values in config.json match your actual sheet IDs
+3. Verify `sheet_name` values match the tab names in your spreadsheets
+4. Check that service account has Editor access (not just Viewer)
+
+### Space keeps crashing or restarting
+
+**Problem**: HF Spaces free tier may have resource limits.
+
+**Solution**:
+1. Consider upgrading to a paid Space for guaranteed uptime
+2. Reduce sync interval (e.g., 15-30 minutes instead of 5)
+3. Check logs for memory/CPU issues
+
+---
+
+## Local Testing (Before Deploying)
+
+Before deploying to HF Spaces, test locally:
+
+### 1. Create actual config files
+
+```bash
+cd /home/kashikuldeep/Desktop/dialect-map
+
+# Copy examples and fill in real values
+cp config.json.example config.json
+cp credentials.json.example credentials.json
+
+# Edit with your actual values
+nano config.json
+nano credentials.json
+```
+
+### 2. Test the app
+
+```bash
+# Run the app locally
+python app.py
+
+# Should see:
+# ✅ Created config.json from HF_CONFIG_JSON secret (if using .env)
+# 🚀 Starting automation runner...
+# 🌐 Starting web server on port 7860...
+
+# Open browser to http://localhost:7860
+```
+
+### 3. Test with environment variables (simulating HF Spaces)
+
+```bash
+# Create .env file
+cp .env.example .env
+
+# Edit .env with your actual JSON (minified)
+nano .env
+
+# Load environment and run
+python -c "from dotenv import load_dotenv; load_dotenv()" && python app.py
+```
+
+---
+
+## Security Best Practices
+
+1. **Never commit secrets to git**
+   - Keep `config.json` and `credentials.json` in `.gitignore`
+   - Double-check before pushing code
+
+2. **Rotate credentials regularly**
+   - Generate new service account keys periodically
+   - Update HF Spaces secrets
+
+3. **Use minimal permissions**
+   - Service account should only have access to necessary sheets
+   - Use Viewer access if you don't need to write back
+
+4. **Monitor usage**
+   - Check Google Cloud Console for API usage
+   - Set up billing alerts
+   - Review Space logs regularly
+
+---
+
+## Need Help?
+
+- **Google Cloud Issues**: [Google Cloud Support](https://cloud.google.com/support)
+- **Hugging Face Spaces**: [HF Documentation](https://huggingface.co/docs/hub/spaces)
+- **Project Issues**: Check the Space logs first, then review this guide
+
+---
+
+**Happy Mapping! 🗺️**

app.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Spaces Entry Point
+This script:
+1. Loads secrets from HF Spaces environment variables
+2. Creates config.json and credentials.json from those secrets
+3. Starts the automation runner in the background
+4. Serves the static web interface
+"""
+
+import os
+import json
+import subprocess
+import signal
+import sys
+import time
+import threading
+from pathlib import Path
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from functools import partial
+
+# Configuration
+PORT = int(os.getenv('PORT', 7860))
+BASE_DIR = Path(__file__).parent
+AUTOMATION_RUNNER = BASE_DIR / "scripts" / "automation_runner.py"
+
+# Global process reference for cleanup
+automation_process = None
+
+
+def load_secrets_from_env():
+    """Load secrets from HF Spaces environment variables and create config files"""
+    print("🔐 Loading secrets from environment variables...")
+    
+    # Load config.json from environment
+    config_json_str = os.getenv('HF_CONFIG_JSON')
+    if config_json_str:
+        try:
+            config_data = json.loads(config_json_str)
+            config_file = BASE_DIR / "config.json"
+            with open(config_file, 'w') as f:
+                json.dump(config_data, f, indent=2)
+            print(f"✅ Created config.json from HF_CONFIG_JSON secret")
+        except json.JSONDecodeError as e:
+            print(f"❌ Error parsing HF_CONFIG_JSON: {e}")
+            sys.exit(1)
+    else:
+        config_file = BASE_DIR / "config.json"
+        if not config_file.exists():
+            print("⚠️  HF_CONFIG_JSON not found in environment")
+            print("⚠️  Please set HF_CONFIG_JSON secret in your Hugging Face Space settings")
+            print("⚠️  See SECRETS_SETUP.md for instructions")
+            # Don't exit - allow the app to run without automation
+    
+    # Load credentials.json from environment
+    credentials_json_str = os.getenv('HF_CREDENTIALS_JSON')
+    if credentials_json_str:
+        try:
+            credentials_data = json.loads(credentials_json_str)
+            credentials_file = BASE_DIR / "credentials.json"
+            with open(credentials_file, 'w') as f:
+                json.dump(credentials_data, f, indent=2)
+            print(f"✅ Created credentials.json from HF_CREDENTIALS_JSON secret")
+        except json.JSONDecodeError as e:
+            print(f"❌ Error parsing HF_CREDENTIALS_JSON: {e}")
+            sys.exit(1)
+    else:
+        credentials_file = BASE_DIR / "credentials.json"
+        if not credentials_file.exists():
+            print("⚠️  HF_CREDENTIALS_JSON not found in environment")
+            print("⚠️  Google Sheets sync will not work without credentials")
+    
+    print()
+
+
+def start_automation():
+    """Start the automation runner in the background"""
+    global automation_process
+    
+    # Check if automation script exists
+    if not AUTOMATION_RUNNER.exists():
+        print(f"⚠️  Automation runner not found: {AUTOMATION_RUNNER}")
+        return
+    
+    # Check if config exists
+    config_file = BASE_DIR / "config.json"
+    if not config_file.exists():
+        print("⚠️  config.json not found, skipping automation startup")
+        return
+    
+    print("🚀 Starting automation runner...")
+    try:
+        automation_process = subprocess.Popen(
+            [sys.executable, str(AUTOMATION_RUNNER)],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1
+        )
+        
+        # Stream automation output in a separate thread
+        def stream_output():
+            for line in automation_process.stdout:
+                print(f"[AUTOMATION] {line}", end='')
+        
+        threading.Thread(target=stream_output, daemon=True).start()
+        print("✅ Automation runner started\n")
+    except Exception as e:
+        print(f"❌ Failed to start automation: {e}\n")
+
+
+def cleanup(signum=None, frame=None):
+    """Cleanup function to terminate background processes"""
+    global automation_process
+    print("\n\n🛑 Shutting down...")
+    
+    if automation_process:
+        print("🧹 Stopping automation runner...")
+        automation_process.terminate()
+        automation_process.wait(timeout=5)
+    
+    print("✅ Cleanup complete\n")
+    sys.exit(0)
+
+
+class CustomHTTPRequestHandler(SimpleHTTPRequestHandler):
+    """Custom handler to serve from the correct directory"""
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, directory=str(BASE_DIR), **kwargs)
+    
+    def log_message(self, format, *args):
+        """Custom logging to show requests"""
+        print(f"[WEB] {self.address_string()} - {format % args}")
+
+
+def start_web_server():
+    """Start the HTTP server to serve the static files"""
+    print(f"🌐 Starting web server on port {PORT}...")
+    
+    handler = CustomHTTPRequestHandler
+    httpd = HTTPServer(('0.0.0.0', PORT), handler)
+    
+    print(f"✅ Web server running at http://0.0.0.0:{PORT}")
+    print(f"📊 Open the map: http://0.0.0.0:{PORT}/index.html")
+    print(f"💡 Press Ctrl+C to stop\n")
+    
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        httpd.shutdown()
+
+
+def main():
+    """Main entry point"""
+    print("=" * 70)
+    print("🗺️  Telugu Dialect Map - Hugging Face Spaces")
+    print("=" * 70)
+    print()
+    
+    # Register signal handlers for graceful shutdown
+    signal.signal(signal.SIGINT, cleanup)
+    signal.signal(signal.SIGTERM, cleanup)
+    
+    # Load secrets from environment variables
+    load_secrets_from_env()
+    
+    # Start background automation
+    start_automation()
+    
+    # Give automation a moment to start
+    time.sleep(2)
+    
+    # Start web server (blocks here)
+    start_web_server()
+    
+    # Cleanup (if we ever get here)
+    cleanup()
+
+
+if __name__ == "__main__":
+    main()

config.json.example

@@ -0,0 +1,27 @@
+{
+  "google_sheets": {
+    "enabled": true,
+    "sync_interval_minutes": 5,
+    "credentials_file": "credentials.json",
+    "spreadsheets": [
+      {
+        "id": "YOUR_SPREADSHEET_ID_1_HERE",
+        "sheet_name": "processed_dialects",
+        "output_file": "sheets_output/processed_dialects.csv"
+      },
+      {
+        "id": "YOUR_SPREADSHEET_ID_2_HERE",
+        "sheet_name": "digiwords_grouped",
+        "output_file": "sheets_output/digiwords_grouped.csv"
+      }
+    ]
+  },
+  "file_watcher": {
+    "enabled": true,
+    "watch_directory": "sheets_output",
+    "file_patterns": ["*.csv"]
+  },
+  "output": {
+    "json_directory": "data/processed"
+  }
+}

credentials.json.example

@@ -0,0 +1,12 @@
+{
+  "type": "service_account",
+  "project_id": "your-project-id",
+  "private_key_id": "your-private-key-id",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nYOUR_PRIVATE_KEY_HERE\n-----END PRIVATE KEY-----\n",
+  "client_email": "your-service-account@your-project.iam.gserviceaccount.com",
+  "client_id": "your-client-id",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/your-service-account%40your-project.iam.gserviceaccount.com"
+}