app.py

#!pip install -q specklepy


# lone github repro & add to sys paths
import gradio as gr
import sys
import time
import os
# delete (if it already exists) , clone repro
#!rm -rf  RECODE_speckle_utils
#!git clone  https://github.com/SerjoschDuering/RECODE_speckle_utils
#sys.path.append('/content/RECODE_speckle_utils')

# import from repro
"""
import speckle_utils
import data_utils
import plots_utils
import color_maps
"""
import requests

from specklepy.api.client import SpeckleClient
from specklepy.api.credentials import get_default_account, get_local_accounts
from specklepy.transports.server import ServerTransport
from specklepy.api import operations
from specklepy.objects.geometry import Polyline, Point
import specklepy

import pandas as pd
import requests
import datetime
import json






def extract_branch_info(stream_id, server_url=None, token=None):
    if server_url and token:
        client = SpeckleClient(host=server_url)
        client.authenticate_with_token(token=token)
    else:
        account = get_default_account()
        client = SpeckleClient(host=account.serverUrl)
        client.authenticate(token=account.token)

    branches = client.branch.list(stream_id, 100)

    branch_info = []

    for branch in branches:
        branch_data = {
            "Name": branch.name,
            "description": branch.description,
            "url": f"{server_url}/streams/{stream_id}/branches/{branch.name.replace('/', '%2F').replace('+', '%2B')}"
            
        }

        # Determine sub-variant
        #if branch.name.startswith(("template_geometry", "graph_geometry")):
        if '+' in branch.name:
            slash_index = branch.name.rfind('/')
            plus_index = branch.name.find('+', slash_index)
            sub_variant = branch.name[slash_index + 1:plus_index]
        else:
            sub_variant = "default"
        branch_data["sub-variant"] = sub_variant

        # Get commits for the branch
        
        #try:
        commits = client.branch.get(stream_id, branch.name).commits.items
        if commits:
            latest_commit = commits[0]
            branch_data["updated"] = latest_commit.createdAt
            branch_data["commit_url"] = f"{server_url}/streams/{stream_id}/commits/{latest_commit.id}"
            branch_data["commit_message"] = latest_commit.message
            branch_data["author"] = latest_commit.authorName
        #except Exception as e:
         #   print(f"Error fetching commits for branch {branch.name}: {str(e)}")

        branch_info.append(branch_data)

    return branch_info



