for Digital Nomads South America vs North America: Which Wins?

import speedtest
import csv
import json
import time
from datetime import datetime
from typing import Dict, Optional, List
import argparse
import geoip2.database
import geoip2.errors

# Configuration: Max retries for failed speed tests, GeoIP DB path
# speedtest-cli: https://github.com/sivel/speedtest-cli
# GeoIP2 Python: https://github.com/maxmind/GeoIP2-python
MAX_RETRIES = 3
GEOIP_DB_PATH = "GeoLite2-City.mmdb"  # Download from MaxMind, free tier
OUTPUT_CSV = "nomad_speed_tests.csv"

def get_geo_location() -> Optional[Dict[str, str]]:
    """Fetch current city/country using GeoIP, with error handling."""
    try:
        # Use public IP API as fallback if GeoIP DB unavailable
        import requests
        ip_resp = requests.get("https://api.ipify.org?format=json", timeout=5)
        ip_resp.raise_for_status()
        public_ip = ip_resp.json()["ip"]

        with geoip2.database.Reader(GEOIP_DB_PATH) as reader:
            response = reader.city(public_ip)
            return {
                "city": response.city.name,
                "country": response.country.name,
                "country_code": response.country.iso_code
            }
    except (FileNotFoundError, geoip2.errors.AddressNotFoundError):
        # Fallback to IP only if GeoIP fails
        print(f"GeoIP DB not found at {GEOIP_DB_PATH}, using IP-only location")
        return {"city": "Unknown", "country": "Unknown", "country_code": "Unknown"}
    except Exception as e:
        print(f"Failed to fetch location: {str(e)}")
        return None

def run_speed_test(retry_count: int = 0) -> Optional[Dict[str, float]]:
    """Run Ookla speed test, retry on failure up to MAX_RETRIES."""
    try:
        st = speedtest.Speedtest()
        st.get_best_server()
        st.download()
        st.upload()
        results = st.results.dict()
        return {
            "download_mbps": results["download"] / 1_000_000,  # Convert to Mbps
            "upload_mbps": results["upload"] / 1_000_000,
            "ping_ms": results["ping"],
            "server": results["server"]["name"]
        }
    except speedtest.SpeedtestException as e:
        if retry_count < MAX_RETRIES:
            print(f"Speed test failed, retrying ({retry_count+1}/{MAX_RETRIES})...")
            time.sleep(2 ** retry_count)  # Exponential backoff
            return run_speed_test(retry_count + 1)
        print(f"Speed test failed after {MAX_RETRIES} retries: {str(e)}")
        return None
    except Exception as e:
        print(f"Unexpected error in speed test: {str(e)}")
        return None

def log_test_result(location: Dict[str, str], speed_results: Dict[str, float]) -> None:
    """Append test results to CSV with timestamp and location."""
    timestamp = datetime.utcnow().isoformat()
    row = {
        "timestamp": timestamp,
        "city": location["city"],
        "country": location["country"],
        "country_code": location["country_code"],
        "download_mbps": round(speed_results["download_mbps"], 2),
        "upload_mbps": round(speed_results["upload_mbps"], 2),
        "ping_ms": round(speed_results["ping_ms"], 2),
        "server": speed_results["server"]
    }

    # Write header if file doesn't exist
    try:
        with open(OUTPUT_CSV, "a", newline="") as f:
            writer = csv.DictWriter(f, fieldnames=row.keys())
            if f.tell() == 0:
                writer.writeheader()
            writer.writerow(row)
        print(f"Logged test result: {row['download_mbps']} Mbps down, {row['upload_mbps']} Mbps up")
    except IOError as e:
        print(f"Failed to write to CSV: {str(e)}")

def main():
    parser = argparse.ArgumentParser(description="Run internet speed tests for digital nomad benchmarking")
    parser.add_argument("--iterations", type=int, default=1, help="Number of speed tests to run")
    args = parser.parse_args()

    print(f"Starting {args.iterations} speed test iterations...")
    location = get_geo_location()
    if not location:
        print("Could not determine location, exiting.")
        return

    for i in range(args.iterations):
        print(f"Running test {i+1}/{args.iterations}...")
        speed_results = run_speed_test()
        if speed_results:
            log_test_result(location, speed_results)
        else:
            print(f"Test {i+1} failed, skipping log.")
        if i < args.iterations - 1:
            time.sleep(60)  # Wait 1 minute between tests

if __name__ == "__main__":
    main()

import json
import argparse
from typing import Dict, List, Optional
from dataclasses import dataclass
import sys

# Local cost database (sourced from NomadList 2024 Q2, n=1200 responses)
COST_DB_PATH = "nomad_costs.json"

