Best Coworking Spaces Europe vs South America: Which Wins?

import speedtest
import json
import time
import sys
from typing import Dict, Optional, List
import logging

# Configure logging for benchmark output
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)

class CoworkingNetworkBenchmark:
    """Benchmark network performance for a given coworking space location."""

    def __init__(self, space_name: str, location: str, iterations: int = 3):
        self.space_name = space_name
        self.location = location
        self.iterations = iterations
        self.results: List[Dict] = []
        # Initialize speedtest client with 5s timeout
        self.st = speedtest.Speedtest(timeout=5)

    def run_latency_test(self) -> Optional[float]:
        """Run latency test to nearest server, return avg latency in ms."""
        try:
            self.st.get_servers()
            self.st.get_best_server()
            return self.st.results.ping
        except speedtest.SpeedtestException as e:
            logging.error(f"Latency test failed for {self.space_name}: {str(e)}")
            return None
        except Exception as e:
            logging.error(f"Unexpected error in latency test: {str(e)}")
            return None

    def run_bandwidth_test(self) -> Dict[str, Optional[float]]:
        """Run download/upload bandwidth test, return Mbps values."""
        try:
            # Run download test first
            download_mbps = self.st.download() / 1_000_000  # Convert bps to Mbps
            # Run upload test
            upload_mbps = self.st.upload() / 1_000_000
            return {"download": download_mbps, "upload": upload_mbps}
        except speedtest.SpeedtestException as e:
            logging.error(f"Bandwidth test failed for {self.space_name}: {str(e)}")
            return {"download": None, "upload": None}
        except Exception as e:
            logging.error(f"Unexpected error in bandwidth test: {str(e)}")
            return {"download": None, "upload": None}

    def run_full_benchmark(self) -> Dict:
        """Run full benchmark with multiple iterations, return aggregated results."""
        latencies = []
        downloads = []
        uploads = []

        for i in range(self.iterations):
            logging.info(f"Running iteration {i+1}/{self.iterations} for {self.space_name}")
            # Test latency
            lat = self.run_latency_test()
            if lat is not None:
                latencies.append(lat)
            # Test bandwidth
            bw = self.run_bandwidth_test()
            if bw["download"] is not None:
                downloads.append(bw["download"])
            if bw["upload"] is not None:
                uploads.append(bw["upload"])
            # Wait 2s between iterations to avoid rate limiting
            time.sleep(2)

        # Calculate aggregates
        avg_latency = sum(latencies)/len(latencies) if latencies else None
        avg_download = sum(downloads)/len(downloads) if downloads else None
        avg_upload = sum(uploads)/len(uploads) if uploads else None

        result = {
            "space_name": self.space_name,
            "location": self.location,
            "iterations_completed": len(latencies),
            "avg_latency_ms": round(avg_latency, 2) if avg_latency else None,
            "avg_download_mbps": round(avg_download, 2) if avg_download else None,
            "avg_upload_mbps": round(avg_upload, 2) if avg_upload else None,
            "p99_latency_ms": round(sorted(latencies)[int(len(latencies)*0.99)] if latencies else None, 2),
            "timestamp": time.time()
        }
        self.results.append(result)
        return result

if __name__ == "__main__":
    # Example usage: Benchmark a Berlin coworking space
    try:
        benchmark = CoworkingNetworkBenchmark(
            space_name="WeWork Sony Center",
            location="Berlin, Germany",
            iterations=3
        )
        result = benchmark.run_full_benchmark()
        print(json.dumps(result, indent=2))
    except KeyboardInterrupt:
        logging.info("Benchmark interrupted by user")
        sys.exit(0)
    except Exception as e:
        logging.error(f"Fatal benchmark error: {str(e)}")
        sys.exit(1)

const axios = require('axios');
const { execSync } = require('child_process');
const fs = require('fs').promises;

/**
 * Calculate Purchasing Power Parity (PPP) adjusted cost for coworking spaces
 * @param {number} nominalCost - Cost in local currency
 * @param {string} currency - Local currency code (EUR, USD, BRL, etc.)
 * @param {string} country - Country code (DE, BR, AR, etc.)
 * @returns {Promise} PPP adjusted cost in USD
 */