def sync_to_notion(token, database_id, branch_data):
    base_url = "https://api.notion.com/v1"
    headers = {
        "Authorization": f"Bearer {token}",
        "Notion-Version": "2022-06-28",
        "Content-Type": "application/json"
    }

    try:
        # Fetch existing data from Notion database
        response = requests.post(f"{base_url}/databases/{database_id}/query", headers=headers)
        response.raise_for_status()
        pages = response.json().get('results', [])
        
        # Create a dictionary for the latest update time of each branch
        latest_updates = {branch['Name']: branch.get('updated', '') for branch in branch_data}

        # Status color mapping
        status_colors = {
            "outdated": "red",
            "up-to-date": "green",
            "empty": "gray"
        }

        # Process each branch and update or create Notion rows
        for branch in branch_data:
            # Find the corresponding page in Notion
            page_id = None
            existing_depends_on = []
            for page in pages:
                notion_name = page['properties']['Name']['title'][0]['text']['content'] if page['properties']['Name']['title'] else ''
                if notion_name == branch['Name']:
                    page_id = page['id']
                    # Retain the existing value of "depends-on"
                    existing_depends_on = [dep['name'] for dep in page['properties'].get('depends-on', {}).get('multi_select', [])]
                    break
            
            # Determine status based on dependencies
            latest_update = latest_updates.get(branch['Name'], '')
            outdated = False
            if existing_depends_on:
                for dep_name in existing_depends_on:
                    if dep_name in latest_updates and latest_updates[dep_name] > latest_update:
                        outdated = True
                        break
            if not latest_update:
                status_tag = "empty"
            elif outdated:
                status_tag = "outdated"
            else:
                status_tag = "up-to-date"

            # Prepare data for updating or creating a page
            print (branch.get("url", ""))
            updated_value = branch.get("updated")
            if isinstance(updated_value, datetime):
                updated_isoformat = updated_value.isoformat()
            else:
                updated_isoformat = datetime.now().isoformat()

            page_data = {
                "properties": {
                    "Name": {"title": [{"text": {"content": branch['Name']}}]},
                    "status-tag": {"select": {"name": status_tag}},  # Assuming 'select' type
                    "status": {"rich_text": [{"text": {"content": "Status: " + status_tag}}]},
                    "url": {"url": branch.get("url", "")},
                    "updated": {"date": {"start": updated_isoformat}},
                    "description": {"rich_text": [{"text": {"content": str(branch.get("description", ""))}}]},
                    "sub-variant": {"rich_text": [{"text": {"content": branch.get("sub-variant", "")}}]},
                    "author": {"rich_text": [{"text": {"content": branch.get("author", "")}}]},
                    "commit_message": {"rich_text": [{"text": {"content": branch.get("commit_message", "")}}]},
                    "depends-on": {"multi_select": [{"name": d} for d in existing_depends_on]}
                }
            }

            # Update an existing page or create a new one
            if page_id:
                update_url = f"{base_url}/pages/{page_id}"
                response = requests.patch(update_url, headers=headers, data=json.dumps(page_data))
            else:
                create_page_data = {
                    "parent": {"database_id": database_id},
                    **page_data
                }
                response = requests.post(f"{base_url}/pages", headers=headers, data=json.dumps(create_page_data))

            response.raise_for_status()

        print("Data synced to Notion successfully.")

    except requests.exceptions.HTTPError as errh:
        print("Http Error:", errh)
    except requests.exceptions.ConnectionError as errc:
        print("Error Connecting:", errc)
    except requests.exceptions.Timeout as errt:
        print("Timeout Error:", errt)
    except requests.exceptions.RequestException as err:
        print("Something went wrong", err)

        
# Wrapper function for the Gradio interface
def run_sync():
    # Define your token, database_id, and branch_data
    token = "your_token"
    database_id = "your_database_id"
    branch_data =  extract_branch_info(stream_id, server_url=None, token=None)

    # Call your function
    sync_to_notion(token, database_id, branch_data)

    return "Sync completed successfully!"

# branch_data = extract_branch_info("287b605243", server_url="https://speckle.xyz/", token="52566d1047b881764e16ad238356abeb2fc35d8b42")
# sync_to_notion("secret_V2olY3GMsTLaC910Ym20xT9RnBfoDdrAwXb1ayBupXI", "402d60c9c1ef4980a3d85c5a4f4a0c97", branch_data)

# Predefined dictionaries of streams to update
streams = {
    "2B_100": {
        "stream": "https://speckle.xyz/streams/287b605243",
        "notionDB": '402d60c9c1ef4980a3d85c5a4f4a0c97'
    },
    "2B_U100": {
        "stream": "https://speckle.xyz/streams/ebcfc50abe",
        "notionDB": '00c3a26a119f487fa028c1ed404f22ba'
    }
}

# Function to run on button click
def update_streams(dummy):
    speckle_token = os.environ.get("SPECKLE_TOKEN")
    notion_token = os.environ.get("NOTION_TOKEN")

    client = SpeckleClient(host="https://speckle.xyz/")
    client.authenticate_with_token(token=speckle_token)
    print("not", notion_token)
    print("spec", speckle_token)
    for key, value in streams.items():
        stream_url = value["stream"]
        notion_db = value["notionDB"]
        stream_id = stream_url.split('/')[-1]

        branch_data = extract_branch_info(stream_id, server_url=stream_url, token=speckle_token)
        sync_to_notion(notion_token, notion_db, branch_data)

    return "All streams updated successfully!"

# Create Gradio interface
iface = gr.Interface(
    fn=update_streams,
    inputs=gr.components.Button(value="Update Streams"),
    outputs="text",
)

# Launch the app
iface.launch()