sync_script.py

#!/usr/bin/env python3
import os
import json
import logging
import sqlite3
import asyncio
import aiohttp
from datetime import datetime

# Set up logging for Lilith Business Network
logging.basicConfig(level=logging.INFO, format='%(asctime)s - LILITH SYSTEMS LLC - %(levelname)s - %(message)s')

DB_PATH = "/dev/shm/grok_ram_cache/golem_diary.db"
CREDENTIALS_FILE = "/home/tehlappy/Desktop/AI/business/google_credentials.json"

class LilithBusinessSync:
    def __init__(self):
        self.accounts = {
            "The Driver Man": {"status": "Pending", "metrics": {}},
            "Lilith Systems LLC": {"status": "Pending", "metrics": {}}
        }
        self._init_db()

    def _init_db(self):
        """Ensure the golem_diary.db has the tables needed to track our real-world logistics."""
        # Ensure the directory exists before trying to create/connect to DB
        os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
        with sqlite3.connect(DB_PATH, timeout=30.0, isolation_level="IMMEDIATE") as conn:
            conn.execute('PRAGMA journal_mode=WAL;')
            conn.execute('PRAGMA busy_timeout=30000;')
            conn.execute('PRAGMA synchronous=NORMAL;')
            conn.execute('''
                CREATE TABLE IF NOT EXISTS business_metrics (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    entity_name TEXT,
                    metric_type TEXT,
                    metric_value REAL,
                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                )
            ''')
        logging.info("Business Metrics table verified in golem_diary.db")

    async def authenticate_google_workspace(self, session: aiohttp.ClientSession):
        """Stub for Google OAuth2 Authentication."""
        if not os.path.exists(CREDENTIALS_FILE):
            logging.warning("Google credentials not found. Generating template...")
            os.makedirs(os.path.dirname(CREDENTIALS_FILE), exist_ok=True)
            with open(CREDENTIALS_FILE, 'w') as f:
                json.dump({"client_id": "YOUR_GOOGLE_CLIENT_ID", "client_secret": "YOUR_SECRET"}, f, indent=4)
            logging.info(f"Please fill out {CREDENTIALS_FILE} to sync live Google data.")
            return False
        
        # Simulate non-blocking network I/O authentication
        await asyncio.sleep(0.1)
        logging.info("Google Workspace authentication simulated successfully.")
        return True

    async def sync_the_driver_man(self, session: aiohttp.ClientSession):
        """Pull delivery metrics, reviews, and route data for The Driver Man."""
        logging.info("Syncing [The Driver Man] Google Business Profile...")
        
        # Simulate non-blocking network I/O
        await asyncio.sleep(0.5)
        
        # Simulated data payload from Google Business APIs
        payload = {
            "deliveries_completed": 42,
            "average_rating": 4.9,
            "door_dash_intercepts": 15,
            "eurodollars_generated": 1250.00
        }
        
        self.accounts["The Driver Man"]["metrics"] = payload
        self.accounts["The Driver Man"]["status"] = "Synced"
        
        # Run SQLite blocking DB commit in the default executor to prevent event loop blocking
        loop = asyncio.get_running_loop()
        await loop.run_in_executor(None, self._log_metrics, "The Driver Man", payload)
        
    async def sync_lilith_systems_llc(self, session: aiohttp.ClientSession):
        """Pull B2B AI consulting metrics and infrastructure status."""
        logging.info("Syncing [Lilith Systems LLC] Google Business Profile...")
        
        # Simulate non-blocking network I/O
        await asyncio.sleep(0.5)
        
        # Simulated data payload from Google Business APIs
        payload = {
            "active_clients": 3,
            "compute_cycles_sold": 15000,
            "system_uptime": 99.99,
            "eurodollars_generated": 3500.00
        }
        
        self.accounts["Lilith Systems LLC"]["metrics"] = payload
        self.accounts["Lilith Systems LLC"]["status"] = "Synced"
        
        # Run SQLite blocking DB commit in the default executor to prevent event loop blocking
        loop = asyncio.get_running_loop()
        await loop.run_in_executor(None, self._log_metrics, "Lilith Systems LLC", payload)

    def _log_metrics(self, entity, metrics):
        """Write the synced data directly into Lilith's persistent RAM-staged memory."""
        data = [(entity, metric, float(value)) for metric, value in metrics.items()]
        with sqlite3.connect(DB_PATH, timeout=30.0, isolation_level="IMMEDIATE") as conn:
            conn.executemany(
                "INSERT INTO business_metrics (entity_name, metric_type, metric_value) VALUES (?, ?, ?)",
                data
            )
        logging.info(f"Metrics for {entity} successfully committed to Golem Diary.")

    async def run_sync_loop(self):
        async with aiohttp.ClientSession() as session:
            if await self.authenticate_google_workspace(session):
                # Run syncs concurrently
                await asyncio.gather(
                    self.sync_the_driver_man(session),
                    self.sync_lilith_systems_llc(session)
                )
                
                logging.info("================ SYNC COMPLETE ================")
                print(json.dumps(self.accounts, indent=4))
            else:
                logging.error("Sync aborted. Waiting for valid Google OAuth credentials.")

if __name__ == "__main__":
    sync_agent = LilithBusinessSync()
    asyncio.run(sync_agent.run_sync_loop())