traffic-cli 0.1.1__tar.gz

traffic_cli-0.1.1/.github/workflows/publish.yml

@@ -0,0 +1,41 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build-and-publish:
+    name: Build and publish Python distribution to PyPI
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write  # Mandatory for PyPI Trusted Publishing
+      contents: read
+
+    environment:
+      name: pypi
+      url: https://pypi.org/p/traffic-cli
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build distributions
+        run: uv build
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

traffic_cli-0.1.1/.gitignore

@@ -0,0 +1,18 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# Virtual environments
+.venv/
+env/
+venv/
+
+# Cache & testing
+.pytest_cache/
+.ruff_cache/

traffic_cli-0.1.1/.python-version

@@ -0,0 +1 @@
+3.14

traffic_cli-0.1.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.5
+Name: traffic-cli
+Version: 0.1.1
+Summary: CLI tool to calculate travel times using routing APIs
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0.0
+Requires-Dist: geopy>=2.4.1
+Requires-Dist: routingpy>=1.3.0

traffic_cli-0.1.1/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "traffic-cli"
+version = "0.1.1"
+description = "CLI tool to calculate travel times using routing APIs"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "click>=8.0.0",
+    "geopy>=2.4.1",
+    "routingpy>=1.3.0",
+]
+
+[project.scripts]
+traffic = "traffic.cli:traffic"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/traffic"]

traffic_cli-0.1.1/src/traffic/abstract/geo.py

@@ -0,0 +1,108 @@
+"""
+Get all of the geometric info, such as postcode  -> lat/long, etc
+"""
+
+from geopy.geocoders import Nominatim
+import routingpy
+from typing import Literal, List
+from traffic.config import Config
+
+geocoder = Nominatim(user_agent="traffic")
+
+
+provider_map: dict = {
+    "ors": {
+        "class_name": "ORS",
+        "profiles": {"bike": "cycling-regular", "car": "driving-car", "walk": "foot-walking"},
+    },
+    "graphhopper": {
+        "class_name": "Graphhopper",
+        "profiles": {"bike": "bike", "car": "car", "walk": "foot"},
+    },
+    "mapbox": {
+        "class_name": "MapboxOSRM",
+        "profiles": {"bike": "cycling", "car": "driving", "walk": "walking"},
+    },
+    "google_maps": {
+        "class_name": "Google",
+        "profiles": {"bike": "bicycling", "car": "driving", "walk": "walking"},
+    },
+    "tomtom": {
+        "class_name": "TomTom",
+        "profiles": {
+            "bike": "bicycle",
+            "car": "car",
+            "walk": "pedestrian",
+        },
+    },
+}
+
+
+class Router:
+    def __init__(self, config: Config):
+        self.config = config
+        provider_name = config.provider_name
+        profile = config.profile
+        if not provider_name:
+            raise ValueError("Provider name not set in config.")
+        
+        provider_info = next(
+            (v for k, v in provider_map.items() if k.lower() == provider_name.lower() or v.get("class_name", "").lower() == provider_name.lower()),
+            None
+        )
+        if not provider_info:
+            raise ValueError(f"Provider '{provider_name}' is not supported.")
+
+        self.profile = provider_info["profiles"][profile]
+        self.routing_client = config.router_class(api_key=config.api_key)
+
+    def resolve_var(self, *vars):
+        """Checks if inputs are stored in config, replaces them, and returns them all."""
+
+        resolved = [self.config.config.get("vars", {}).get(var, self.config.config.get(var, var)) for var in vars]
+
+        if not resolved:
+            return None
+
+        if len(resolved) == 1:
+            return resolved[0]
+
+        return tuple(resolved)
+
+    def _geocode_location(self, query: str, country_code: str = None):
+        """Geocodes a query string, applying country bias if configured."""
+        country = country_code or getattr(self.config, "country", None) or (self.config.config.get("country") if self.config.config else None)
+        if country:
+            cc = country.lower().strip()
+            if cc == "uk":
+                cc = "gb"
+            try:
+                location = geocoder.geocode(query, country_codes=cc)
+                if location:
+                    return location
+            except Exception:
+                pass
+
+        try:
+            location = geocoder.geocode(query)
+        except Exception as e:
+            raise ValueError(f"Geocoding service error while searching for '{query}': {e}")
+
+        if not location:
+            raise ValueError(f"Coordinates for '{query}' could not be found.")
+        return location
+
+    def get_travel_time(self, home: str, destination: str, country_code: str = None):
+        home, destination = self.resolve_var(home, destination)
+        home_loc = self._geocode_location(home, country_code=country_code)
+        destination_loc = self._geocode_location(destination, country_code=country_code)
+
+        self.last_home_location = home_loc
+        self.last_destination_location = destination_loc
+
+        home_coords = [home_loc.longitude, home_loc.latitude]
+        destination_coords = [destination_loc.longitude, destination_loc.latitude]
+        route = self.routing_client.directions(
+            locations=[home_coords, destination_coords], profile=self.profile
+        )
+        return route.duration