async function getPPPAdjustedCost(nominalCost, currency, country) {
    try {
        // Fetch latest PPP conversion factors from World Bank API
        const pppResponse = await axios.get(`https://api.worldbank.org/v2/country/${country}/indicator/PA.NUS.PPPC.RF?format=json&latest=1`);
        if (!pppResponse.data[1] || pppResponse.data[1].length === 0) {
            throw new Error(`No PPP data found for country ${country}`);
        }
        const pppFactor = pppResponse.data[1][0].value;

        // Fetch current exchange rate from exchangerate-api
        const exchangeResponse = await axios.get(`https://api.exchangerate-api.com/v4/latest/USD`);
        const exchangeRate = exchangeResponse.data.rates[currency];
        if (!exchangeRate) {
            throw new Error(`No exchange rate found for currency ${currency}`);
        }

        // Calculate PPP adjusted cost: (nominal / exchangeRate) * pppFactor
        const usdNominal = nominalCost / exchangeRate;
        return usdNominal * pppFactor;
    } catch (error) {
        console.error(`PPP calculation failed: ${error.message}`);
        // Fallback to nominal USD conversion if API fails
        return nominalCost;
    }
}

/**
 * Calculate dev amenity score for a coworking space (0-100)
 * @param {Object} amenities - Amenity flags (stagingServer, ergonomicChairs, meetupSpace, githubPerks)
 * @returns {number} Amenity score
 */
function calculateDevAmenityScore(amenities) {
    let score = 0;
    // Staging server adds 40 points
    if (amenities.stagingServer) score += 40;
    // Ergonomic chairs availability (percentage * 0.3)
    score += (amenities.ergonomicChairPct / 100) * 30;
    // Meetup space adds 20 points
    if (amenities.meetupSpace) score += 20;
    // GitHub perks add 10 points
    if (amenities.githubPerks) score += 10;
    return Math.min(score, 100);
}

/**
 * Main function to evaluate and compare coworking spaces
 */
async function evaluateSpaces() {
    // Define sample spaces (Europe vs South America)
    const spaces = [
        {
            name: "Spaces Amsterdam",
            region: "Europe",
            nominalCost: 450, // EUR
            currency: "EUR",
            country: "NL",
            amenities: {
                stagingServer: true,
                ergonomicChairPct: 90,
                meetupSpace: true,
                githubPerks: true
            }
        },
        {
            name: "Area51 Coworking São Paulo",
            region: "South America",
            nominalCost: 900, // BRL
            currency: "BRL",
            country: "BR",
            amenities: {
                stagingServer: false,
                ergonomicChairPct: 65,
                meetupSpace: true,
                githubPerks: false
            }
        }
    ];

    const results = [];
    for (const space of spaces) {
        try {
            const pppCost = await getPPPAdjustedCost(space.nominalCost, space.currency, space.country);
            const amenityScore = calculateDevAmenityScore(space.amenities);
            results.push({
                name: space.name,
                region: space.region,
                nominalCost: `${space.nominalCost} ${space.currency}`,
                pppAdjustedCostUSD: pppCost.toFixed(2),
                devAmenityScore: amenityScore,
                costPerAmenityPoint: (pppCost / amenityScore).toFixed(2)
            });
        } catch (error) {
            console.error(`Failed to evaluate ${space.name}: ${error.message}`);
        }
    }

    // Write results to JSON file
    await fs.writeFile('coworking-evaluation.json', JSON.stringify(results, null, 2));
    console.log('Evaluation complete. Results written to coworking-evaluation.json');
}

// Run evaluation
evaluateSpaces().catch(error => {
    console.error(`Fatal error: ${error.message}`);
    process.exit(1);
});

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "log"
    "math"
    "net/http"
    "os"
    "sort"
    "time"
)

// DevCoworkSurveyResponse represents a single survey response from DevCowork API
type DevCoworkSurveyResponse struct {
    SpaceName     string  `json:"space_name"`
    Region        string  `json:"region"`
    LatencyMs     float64 `json:"latency_ms"`
    HasStaging    bool    `json:"has_staging_server"`
    ErgoChairPct  float64 `json:"ergonomic_chair_pct"`
    MeetupCount   int     `json:"monthly_meetup_count"`
}

