Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tracklight_server/tracklight.db filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,7 @@
+
+FROM python:3.9-slim
+WORKDIR /app
+COPY ./tracklight_server /app/tracklight_server
+RUN pip install "tracklight @ git+https://github.com/your_username/your_repo.git" # Replace with your repo
+EXPOSE 7860
+CMD ["uvicorn", "tracklight_server.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,5 @@
----
-title: Tracklight
-emoji: 🏢
-colorFrom: purple
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+---
+title: Tracklight Server
+sdk: docker
+---

tracklight_server/api/artifacts.py

@@ -0,0 +1,43 @@
+# tracklight_server/api/artifacts.py
+
+from fastapi import APIRouter, Depends, UploadFile, File
+from fastapi.responses import FileResponse
+from .auth import verify_token
+import os
+import shutil
+
+router = APIRouter()
+
+# Get the absolute path to the artifacts directory
+SERVER_DIR = os.path.dirname(os.path.dirname(__file__))
+ARTIFACTS_DIR = os.path.join(SERVER_DIR, "artifacts")
+
+# Create artifacts directory if it doesn't exist
+os.makedirs(ARTIFACTS_DIR, exist_ok=True)
+
+@router.post("/upload/{run_id}")
+async def upload_artifact(run_id: str, file: UploadFile = File(...), token: str = Depends(verify_token)):
+    """
+    Uploads an artifact file for a given run.
+    """
+    run_artifact_dir = os.path.join(ARTIFACTS_DIR, run_id)
+    os.makedirs(run_artifact_dir, exist_ok=True)
+    
+    file_path = os.path.join(run_artifact_dir, file.filename)
+    
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+        
+    return {"filename": file.filename, "run_id": run_id}
+
+@router.get("/download/{run_id}/{filename}")
+async def download_artifact(run_id: str, filename: str, token: str = Depends(verify_token)):
+    """
+    Downloads an artifact file for a given run.
+    """
+    file_path = os.path.join(ARTIFACTS_DIR, run_id, filename)
+    
+    if not os.path.exists(file_path):
+        return {"error": "File not found"}
+        
+    return FileResponse(file_path)

tracklight_server/api/auth.py

@@ -0,0 +1,21 @@
+# tracklight_server/api/auth.py
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+import os
+
+# This is a simple example of a bearer token.
+# In a real application, you would use a more secure method.
+API_TOKEN = os.environ.get("TRACKLIGHT_API_TOKEN", "secret-token")
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+def verify_token(token: str = Depends(oauth2_scheme)):
+    """Verifies the provided bearer token."""
+    if token != API_TOKEN:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return token

tracklight_server/api/dashboard.py

@@ -0,0 +1,47 @@
+# tracklight_server/api/dashboard.py
+
+from fastapi import APIRouter, Depends, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from ..db import duckdb
+from .auth import verify_token
+import os
+
+router = APIRouter()
+
+# Get the absolute path to the templates directory
+SERVER_DIR = os.path.dirname(os.path.dirname(__file__))
+TEMPLATES_DIR = os.path.join(SERVER_DIR, "templates")
+templates = Jinja2Templates(directory=TEMPLATES_DIR)
+
+@router.get("/login", response_class=HTMLResponse)
+async def get_login_page(request: Request):
+    """
+    Serves the login page.
+    """
+    return templates.TemplateResponse("login.html", {"request": request})
+
+@router.get("/dashboard", response_class=HTMLResponse)
+async def get_dashboard(request: Request):
+    """
+    Serves the main dashboard page with a list of projects.
+    """
+    projects = duckdb.get_projects()
+    return templates.TemplateResponse("project_list.html", {"request": request, "projects": projects})
+
+@router.get("/project/{project_name}", response_class=HTMLResponse)
+async def get_project_page(request: Request, project_name: str, user: str):
+    """
+    Serves the project-specific page with a list of runs.
+    """
+    runs = duckdb.get_runs(project_name, user)
+    return templates.TemplateResponse("dashboard.html", {"request": request, "project": project_name, "user": user, "runs": runs})
+
+@router.get("/api/metrics")
+async def get_metrics(run_id: str, token: str = Depends(verify_token)):
+    """
+    Returns metrics and config for a given run.
+    """
+    metrics = duckdb.get_metrics_for_run(run_id)
+    config = duckdb.get_config_for_run(run_id)
+    return {"metrics": metrics, "config": config}

tracklight_server/api/ingest.py

@@ -0,0 +1,44 @@
+# tracklight_server/api/ingest.py
+
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List
+from pydantic import BaseModel
+from ..db import duckdb
+from .auth import verify_token
+
+router = APIRouter()
+
+class Metric(BaseModel):
+    run_id: str
+    project: str
+    user: str
+    metric_name: str
+    value: float
+    timestamp: str
+
+class Config(BaseModel):
+    run_id: str
+    config_name: str
+    value: str
+
+@router.post("/log", status_code=200)
+def log_metrics(metrics: List[Metric], token: str = Depends(verify_token)):
+    """
+    Receives a list of metrics and logs them to the database.
+    """
+    try:
+        duckdb.insert_metrics([metric.dict() for metric in metrics])
+        return {"message": "Metrics logged successfully."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/log_config", status_code=200)
+def log_config(configs: List[Config], token: str = Depends(verify_token)):
+    """
+    Receives a list of config values and logs them to the database.
+    """
+    try:
+        duckdb.insert_config([config.dict() for config in configs])
+        return {"message": "Configs logged successfully."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

tracklight_server/api/sync.py

@@ -0,0 +1,34 @@
+# tracklight_server/api/sync.py
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from ..hf import push, pull
+from .auth import verify_token
+
+router = APIRouter()
+
+class SyncRequest(BaseModel):
+    repo_id: str
+    hf_token: str
+
+@router.post("/sync/push")
+async def sync_push(request: SyncRequest, token: str = Depends(verify_token)):
+    """
+    Pushes local data to a Hugging Face Dataset repo.
+    """
+    try:
+        push.push_to_hub(request.repo_id, request.hf_token)
+        return {"message": "Data push initiated."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/sync/pull")
+async def sync_pull(request: SyncRequest, token: str = Depends(verify_token)):
+    """
+    Pulls data from a Hugging Face Dataset repo.
+    """
+    try:
+        pull.pull_from_hub(request.repo_id, request.hf_token)
+        return {"message": "Data pull initiated."}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

tracklight_server/db/duckdb.py

@@ -0,0 +1,87 @@
+# tracklight_server/db/duckdb.py
+
+import duckdb
+import os
+
+DB_FILE = "tracklight.db"
+TABLE_NAME = "metrics"
+
+# Define the database path in the user's home directory
+HOME_DIR = os.path.expanduser("~")
+TRACKLIGHT_DIR = os.path.join(HOME_DIR, ".tracklight")
+DB_PATH = os.path.join(TRACKLIGHT_DIR, DB_FILE)
+
+# Ensure the .tracklight directory exists
+os.makedirs(TRACKLIGHT_DIR, exist_ok=True)
+
+def get_connection():
+    """Returns a connection to the DuckDB database."""
+    return duckdb.connect(DB_PATH)
+
+def create_tables():
+    """Creates the metrics and config tables if they don't exist."""
+    with get_connection() as con:
+        con.execute(f"""
+            CREATE TABLE IF NOT EXISTS {TABLE_NAME} (
+                run_id VARCHAR,
+                project VARCHAR,
+                user_name VARCHAR,
+                metric_name VARCHAR,
+                value DOUBLE,
+                timestamp TIMESTAMP
+            )
+        """)
+        con.execute("""
+            CREATE TABLE IF NOT EXISTS config (
+                run_id VARCHAR,
+                config_name VARCHAR,
+                value VARCHAR
+            )
+        """)
+
+def insert_metrics(metrics: list):
+    """Inserts a list of metrics into the database."""
+    with get_connection() as con:
+        con.executemany(f"INSERT INTO {TABLE_NAME} VALUES (?, ?, ?, ?, ?, ?)", 
+                        [(m['run_id'], m['project'], m['user'], m['metric_name'], m['value'], m['timestamp']) for m in metrics])
+
+def insert_config(configs: list):
+    """Inserts a list of config values into the database."""
+    with get_connection() as con:
+        con.executemany("INSERT INTO config VALUES (?, ?, ?)", 
+                        [(c['run_id'], c['config_name'], c['value']) for c in configs])
+
+def get_projects():
+    """Retrieves all projects with their creation timestamp."""
+    with get_connection() as con:
+        return con.execute(f"""
+            SELECT project, MIN(timestamp) as creation_time
+            FROM {TABLE_NAME}
+            GROUP BY project
+            ORDER BY creation_time DESC
+        """).fetchall()
+
+def get_runs(project: str, user: str):
+    """Retrieves all runs for a given project and user, sorted by the most recent timestamp."""
+    with get_connection() as con:
+        return con.execute(f"""
+            SELECT run_id 
+            FROM {TABLE_NAME} 
+            WHERE project = ? AND user_name = ?
+            GROUP BY run_id
+            ORDER BY MAX(timestamp) DESC
+        """, [project, user]).fetchall()
+
+def get_metrics_for_run(run_id: str):
+    """Retrieves all metrics for a given run, excluding config parameters."""
+    with get_connection() as con:
+        return con.execute(f"SELECT metric_name, value, timestamp FROM {TABLE_NAME} WHERE run_id = ? AND metric_name NOT LIKE 'config/%' ORDER BY timestamp", [run_id]).fetchall()
+
+def get_config_for_run(run_id: str):
+    """Retrieves all configuration parameters for a given run."""
+    with get_connection() as con:
+        return con.execute(f"SELECT config_name, value FROM config WHERE run_id = ?", [run_id]).fetchall()
+
+
+# Initialize the database
+create_tables()

tracklight_server/hf/pull.py

@@ -0,0 +1,40 @@
+# tracklight_server/hf/pull.py
+
+from datasets import load_dataset
+from huggingface_hub import HfFolder
+from ..db import duckdb
+
+def pull_from_hub(repo_id: str, hf_token: str):
+    """
+    Pulls data from a Hugging Face Dataset repo and merges it into the local DuckDB.
+    """
+    # Authenticate with Hugging Face
+    HfFolder.save_token(hf_token)
+
+    try:
+        # Load the dataset from the Hub
+        dataset = load_dataset(repo_id)
+    except Exception as e:
+        print(f"Failed to load dataset from {repo_id}: {e}")
+        return
+
+    if 'train' not in dataset:
+        print(f"No 'train' split found in the dataset {repo_id}.")
+        return
+
+    df = dataset['train'].to_pandas()
+
+    if df.empty:
+        print("No data to pull.")
+        return
+
+    # Merge the data into the local DuckDB
+    with duckdb.get_connection() as con:
+        # A simple approach is to just insert all data.
+        # A more sophisticated approach would be to handle duplicates.
+        con.execute(f"CREATE TABLE IF NOT EXISTS temp_table AS SELECT * FROM {duckdb.TABLE_NAME} WHERE 1=0")
+        con.execute("INSERT INTO temp_table SELECT * FROM df")
+        con.execute(f"INSERT INTO {duckdb.TABLE_NAME} SELECT * FROM temp_table ON CONFLICT DO NOTHING")
+        con.execute("DROP TABLE temp_table")
+
+    print(f"Successfully pulled and merged data from {repo_id}")

tracklight_server/hf/push.py

@@ -0,0 +1,31 @@
+# tracklight_server/hf/push.py
+
+from datasets import Dataset
+from huggingface_hub import HfApi, HfFolder
+from ..db import duckdb
+import os
+
+def push_to_hub(repo_id: str, hf_token: str):
+    """
+    Pushes the local DuckDB data to a Hugging Face Dataset repo.
+    """
+    # Authenticate with Hugging Face
+    HfFolder.save_token(hf_token)
+
+    # Get all data from DuckDB
+    with duckdb.get_connection() as con:
+        df = con.execute(f"SELECT * FROM {duckdb.TABLE_NAME}").fetchdf()
+
+    if df.empty:
+        print("No data to push.")
+        return
+
+    # Create a Hugging Face Dataset
+    dataset = Dataset.from_pandas(df)
+
+    # Push the dataset to the Hub
+    try:
+        dataset.push_to_hub(repo_id=repo_id, private=True)
+        print(f"Successfully pushed data to {repo_id}")
+    except Exception as e:
+        print(f"Failed to push data to {repo_id}: {e}")

tracklight_server/main.py

@@ -0,0 +1,33 @@
+# tracklight_server/main.py
+
+from fastapi import FastAPI, Depends
+from fastapi.responses import RedirectResponse
+from fastapi.security import OAuth2PasswordRequestForm
+
+from .api import ingest, auth, dashboard, artifacts, sync
+from contextlib import asynccontextmanager
+from .db import duckdb
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Create the database and table on startup
+    duckdb.create_tables()
+    yield
+
+app = FastAPI(title="Tracklight Server", lifespan=lifespan)
+
+# Include the API routers
+app.include_router(ingest.router, prefix="/api", tags=["ingest"])
+app.include_router(artifacts.router, prefix="/api", tags=["artifacts"])
+app.include_router(sync.router, prefix="/api", tags=["sync"])
+app.include_router(dashboard.router, tags=["dashboard"])
+
+@app.get("/")
+def read_root():
+    return RedirectResponse(url="/dashboard")
+
+# This is needed for the OAuth2PasswordBearer to work
+@app.post("/token")
+async def token(form_data: OAuth2PasswordRequestForm = Depends()):
+    # In a real app, you'd verify the username and password here
+    return {"access_token": auth.API_TOKEN, "token_type": "bearer"}

tracklight_server/requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+duckdb
+python-multipart
+jinja2
+datasets
+huggingface_hub
+pandas

tracklight_server/templates/dashboard.html

@@ -0,0 +1,188 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Tracklight Dashboard</title>
+    <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+    <style>
+        body { font-family: sans-serif; }
+        .container { max-width: 1200px; margin: 0 auto; padding: 20px; }
+        .header { display: flex; justify-content: space-between; align-items: center; }
+        .run { border: 1px solid #ccc; padding: 10px; margin-bottom: 10px; }
+        .metric-summary { display: flex; align-items: center; }
+        .play-button { margin-left: 10px; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <div>
+                <h1><a href="/dashboard">Tracklight Dashboard</a></h1>
+                <h2>Project: {{ project }}</h2>
+                <h3>User: {{ user }}</h3>
+            </div>
+            <button onclick="logout()">Logout</button>
+        </div>
+
+        <div id="runs">
+            {% for run in runs %}
+            <div class="run" role="region" aria-labelledby="run-heading-{{ loop.index }}">
+                <h4 id="run-heading-{{ loop.index }}">Run ID: {{ run[0] }}</h4>
+                <button onclick="loadMetrics('{{ run[0] }}')">Load Metrics</button>
+                <div id="config-{{ run[0] }}"></div>
+                <div id="plot-{{ run[0] }}" role="img" aria-label="A plot of metrics for this run."></div>
+                <div id="summary-{{ run[0] }}" aria-live="polite"></div>
+            </div>
+            {% endfor %}
+        </div>
+    </div>
+
+    <script>
+        const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+        const token = localStorage.getItem('tracklight-token');
+
+        // If no token, redirect to login
+        if (!token) {
+            const urlParams = new URLSearchParams(window.location.search);
+            window.location.href = '/login?' + urlParams.toString();
+        }
+
+        async function loadMetrics(runId) {
+            const response = await fetch(`/api/metrics?run_id=${runId}`, {
+                headers: {
+                    'Authorization': `Bearer ${token}`
+                }
+            });
+
+            if (response.status === 401) {
+                alert('Invalid or expired token. Please log in again.');
+                logout();
+                return;
+            }
+
+            const data = await response.json();
+            
+            // Render config table
+            const configDiv = document.getElementById(`config-${runId}`);
+            configDiv.innerHTML = generateConfigTable(data.config);
+
+            // Process and render metrics
+            const metrics = data.metrics;
+            const plotData = {};
+
+            metrics.forEach(metric => {
+                const [name, value, timestamp] = metric;
+                if (!plotData[name]) {
+                    plotData[name] = {
+                        x: [],
+                        y: [],
+                        mode: 'lines+markers',
+                        name: name
+                    };
+                }
+                plotData[name].x.push(new Date(timestamp));
+                plotData[name].y.push(value);
+            });
+
+            const plotDiv = document.getElementById(`plot-${runId}`);
+            Plotly.newPlot(plotDiv, Object.values(plotData), {title: `Metrics for run ${runId}`});
+
+            // Generate and display summary
+            const summaryDiv = document.getElementById(`summary-${runId}`);
+            summaryDiv.innerHTML = generateSummary(plotData);
+        }
+
+        function generateConfigTable(config) {
+            if (!config || config.length === 0) {
+                return '';
+            }
+            let table = '<h4>Configuration:</h4><table><thead><tr><th>Parameter</th><th>Value</th></tr></thead><tbody>';
+            config.forEach(param => {
+                const name = param[0].replace('config/', '');
+                const value = param[1];
+                table += `<tr><td>${name}</td><td>${value}</td></tr>`;
+            });
+            table += '</tbody></table>';
+            return table;
+        }
+
+        function generateSummary(plotData) {
+            let summary = '<h4>Metrics Summary:</h4><ul>';
+            for (const metricName in plotData) {
+                const metric = plotData[metricName];
+                const values = metric.y;
+                const firstVal = values[0];
+                const lastVal = values[values.length - 1];
+
+                // Check for constant metric
+                const isConstant = values.every(v => v === firstVal);
+                if (isConstant) {
+                    summary += `<li><b>${metricName}</b>: is constant at ${firstVal.toFixed(4)} throughout the run.</li>`;
+                    continue;
+                }
+
+                // Descriptive stats for volatile metrics
+                const minVal = Math.min(...values);
+                const maxVal = Math.max(...values);
+                const trend = lastVal > firstVal ? 'increased' : 'decreased';
+                
+                // Momentum analysis (simple version)
+                const deltas = values.slice(1).map((v, i) => Math.abs(v - values[i]));
+                const avgDelta = deltas.reduce((a, b) => a + b, 0) / deltas.length;
+                const stdDev = Math.sqrt(deltas.map(d => Math.pow(d - avgDelta, 2)).reduce((a, b) => a + b, 0) / deltas.length);
+
+                let momentumDesc = '';
+                if (stdDev / avgDelta > 0.5) {
+                    momentumDesc = 'volatilely';
+                } else if (avgDelta > (maxVal - minVal) / values.length * 2) {
+                    momentumDesc = 'sharply';
+                } else {
+                    momentumDesc = 'steadily';
+                }
+
+                summary += `<li class="metric-summary">
+                    <b>${metricName}</b>: ${momentumDesc} ${trend} from ${firstVal.toFixed(4)} to ${lastVal.toFixed(4)} over ${values.length} steps. 
+                    (Min: ${minVal.toFixed(4)}, Max: ${maxVal.toFixed(4)})
+                    <button class="play-button" onclick="playSlopeSound('${metricName}', [${values}])" aria-label="Play audio representation of the ${metricName} slope">Play Slope</button>
+                </li>`;
+            }
+            summary += '</ul>';
+            return summary;
+        }
+
+        function playSlopeSound(metricName, values) {
+            const duration = 2; // seconds
+            const sampleRate = audioContext.sampleRate;
+            const buffer = audioContext.createBuffer(1, sampleRate * duration, sampleRate);
+            const data = buffer.getChannelData(0);
+
+            const minVal = Math.min(...values);
+            const maxVal = Math.max(...values);
+
+            for (let i = 0; i < data.length; i++) {
+                const t = i / sampleRate;
+                const progress = t / duration;
+                const index = Math.floor(progress * (values.length - 1));
+                
+                const value1 = values[index];
+                const value2 = values[index + 1];
+                const normalizedValue = (value1 + (value2 - value1) * (progress * (values.length - 1) - index) - minVal) / (maxVal - minVal);
+
+                const freq = 220 + (normalizedValue * 660); // Map value to frequency range (A3 to A5)
+                data[i] = Math.sin(2 * Math.PI * freq * t);
+            }
+
+            const source = audioContext.createBufferSource();
+            source.buffer = buffer;
+            source.connect(audioContext.destination);
+            source.start();
+        }
+
+        function logout() {
+            localStorage.removeItem('tracklight-token');
+            window.location.href = '/login';
+        }
+    </script>
+</body>
+</html>

tracklight_server/templates/login.html

@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Login - Tracklight</title>
+    <style>
+        body { font-family: sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; }
+        .login-container { border: 1px solid #ccc; padding: 40px; border-radius: 8px; text-align: center; }
+        input { padding: 10px; margin-bottom: 20px; width: 250px; }
+        button { padding: 10px 20px; cursor: pointer; }
+    </style>
+</head>
+<body>
+    <div class="login-container">
+        <h1>Tracklight Login</h1>
+        <p>Please enter the API token to proceed.</p>
+        <input type="password" id="tokenInput" placeholder="API Token">
+        <br>
+        <button onclick="login()">Login</button>
+    </div>
+
+    <script>
+        function login() {
+            const token = document.getElementById('tokenInput').value;
+            if (token) {
+                localStorage.setItem('tracklight-token', token);
+                // Redirect to the dashboard, preserving query params if they exist
+                const urlParams = new URLSearchParams(window.location.search);
+                window.location.href = '/dashboard?' + urlParams.toString();
+            } else {
+                alert('Please enter a token.');
+            }
+        }
+    </script>
+</body>
+</html>

tracklight_server/templates/project_list.html

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Tracklight Projects</title>
+    <style>
+        body { font-family: sans-serif; }
+        .container { max-width: 1200px; margin: 0 auto; padding: 20px; }
+        table { width: 100%; border-collapse: collapse; }
+        th, td { border: 1px solid #ccc; padding: 8px; text-align: left; }
+        th { background-color: #f2f2f2; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Projects</h1>
+        <table>
+            <thead>
+                <tr>
+                    <th>Project Name</th>
+                    <th>Created At</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for project in projects %}
+                <tr>
+                    <td><a href="/project/{{ project[0] }}?user=hf-user">{{ project[0] }}</a></td>
+                    <td>{{ project[1] }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+</body>
+</html>

tracklight_server/tracklight.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bab1c02e7c2483e53a6560ebb41d71ade11d167a0ced73acfe0aac8605c7ed0c
+size 536576