Best Coworking Spaces Asia vs Europe: What You Need to Know

#!/usr/bin/env python3
"""
Coworking Space Internet Benchmark Tool
Version: 1.0.0
Dependencies: speedtest-cli==2.1.3, pandas==2.1.4
Methodology: Runs 10 sequential speed tests per location, logs to CSV with timestamp, location, hardware metadata.
"""

import sys
import csv
import time
import logging
import argparse
from dataclasses import dataclass
from typing import Optional
import speedtest
import platform

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.StreamHandler(sys.stdout)]
)
logger = logging.getLogger(__name__)

@dataclass
class BenchmarkResult:
    timestamp: str
    location: str
    hardware: str
    download_mbps: float
    upload_mbps: float
    ping_ms: float
    error: Optional[str] = None

def get_hardware_metadata() -> str:
    """Returns standardized hardware string for benchmark reproducibility."""
    return f"{platform.system()}-{platform.node()}-{platform.processor()}"

def run_speed_test() -> Optional[BenchmarkResult]:
    """Runs a single speed test, returns BenchmarkResult or None on failure."""
    try:
        logger.info("Initializing speed test...")
        st = speedtest.Speedtest(secure=True)
        st.get_servers()
        st.get_best_server()

        # Download test
        download_mbps = st.download() / 1_000_000  # Convert to Mbps
        # Upload test
        upload_mbps = st.upload() / 1_000_000
        # Ping
        ping_ms = st.results.ping

        return BenchmarkResult(
            timestamp=time.strftime("%Y-%m-%d %H:%M:%S"),
            location=args.location,
            hardware=get_hardware_metadata(),
            download_mbps=round(download_mbps, 2),
            upload_mbps=round(upload_mbps, 2),
            ping_ms=round(ping_ms, 2)
        )
    except speedtest.ConfigRetrievalError as e:
        logger.error(f"Failed to retrieve speedtest config: {e}")
        return BenchmarkResult(
            timestamp=time.strftime("%Y-%m-%d %H:%M:%S"),
            location=args.location,
            hardware=get_hardware_metadata(),
            download_mbps=0.0,
            upload_mbps=0.0,
            ping_ms=0.0,
            error=f"ConfigRetrievalError: {str(e)}"
        )
    except speedtest.SpeedtestException as e:
        logger.error(f"Speed test failed: {e}")
        return BenchmarkResult(
            timestamp=time.strftime("%Y-%m-%d %H:%M:%S"),
            location=args.location,
            hardware=get_hardware_metadata(),
            download_mbps=0.0,
            upload_mbps=0.0,
            ping_ms=0.0,
            error=f"SpeedtestException: {str(e)}"
        )
    except Exception as e:
        logger.error(f"Unexpected error: {e}")
        return BenchmarkResult(
            timestamp=time.strftime("%Y-%m-%d %H:%M:%S"),
            location=args.location,
            hardware=get_hardware_metadata(),
            download_mbps=0.0,
            upload_mbps=0.0,
            ping_ms=0.0,
            error=f"UnexpectedError: {str(e)}"
        )

def main():
    parser = argparse.ArgumentParser(description="Benchmark internet speed at coworking spaces.")
    parser.add_argument("--location", required=True, help="Coworking space location (e.g., 'Singapore-WeWork-CapitalTower')")
    parser.add_argument("--iterations", type=int, default=10, help="Number of speed tests to run (default: 10)")
    parser.add_argument("--output", default="coworking_speed_results.csv", help="Output CSV file path")
    global args
    args = parser.parse_args()

    logger.info(f"Starting benchmark for location: {args.location}")
    logger.info(f"Hardware: {get_hardware_metadata()}")
    logger.info(f"Running {args.iterations} iterations...")

    results = []
    for i in range(args.iterations):
        logger.info(f"Iteration {i+1}/{args.iterations}")
        result = run_speed_test()
        if result:
            results.append(result)
        time.sleep(5)  # Wait 5 seconds between tests to avoid rate limiting

    # Write results to CSV
    try:
        with open(args.output, mode="w", newline="") as f:
            writer = csv.writer(f)
            writer.writerow(["timestamp", "location", "hardware", "download_mbps", "upload_mbps", "ping_ms", "error"])
            for res in results:
                writer.writerow([
                    res.timestamp, res.location, res.hardware,
                    res.download_mbps, res.upload_mbps, res.ping_ms, res.error or ""
                ])
        logger.info(f"Results written to {args.output}")
    except IOError as e:
        logger.error(f"Failed to write output file: {e}")
        sys.exit(1)

    # Print summary
    successful_results = [r for r in results if r.error is None]
    if successful_results:
        avg_down = sum(r.download_mbps for r in successful_results) / len(successful_results)
        avg_up = sum(r.upload_mbps for r in successful_results) / len(successful_results)
        avg_ping = sum(r.ping_ms for r in successful_results) / len(successful_results)
        logger.info(f"Summary: Avg Download: {avg_down:.2f} Mbps, Avg Upload: {avg_up:.2f} Mbps, Avg Ping: {avg_ping:.2f} ms")
    else:
        logger.error("No successful speed tests completed.")
        sys.exit(1)