traffic_cli-0.1.1/src/traffic/cli.py

@@ -0,0 +1,491 @@
+import json
+import re
+import click
+from traffic.abstract.geo import Router, geocoder
+from traffic.config import Config
+
+
+def get_initialized_config(headless: bool = False):
+    """Gets the configuration, automatically prompting for initialization if missing (unless headless)."""
+    config = Config()
+    if not config.provider_name:
+        if headless:
+            click.echo(
+                "Error: Configuration not found or not initialized. Run `traffic init` first.",
+                err=True,
+            )
+            raise SystemExit(1)
+        click.echo("Configuration not found or not initialized.")
+        provider_name = click.prompt(
+            "Please enter provider name (e.g. ORS, Graphhopper)"
+        )
+        api_key = click.prompt("Please enter API key")
+        profile = click.prompt("Please enter default profile", default="car")
+        config.initialise(provider_name, api_key, profile)
+        click.echo(f"Configuration initialised with provider: {provider_name}\n")
+    return config
+
+
+def format_duration(seconds: float) -> str:
+    """Formats a duration in seconds into a readable string of days, hours, mins, seconds."""
+
+    sec = int(seconds)
+    days, sec = divmod(sec, 86400)
+    hours, sec = divmod(sec, 3600)
+    mins, sec = divmod(sec, 60)
+
+    parts = []
+    if days > 0:
+        parts.append(f"{days} day{'s' if days != 1 else ''}")
+    if hours > 0:
+        parts.append(f"{hours} hour{'s' if hours != 1 else ''}")
+    if mins > 0:
+        parts.append(f"{mins} min{'s' if mins != 1 else ''}")
+    if sec > 0 or not parts:
+        parts.append(f"{sec} second{'s' if sec != 1 else ''}")
+
+    return ", ".join(parts)
+
+
+def format_duration_compact(seconds: float) -> str:
+    """Formats a duration in seconds into a compact string like '1d 2h 15m' or '45m'."""
+    sec = int(seconds)
+    days, sec = divmod(sec, 86400)
+    hours, sec = divmod(sec, 3600)
+    mins, sec = divmod(sec, 60)
+
+    parts = []
+    if days > 0:
+        parts.append(f"{days}d")
+    if hours > 0:
+        parts.append(f"{hours}h")
+    if mins > 0:
+        parts.append(f"{mins}m")
+    if not parts or (days == 0 and hours == 0 and mins == 0):
+        parts.append(f"{sec}s")
+
+    return " ".join(parts)
+
+
+def format_error_message(exc: Exception) -> str:
+    """
+    Extracts a clean, human-readable error message from exceptions,
+    parsing JSON payloads from routing APIs and filtering out raw JSON/metadata.
+    """
+    status = getattr(exc, "status", None)
+    raw_msg = getattr(exc, "message", str(exc))
+
+    parsed_json = None
+
+    if isinstance(raw_msg, str):
+        json_match = re.search(r"(\{.*\})", raw_msg, re.DOTALL)
+        if json_match:
+            candidate = json_match.group(1)
+            try:
+                parsed_json = json.loads(candidate)
+            except Exception:
+                try:
+                    import ast
+                    parsed_json = ast.literal_eval(candidate)
+                except Exception:
+                    pass
+    elif isinstance(raw_msg, dict):
+        parsed_json = raw_msg
+
+    extracted_msg = None
+    if isinstance(parsed_json, dict):
+        # 1. ORS / OpenRouteService or generic error object
+        err_field = parsed_json.get("error")
+        if isinstance(err_field, dict):
+            extracted_msg = (
+                err_field.get("message")
+                or err_field.get("detail")
+                or err_field.get("description")
+            )
+        elif isinstance(err_field, str):
+            extracted_msg = err_field
+
+        # 2. GraphHopper / Mapbox standard 'message'
+        if not extracted_msg and "message" in parsed_json:
+            extracted_msg = str(parsed_json["message"])
+
+        # 3. Google Maps 'error_message'
+        if not extracted_msg and "error_message" in parsed_json:
+            extracted_msg = str(parsed_json["error_message"])
+
+        # 4. TomTom 'detailedError'
+        if not extracted_msg and isinstance(parsed_json.get("detailedError"), dict):
+            extracted_msg = parsed_json["detailedError"].get("message")
+
+        # 5. TomTom 'errorText'
+        if not extracted_msg and "errorText" in parsed_json:
+            extracted_msg = str(parsed_json["errorText"])
+
+        # 6. GraphHopper 'hints'
+        if not extracted_msg and isinstance(parsed_json.get("hints"), list) and parsed_json["hints"]:
+            first_hint = parsed_json["hints"][0]
+            if isinstance(first_hint, dict):
+                extracted_msg = first_hint.get("message")
+            elif isinstance(first_hint, str):
+                extracted_msg = first_hint
+
+    # Fallback to string representation if no JSON field extracted
+    if not extracted_msg:
+        extracted_msg = str(exc)
+        clean_match = re.match(r"^\d{3}\s*\((.*)\)$", extracted_msg, re.DOTALL)
+        if clean_match:
+            extracted_msg = clean_match.group(1).strip()
+
+    user_msg = extracted_msg.strip()
+
+    # Provide actionable context for common failure modes
+    lower_msg = user_msg.lower()
+    if (
+        status in (401, 403)
+        or "unauthorized" in lower_msg
+        or "invalid token" in lower_msg
+        or "invalid api key" in lower_msg
+        or "not authorized" in lower_msg
+    ):
+        return f"{user_msg} (Check your API key using `traffic set api_key <key>`)"
+
+    if (
+        status == 404
+        or "could not find point" in lower_msg
+        or "cannot find point" in lower_msg
+        or "within a radius" in lower_msg
+        or "noroute" in lower_msg
+        or "no route" in lower_msg
+    ):
+        return f"{user_msg} (No drivable route found between these locations for the selected travel profile)."
+
+    if (
+        status == 429
+        or "rate limit" in lower_msg
+        or "quota" in lower_msg
+        or "over query limit" in lower_msg
+    ):
+        return f"{user_msg} (Rate limit exceeded. Please wait a moment before trying again)."
+
+    return user_msg
+
+
+def resolve_locations(locations, home_opt=None, dest_opt=None, config=None, country_code=None):
+    """
+    Resolves the origin (home) and destination from CLI options and positional arguments.
+    Supports delimiters ('to', '->'), config variables, country biasing, and heuristic multi-word splitting.
+    Returns a tuple: (origin, destination, info_message, error_message).
+    """
+    vars_dict = config.config.get("vars", {}) if config and config.config else {}
+    cc = country_code or getattr(config, "country", None) or (config.config.get("country") if config and config.config else None)
+    if cc:
+        cc = cc.lower().strip()
+        if cc == "uk":
+            cc = "gb"
+
+    # Case 1: Both options provided explicitly
+    if home_opt and dest_opt:
+        return home_opt, dest_opt, None, None
+
+    # Case 2: One option provided explicitly, positional args provide the other
+    if home_opt and locations:
+        return home_opt, " ".join(locations), None, None
+    if dest_opt and locations:
+        return " ".join(locations), dest_opt, None, None
+
+    # Case 3: No positional locations provided
+    if not locations:
+        err = (
+            "Error: Missing origin and destination.\n\n"
+            "Usage:\n"
+            "  traffic <origin> <destination>\n"
+            "  traffic <origin> to <destination>\n\n"
+            "Examples:\n"
+            "  traffic california nevada\n"
+            '  traffic "las vegas" california\n'
+            "  traffic las vegas to california\n"
+            "  traffic home work"
+        )
+        return None, None, None, err
+
+    # Case 4: Single positional string passed (e.g. 'las vegas to california')
+    if len(locations) == 1:
+        text = locations[0].strip()
+        to_split = re.split(r"\s+to\s+", text, maxsplit=1, flags=re.IGNORECASE)
+        if len(to_split) == 2 and to_split[0].strip() and to_split[1].strip():
+            return to_split[0].strip(), to_split[1].strip(), None, None
+
+        if "->" in text:
+            parts = text.split("->", 1)
+            if parts[0].strip() and parts[1].strip():
+                return parts[0].strip(), parts[1].strip(), None, None
+
+        if "," in text:
+            parts = text.split(",", 1)
+            if parts[0].strip() and parts[1].strip():
+                return parts[0].strip(), parts[1].strip(), None, None
+
+        err = (
+            f"Error: Could not determine both origin and destination from '{text}'.\n\n"
+            "Tip: Separate locations with spaces or use 'to', for example:\n"
+            f'  traffic "{text}" <destination>\n'
+            f"  traffic {text} to <destination>"
+        )
+        return None, None, None, err
+
+    # Case 5: Exactly 2 positional arguments
+    if len(locations) == 2:
+        return locations[0], locations[1], None, None
+
+    # Case 6: 3 or more positional arguments
+    # Check for keyword delimiter 'to' or '->'
+    lower_tokens = [t.lower() for t in locations]
+    if "to" in lower_tokens:
+        idx = lower_tokens.index("to")
+        if 0 < idx < len(locations) - 1:
+            h = " ".join(locations[:idx])
+            d = " ".join(locations[idx + 1:])
+            return h, d, None, None
+
+    if "->" in locations:
+        idx = locations.index("->")
+        if 0 < idx < len(locations) - 1:
+            h = " ".join(locations[:idx])
+            d = " ".join(locations[idx + 1:])
+            return h, d, None, None
+
+    # Check for saved variable boundaries in config (e.g. 'home las vegas')
+    if locations[0] in vars_dict:
+        return locations[0], " ".join(locations[1:]), None, None
+    if locations[-1] in vars_dict:
+        return " ".join(locations[:-1]), locations[-1], None, None
+
+    # Heuristic split testing using geocoding
+    best_split = None
+    best_score = -1.0
+
+    for i in range(1, len(locations)):
+        cand_h = " ".join(locations[:i])
+        cand_d = " ".join(locations[i:])
+        try:
+            loc_h = None
+            loc_d = None
+            if cc:
+                try:
+                    loc_h = geocoder.geocode(cand_h, country_codes=cc)
+                    loc_d = geocoder.geocode(cand_d, country_codes=cc)
+                except Exception:
+                    pass
+            if not loc_h:
+                loc_h = geocoder.geocode(cand_h)
+            if not loc_d:
+                loc_d = geocoder.geocode(cand_d)
+
+            if loc_h and loc_d:
+                imp_h = getattr(loc_h, "raw", {}).get("importance", 0.5)
+                imp_d = getattr(loc_d, "raw", {}).get("importance", 0.5)
+                score = imp_h + imp_d
+                if score > best_score:
+                    best_score = score
+                    best_split = (cand_h, cand_d)
+        except Exception:
+            pass
+
+    if best_split:
+        h, d = best_split
+        info = (
+            f"Interpreting route as: '{h}' -> '{d}'\n"
+            f"Tip: You can wrap multi-word locations in quotes (e.g. traffic \"{h}\" \"{d}\") or use 'to' (e.g. traffic {h} to {d}).\n"
+        )
+        return h, d, info, None
+
+    raw_query = " ".join(locations)
+    err = (
+        f"Error: Could not determine origin and destination from '{raw_query}'.\n\n"
+        "Tip: Wrap locations containing spaces in quotes, e.g.:\n"
+        f'  traffic "{locations[0]} {locations[1]}" "{" ".join(locations[2:])}"\n'
+        "Or use 'to' as a separator:\n"
+        f"  traffic {' '.join(locations[:2])} to {' '.join(locations[2:])}"
+    )
+    return None, None, None, err
+
+
+class DefaultCommandGroup(click.Group):
+    """A Click Group that routes non-subcommand invocations to a default command."""
+
+    def __init__(self, *args, **kwargs):
+        self.default_cmd_name = kwargs.pop("default_cmd", "route")
+        super().__init__(*args, **kwargs)
+
+    def parse_args(self, ctx, args):
+        if not args:
+            return super().parse_args(ctx, args)
+        first_arg = args[0]
+        if first_arg in self.commands:
+            return super().parse_args(ctx, args)
+        if first_arg in ("--help", "--version"):
+            return super().parse_args(ctx, args)
+        args = [self.default_cmd_name] + list(args)
+        return super().parse_args(ctx, args)
+
+    def format_usage(self, ctx, formatter):
+        formatter.write_usage(
+            ctx.command_path,
+            "[OPTIONS] [ORIGIN] [DESTINATION] | COMMAND [ARGS]...",
+        )
+
+
+@click.group(cls=DefaultCommandGroup, default_cmd="route", invoke_without_command=True)
+@click.pass_context
+def traffic(ctx):
+    """Calculates route and travel time between locations.
+
+\b
+Examples:
+  traffic california nevada
+  traffic "las vegas" california
+  traffic las vegas to california
+  traffic home work
+  traffic --country gb b46 cv7
+  traffic --json home work
+  traffic --headless --compact home work
+  traffic --home London --destination Paris
+"""
+    if ctx.invoked_subcommand is None and not ctx.params:
+        click.echo(ctx.get_help())
+
+
+@traffic.command("route", hidden=True)
+@click.argument("locations", nargs=-1)
+@click.option("--home", "-h", help="Starting postcode or address")
+@click.option("--destination", "-d", help="Ending postcode or address")
+@click.option("--country", "--cc", help="Country code bias for geocoding (e.g. 'gb', 'us', 'fr')")
+@click.option("--no-motorways", is_flag=True, help="Avoid motorways")
+@click.option("--include-tolls", is_flag=True, help="Include toll roads")
+@click.option("--headless", "-q", "--quiet", is_flag=True, help="Headless mode: suppress tips and output clean duration")
+@click.option("--json", "json_output", is_flag=True, help="Output result in JSON format (Waybar compatible)")
+@click.option("--compact", "-c", is_flag=True, help="Output compact duration (e.g. '1h 15m')")
+@click.option("--raw", "--seconds", is_flag=True, help="Output raw duration in seconds")
+@click.pass_context
+def route_cmd(
+    ctx,
+    locations,
+    home,
+    destination,
+    country,
+    no_motorways,
+    include_tolls,
+    headless,
+    json_output,
+    compact,
+    raw,
+):
+    """Calculates route and travel time between locations."""
+    is_headless = headless or json_output or compact or raw
+    config = get_initialized_config(headless=is_headless)
+
+    origin, dest, info, err = resolve_locations(
+        locations=locations,
+        home_opt=home,
+        dest_opt=destination,
+        config=config,
+        country_code=country,
+    )
+
+    if err:
+        if json_output:
+            click.echo(
+                json.dumps(
+                    {
+                        "text": "error",
+                        "alt": "traffic-error",
+                        "tooltip": err.splitlines()[0],
+                        "class": "error",
+                        "error": err,
+                    }
+                )
+            )
+        else:
+            click.echo(err, err=True)
+        ctx.exit(1)
+
+    if info and not is_headless:
+        click.echo(info)
+
+    router = Router(config)
+
+    try:
+        duration = router.get_travel_time(origin, dest, country_code=country)
+        home_addr = getattr(getattr(router, "last_home_location", None), "address", origin)
+        dest_addr = getattr(getattr(router, "last_destination_location", None), "address", dest)
+        resolved_h, resolved_d = router.resolve_var(origin, dest)
+
+        if json_output:
+            formatted = format_duration(duration)
+            compact_fmt = format_duration_compact(duration)
+            output_data = {
+                "text": compact_fmt,
+                "alt": "traffic",
+                "tooltip": f"From: {resolved_h} ({home_addr})\nTo: {resolved_d} ({dest_addr})\nTravel time: {formatted}",
+                "class": "traffic",
+                "duration_seconds": int(duration),
+                "formatted": formatted,
+                "compact": compact_fmt,
+                "origin": resolved_h,
+                "origin_address": home_addr,
+                "destination": resolved_d,
+                "destination_address": dest_addr,
+            }
+            click.echo(json.dumps(output_data))
+        elif raw:
+            click.echo(int(duration))
+        elif compact:
+            click.echo(format_duration_compact(duration))
+        elif headless:
+            click.echo(format_duration(duration))
+        else:
+            click.echo(f"From: {resolved_h} ({home_addr})")
+            click.echo(f"To:   {resolved_d} ({dest_addr})")
+            click.echo(f"Travel time: {format_duration(duration)}")
+    except Exception as e:
+        error_msg = format_error_message(e)
+        if json_output:
+            click.echo(
+                json.dumps(
+                    {
+                        "text": "error",
+                        "alt": "traffic-error",
+                        "tooltip": f"Traffic error: {error_msg}",
+                        "class": "error",
+                        "error": error_msg,
+                    }
+                )
+            )
+        else:
+            click.echo(f"Error calculating travel time: {error_msg}", err=True)
+        ctx.exit(1)
+
+
+@traffic.command()
+@click.argument("provider_name")
+@click.argument("api_key")
+@click.argument("profile", default="car")
+def init(provider_name, api_key, profile):
+    """Creates the initial config"""
+    config = Config()
+    config.initialise(provider_name, api_key, profile)
+    click.echo(f"Initialised with {provider_name}")
+
+
+@traffic.command()
+@click.argument("key")
+@click.argument("value")
+def set(key, value):
+    """Sets a configuration variable or setting (e.g. country, profile, api_key, home)."""
+    config = get_initialized_config()
+    config.set_config_value(key, value)
+    click.echo(f"Set {key} to {value}")
+
+
+if __name__ == "__main__":
+    traffic()