@dataclass
class MonthlyCosts:
    """Dataclass to hold monthly cost components for a city."""
    rent_1br_central: float  # USD, 1-bedroom apartment in city center
    rent_1br_outskirts: float  # USD, 1-bedroom outside center
    co_working_monthly: float  # USD, dedicated desk monthly
    food_monthly: float  # USD, 3 meals/day, mid-range
    transit_monthly: float  # USD, public transit pass
    health_insurance_monthly: float  # USD, expat health insurance
    internet_monthly: float  # USD, fixed broadband 100Mbps+

    def calculate_all_in(self, prefer_central: bool = True) -> float:
        """Calculate total monthly all-in cost, optional central rent preference."""
        rent = self.rent_1br_central if prefer_central else self.rent_1br_outskirts
        return sum([
            rent,
            self.co_working_monthly,
            self.food_monthly,
            self.transit_monthly,
            self.health_insurance_monthly,
            self.internet_monthly
        ])

def load_cost_db() -> Optional[Dict[str, Dict]]:
    """Load cost database from JSON, with error handling."""
    try:
        with open(COST_DB_PATH, "r") as f:
            data = json.load(f)
            # Validate required fields for each city
            required_fields = ["rent_1br_central", "rent_1br_outskirts", "co_working_monthly",
                             "food_monthly", "transit_monthly", "health_insurance_monthly",
                             "internet_monthly", "region", "country"]
            for city, city_data in data.items():
                for field in required_fields:
                    if field not in city_data:
                        raise ValueError(f"City {city} missing required field: {field}")
            return data
    except FileNotFoundError:
        print(f"Cost database not found at {COST_DB_PATH}", file=sys.stderr)
        return None
    except json.JSONDecodeError as e:
        print(f"Invalid JSON in cost database: {str(e)}", file=sys.stderr)
        return None
    except ValueError as e:
        print(f"Invalid cost database format: {str(e)}", file=sys.stderr)
        return None

def compare_cities(region: str, db: Dict[str, Dict], prefer_central: bool = True) -> List[Dict]:
    """Compare all cities in a region, return sorted list of all-in costs."""
    region_cities = []
    for city, data in db.items():
        if data["region"].lower() == region.lower():
            costs = MonthlyCosts(
                rent_1br_central=data["rent_1br_central"],
                rent_1br_outskirts=data["rent_1br_outskirts"],
                co_working_monthly=data["co_working_monthly"],
                food_monthly=data["food_monthly"],
                transit_monthly=data["transit_monthly"],
                health_insurance_monthly=data["health_insurance_monthly"],
                internet_monthly=data["internet_monthly"]
            )
            all_in = costs.calculate_all_in(prefer_central)
            region_cities.append({
                "city": city,
                "country": data["country"],
                "all_in_usd": round(all_in, 2),
                "prefer_central": prefer_central
            })
    # Sort by all-in cost ascending
    return sorted(region_cities, key=lambda x: x["all_in_usd"])

def print_comparison(sa_cities: List[Dict], na_cities: List[Dict]) -> None:
    """Print formatted comparison table to stdout."""
    print(f"{"South America Cities":<30} {"All-In USD":<15} | {"North America Cities":<30} {"All-In USD":<15}")
    print("-" * 90)
    max_len = max(len(sa_cities), len(na_cities))
    for i in range(max_len):
        sa_entry = sa_cities[i] if i < len(sa_cities) else {"city": "", "all_in_usd": ""}
        na_entry = na_cities[i] if i < len(na_cities) else {"city": "", "all_in_usd": ""}
        sa_str = f"{sa_entry['city']:<30} ${sa_entry['all_in_usd']:<14}" if sa_entry['city'] else " " * 45
        na_str = f"{na_entry['city']:<30} ${na_entry['all_in_usd']:<14}" if na_entry['city'] else ""
        print(f"{sa_str} | {na_str}")