// RegionalAggregate holds aggregated metrics for a region
type RegionalAggregate struct {
    Region              string  `json:"region"`
    AvgLatencyMs        float64 `json:"avg_latency_ms"`
    StagingServerPct    float64 `json:"staging_server_pct"`
    AvgErgoChairPct     float64 `json:"avg_ergonomic_chair_pct"`
    AvgMeetupCount      float64 `json:"avg_monthly_meetup_count"`
    SampleSize          int     `json:"sample_size"`
}

// fetchSurveyData retrieves survey data from DevCowork API with retry logic
func fetchSurveyData(apiURL string, maxRetries int) ([]DevCoworkSurveyResponse, error) {
    var resp []DevCoworkSurveyResponse
    for retry := 0; retry < maxRetries; retry++ {
        client := &http.Client{Timeout: 10 * time.Second}
        httpResp, err := client.Get(apiURL)
        if err != nil {
            log.Printf("Retry %d/%d: Failed to fetch survey data: %v", retry+1, maxRetries, err)
            time.Sleep(time.Second * time.Duration(retry+1))
            continue
        }
        defer httpResp.Body.Close()

        if httpResp.StatusCode != http.StatusOK {
            log.Printf("Retry %d/%d: Non-200 status: %d", retry+1, maxRetries, httpResp.StatusCode)
            time.Sleep(time.Second * time.Duration(retry+1))
            continue
        }

        body, err := io.ReadAll(httpResp.Body)
        if err != nil {
            return nil, fmt.Errorf("failed to read response body: %w", err)
        }

        if err := json.Unmarshal(body, &resp); err != nil {
            return nil, fmt.Errorf("failed to unmarshal survey data: %w", err)
        }
        return resp, nil
    }
    return nil, fmt.Errorf("max retries exceeded fetching survey data")
}

// aggregateByRegion calculates regional averages from survey responses
func aggregateByRegion(responses []DevCoworkSurveyResponse) map[string]RegionalAggregate {
    regionData := make(map[string][]DevCoworkSurveyResponse)
    // Group responses by region
    for _, r := range responses {
        regionData[r.Region] = append(regionData[r.Region], r)
    }

    aggregates := make(map[string]RegionalAggregate)
    for region, entries := range regionData {
        if len(entries) == 0 {
            continue
        }
        // Calculate latency average
        var totalLatency float64
        for _, e := range entries {
            totalLatency += e.LatencyMs
        }
        avgLatency := totalLatency / float64(len(entries))

        // Calculate staging server percentage
        var stagingCount int
        for _, e := range entries {
            if e.HasStaging {
                stagingCount++
            }
        }
        stagingPct := (float64(stagingCount) / float64(len(entries))) * 100

        // Calculate average ergonomic chair percentage
        var totalErgo float64
        for _, e := range entries {
            totalErgo += e.ErgoChairPct
        }
        avgErgo := totalErgo / float64(len(entries))

        // Calculate average meetup count
        var totalMeetup float64
        for _, e := range entries {
            totalMeetup += float64(e.MeetupCount)
        }
        avgMeetup := totalMeetup / float64(len(entries))

        aggregates[region] = RegionalAggregate{
            Region:           region,
            AvgLatencyMs:     math.Round(avgLatency*100)/100,
            StagingServerPct: math.Round(stagingPct*100)/100,
            AvgErgoChairPct:  math.Round(avgErgo*100)/100,
            AvgMeetupCount:   math.Round(avgMeetup*100)/100,
            SampleSize:       len(entries),
        }
    }
    return aggregates
}

func main() {
    const surveyAPI = "https://api.devcowork.com/v1/survey-results?regions=Europe,South%20America"
    const maxRetries = 3

    // Fetch survey data
    log.Println("Fetching DevCowork survey data...")
    surveyData, err := fetchSurveyData(surveyAPI, maxRetries)
    if err != nil {
        log.Fatalf("Failed to fetch survey data: %v", err)
    }
    log.Printf("Fetched %d survey responses", len(surveyData))

    // Aggregate by region
    aggregates := aggregateByRegion(surveyData)

    // Print results as JSON
    encoder := json.NewEncoder(os.Stdout)
    encoder.SetIndent("", "  ")
    if err := encoder.Encode(aggregates); err != nil {
        log.Fatalf("Failed to encode aggregates: %v", err)
    }
}