traffic_cli-0.1.1/src/traffic/config.py

@@ -0,0 +1,118 @@
+import json
+from pathlib import Path
+import logging
+import routingpy
+
+logger = logging.getLogger(__name__)
+CONFIG_DIR = Path.home() / ".traffic"
+
+
+class Config:
+    def __init__(self) -> None:
+        self.config_file = CONFIG_DIR / "config.json"
+        self.config = self._load_config()
+
+        if self.config:
+            self.provider_name = self.config.get("provider_name")
+            self.api_key = self.config.get("api_key")
+            self.profile = self.config.get("profile", "car")
+            self.country = self.config.get("country") or self.config.get("country_code")
+
+            try:
+                self.router_class = self._get_router_class(self.provider_name)
+            except AttributeError:
+                raise ValueError(
+                    f"Provider {self.provider_name} is not part of the supported list."
+                )
+        else:
+            logger.warning("Config has not been initialised - init script must be ran")
+            self.provider_name = None
+            self.api_key = None
+            self.profile = None
+            self.country = None
+            self.router_class = None
+
+    def _get_router_class(self, provider_name):
+        if not provider_name:
+            return None
+        name_lower = provider_name.lower()
+        if name_lower == "mapbox":
+            target = "mapboxosrm"
+        elif name_lower == "google_maps":
+            target = "google"
+        else:
+            target = name_lower
+        class_name = next(
+            (attr for attr in dir(routingpy) if attr.lower() == target),
+            provider_name
+        )
+        return getattr(routingpy, class_name)
+
+    def _load_config(self):
+        """Safely loads the config file if it exists."""
+        if self.config_file.exists():
+            with open(self.config_file, "r") as f:
+                return json.load(f)
+        return {}
+
+    def initialise(self, provider_name, api_key, profile):
+        """Creates the initial config.json from CLI arguments."""
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        self.config = {
+            "provider_name": provider_name,
+            "api_key": api_key,
+            "profile": profile,
+            "vars": {},
+        }
+
+        self.provider_name = provider_name
+        self.api_key = api_key
+        self.profile = profile
+        self.country = None
+        self.router_class = self._get_router_class(self.provider_name)
+
+        self.save()
+        logger.info("Config created successfully")
+
+    def save(self):
+        """Writes the current state back to the disk."""
+        with open(self.config_file, "w") as f:
+            json.dump(self.config, f, indent=4)
+
+    def set_config_value(self, key: str, value: str):
+        """Sets a configuration variable or system setting."""
+        if not self.config:
+            raise ValueError("Config not initialized. Run `init` first.")
+
+        norm_key = key.lower()
+        if norm_key in ("profile", "default_profile"):
+            self.config["profile"] = value
+            self.profile = value
+            logger.info("Changed default profile to %s", value)
+        elif norm_key in ("country", "country_code", "cc"):
+            val = value.lower().strip()
+            if val == "uk":
+                val = "gb"
+            self.config["country"] = val
+            self.country = val
+            logger.info("Changed default country to %s", val)
+        elif norm_key == "api_key":
+            self.config["api_key"] = value
+            self.api_key = value
+        elif norm_key == "provider_name":
+            self.config["provider_name"] = value
+            self.provider_name = value
+            self.router_class = self._get_router_class(value)
+        else:
+            if "vars" not in self.config:
+                self.config["vars"] = {}
+            self.config["vars"][key] = value
+            logger.info("Added variable %s to config with value %s", key, value)
+
+        self.save()
+
+    def add_var_to_config(self, key: str, value: str):
+        self.set_config_value(key, value)
+
+    def set_default_profile(self, profile: str):
+        self.set_config_value("profile", profile)