if __name__ == "__main__":
    main()

#!/usr/bin/env node
/**
 * Coworking Space Cost Comparison Tool (Asia vs Europe)
 * Version: 1.0.0
 * Dependencies: axios@1.6.2, csv-parse@5.5.3
 * API Docs: https://github.com/coworking-io/api (v2.1.0)
 */

const axios = require('axios');
const { parse } = require('csv-parse');
const fs = require('fs');
const path = require('path');

// Configuration
const COWORKING_API_BASE = 'https://api.coworking-io.com/v2';
const API_KEY = process.env.COWORKING_API_KEY; // Set via environment variable
const ASIA_CITIES = ['singapore', 'tokyo', 'bangkok', 'kuala-lumpur', 'mumbai'];
const EUROPE_CITIES = ['berlin', 'paris', 'london', 'amsterdam', 'barcelona'];
const OUTPUT_PATH = path.join(__dirname, 'coworking_cost_comparison.json');

// Validate environment
if (!API_KEY) {
    console.error('Error: COWORKING_API_KEY environment variable is not set.');
    process.exit(1);
}

/**
 * Fetches coworking spaces for a given city and region
 * @param {string} city - City slug (e.g., 'singapore')
 * @param {string} region - 'asia' or 'europe'
 * @returns {Promise} List of coworking space objects
 */
async function fetchCoworkingSpaces(city, region) {
    try {
        const response = await axios.get(`${COWORKING_API_BASE}/spaces`, {
            params: {
                city,
                region,
                limit: 100, // Max per page
                plan_type: 'dedicated_desk', // Filter for dedicated desks
                plan_term: '12m' // 12-month plan
            },
            headers: {
                'Authorization': `Bearer ${API_KEY}`,
                'User-Agent': 'CoworkingCostComparer/1.0.0'
            },
            timeout: 10000 // 10 second timeout
        });

        if (response.status !== 200) {
            throw new Error(`API returned status ${response.status} for city ${city}`);
        }

        return response.data.spaces || [];
    } catch (error) {
        if (error.response) {
            console.error(`API Error for ${city}: ${error.response.status} - ${error.response.data.message || 'Unknown error'}`);
        } else if (error.request) {
            console.error(`No response received for ${city}: ${error.message}`);
        } else {
            console.error(`Error fetching ${city}: ${error.message}`);
        }
        return []; // Return empty array to continue processing other cities
    }
}

/**
 * Aggregates cost metrics for a list of coworking spaces
 * @param {Array} spaces - List of coworking space objects
 * @returns {Object} Aggregated metrics (avg_cost_eur, min_cost, max_cost, count)
 */
function aggregateCostMetrics(spaces) {
    if (spaces.length === 0) {
        return { avg_cost_eur: 0, min_cost: 0, max_cost: 0, count: 0 };
    }

    const costs = spaces
        .map(space => space.plans?.dedicated_desk_12m_eur)
        .filter(cost => typeof cost === 'number' && cost > 0);

    if (costs.length === 0) {
        return { avg_cost_eur: 0, min_cost: 0, max_cost: 0, count: 0 };
    }

    const sum = costs.reduce((acc, val) => acc + val, 0);
    return {
        avg_cost_eur: parseFloat((sum / costs.length).toFixed(2)),
        min_cost: Math.min(...costs),
        max_cost: Math.max(...costs),
        count: costs.length
    };
}

/**
 * Main execution function
 */
