ip map

.env.example

@@ -4,7 +4,3 @@ MONGO_COLLECTION=events
 HOST=0.0.0.0
 PORT=7860
 GRADIO_SHARE=false
-GRADIO_SSR_MODE=false
-GEOIP_DATABASE_PATH=GeoLite2-Country.mmdb
-GEOIP_DATABASE_URL=https://cdn.jsdelivr.net/npm/geolite2-country/GeoLite2-Country.mmdb.gz
-GEOIP_AUTO_DOWNLOAD=true

.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install package
+        run: python -m pip install --upgrade pip && python -m pip install ".[dev]"
+
+      - name: Check formatting
+        run: ruff format --check .
+
+      - name: Lint
+        run: ruff check .
+
+      - name: Test
+        run: pytest

.gitignore

@@ -49,7 +49,6 @@ coverage.xml
 *.py.cover
 .hypothesis/
 .pytest_cache/
-.pytest_tmp/
 cover/
 
 # Translations
@@ -145,13 +144,6 @@ ENV/
 env.bak/
 venv.bak/
 
-# Local GeoIP databases
-*.mmdb
-*.mmdb.gz
-
-# Local analytics exports
-visitor_ips*.csv
-
 # Spyder project settings
 .spyderproject
 .spyproject

README.md

@@ -26,7 +26,6 @@ All analytics are based on the `events` collection and the following stable fiel
 - Preferred event time: `ts` as a MongoDB Date
 - Behavior context: `benchmark`, `filters`
 - Visitor identity (approximate): `properties.visitor_id`
-- Visitor IP for country analysis: `properties.ip`
 - Change context: `properties.old_value`, `properties.new_value`, `properties.filter_name`
 
 Important event names:
@@ -162,19 +161,6 @@ Recommended session-level funnel:
   - If event date is later than first-seen date, classify as `returning`
   - Count distinct `visitor_id` by period
 
-### 13) Visitor Locations by Country
-
-- **Definition**: Page view volume by visitor IP country/region.
-- **Source fields**: `event_name`, `properties.ip`
-- **Calculation**:
-  - Filter `event_name == "page_view"`
-  - Remove null/empty `properties.ip`
-  - Group page views by IP in MongoDB
-  - Resolve each IP to a country using the local MaxMind GeoLite2 Country database
-  - Group by `country_code` and `country_name`
-  - Map color = page view count (`pv`)
-  - Private, invalid, unresolved, or unconfigured IPs are grouped as `Unknown`
-
 ---
 
 ## Time Aggregation Rules
@@ -219,7 +205,6 @@ db.events.createIndex({ ts: 1, benchmark: 1 })
 db.events.createIndex({ event_name: 1, ts: 1 })
 db.events.createIndex({ session_id: 1, ts: 1 })
 db.events.createIndex({ "properties.visitor_id": 1, ts: 1 })