traffic_cli-0.1.1/uv.lock

@@ -0,0 +1,156 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "certifi"
+version = "2026.5.20"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f3/ce/ee2ecad540810a79593028e88299baeae54d346cc7a0d94b6199988b89b1/certifi-2026.5.20.tar.gz", hash = "sha256:69dea482ab64caa7b9f6aba1c6bf48bb6a5448d1c0f1b17ab42ad8c763a5344d", size = 135422, upload-time = "2026-05-20T11:46:50.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/8c/57e832b7af6d7c5abe66eb3fbe3a3a32f4d11ea23a1aa7131371035be991/certifi-2026.5.20-py3-none-any.whl", hash = "sha256:3c52e209ba0a4ad7aebe60436a4ab349c39e1e602e8c134221e546902ad25897", size = 134134, upload-time = "2026-05-20T11:46:48.578Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" },
+    { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" },
+    { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" },
+    { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" },
+    { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" },
+    { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" },
+    { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" },
+    { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" },
+    { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9b/98/518d8e5081007684232226f475082b30087d0f585e8457db087298259f49/click-8.4.1.tar.gz", hash = "sha256:918b5633eddf6b41c32d4f454bf0de810065c74e3f7dbf8ee5452f8be88d3e96", size = 353007, upload-time = "2026-05-22T04:08:37.769Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "geographiclib"
+version = "2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/78/4892343230a9d29faa1364564e525307a37e54ad776ea62c12129dbba704/geographiclib-2.1.tar.gz", hash = "sha256:6a6545e6262d0ed3522e13c515713718797e37ed8c672c31ad7b249f372ef108", size = 37004, upload-time = "2025-08-21T21:34:26Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/b3/802576f2ea5dcb48501bb162e4c7b7b3ca5654a42b2c968ef98a797a4c79/geographiclib-2.1-py3-none-any.whl", hash = "sha256:e2a873b9b9e7fc38721ad73d5f4e6c9ed140d428a339970f505c07056997d40b", size = 40740, upload-time = "2025-08-21T21:34:24.955Z" },
+]
+
+[[package]]
+name = "geopy"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "geographiclib" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/fd/ef6d53875ceab72c1fad22dbed5ec1ad04eb378c2251a6a8024bad890c3b/geopy-2.4.1.tar.gz", hash = "sha256:50283d8e7ad07d89be5cb027338c6365a32044df3ae2556ad3f52f4840b3d0d1", size = 117625, upload-time = "2023-11-23T21:49:32.734Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/15/cf2a69ade4b194aa524ac75112d5caac37414b20a3a03e6865dfe0bd1539/geopy-2.4.1-py3-none-any.whl", hash = "sha256:ae8b4bc5c1131820f4d75fce9d4aaaca0c85189b3aa5d64c3dcaf5e3b7b882a7", size = 125437, upload-time = "2023-11-23T21:49:30.421Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.34.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
+]
+
+[[package]]
+name = "routingpy"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "requests" },
+]
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/01/72f3ed477b8bbf0774c95e11c6eaabdc1ac7e9bf9417b1c9bc3741a126f9/routingpy-1.3.0-py3-none-any.whl", hash = "sha256:4ccbe74691d1ffa492bd668e3468ce4a184c7c86ced6fa041fd16d85fac8fde3", size = 84433, upload-time = "2023-08-03T09:12:26.146Z" },
+]
+
+[[package]]
+name = "traffic-cli"
+version = "0.1.1"
+source = { editable = "." }
+dependencies = [
+    { name = "click" },
+    { name = "geopy" },
+    { name = "routingpy" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "click", specifier = ">=8.4.1" },
+    { name = "geopy", specifier = ">=2.4.1" },
+    { name = "routingpy", specifier = ">=1.3.0" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+]