async function main() {
    console.log('Starting coworking space cost comparison...');
    console.log(`Fetching data for Asia cities: ${ASIA_CITIES.join(', ')}`);
    console.log(`Fetching data for Europe cities: ${EUROPE_CITIES.join(', ')}`);

    // Fetch Asia spaces
    const asiaSpaces = [];
    for (const city of ASIA_CITIES) {
        console.log(`Fetching ${city} (Asia)...`);
        const spaces = await fetchCoworkingSpaces(city, 'asia');
        asiaSpaces.push(...spaces);
        await new Promise(resolve => setTimeout(resolve, 1000)); // Rate limit: 1 req/sec
    }

    // Fetch Europe spaces
    const europeSpaces = [];
    for (const city of EUROPE_CITIES) {
        console.log(`Fetching ${city} (Europe)...`);
        const spaces = await fetchCoworkingSpaces(city, 'europe');
        europeSpaces.push(...spaces);
        await new Promise(resolve => setTimeout(resolve, 1000)); // Rate limit: 1 req/sec
    }

    // Aggregate metrics
    const asiaMetrics = aggregateCostMetrics(asiaSpaces);
    const europeMetrics = aggregateCostMetrics(europeSpaces);

    // Build comparison report
    const report = {
        generated_at: new Date().toISOString(),
        api_version: 'v2.1.0',
        asia: {
            regions: ASIA_CITIES,
            total_spaces: asiaSpaces.length,
            cost_metrics: asiaMetrics
        },
        europe: {
            regions: EUROPE_CITIES,
            total_spaces: europeSpaces.length,
            cost_metrics: europeMetrics
        },
        comparison: {
            avg_cost_diff_eur: parseFloat((europeMetrics.avg_cost_eur - asiaMetrics.avg_cost_eur).toFixed(2)),
            percent_diff: asiaMetrics.avg_cost_eur > 0 
                ? parseFloat(((europeMetrics.avg_cost_eur - asiaMetrics.avg_cost_eur) / asiaMetrics.avg_cost_eur * 100).toFixed(2))
                : 0
        }
    };

    // Write report to JSON
    try {
        fs.writeFileSync(OUTPUT_PATH, JSON.stringify(report, null, 2));
        console.log(`Comparison report written to ${OUTPUT_PATH}`);
    } catch (error) {
        console.error(`Failed to write report: ${error.message}`);
        process.exit(1);
    }

    // Print summary
    console.log('\n=== Comparison Summary ===');
    console.log(`Asia: ${asiaMetrics.count} spaces, Avg cost €${asiaMetrics.avg_cost_eur}/month`);
    console.log(`Europe: ${europeMetrics.count} spaces, Avg cost €${europeMetrics.avg_cost_eur}/month`);
    console.log(`Difference: €${report.comparison.avg_cost_diff_eur}/month (${report.comparison.percent_diff}%)`);
}

// Execute main function
main().catch(error => {
    console.error('Fatal error:', error);
    process.exit(1);
});

// Coworking Space Latency Benchmark Tool
// Version: 1.0.0
// Dependencies: github.com/go-ping/ping/v2 v2.1.0
// Methodology: Pings AWS endpoints 100 times per region, calculates p50/p90/p99 latency.
package main

import (
    "fmt"
    "log"
    "math"
    "os"
    "sort"
    "time"

    "github.com/go-ping/ping"
)

// Config holds benchmark configuration
type Config struct {
    Location      string
    Count         int
    Timeout       time.Duration
    AWSRegions    []string
    OutputPath    string
}

// LatencyResult holds per-region latency stats
type LatencyResult struct {
    Region     string
    P50Ms      float64
    P90Ms      float64
    P99Ms      float64
    MinMs      float64
    MaxMs      float64
    PacketLoss float64
}