def main():
    parser = argparse.ArgumentParser(description="Compare digital nomad cost of living between SA and NA")
    parser.add_argument("--region-sa", type=str, default="South America", help="Region name for South America")
    parser.add_argument("--region-na", type=str, default="North America", help="Region name for North America")
    parser.add_argument("--outskirts", action="store_true", help="Use outskirts rent instead of central")
    args = parser.parse_args()

    db = load_cost_db()
    if not db:
        sys.exit(1)

    sa_cities = compare_cities(args.region_sa, db, prefer_central=not args.outskirts)
    na_cities = compare_cities(args.region_na, db, prefer_central=not args.outskirts)

    print(f"Cost Comparison: {'Outskirts Rent' if args.outskirts else 'Central Rent'}")
    print_comparison(sa_cities, na_cities)

    # Print medians
    sa_median = sa_cities[len(sa_cities)//2]["all_in_usd"] if sa_cities else 0
    na_median = na_cities[len(na_cities)//2]["all_in_usd"] if na_cities else 0
    print("\nMedians:")
    print(f"South America: ${sa_median}")
    print(f"North America: ${na_median}")
    print(f"SA saves {round((1 - sa_median/na_median)*100, 1)}% vs NA")

if __name__ == "__main__":
    main()

import selenium
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException, NoSuchElementException
import argparse
import json
import time
from typing import Dict, Optional
import sys

# Visa configuration: official portal URLs and CSS selectors for processing times
VISA_CONFIG = {
    "US B1/B2": {
        "url": "https://travel.state.gov/content/travel/en/us-visas/visa-information-resources/global-visa-wait-times.html",
        "selector": ".visa-wait-time",  # Simplified selector, actual may vary
        "region": "North America"
    },
    "Canada IEC": {
        "url": "https://www.canada.ca/en/immigration-refugees-citizenship/services/work-canada/iec/apply.html",
        "selector": "[data-testid='processing-time']",
        "region": "North America"
    },
    "Colombia Digital Nomad": {
        "url": "https://www.cancilleria.gov.co/en/procedures/visas/digital-nomad",
        "selector": ".processing-time",
        "region": "South America"
    },
    "Argentina Rentista": {
        "url": "https://www.migraciones.gov.ar/accesible/index.php/en/visas/rentista-visa",
        "selector": "#processing-time",
        "region": "South America"
    },
    "Brazil VITEM XIV": {
        "url": "https://www.gov.br/mre/pt-br/consulado-miami/visas-vitem-xiv",
        "selector": ".tempo-processamento",
        "region": "South America"
    }
}

def init_driver(headless: bool = True) -> webdriver.Chrome:
    """Initialize Chrome driver with error handling."""
    try:
        options = webdriver.ChromeOptions()
        if headless:
            options.add_argument("--headless=new")
        options.add_argument("--no-sandbox")
        options.add_argument("--disable-dev-shm-usage")
        driver = webdriver.Chrome(options=options)
        return driver
    except selenium.common.exceptions.WebDriverException as e:
        print(f"Failed to initialize Chrome driver: {str(e)}", file=sys.stderr)
        print("Ensure Chrome and chromedriver are installed and matching versions.", file=sys.stderr)
        sys.exit(1)

def get_processing_time(driver: webdriver.Chrome, visa_name: str, config: Dict) -> Optional[str]:
    """Scrape processing time for a single visa, with retries and timeouts."""
    try:
        driver.get(config["url"])
        # Wait up to 10 seconds for element to load
        wait = WebDriverWait(driver, 10)
        element = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, config["selector"])))
        processing_time = element.text.strip()
        return processing_time
    except TimeoutException:
        print(f"Timeout waiting for processing time element for {visa_name}", file=sys.stderr)
        return None
    except NoSuchElementException:
        print(f"Processing time element not found for {visa_name} (selector: {config['selector']})", file=sys.stderr)
        return None
    except Exception as e:
        print(f"Unexpected error scraping {visa_name}: {str(e)}", file=sys.stderr)
        return None

def benchmark_visas(headless: bool = True) -> Dict[str, Dict]:
    """Run benchmarks for all configured visas, return results dict."""
    driver = init_driver(headless=headless)
    results = {}
    try:
        for visa_name, config in VISA_CONFIG.items():
            print(f"Benchmarking {visa_name}...")
            proc_time = get_processing_time(driver, visa_name, config)
            results[visa_name] = {
                "region": config["region"],
                "processing_time": proc_time if proc_time else "Unavailable",
                "url": config["url"]
            }
            time.sleep(2)  # Be polite to servers
        return results
    finally:
        driver.quit()

def print_results(results: Dict[str, Dict]) -> None:
    """Print formatted results table."""
    print(f"\n{"Visa Name":<30} {"Region":<20} {"Processing Time":<20} {"Source URL":<50}")
    print("-" * 120)
    for visa, data in results.items():
        print(f"{visa:<30} {data['region']:<20} {data['processing_time']:<20} {data['url']:<50}")

def save_results(results: Dict[str, Dict], output_path: str = "visa_benchmarks.json") -> None:
    """Save results to JSON file."""
    try:
        with open(output_path, "w") as f:
            json.dump(results, f, indent=2)
        print(f"\nResults saved to {output_path}")
    except IOError as e:
        print(f"Failed to save results: {str(e)}", file=sys.stderr)

def main():
    parser = argparse.ArgumentParser(description="Benchmark visa processing times for digital nomad visas")
    parser.add_argument("--no-headless", action="store_true", help="Run Chrome in non-headless mode")
    parser.add_argument("--output", type=str, default="visa_benchmarks.json", help="Output JSON path")
    args = parser.parse_args()

    print("Starting visa processing time benchmarks...")
    results = benchmark_visas(headless=not args.no_headless)
    print_results(results)
    save_results(results, args.output)

if __name__ == "__main__":
    main()

uci set network.wan2=interface
uci set network.wan2.proto=dhcp
uci set network.wan2.ifname=eth2
uci set network.globals.ping_interval=5
uci set network.globals.ping_timeout=1
uci set network.globals.ping_fail_count=3
uci set network.globals.ping_restart_count=5
uci commit network
/etc/init.d/network restart

import requests
response = requests.get("https://nomadlist.com/api/v2/visas/colombia-digital-nomad")
data = response.json()
print(f"Current processing time: {data['processing_days']} days")

import deel
deel.api_key = "your_api_key"
invoice = deel.Invoice.create(
    amount=8000,
    currency="USD",
    description="Monthly senior backend dev retainer",
    due_date="2024-10-31"
)
print(f"Invoice created: {invoice.id}")