-db.events.createIndex({ event_name: 1, ts: 1, "properties.ip": 1 })
 ```
 
 Legacy events with only `timestamp` remain supported, but backfilling `ts` is recommended before running this dashboard against large collections.
@@ -233,19 +218,6 @@ Only required runtime inputs:
 - MongoDB connection URI (`MONGO_URI`)
 - Mongo database/collection names (defaults supported)
 
-Optional visitor location input:
-
-- `GEOIP_DATABASE_PATH`: path to a local MaxMind `GeoLite2-Country.mmdb` file
-- `GEOIP_DATABASE_URL`: URL for a gzipped GeoLite2 Country MMDB download
-- `GEOIP_AUTO_DOWNLOAD`: whether to download and decompress the MMDB when missing
-
-The dashboard does not call an external IP lookup API for visitor lookups. By default,
-startup downloads `https://cdn.jsdelivr.net/npm/geolite2-country/GeoLite2-Country.mmdb.gz`
-when `GEOIP_DATABASE_PATH` is missing, decompresses it, and uses the resulting MMDB file
-locally. Set `GEOIP_AUTO_DOWNLOAD=false` if the runtime cannot access the network or if
-you prefer to mount the MMDB yourself. If the database is unavailable, visitor location
-rows are grouped as `Unknown`.
-
 Local commands:
 
 ```bash

app.py

@@ -7,9 +7,7 @@ SRC_DIR = ROOT_DIR / "src"
 if str(SRC_DIR) not in sys.path:
     sys.path.insert(0, str(SRC_DIR))
 
-from leaderboard_analytics.main import create_demo, launch_demo  # noqa: E402
-
-demo = create_demo()
+from leaderboard_analytics.main import run  # noqa: E402
 
 if __name__ == "__main__":
-    launch_demo(demo)
+    run()

pyproject.toml

@@ -12,7 +12,6 @@ dependencies = [
   "python-dotenv>=1.0.1",
   "pandas>=2.2.3",
   "plotly>=5.24.1",
-  "geoip2>=4.8.0",
 ]
 
 [project.optional-dependencies]

requirements.txt

@@ -5,4 +5,3 @@ pydantic-settings>=2.6.0
 python-dotenv>=1.0.1
 pandas>=2.2.3
 plotly>=5.24.1
-geoip2>=4.8.0

src/leaderboard_analytics/config.py

@@ -12,12 +12,6 @@ class Settings(BaseSettings):
     host: str = "0.0.0.0"
     port: int = 7860
     gradio_share: bool = False
-    gradio_ssr_mode: bool = False
-    geoip_database_path: str = "GeoLite2-Country.mmdb"
-    geoip_database_url: str = (
-        "https://cdn.jsdelivr.net/npm/geolite2-country/GeoLite2-Country.mmdb.gz"
-    )
-    geoip_auto_download: bool = True
 
 
 @lru_cache(maxsize=1)

src/leaderboard_analytics/geoip_database.py

@@ -1,36 +0,0 @@
-import gzip
-import shutil
-import tempfile
-from pathlib import Path
-from urllib.request import urlopen
-
-DEFAULT_GEOIP_DATABASE_URL = (
-    "https://cdn.jsdelivr.net/npm/geolite2-country/GeoLite2-Country.mmdb.gz"
-)
-
-
-def ensure_geoip_database(
-    database_path: str | Path,
-    source_url: str = DEFAULT_GEOIP_DATABASE_URL,
-    *,
-    auto_download: bool = True,
-    timeout: float = 30.0,
-) -> Path:
-    target_path = Path(database_path)
-    if target_path.exists() or not auto_download:
-        return target_path
-
-    target_path.parent.mkdir(parents=True, exist_ok=True)
-    with tempfile.NamedTemporaryFile(
-        prefix=f"{target_path.name}.",
-        suffix=".tmp",
-        dir=target_path.parent,
-        delete=False,
-    ) as temp_file:
-        temp_path = Path(temp_file.name)
-        with urlopen(source_url, timeout=timeout) as response:
-            with gzip.GzipFile(fileobj=response) as gzip_file:
-                shutil.copyfileobj(gzip_file, temp_file)
-
-    temp_path.replace(target_path)
-    return target_path

src/leaderboard_analytics/main.py

@@ -1,48 +1,20 @@
 from leaderboard_analytics.config import get_settings
 from leaderboard_analytics.db import get_database, get_events_collection, get_mongo_client
-from leaderboard_analytics.geoip_database import ensure_geoip_database
 from leaderboard_analytics.repositories import AnalyticsRepository
 from leaderboard_analytics.services import AnalyticsService
 from leaderboard_analytics.ui import build_dashboard
 
 
-def create_demo():
+def run() -> None:
     settings = get_settings()
     client = get_mongo_client()
     db = get_database(client)
     events_collection = get_events_collection(db)
-    geoip_database_path = settings.geoip_database_path
-    try:
-        geoip_database_path = str(
-            ensure_geoip_database(
-                settings.geoip_database_path,
-                settings.geoip_database_url,
-                auto_download=settings.geoip_auto_download,
-            )
-        )
-    except Exception as exc:
-        print(f"GeoIP database download failed: {exc}")
 
     repository = AnalyticsRepository(events_collection=events_collection)
-    service = AnalyticsService(
-        repository=repository,
-        geoip_database_path=geoip_database_path,
-    )
-    return build_dashboard(service=service)
-
-
-def launch_demo(demo) -> None:
-    settings = get_settings()
-    demo.launch(
-        server_name=settings.host,
-        server_port=settings.port,
-        share=settings.gradio_share,
-        ssr_mode=settings.gradio_ssr_mode,
-    )
-
-
-def run() -> None:
-    launch_demo(create_demo())
+    service = AnalyticsService(repository=repository)
+    demo = build_dashboard(service=service)
+    demo.launch(server_name=settings.host, server_port=settings.port, share=settings.gradio_share)
 
 
 if __name__ == "__main__":

src/leaderboard_analytics/repositories.py

@@ -419,23 +419,6 @@ class AnalyticsRepository:
         ]
         return list(self.events_collection.aggregate(pipeline))
 
-    def visitor_ip_counts(self, filters: QueryFilters) -> list[dict]:
-        pipeline: list[dict] = [
-            {"$match": _indexed_time_prefilter(filters)},
-            _with_normalized_time(),
-            {
-                "$match": {
-                    **_with_time_and_optional_benchmark(filters),
-                    "event_name": "page_view",
-                    "properties.ip": {"$nin": [None, ""]},
-                }
-            },
-            {"$group": {"_id": "$properties.ip", "pv": {"$sum": 1}}},
-            {"$project": {"_id": 0, "ip": "$_id", "pv": 1}},
-            {"$sort": {"pv": -1}},
-        ]
-        return list(self.events_collection.aggregate(pipeline))
-
     def available_benchmarks(
         self, filters: QueryFilters | None = None, limit: int = 100
     ) -> list[str]:

src/leaderboard_analytics/services.py

@@ -1,162 +1,12 @@
-import ipaddress
-from pathlib import Path
-from typing import Any, Protocol
-
 import pandas as pd
 
 from leaderboard_analytics.repositories import AnalyticsRepository
 from leaderboard_analytics.schemas import QueryFilters
 
-UNKNOWN_COUNTRY_CODE = "Unknown"
-UNKNOWN_COUNTRY_NAME = "Unknown"
-
-
-def _empty_ip_debug() -> dict[str, object]:
-    return {
-        "total_unique_ips": 0,
-        "total_ip_pv": 0,
-        "global_ips": 0,
-        "global_ip_pv": 0,
-        "private_ips": 0,
-        "private_ip_pv": 0,
-        "loopback_ips": 0,
-        "loopback_ip_pv": 0,
-        "reserved_ips": 0,
-        "reserved_ip_pv": 0,
-        "link_local_ips": 0,
-        "link_local_ip_pv": 0,
-        "multicast_ips": 0,
-        "multicast_ip_pv": 0,
-        "unspecified_ips": 0,
-        "unspecified_ip_pv": 0,
-        "invalid_ips": 0,
-        "invalid_ip_pv": 0,
-        "top_ip_pv_buckets": {
-            "1": 0,
-            "2-10": 0,
-            "11-100": 0,
-            "101-1000": 0,
-            ">1000": 0,
-        },
-    }
-
-
-def _ip_debug_category(ip_address: str) -> str:
-    try:
-        parsed_ip = ipaddress.ip_address(ip_address.strip())
-    except ValueError:
-        return "invalid"
-
-    if parsed_ip.is_global:
-        return "global"
-    if parsed_ip.is_loopback:
-        return "loopback"
-    if parsed_ip.is_private:
-        return "private"
-    if parsed_ip.is_reserved:
-        return "reserved"
-    if parsed_ip.is_link_local:
-        return "link_local"
-    if parsed_ip.is_multicast:
-        return "multicast"
-    if parsed_ip.is_unspecified:
-        return "unspecified"
-    return "reserved"
-
-
-def _ip_pv_bucket(pv: int) -> str:
-    if pv <= 1:
-        return "1"
-    if pv <= 10:
-        return "2-10"
-    if pv <= 100:
-        return "11-100"
-    if pv <= 1000:
-        return "101-1000"
-    return ">1000"
-
-
-class GeoIpCountryReader(Protocol):
-    def country(self, ip_address: str) -> Any: ...
-
-
-class GeoIpResolver:
-    def __init__(
-        self,
-        database_path: str | Path | None = None,
-        reader: GeoIpCountryReader | None = None,
-    ) -> None:
-        self.database_path = Path(database_path) if database_path else None
-        self._reader = reader
-        self._load_attempted = reader is not None
-
-    def resolve_country(self, ip_address: str) -> tuple[str, str]:
-        try:
-            parsed_ip = ipaddress.ip_address(ip_address.strip())
-        except ValueError:
-            return UNKNOWN_COUNTRY_CODE, UNKNOWN_COUNTRY_NAME
-
-        if not parsed_ip.is_global:
-            return UNKNOWN_COUNTRY_CODE, UNKNOWN_COUNTRY_NAME
-
-        reader = self._get_reader()
-        if reader is None:
-            return UNKNOWN_COUNTRY_CODE, UNKNOWN_COUNTRY_NAME
-
-        try:
-            response = reader.country(str(parsed_ip))
-        except Exception:
-            return UNKNOWN_COUNTRY_CODE, UNKNOWN_COUNTRY_NAME
-
-        country = response.country
-        if not getattr(country, "iso_code", None):
-            country = response.registered_country
-
-        code = getattr(country, "iso_code", None)
-        if not code:
-            return UNKNOWN_COUNTRY_CODE, UNKNOWN_COUNTRY_NAME
-
-        return code, getattr(country, "name", None) or code
-
-    def debug_status(self) -> dict[str, object]:
-        return {
-            "database_path": str(self.database_path) if self.database_path else "",
-            "database_configured": self.database_path is not None,
-            "database_exists": self.database_path.exists() if self.database_path else False,
-            "load_attempted": self._load_attempted,
-            "reader_loaded": self._reader is not None,
-        }
-
-    def _get_reader(self) -> GeoIpCountryReader | None:
-        if self._reader is not None:
-            return self._reader
-
-        if self._load_attempted:
-            return None
-
-        self._load_attempted = True
-        if self.database_path is None or not self.database_path.exists():
-            return None
-
-        try:
-            import geoip2.database
-
-            self._reader = geoip2.database.Reader(str(self.database_path))
-        except Exception:
-            return None
-
-        return self._reader
-
 
 class AnalyticsService:
-    def __init__(
-        self,
-        repository: AnalyticsRepository,
-        geoip_database_path: str | Path | None = None,
-        geoip_resolver: GeoIpResolver | None = None,
-    ) -> None:
+    def __init__(self, repository: AnalyticsRepository) -> None:
         self.repository = repository
-        self.geoip_resolver = geoip_resolver or GeoIpResolver(geoip_database_path)
 
     def get_overview(self, filters: QueryFilters) -> tuple[pd.DataFrame, dict]:
         rows = self.repository.overview_timeseries(filters)
@@ -204,61 +54,5 @@ class AnalyticsService:
         frame["visitor_type"] = frame["is_new"].map({True: "new", False: "returning"})
         return frame
 
-    def get_visitor_locations(self, filters: QueryFilters) -> pd.DataFrame:
-        frame, _debug = self.get_visitor_location_details(filters)
-        return frame
-
-    def get_visitor_location_details(self, filters: QueryFilters) -> tuple[pd.DataFrame, dict]:
-        locations: dict[tuple[str, str], dict[str, int | str]] = {}
-        ip_debug = _empty_ip_debug()
-        for row in self.repository.visitor_ip_counts(filters):
-            ip = str(row.get("ip", "")).strip()
-            if not ip:
-                continue
-
-            pv = int(row.get("pv", 0))
-            category = _ip_debug_category(ip)
-            ip_debug["total_unique_ips"] = int(ip_debug["total_unique_ips"]) + 1
-            ip_debug["total_ip_pv"] = int(ip_debug["total_ip_pv"]) + pv
-            ip_debug[f"{category}_ips"] = int(ip_debug[f"{category}_ips"]) + 1
-            ip_debug[f"{category}_ip_pv"] = int(ip_debug[f"{category}_ip_pv"]) + pv
-            ip_debug["top_ip_pv_buckets"][_ip_pv_bucket(pv)] += 1  # type: ignore[index]
-
-            code, name = self.geoip_resolver.resolve_country(ip)
-            key = (code, name)
-            if key not in locations:
-                locations[key] = {
-                    "country_code": code,
-                    "country_name": name,
-                    "pv": 0,
-                    "ip_count": 0,
-                }
-
-            locations[key]["pv"] = int(locations[key]["pv"]) + pv
-            locations[key]["ip_count"] = int(locations[key]["ip_count"]) + 1
-
-        frame = pd.DataFrame(
-            locations.values(),
-            columns=["country_code", "country_name", "pv", "ip_count"],
-        )
-        if frame.empty:
-            return frame, ip_debug
-        frame = frame.sort_values(["pv", "ip_count"], ascending=[False, False]).reset_index(
-            drop=True
-        )
-        return frame, ip_debug
-
-    def get_geoip_debug_info(self) -> dict[str, object]:
-        debug_status = getattr(self.geoip_resolver, "debug_status", None)
-        if debug_status is None:
-            return {
-                "database_path": "",
-                "database_configured": False,
-                "database_exists": False,
-                "load_attempted": False,
-                "reader_loaded": False,
-            }
-        return debug_status()
-
     def get_available_benchmarks(self, filters: QueryFilters | None = None) -> list[str]:
         return self.repository.available_benchmarks(filters)

src/leaderboard_analytics/ui.py

@@ -8,7 +8,6 @@ from typing import Any
 import gradio as gr
 import pandas as pd
 import plotly.express as px
-import plotly.graph_objects as go
 
 from leaderboard_analytics.schemas import Granularity, QueryFilters
 from leaderboard_analytics.services import AnalyticsService
@@ -40,12 +39,6 @@ def _empty_plot(title: str):
     return px.line(title=title)
 
 
-def _empty_map(title: str):
-    figure = go.Figure()
-    _style_visitor_location_map(figure, title)
-    return figure
-
-
 def _query_range_text(filters: QueryFilters) -> str:
     return f"{filters.start_time.isoformat()} to {filters.end_time.isoformat()}"
 
@@ -64,160 +57,6 @@ def _write_csv_archive(tables: dict[str, pd.DataFrame]) -> str | None:
     return archive.name
 
 
-def _visitor_location_top_table(visitor_locations: pd.DataFrame) -> pd.DataFrame:
-    if visitor_locations.empty:
-        return pd.DataFrame(columns=["Region", "Users"])
-
-    return (
-        visitor_locations.sort_values(["ip_count", "pv"], ascending=[False, False])
-        .head(10)
-        .rename(columns={"country_name": "Region", "ip_count": "Users"})[["Region", "Users"]]
-        .reset_index(drop=True)
-    )
-
-
-def _visitor_location_debug_text(
-    visitor_locations: pd.DataFrame,
-    geoip_debug: dict[str, object],
-    ip_debug: dict[str, object] | None = None,
-) -> str:
-    if visitor_locations.empty:
-        total_pv = 0
-        total_users = 0
-        mapped_regions = 0
-        unknown_pv = 0
-        unknown_users = 0
-    else:
-        unknown_rows = visitor_locations[visitor_locations["country_code"] == "Unknown"]
-        mapped_rows = visitor_locations[visitor_locations["country_code"] != "Unknown"]
-        total_pv = int(visitor_locations["pv"].sum())
-        total_users = int(visitor_locations["ip_count"].sum())
-        mapped_regions = len(mapped_rows)
-        unknown_pv = int(unknown_rows["pv"].sum()) if not unknown_rows.empty else 0
-        unknown_users = int(unknown_rows["ip_count"].sum()) if not unknown_rows.empty else 0
-
-    configured = "yes" if geoip_debug.get("database_configured") else "no"
-    exists = "yes" if geoip_debug.get("database_exists") else "no"
-    loaded = "yes" if geoip_debug.get("reader_loaded") else "no"
-    attempted = "yes" if geoip_debug.get("load_attempted") else "no"
-    path = geoip_debug.get("database_path") or "(not configured)"
-    ip_debug = ip_debug or {}
-    global_ips = int(ip_debug.get("global_ips", 0))
-    global_pv = int(ip_debug.get("global_ip_pv", 0))
-    private_ips = int(ip_debug.get("private_ips", 0))
-    private_pv = int(ip_debug.get("private_ip_pv", 0))
-    loopback_ips = int(ip_debug.get("loopback_ips", 0))
-    loopback_pv = int(ip_debug.get("loopback_ip_pv", 0))
-    invalid_ips = int(ip_debug.get("invalid_ips", 0))
-    invalid_pv = int(ip_debug.get("invalid_ip_pv", 0))
-    buckets = ip_debug.get("top_ip_pv_buckets", {})
-
-    return (
-        f"GeoIP DB: configured={configured}, exists={exists}, loaded={loaded}, "
-        f"load_attempted={attempted}  \n"
-        f"GeoIP path: `{path}`  \n"
-        f"Total location PV: {total_pv} | Users/IPs: {total_users} | "
-        f"Mapped regions: {mapped_regions}  \n"
-        f"Unknown PV: {unknown_pv} | Unknown users/IPs: {unknown_users}  \n"
-        f"Public IPs: {global_ips} ({global_pv} PV) | Private IPs: {private_ips} "
-        f"({private_pv} PV)  \n"
-        f"Loopback IPs: {loopback_ips} ({loopback_pv} PV) | Invalid IPs: {invalid_ips} "
-        f"({invalid_pv} PV)  \n"
-        f"PV/IP buckets: {buckets}"
-    )
-
-
-def _style_visitor_location_map(figure: go.Figure, title: str) -> None:
-    figure.update_geos(
-        projection_type="mercator",
-        showframe=False,
-        showcoastlines=True,
-        coastlinecolor="#cfd6df",
-        coastlinewidth=0.6,
-        showcountries=True,
-        countrycolor="#cfd6df",
-        countrywidth=0.7,
-        showland=True,
-        landcolor="#eef2f7",
-        showocean=True,
-        oceancolor="#f8fafc",
-        showlakes=True,
-        lakecolor="#f8fafc",
-        bgcolor="#ffffff",
-        lataxis_range=[-55, 75],
-        lonaxis_range=[-180, 180],
-    )
-    figure.update_layout(
-        title={"text": title, "x": 0.02, "xanchor": "left"},
-        height=560,
-        paper_bgcolor="#ffffff",
-        plot_bgcolor="#ffffff",
-        font={"color": "#1f2937"},
-        margin={"l": 0, "r": 0, "t": 52, "b": 0},
-        showlegend=False,
-        hoverlabel={
-            "bgcolor": "#ffffff",
-            "bordercolor": "#3b82f6",
-            "font_color": "#111827",
-        },
-    )
-
-
-def _visitor_location_map(visitor_locations: pd.DataFrame, range_text: str) -> go.Figure:
-    map_df = (
-        visitor_locations[visitor_locations["country_code"] != "Unknown"].copy()
-        if not visitor_locations.empty
-        else visitor_locations.copy()
-    )
-    if map_df.empty:
-        return _empty_map(f"Visitor locations by country (no mapped data for {range_text})")
-
-    max_pv = max(int(map_df["pv"].max()), 1)
-    size_ref = 2.0 * max_pv / (52**2)
-    figure = go.Figure(
-        go.Scattergeo(
-            locationmode="country names",
-            locations=map_df["country_name"],
-            mode="markers",
-            text=map_df["country_name"],
-            customdata=map_df[["country_code", "pv", "ip_count"]],
-            hovertemplate=(
-                "<b>%{text}</b><br>"
-                "Country code: %{customdata[0]}<br>"
-                "PV: %{customdata[1]:,}<br>"
-                "Users/IPs: %{customdata[2]:,}<extra></extra>"
-            ),
-            marker={
-                "size": map_df["pv"],
-                "sizemode": "area",
-                "sizeref": size_ref,
-                "sizemin": 8,
-                "color": "rgba(59, 130, 246, 0.55)",
-                "line": {"color": "rgba(37, 99, 235, 0.92)", "width": 1.2},
-            },
-        )
-    )
-    _style_visitor_location_map(figure, "Visitor locations by country")
-    figure.add_annotation(
-        x=0.02,
-        y=0.08,
-        xref="paper",
-        yref="paper",
-        text=(
-            f"Mapped regions: {len(map_df)}<br>"
-            f"Mapped PV: {int(map_df['pv'].sum()):,}<br>"
-            f"Users/IPs: {int(map_df['ip_count'].sum()):,}"
-        ),
-        showarrow=False,
-        align="left",
-        bgcolor="rgba(255, 255, 255, 0.88)",
-        bordercolor="rgba(148, 163, 184, 0.55)",
-        borderwidth=1,
-        font={"color": "#1f2937", "size": 12},
-    )
-    return figure
-
-
 def build_dashboard(service: AnalyticsService) -> gr.Blocks:
     default_end = datetime.now(tz=UTC)
     default_start = (default_end - timedelta(days=7)).replace(microsecond=0)
@@ -247,10 +86,6 @@ def build_dashboard(service: AnalyticsService) -> gr.Blocks:
         object,
         object,
         object,
-        object,
-        object,
-        object,
-        object,
     ]:
         try:
             filters = QueryFilters(
@@ -264,22 +99,9 @@ def build_dashboard(service: AnalyticsService) -> gr.Blocks:
             filter_df = service.get_filter_distribution(filters)
             funnel_df = service.get_funnel(filters)
             visitors_df = service.get_new_vs_returning(filters)
-            visitor_locations_df, ip_debug = service.get_visitor_location_details(filters)
-            visitor_locations_top_df = _visitor_location_top_table(visitor_locations_df)
-            visitor_locations_debug = _visitor_location_debug_text(
-                visitor_locations_df,
-                service.get_geoip_debug_info(),
-                ip_debug,
-            )
 
             range_text = _query_range_text(filters)
-            if (
-                overview_df.empty
-                and benchmark_df.empty
-                and filter_df.empty
-                and visitors_df.empty
-                and visitor_locations_df.empty
-            ):
+            if overview_df.empty and benchmark_df.empty and filter_df.empty and visitors_df.empty:
                 metrics = f"No data for {range_text}."
             else:
                 metrics = (
@@ -322,7 +144,6 @@ def build_dashboard(service: AnalyticsService) -> gr.Blocks:
                 if not visitors_df.empty
                 else px.bar(title=f"New vs returning visitors (no data for {range_text})")
             )
-            visitor_locations_plot = _visitor_location_map(visitor_locations_df, range_text)
             csv_archive = _write_csv_archive(
                 {
                     "overview": overview_df,
@@ -330,7 +151,6 @@ def build_dashboard(service: AnalyticsService) -> gr.Blocks:
                     "filters": filter_df,
                     "funnel": funnel_df,
                     "visitors": visitors_df,
-                    "visitor_locations": visitor_locations_df,
                 }
             )
 
@@ -341,21 +161,16 @@ def build_dashboard(service: AnalyticsService) -> gr.Blocks:
                 filter_plot,
                 funnel_plot,
                 visitor_plot,
-                visitor_locations_plot,
-                visitor_locations_debug,
-                visitor_locations_top_df,
                 overview_df,
                 benchmark_df,
                 filter_df,
                 funnel_df,
                 visitors_df,
-                visitor_locations_df,
                 csv_archive,
             )
         except Exception as exc:
             message = f"Query failed: {exc}"
             empty = pd.DataFrame()
-            empty_top = pd.DataFrame(columns=["Region", "Users"])
             return (
                 message,
                 _empty_plot(message),
@@ -368,10 +183,6 @@ def build_dashboard(service: AnalyticsService) -> gr.Blocks:
                     title=message,
                 ),
                 px.bar(title=message),
-                _empty_map(message),
-                message,
-                empty_top,
-                empty,
                 empty,
                 empty,
                 empty,
@@ -422,19 +233,6 @@ def build_dashboard(service: AnalyticsService) -> gr.Blocks:
             filter_plot = gr.Plot(label="Filter Behavior")
             funnel_plot = gr.Plot(label="Funnel")
         visitor_plot = gr.Plot(label="Visitor Segmentation")
-        with gr.Row():
-            with gr.Column(scale=2):
-                visitor_locations_plot = gr.Plot(label="Visitor Locations")
-            with gr.Column(scale=1):
-                visitor_locations_debug = gr.Markdown(
-                    "GeoIP DB: not checked  \n"
-                    "Total location PV: 0 | Users/IPs: 0 | Mapped regions: 0"
-                )
-                visitor_locations_top_table = gr.DataFrame(
-                    label="Top 10 Regions",
-                    interactive=False,
-                    wrap=True,
-                )
 
         with gr.Accordion("Raw data", open=False):
             csv_file = gr.File(label="CSV export")
@@ -443,7 +241,6 @@ def build_dashboard(service: AnalyticsService) -> gr.Blocks:
             filter_table = gr.DataFrame(label="Filter Behavior")
             funnel_table = gr.DataFrame(label="Funnel")
             visitor_table = gr.DataFrame(label="Visitor Segmentation")
-            visitor_locations_table = gr.DataFrame(label="Visitor Locations")
 
         outputs = [
             metrics_text,
@@ -452,15 +249,11 @@ def build_dashboard(service: AnalyticsService) -> gr.Blocks:
             filter_plot,
             funnel_plot,
             visitor_plot,
-            visitor_locations_plot,
-            visitor_locations_debug,
-            visitor_locations_top_table,
             overview_table,
             benchmark_table,
             filter_table,
             funnel_table,
             visitor_table,
-            visitor_locations_table,
             csv_file,
         ]
 

tests/test_geoip_database.py

@@ -1,29 +0,0 @@
-import gzip
-
-from leaderboard_analytics.geoip_database import ensure_geoip_database
-
-
-def test_ensure_geoip_database_downloads_and_decompresses_gzip(tmp_path) -> None:
-    source = tmp_path / "GeoLite2-Country.mmdb.gz"
-    target = tmp_path / "GeoLite2-Country.mmdb"
-    expected_bytes = b"fake-mmdb-bytes"
-
-    with gzip.open(source, "wb") as gzip_file:
-        gzip_file.write(expected_bytes)
-
-    result = ensure_geoip_database(target, source.as_uri())
-
-    assert result == target
-    assert target.read_bytes() == expected_bytes
-
-
-def test_ensure_geoip_database_keeps_existing_file(tmp_path) -> None:
-    source = tmp_path / "missing.mmdb.gz"
-    target = tmp_path / "GeoLite2-Country.mmdb"
-    expected_bytes = b"existing-mmdb-bytes"
-    target.write_bytes(expected_bytes)
-
-    result = ensure_geoip_database(target, source.as_uri())
-
-    assert result == target
-    assert target.read_bytes() == expected_bytes

tests/test_repositories.py

@@ -72,24 +72,3 @@ def test_overview_totals_filters_empty_identifiers() -> None:
     assert '"$visitors"' in pipeline_text or "'$visitors'" in pipeline_text
     assert "$$s" in pipeline_text
     assert "$$v" in pipeline_text
-
-
-def test_visitor_ip_counts_groups_page_view_ips_with_existing_filters() -> None:
-    collection = CapturingCollection([{"ip": "8.8.8.8", "pv": 3}])
-    repository = AnalyticsRepository(collection)  # type: ignore[arg-type]
-    filters = QueryFilters(
-        start_time=datetime(2026, 1, 1, tzinfo=UTC),
-        end_time=datetime(2026, 1, 31, tzinfo=UTC),
-        benchmark="MTEB",
-    )
-
-    rows = repository.visitor_ip_counts(filters)
-
-    assert rows == [{"ip": "8.8.8.8", "pv": 3}]
-    assert collection.pipeline is not None
-    pipeline_text = str(collection.pipeline)
-    assert "properties.ip" in pipeline_text
-    assert "page_view" in pipeline_text
-    assert "MTEB" in pipeline_text
-    assert "$nin" in pipeline_text
-    assert "$properties.ip" in pipeline_text

tests/test_services.py

@@ -1,5 +1,4 @@
 from datetime import UTC, datetime
-from pathlib import Path
 
 from leaderboard_analytics.schemas import QueryFilters
 from leaderboard_analytics.services import AnalyticsService
@@ -16,22 +15,6 @@ class FakeRepository:
         return {"pv": 3, "uv": 1, "sessions": 1, "events": 5}
 
 
-class LocationRepository:
-    def __init__(self, rows: list[dict]) -> None:
-        self.rows = rows
-
-    def visitor_ip_counts(self, filters: QueryFilters) -> list[dict]:
-        return self.rows
-
-
-class FakeGeoIpResolver:
-    def __init__(self, countries: dict[str, tuple[str, str]]) -> None:
-        self.countries = countries
-
-    def resolve_country(self, ip_address: str) -> tuple[str, str]:
-        return self.countries[ip_address]
-
-
 def test_overview_uses_full_range_distinct_totals() -> None:
     service = AnalyticsService(FakeRepository())  # type: ignore[arg-type]
     filters = QueryFilters(
@@ -50,61 +33,3 @@ def test_overview_uses_full_range_distinct_totals() -> None:
         "events_per_session": 5.0,
         "sessions_per_visitor": 1.0,
     }
-
-
-def test_visitor_locations_groups_pv_and_ip_count_by_country() -> None:
-    repository = LocationRepository(
-        [
-            {"ip": "8.8.8.8", "pv": 3},
-            {"ip": "8.8.4.4", "pv": 2},
-            {"ip": "1.1.1.1", "pv": 4},
-        ]
-    )
-    resolver = FakeGeoIpResolver(
-        {
-            "8.8.8.8": ("US", "United States"),
-            "8.8.4.4": ("US", "United States"),
-            "1.1.1.1": ("AU", "Australia"),
-        }
-    )
-    service = AnalyticsService(
-        repository,  # type: ignore[arg-type]
-        geoip_resolver=resolver,  # type: ignore[arg-type]
-    )
-
-    frame = service.get_visitor_locations(
-        QueryFilters(
-            start_time=datetime(2026, 1, 1, tzinfo=UTC),
-            end_time=datetime(2026, 1, 2, tzinfo=UTC),
-        )
-    )
-
-    assert frame.to_dict("records") == [
-        {"country_code": "US", "country_name": "United States", "pv": 5, "ip_count": 2},
-        {"country_code": "AU", "country_name": "Australia", "pv": 4, "ip_count": 1},
-    ]
-
-
-def test_visitor_locations_groups_unresolved_ips_as_unknown() -> None:
-    repository = LocationRepository(
-        [
-            {"ip": "10.0.0.1", "pv": 2},
-            {"ip": "not-an-ip", "pv": 1},
-            {"ip": "8.8.8.8", "pv": 3},
-        ]
-    )
-    service = AnalyticsService(
-        repository,  # type: ignore[arg-type]
-        geoip_database_path=Path("missing-geolite2-country.mmdb"),
-    )
-
-    frame = service.get_visitor_locations(
-        QueryFilters(
-            start_time=datetime(2026, 1, 1, tzinfo=UTC),
-            end_time=datetime(2026, 1, 2, tzinfo=UTC),
-        )
-    )
-
-    assert frame.to_dict("records") == [
-        {"country_code": "Unknown", "country_name": "Unknown", "pv": 6, "ip_count": 3}
-    ]