func main() {
    // Parse config (hardcoded for reproducibility, can be extended to CLI flags)
    cfg := Config{
        Location:   "Berlin-WeWork-PotsdamerPlatz",
        Count:      100,
        Timeout:    2 * time.Second,
        AWSRegions: []string{
            "ec2.eu-central-1.amazonaws.com", // Frankfurt
            "ec2.ap-southeast-1.amazonaws.com", // Singapore
            "ec2.us-west-2.amazonaws.com", // Oregon
        },
        OutputPath: "coworking_latency_results.txt",
    }

    log.Printf("Starting latency benchmark for location: %s", cfg.Location)
    log.Printf("Ping count: %d, Timeout: %s", cfg.Count, cfg.Timeout)
    log.Printf("AWS Regions: %v", cfg.AWSRegions)

    results := make([]LatencyResult, 0, len(cfg.AWSRegions))

    for _, region := range cfg.AWSRegions {
        log.Printf("Pinging %s...", region)
        result, err := pingRegion(region, cfg)
        if err != nil {
            log.Printf("Failed to ping %s: %v", region, err)
            continue
        }
        results = append(results, *result)
        log.Printf("Region %s: P50=%.2fms, P90=%.2fms, P99=%.2fms, Loss=%.2f%%",
            region, result.P50Ms, result.P90Ms, result.P99Ms, result.PacketLoss)
    }

    // Write results to file
    outputFile, err := os.Create(cfg.OutputPath)
    if err != nil {
        log.Fatalf("Failed to create output file: %v", err)
    }
    defer outputFile.Close()

    outputFile.WriteString(fmt.Sprintf("Latency Benchmark Results\nLocation: %s\nGenerated: %s\n\n",
        cfg.Location, time.Now().Format(time.RFC3339)))

    for _, res := range results {
        outputFile.WriteString(fmt.Sprintf("Region: %s\n", res.Region))
        outputFile.WriteString(fmt.Sprintf("  P50 Latency: %.2f ms\n", res.P50Ms))
        outputFile.WriteString(fmt.Sprintf("  P90 Latency: %.2f ms\n", res.P90Ms))
        outputFile.WriteString(fmt.Sprintf("  P99 Latency: %.2f ms\n", res.P99Ms))
        outputFile.WriteString(fmt.Sprintf("  Min Latency: %.2f ms\n", res.MinMs))
        outputFile.WriteString(fmt.Sprintf("  Max Latency: %.2f ms\n", res.MaxMs))
        outputFile.WriteString(fmt.Sprintf("  Packet Loss: %.2f %%\n\n", res.PacketLoss))
    }

    log.Printf("Results written to %s", cfg.OutputPath)
}

// pingRegion pings a given AWS region and returns latency stats
func pingRegion(region string, cfg Config) (*LatencyResult, error) {
    pinger, err := ping.NewPinger(region)
    if err != nil {
        return nil, fmt.Errorf("failed to create pinger: %w", err)
    }
    defer pinger.Stop()

    pinger.Count = cfg.Count
    pinger.Timeout = cfg.Timeout
    pinger.SetPrivileged(false) // Use unprivileged ICMP (requires net.icmp.allow for non-root)

    // Collect latencies
    var latencies []float64
    var sent, received int

    err = pinger.Run()
    if err != nil {
        return nil, fmt.Errorf("ping failed: %w", err)
    }

    stats := pinger.Statistics()
    sent = stats.PacketsSent
    received = stats.PacketsRecv

    // Extract rtts
    for _, rtt := range stats.Rtts {
        latencies = append(latencies, rtt.Seconds()*1000) // Convert to ms
    }

    if len(latencies) == 0 {
        return &LatencyResult{
            Region:      region,
            P50Ms:       0,
            P90Ms:       0,
            P99Ms:       0,
            MinMs:       0,
            MaxMs:       0,
            PacketLoss:  100.0,
        }, nil
    }

    // Sort latencies for percentile calculation
    sort.Float64s(latencies)

    // Calculate percentiles
    p50 := percentile(latencies, 50)
    p90 := percentile(latencies, 90)
    p99 := percentile(latencies, 99)
    min := latencies[0]
    max := latencies[len(latencies)-1]
    packetLoss := (1 - float64(received)/float64(sent)) * 100

    return &LatencyResult{
        Region:      region,
        P50Ms:       p50,
        P90Ms:       p90,
        P99Ms:       p99,
        MinMs:       min,
        MaxMs:       max,
        PacketLoss:  math.Round(packetLoss*100) / 100,
    }, nil
}

// percentile calculates the nth percentile of a sorted slice
func percentile(sorted []float64, n int) float64 {
    if len(sorted) == 0 {
        return 0
    }
    // Index calculation: (n/100) * (len - 1)
    index := (float64(n) / 100.0) * (float64(len(sorted)) - 1.0)
    lower := int(math.Floor(index))
    upper := int(math.Ceil(index))

    if lower == upper {
        return sorted[lower]
    }

    // Linear interpolation
    weight := index - float64(lower)
    return sorted[lower]*(1-weight) + sorted[upper]*weight
}