Datasets:

CRUISEResearchGroup
/

TripWorld

+{
+  "dataset": "Trip World",
+  "generated_at": "2026-05-05T22:28:45.365895+00:00",
+  "files": [
+    {
+      "path": "README.md",
+      "size_bytes": 23469,
+      "sha256": "9ddd2b7a87a6eab02615519a6b700752fb7800740fb96f89d0813db24a6d9a91"
+    },
+    {
+      "path": "_scripts/00_build_metro_map.py",
+      "size_bytes": 25849,
+      "sha256": "cd7f25a0516edb421e81636e37a9fa8a55584fa2ed06fed3c12ac1773ed03567"
+    },
+    {
+      "path": "_scripts/01_consolidate_filter.py",
+      "size_bytes": 5289,
+      "sha256": "0e5c3a29c2df1f08aceccc686b2892a4ab120e161ed2e373d446241f095ae765"
+    },
+    {
+      "path": "_scripts/02_hometown_discovery.py",
+      "size_bytes": 3580,
+      "sha256": "748ae827e6136e4d8fe19e335112ba035bd9424a5464b4c2e40bfa00da39716d"
+    },
+    {
+      "path": "_scripts/03_build_travelers.py",
+      "size_bytes": 3582,
+      "sha256": "a8ef6b5a7da35480a7b5f4ec4cb3faea06117133a37b8e3496dffbc5a934979f"
+    },
+    {
+      "path": "_scripts/04_build_travel_behaviors.py",
+      "size_bytes": 3277,
+      "sha256": "7c2e64df23a33a9053b1b51c429c3505c2b3fb76f7d80532a268528ee770a1b0"
+    },
+    {
+      "path": "_scripts/05_build_pois.py",
+      "size_bytes": 3711,
+      "sha256": "92ef5f7521cfe2ca39d7ac17ec4d42599f77cd0de00e50b856c6dedcbae69a6c"
+    },
+    {
+      "path": "_scripts/06_build_region_labels.py",
+      "size_bytes": 2681,
+      "sha256": "b83f1644e2e8ac811f1f4cf4ffdedd77fbb5590a8fb043d4f7ab9f2d63397f8b"
+    },
+    {
+      "path": "_scripts/07_subset_metadata.py",
+      "size_bytes": 1459,
+      "sha256": "a5d879b4c71babeb58b2f0a0440cb178393389c495a49d0812832ffb0009caa6"
+    },
+    {
+      "path": "_scripts/08_subset_reviews.py",
+      "size_bytes": 1998,
+      "sha256": "abb67be5115a05bd6eb7808517dd72df1107404866ddeb77c87c361d8a6cb794"
+    },
+    {
+      "path": "_scripts/09_validate.py",
+      "size_bytes": 3835,
+      "sha256": "789c0b79340539b003e55c0473bc62a7060a0eb15fb52870cad9f73781eea735"
+    },
+    {
+      "path": "_scripts/10_enrich_new_pois.py",
+      "size_bytes": 6970,
+      "sha256": "72f591ae9991ca02e847355308466f5a1a92825d23795adec9acbec5b364c13b"
+    },
+    {
+      "path": "_scripts/11_fsq_api_recover.py",
+      "size_bytes": 16289,
+      "sha256": "130cb8a98764e1bf84dcc3b00a4e94a5e63026276d16f78d816567b60772c4e4"
+    },
+    {
+      "path": "_scripts/12_ucsd_bridge.py",
+      "size_bytes": 14575,
+      "sha256": "6a0744ca1623294f0e0534edd0233e98b6b3e6522f0cd00a6e5fcf12b0037b9c"
+    },
+    {
+      "path": "_scripts/13_merge_ucsd_into_metadata.py",
+      "size_bytes": 6356,
+      "sha256": "939ab7cf2ab06762923d8cd76a9066ddcc14d4b02b3b1124fecc70ecbec2922b"
+    },
+    {
+      "path": "_scripts/14_merge_gcp_search_results.py",
+      "size_bytes": 12310,
+      "sha256": "25befa67bbd7d9108f93b1436b11c2fe1b38ebf81f98cc63f0c60b1ace111a82"
+    },
+    {
+      "path": "_scripts/15_merge_stage2_reviews.py",
+      "size_bytes": 7847,
+      "sha256": "fb3930ea05174d6508f42076055a4637e9553dd39a63edae213d6df19daa84cc"
+    },
+    {
+      "path": "_scripts/16_unify_reviews.py",
+      "size_bytes": 7196,
+      "sha256": "480bb93e479580cecdb18d3eaa2d6cd32ab755028228d9b3ebae3bbef2229d55"
+    },
+    {
+      "path": "_scripts/lib_wikidata.py",
+      "size_bytes": 5360,
+      "sha256": "9fb66e3aca1516e14693fa5f1f66e879f389c8ce22514e9edad6ebcc8deb4531"
+    },
+    {
+      "path": "_scripts/viz_clean_raw.py",
+      "size_bytes": 22248,
+      "sha256": "24a730d7bd73a536bc14f3c3cfc03dac45823dc505bfd8bd2107c75a2d186f54"
+    },
+    {
+      "path": "_scripts/viz_traj_length.py",
+      "size_bytes": 3993,
+      "sha256": "3e57d0a39ff9055f14c07a04b73359a9065dd8d3f0bbf3c0d51c597e8a9e3445"
+    },
+    {
+      "path": "metadata/metadata_all.parquet",
+      "size_bytes": 119796103,
+      "sha256": "20c8affe6092df1202074e4458672a57e77d96505ede4fb63fa65b0b3d0b22d3",
+      "rows": 687173
+    },
+    {
+      "path": "metadata/place_attributes.parquet",
+      "size_bytes": 5580621,
+      "sha256": "4c31fda0a865c6773ff4067bb20ebd16c2ffde8925ded0da3b26d322d942c3b8",
+      "rows": 28776
+    },
+    {
+      "path": "metro_mapping_clean.json",
+      "size_bytes": 410138,
+      "sha256": "53086b8988147692f8e649f4df5c96b914cfe1b5c3c52f9d90807190b404066b"
+    },
+    {
+      "path": "pois.parquet",
+      "size_bytes": 69707931,
+      "sha256": "43c3d385700ca050bb1b109ab98481dddce85150b4a8f1cc455fa4994b8f3f0e",
+      "rows": 687173
+    },
+    {
+      "path": "region_labels.parquet",
+      "size_bytes": 19217,
+      "sha256": "98134206f3ae04366de219e181380a5c9c302873391ccc9109fa491fe9f11c59",
+      "rows": 1173
+    },
+    {
+      "path": "reviews/reviews_all.parquet",
+      "size_bytes": 23400867153,
+      "sha256": "60aa08489743419a26475a842398040dfdc9a508572cb51aa19e864966f10a7c",
+      "rows": 186760186
+    },
+    {
+      "path": "travel_behaviors.parquet",
+      "size_bytes": 151509028,
+      "sha256": "59d473611daca78404fda149832012562e11469cd0339094c92d2f86d4655034",
+      "rows": 518567
+    }
+  ]
+}

README.md CHANGED Viewed

@@ -1,3 +1,521 @@
----
-license: cc-by-nc-4.0
----

+---
+pretty_name: Trip World
+license: cc-by-nc-4.0
+license_name: trip-world-noncommercial
+license_link: LICENSE
+language:
+- en
+- ja
+- tr
+- ms
+- pt
+- th
+- es
+- multilingual
+multilinguality:
+- multilingual
+size_categories:
+- 100M<n<1B
+task_categories:
+- text-classification
+- text-retrieval
+- summarization
+- other
+task_ids:
+- sentiment-classification
+- multi-class-classification
+tags:
+- POI
+- trajectory-recommendation
+- next-location-prediction
+- check-ins
+- mobility
+- tourism
+- cross-city
+- foursquare
+- google-maps
+- reviews
+annotations_creators:
+- machine-generated
+- found
+language_creators:
+- found
+source_datasets:
+- extended
+configs:
+- config_name: travel_behaviors
+  data_files: travel_behaviors.parquet
+- config_name: pois
+  data_files: pois.parquet
+- config_name: regions
+  data_files: region_labels.parquet
+- config_name: metadata
+  data_files: metadata/metadata_all.parquet
+- config_name: place_attributes
+  data_files: metadata/place_attributes.parquet
+- config_name: reviews
+  data_files: reviews/reviews_all.parquet
+---
+# Trip World
+**Trip World** is a publicly redistributable, METRO-level cross-city travel
+benchmark.  It pairs a large corpus of out-of-town travel sequences with
+rich Foursquare and Google Maps point-of-interest (POI) metadata and an
+unified Google reviews corpus.  The dataset is designed to support:
+- **Trajectory recommendation** — recommend a sequence of POIs in an
+  unfamiliar city, given the traveller's home-city behaviour and a
+  desired start / end / length.
+- **Cross-city POI ranking and next-POI prediction** — score POIs in a
+  destination region by likelihood for an out-of-town visitor.
+- **Place modelling** — text/category/sentiment work driven by 186 M
+  Google reviews and structured FSQ + Google attributes for 687 K POIs.
+- **Tourism and mobility analytics** — aggregate analyses of travel
+  flows between 1,173 cities in 90+ countries.
+The release is built on top of the STD-2018 check-in stream, with metro-
+consolidation, hometown discovery, traveller filtering, and POI
+enrichment applied; see *Provenance* below for the exact pipeline.
+## Headline statistics
+| Quantity                                       | Value          |
+|------------------------------------------------|---------------:|
+| Travel-behavior records (τ)                    | **518,567**    |
+| Distinct travellers                            | **148,402**    |
+| Hometown regions / destination regions         | 723 / 1,165    |
+| Distinct (hometown → destination) pairs        | 6,246          |
+| Qualifying check-ins                           | 7,416,219      |
+| Distinct trails (sessions)                     | 2,723,551      |
+| Distinct POIs                                  | 687,173        |
+| POIs with Google metadata                      | 309,941 (45%)  |
+| POIs with ≥ 1 review                           | 285,693 (42%)  |
+| Total reviews                                  | **186,760,186**|
+| POIs with extra place attributes (desc / hours / price) | 28,776 |
+| Distinct cities (Wikidata QIDs)                | 1,173          |
+| Time span                                      | 2017-10-03 — 2018-10-20 |
+Geographic coverage is strongest in East Asia and the Mediterranean
+(Japan, Turkey, Malaysia, USA, Brazil, Thailand, Mexico, Philippines …).
+See the figures bundled with the source repository for breakdowns.
+## Definitions
+A **travel-behavior record** captures one traveller's activity around
+one out-of-town destination.  Following the dataset's formal definition,
+each τ record is a five-tuple
+> τ = (u, c_h, c_o, r_h, r_o)
+with the following components:
+| Symbol | Meaning                                                       |
+|--------|---------------------------------------------------------------|
+| `u`    | the traveller (anonymous integer ID, 1..148,402)              |
+| `r_h`  | their identified hometown region (Wikidata city QID)          |
+| `r_o`  | the out-of-town destination region (Wikidata city QID)        |
+| `c_h`  | the traveller's check-in stream **at home** around this trip  |
+| `c_o`  | the traveller's check-in stream **at the destination**        |
+`c_h` and `c_o` are sequences of `(trail_id, venue_id, venue_category,
+venue_schema, ts)` records.  Each `trail_id` identifies a single
+contiguous session of check-ins (one "trajectory" in the trajectory-
+recommendation sense); a single τ record may contain several distinct
+trails on each side because the same traveller can have multiple home
+sessions and multiple visits to the same destination.
+A **POI** is identified by a Foursquare place ID
+(`foursquare:<24-hex>`).  Each POI is annotated with a Wikidata-QID
+locality (the city it belongs to), a Foursquare venue category, a
+schema.org venue type, and (for ~45 % of POIs) the corresponding Google
+Maps CID and rich Google metadata.
+## Layout
+```
+trip_world/
+├── README.md                          (this file)
+├── MANIFEST.json                      — file list with sizes, sha256, and row counts
+├── metro_mapping_clean.json           — metro consolidation map (municipality QID → parent metro QID)
+├── travel_behaviors.parquet           — 518,567 τ records
+├── pois.parquet                       — 687,173 POI summaries (per-POI usage stats + flat google_*)
+├── region_labels.parquet              — 1,173 (region_id → city name + country)
+├── metadata/
+│   ├── metadata_all.parquet           — 687,173 rows; full Foursquare + Google metadata per POI
+│   └── place_attributes.parquet       — 28,776 rows; description / hours / price for the most enriched POIs
+├── reviews/
+│   └── reviews_all.parquet            — 186,760,186 unified Google reviews
+└── _scripts/                          — full build-pipeline source code (reproduces the dataset)
+```
+## Schema (column reference)
+### `travel_behaviors.parquet`  (518,567 rows)
+| Column        | Type                              | Notes |
+|---------------|-----------------------------------|-------|
+| `user_id`     | int64                             | 1..148,402, fresh public IDs (see *Privacy*) |
+| `r_h`         | string                            | hometown region — Wikidata QID, e.g. `Q35178` |
+| `r_o`         | string                            | destination region — Wikidata QID |
+| `n_home_ci`   | int64                             | total home-side check-ins in `c_h` |
+| `n_travel_ci` | int64                             | total destination-side check-ins in `c_o` |
+| `c_h`         | list<struct>                      | home check-ins (see element schema below) |
+| `c_o`         | list<struct>                      | destination check-ins (same element schema) |
+Each element of `c_h` / `c_o` is:
+| Field              | Type                       | Notes |
+|--------------------|----------------------------|-------|
+| `trail_id`         | int64                      | 1..2,723,551 (fresh public IDs) — same trail can re-appear across τ records |
+| `venue_id`         | string                     | `foursquare:<24-hex>` POI key |
+| `venue_category`   | string                     | Foursquare category UUID (4-byte hex, optional) |
+| `venue_schema`     | string                     | schema.org venue type, e.g. `schema:CafeOrCoffeeShop` |
+| `ts`               | timestamp[us, UTC]         | observation time |
+### `pois.parquet`  (687,173 rows)
+POI-level summary, optimised for the 99 % of analyses that only need
+the flat columns.  Every POI in the benchmark appears exactly once.
+| Column                | Type                | Notes |
+|-----------------------|---------------------|-------|
+| `fsq_place_id`        | string              | primary key |
+| `locality`            | string              | Wikidata QID of the city |
+| `venue_category`      | string              | Foursquare category UUID |
+| `venue_schema`        | string              | schema.org type |
+| `n_checkins`          | int64               | total check-ins for this POI in the dataset |
+| `n_users_visited`     | int64               | distinct travellers who visited |
+| `google_cid`          | string \| null      | Google Maps customer ID (= `place_id` in some APIs) |
+| `google_name`         | string \| null      | Google business name |
+| `google_full_address` | string \| null      | Google formatted address |
+| `google_address`      | string \| null      | Google street address |
+| `google_website`      | string \| null      | Google business website |
+| `google_rating`       | double \| null      | average Google star rating |
+| `google_num_reviews`  | int64 \| null       | Google review count |
+| `google_categories`   | list<string> \| null| Google category labels |
+| `google_place_id`     | string \| null      | Google Places API ID (when known) |
+| `google_gmaps_url`    | string \| null      | canonical maps.google.com URL |
+| `google_meta_source`  | string              | provenance tag identifying which collection step produced this metadata |
+| `has_google_metadata` | bool                | convenience flag |
+| `n_reviews`           | int64               | reviews available for this POI |
+| `n_reviews_with_text` | int64               | reviews with non-empty text |
+| `review_source`       | string              | provenance tag |
+| `has_reviews`         | bool                | convenience flag |
+### `metadata/metadata_all.parquet`  (687,173 rows)
+Per-POI Foursquare + Google metadata.  Same `fsq_place_id` primary key
+as `pois.parquet`; richer FSQ fields (name, lat/lon, address, country,
+website, …).  Personal-leaning Foursquare contact fields
+(`fsq_email`, `fsq_tel`, `fsq_facebook_id`, `fsq_instagram`,
+`fsq_twitter`) are intentionally **not** present.
+Notable columns: `fsq_name`, `fsq_latitude`, `fsq_longitude`,
+`fsq_address`, `fsq_locality`, `fsq_region`, `fsq_country`,
+`fsq_postcode`, `fsq_formatted_address`, `fsq_category_ids`,
+`fsq_category_labels`, `fsq_website`, `fsq_date_created`,
+`fsq_date_refreshed`, `fsq_date_closed`.
+The `google_*` columns mirror those in `pois.parquet`.
+### `metadata/place_attributes.parquet`  (28,776 rows)
+Rich place-level attributes for the most enriched POIs (descriptions,
+opening hours, price tier, free-form attributes).
+| Column              | Type   | Notes |
+|---------------------|--------|-------|
+| `fsq_place_id`      | string | join key |
+| `google_cid`        | string | the Google CID this enrichment came from |
+| `search_query`      | string | query used to recover the place |
+| `match_dist_m`      | double | metres between FSQ point and Google point |
+| `match_name_sim`    | double | normalized name-similarity score |
+| `description_short` | string | one-line description |
+| `description_long`  | string | longer description |
+| `hours_today`       | string | today's opening hours, free-text |
+| `hours_week`        | string | weekly hours, free-text |
+| `price_token`       | string | Google price symbol (`$`, `$$`, …) |
+| `price_min`         | string | min price (when known) |
+| `price_max`         | string | max price (when known) |
+| `attributes`        | string | JSON-encoded attribute bag |
+| `n_inline_reviews`  | int64  | count of reviews scraped at enrichment time |
+| `fetched_at`        | string | timestamp of enrichment fetch |
+### `region_labels.parquet`  (1,173 rows)
+| Column         | Type   | Example      |
+|----------------|--------|--------------|
+| `region_id`    | string | `Q100`       |
+| `city_name`    | string | `Boston`     |
+| `country_qid`  | string | `wd:Q30`     |
+| `country_name` | string | `United States` |
+### `reviews/reviews_all.parquet`  (186,760,186 rows)
+Unified Google reviews corpus, one row per review.
+| Column           | Type                  | Notes |
+|------------------|-----------------------|-------|
+| `fsq_place_id`   | string                | links to `pois.parquet` |
+| `google_cid`     | string                | links to `metadata_all.parquet` |
+| `review_id`      | string                | Google's review ID |
+| `rating`         | int64                 | 1..5 |
+| `text`           | string                | original review text (may be empty) |
+| `text_translated`| string \| null        | Google's machine translation, if any |
+| `lang`           | string \| null        | BCP-47 language tag |
+| `relative_time`  | string \| null        | Google's "3 weeks ago" string |
+| `timestamp_us`   | int64                 | absolute review time, microseconds since epoch |
+| `review_time`    | timestamp[us, UTC]    | same value, parsed |
+| `owner_reply`    | string \| null        | business-owner reply text, if any |
+| `source`         | string                | provenance tag identifying which collection step produced this review |
+| `author_pid`     | string                | salted blake2b 16-hex pseudonym (see *Privacy*) |
+The display name and Google profile ID of each reviewer are **removed
+from the public release**; the `author_pid` column lets you link
+multiple reviews from the same author *within* the dataset without
+exposing real identities.
+### `metro_mapping_clean.json`
+A JSON dictionary mapping individual municipality QIDs to the parent
+metro QID used as `region_id` everywhere else.  Useful if you want to
+recover the original sub-municipal granularity, or extend the mapping.
+## Quick start
+The release uses Apache Parquet throughout; any tool that reads parquet
+will work.  Below are minimal examples in three common stacks.
+### Python — pandas / pyarrow
+```python
+import pandas as pd, pyarrow.parquet as pq
+ROOT = "/path/to/trip_world"
+travel  = pq.read_table(f"{ROOT}/travel_behaviors.parquet").to_pandas()
+pois    = pq.read_table(f"{ROOT}/pois.parquet").to_pandas()
+regions = pq.read_table(f"{ROOT}/region_labels.parquet").to_pandas()
+# How many trips originate from each city?
+top_origins = (travel.merge(regions, left_on="r_h", right_on="region_id")
+                     .groupby("city_name").size()
+                     .sort_values(ascending=False).head(10))
+print(top_origins)
+```
+### Python — DuckDB (recommended for the 22 GB review file)
+DuckDB streams parquet without loading everything into RAM and supports
+the full SQL surface, including joins across files.
+```python
+import duckdb
+con = duckdb.connect()
+con.execute(f"""
+  CREATE VIEW travel  AS SELECT * FROM '{ROOT}/travel_behaviors.parquet';
+  CREATE VIEW pois    AS SELECT * FROM '{ROOT}/pois.parquet';
+  CREATE VIEW regions AS SELECT * FROM '{ROOT}/region_labels.parquet';
+  CREATE VIEW reviews AS SELECT * FROM '{ROOT}/reviews/reviews_all.parquet';
+""")
+# Top destinations for travellers from Boston (Q100):
+con.sql("""
+  SELECT regions.city_name, COUNT(*) AS trips
+  FROM travel JOIN regions ON travel.r_o = regions.region_id
+  WHERE travel.r_h = 'Q100'
+  GROUP BY regions.city_name
+  ORDER BY trips DESC
+  LIMIT 10
+""").show()
+# Average review rating per category in Tokyo:
+con.sql("""
+  SELECT pois.venue_schema,
+         AVG(reviews.rating)        AS avg_rating,
+         COUNT(*)                   AS n
+  FROM reviews
+  JOIN pois ON reviews.fsq_place_id = pois.fsq_place_id
+  WHERE pois.locality = 'Q1490'   -- Tokyo
+  GROUP BY pois.venue_schema
+  HAVING COUNT(*) > 100
+  ORDER BY avg_rating DESC
+""").show()
+```
+### Iterating over the trajectories of one traveller
+```python
+import pyarrow.parquet as pq, pandas as pd
+tb = pq.read_table(f"{ROOT}/travel_behaviors.parquet").to_pandas()
+row = tb.iloc[0]
+print(f"User {row['user_id']} travelled from {row['r_h']} to {row['r_o']}")
+print(f"  {row['n_home_ci']} home check-ins, {row['n_travel_ci']} destination check-ins")
+# Group destination check-ins by trail (= individual trajectory):
+import collections
+trails = collections.defaultdict(list)
+for ck in row["c_o"]:
+    trails[ck["trail_id"]].append(ck)
+for trail_id, points in trails.items():
+    points.sort(key=lambda p: p["ts"])
+    venues = " → ".join(p["venue_schema"] for p in points)
+    print(f"  trail {trail_id}: {venues}")
+```
+### Counting reviews per place without loading all 22 GB
+```python
+con.sql("""
+  SELECT fsq_place_id, COUNT(*) AS n_reviews
+  FROM '{ROOT}/reviews/reviews_all.parquet'
+  GROUP BY fsq_place_id
+  ORDER BY n_reviews DESC
+  LIMIT 20
+""".format(ROOT=ROOT)).show()
+```
+## Common join patterns
+| To go from … | … to …                       | Join key                                   |
+|--------------|------------------------------|--------------------------------------------|
+| τ record     | hometown / destination name  | `travel.r_h = regions.region_id` (and `r_o`) |
+| τ record     | per-POI usage / Google meta  | element `venue_id = pois.fsq_place_id`     |
+| τ record     | full FSQ + Google metadata   | element `venue_id = metadata_all.fsq_place_id` |
+| POI summary  | rich place attributes        | `pois.fsq_place_id = place_attributes.fsq_place_id` |
+| POI summary  | reviews                      | `pois.fsq_place_id = reviews.fsq_place_id` |
+| Reviews      | place-level Google ratings   | `reviews.google_cid = pois.google_cid`     |
+| Reviews      | author identity (within set) | `reviews.author_pid` (no external linking) |
+| Region       | municipalities folded into it| `metro_mapping_clean.json[municipality_qid] == region_id` |
+## Privacy and redaction
+The following transforms have been applied relative to the build-time
+working set so the release can be redistributed without exposing
+individual identities:
+1. **User IDs.**  `user_id` in `travel_behaviors.parquet` is remapped
+   to a fresh consecutive 1..148,402 sequence; original
+   STD-2018-derived IDs are not present.
+2. **Trail IDs.**  `trail_id` inside each `c_h` / `c_o` element is
+   likewise remapped to a fresh consecutive 1..2,723,551 sequence.
+3. **Reviewer identity.**  Reviewer display names (`author`) are
+   removed entirely.  The original numeric Google `author_id` is
+   replaced with a salted blake2b pseudonym `author_pid` (16 hex
+   characters per author).  The salt is generated at release time and
+   kept private; cross-review author linking remains possible *inside*
+   the dataset but cannot be inverted to a real Google profile.
+4. **Foursquare contact fields.**  The columns `fsq_email`, `fsq_tel`,
+   `fsq_facebook_id`, `fsq_instagram`, `fsq_twitter` are dropped from
+   `metadata_all.parquet`.
+5. **Review text.**  Review bodies are kept verbatim (they are the
+   dataset's primary signal).  Users of this release should be aware
+   that user-generated text may incidentally contain personal
+   references and should treat downstream analyses accordingly.
+If you discover residual identifying information that we missed, please
+contact the maintainers so it can be redacted in the next release.
+## Reproducibility
+The build-pipeline source is shipped under `_scripts/` for
+documentation and audit purposes.  **Re-running it end-to-end requires
+several external data sources that are not part of this release** — see
+the table below.  The released parquet files are the canonical
+artefacts; the scripts let you verify *how* they were produced and
+re-derive subsets you may need.
+### What the scripts can re-derive
+| Stage(s) | Output | External data needed |
+|----------|--------|----------------------|
+| 0–6      | metro map, τ records, POIs, region labels | STD-2018 raw check-in CSV |
+| 7        | per-POI Foursquare metadata    | Foursquare Open Source Places parquet dump |
+| 10       | extra FSQ enrichment for new POIs | Foursquare Open Source Places parquet dump |
+| 11       | FSQ-API rescue of unresolved POIs | Foursquare Places API key |
+| 12–13    | UCSD-bridge Google metadata for new POIs | UCSD all20 + benchmark POI corpus |
+| 14–16    | merged Google reviews + place attributes | **raw GCP scrape shards (not redistributable; the scrape code is not included)** |
+In other words, the structural side of Trip World (τ records, POIs,
+region labels, FSQ metadata) can be reproduced if you supply STD-2018
+and an FSQ-OS dump.  The Google reviews corpus cannot be re-derived
+from this release alone — it is provided as a static parquet because
+the scrape that produced it is not redistributable.
+### Configuring paths
+All scripts read their filesystem locations from environment variables
+so the source tree contains no personal paths.  Defaults assume the
+script is launched from inside the release's `_scripts/` subfolder.
+```bash
+export TRIP_WORLD_ROOT=/path/to/trip_world           # default: ../ relative to the script
+export STD_2018_PATH=/path/to/std_2018.csv           # raw STD-2018 stream
+export FSQ_OS_PARQUET_GLOB="/path/to/fsq_os/places/parquet/*.parquet"
+export PRECURSOR_BUILD_ROOT=/path/to/previous_build  # optional; an earlier output of this pipeline whose POI metadata and reviews stages 5/7/8/16 inherit from. Omit unless you are rebuilding incrementally on top of a prior run.
+export GMAPS_FULL_ROOT=/path/to/gmaps_full_dataset   # optional, only for stage 12
+export DUCKDB_TMP_DIR=/tmp/duckdb_trip_world          # any large local scratch directory
+export FSQ_API_KEY=fsq3...                            # only if running stage 11
+```
+### Stage-by-stage map
+```
+_scripts/00_build_metro_map.py            — metro consolidation map (Wikidata SPARQL)
+_scripts/01_consolidate_filter.py         — apply consolidation, filter to MIN_PAIR
+_scripts/02_hometown_discovery.py         — temporal-decay hometown identification
+_scripts/03_build_travelers.py            — split travellers / non-travellers
+_scripts/04_build_travel_behaviors.py     — emit τ records
+_scripts/05_build_pois.py                 — per-POI usage stats
+_scripts/06_build_region_labels.py        — Wikidata-derived city names
+_scripts/07_subset_metadata.py            — slice FSQ-OS metadata
+_scripts/08_subset_reviews.py             — slice reviews
+_scripts/09_validate.py                   — invariants + descriptive stats
+_scripts/10_enrich_new_pois.py            — local-dump enrichment for new POIs
+_scripts/11_fsq_api_recover.py            — live FSQ Places API recovery
+_scripts/12_ucsd_bridge.py                — UCSD all20+bench match
+_scripts/13_merge_ucsd_into_metadata.py   — merge UCSD matches into metadata
+_scripts/14_merge_gcp_search_results.py   — merge Stage-1 GCP scrape shards (shards not shipped)
+_scripts/15_merge_stage2_reviews.py       — merge Stage-2 listugcposts shards (shards not shipped)
+_scripts/16_unify_reviews.py              — final review unification
+_scripts/lib_wikidata.py                  — small Wikidata helper
+_scripts/viz_clean_raw.py                 — descriptive figures
+_scripts/viz_traj_length.py               — trajectory-length figure
+```
+No API keys are embedded in any released script; stages that hit
+external services (Wikidata SPARQL, FSQ Places API) read credentials
+from environment variables or CLI flags exclusively.
+## Citation
+If you use Trip World in academic work, please cite the accompanying
+paper (BibTeX entry to be released alongside the official publication).
+## License
+The Trip World release is distributed for **non-commercial research
+use** only.  Redistributions must preserve this README and the
+provenance scripts in `_scripts/`.  Use of the dataset implies
+acceptance of the upstream Foursquare Open Source Places licence and
+the Google Maps Platform Terms of Service for any further analysis
+that re-fetches data from those services.
+Released on 2026-05-05.

_scripts/00_build_metro_map.py ADDED Viewed

	@@ -0,0 +1,656 @@

+"""
+Build the METRO-level metro_mapping_clean.json for the Trip World build pipeline.
+The a precursor build used CITY-level consolidation, which left commuter-belt
+municipalities (Yokohama -> Tokyo, Suita -> Osaka, ...) as separate
+"destinations".  This produced ~14% phantom intra-metro travel records.
+The Trip World build pipeline uses METRO-level consolidation: any administrative entity
+inside a known metropolitan area collapses to a single anchor QID.
+Sources:
+  1) Optional pre-existing metro map provided via an existing metro map seed (optional, supplied via the --existing CLI flag; carried over verbatim and only extended) (carried through if set; only adds, never removes).
+  2) Hand-curated METRO_DEFINITIONS giving each anchor metro and the cities,
+     districts and prefectures inside its commuter belt.  Member QIDs are
+     drawn from Wikidata (verified by name lookup -- see _scripts/lookup_qids.txt).
+  3) SPARQL P131+ descendants of each anchor (gathers any sub-municipal entity
+     reachable via "located in administrative entity" within the metro).
+  4) Foursquare-internal "Q49xxxxxxx / Q27347xxx / Q35xxxxxxx" QIDs that lack
+     proper P131 chains -- explicitly listed below by raw_QID -> metro_QID.
+Output: $TRIP_WORLD_ROOT/metro_mapping_clean.json
+"""
+from __future__ import annotations
+import argparse, csv, json, time, collections
+from pathlib import Path
+from lib_wikidata import sparql, labels_batch
+import os
+# ---------------------------------------------------------------- METRO DEFINITIONS
+# Anchor metro QID -> human-readable name and member sub-entity QIDs.
+# Each member is a Wikidata QID (city, district, ward, prefecture, governorate)
+# that should collapse to the anchor.  Members include:
+#   * the anchor itself (no-op identity)
+#   * core city wards / boroughs / special wards
+#   * commuter-belt municipalities
+#   * the prefecture(s)/province(s)/state(s) that *primarily* serve the metro
+#     (NOT vast prefectures with rural areas spanning multiple metros, e.g.
+#      Hokkaido or Saitama-mountain regions are kept out)
+METRO_DEFINITIONS: dict[str, dict] = {
+    # ---- Greater Tokyo (Shutoken) ----
+    "Q1490": {
+        "name": "Tokyo (Greater Tokyo Area)",
+        "members": [
+            "Q1490",      # Tokyo (anchor)
+            "Q308891",    # ward area of Tokyo
+            "Q956318",    # special ward of Tokyo (the type itself)
+            # core 23 special wards
+            "Q161176",    # Chiyoda
+            "Q281289",    # Chuo
+            "Q281254",    # Minato
+            "Q235923",    # Shinjuku
+            "Q170204",    # Bunkyo
+            "Q277338",    # Taito
+            "Q281286",    # Sumida
+            "Q220977",    # Koto
+            "Q281295",    # Shinagawa
+            "Q220957",    # Meguro
+            "Q260106",    # Ota
+            "Q160438",    # Setagaya
+            "Q207601",    # Shibuya
+            "Q263552",    # Nakano
+            "Q277331",    # Suginami
+            "Q275007",    # Toshima
+            "Q281324",    # Kita
+            "Q277021",    # Arakawa
+            "Q220962",    # Itabashi
+            "Q207370",    # Nerima
+            "Q227773",    # Adachi
+            "Q281321",    # Katsushika
+            "Q281332",    # Edogawa
+            # Tama region (Western Tokyo) cities
+            "Q391093",    # Hachioji
+            "Q486868",    # Tachikawa
+            "Q406798",    # Musashino
+            "Q486876",    # Mitaka
+            "Q210667",    # Chofu
+            "Q1133105",   # Fuchu
+            "Q317813",    # Fussa
+            "Q390788",    # Higashiyamato
+            # Greater Tokyo commuter cities (Kanagawa)
+            "Q38283",     # Yokohama
+            "Q201136",    # Kawasaki
+            "Q406798",    # (dup)
+            "Q461920",    # Fujisawa
+            "Q319330",    # Yokosuka
+            "Q277260",    # Sagamihara
+            "Q319737",    # Atsugi
+            "Q1057611",   # Hiratsuka
+            "Q132860",    # Kamakura
+            # Greater Tokyo commuter cities (Saitama)
+            "Q205616",    # Saitama (city)
+            "Q380049",    # Kawaguchi
+            "Q425418",    # Soka
+            "Q425556",    # Tokorozawa
+            "Q390655",    # Asaka
+            "Q425481",    # Koshigaya
+            # Greater Tokyo commuter cities (Chiba)
+            "Q121054",    # Chiba (city)
+            "Q319729",    # Urayasu (canonical Wikidata)
+            "Q271417",    # Funabashi
+            "Q487247",    # Matsudo
+            "Q425556",    # (dup)
+            "Q486883",    # Ichikawa
+            "Q200988",    # Kashiwa
+            # Prefectures that are essentially the Greater Tokyo commuter belt
+            "Q127513",    # Kanagawa Prefecture
+            "Q128186",    # Saitama Prefecture
+            "Q80011",     # Chiba Prefecture
+            # Foursquare-internal Tokyo / Greater Tokyo QIDs (Q49xxxxxxx)
+            "Q49295377",  # Yokohama-area (Foursquare-internal, P131->Kanagawa)
+            "Q49369715",  # 浦�� Urayasu (Foursquare-internal)
+            "Q49369649",  # likely Tokyo area
+            "Q49371464",  # likely Tokyo area
+            "Q49371967",  # likely Tokyo area
+            "Q49371923",  # likely Tokyo area
+            "Q49371907",  # likely Tokyo area
+            "Q49371895",  # likely Tokyo area
+            "Q49371841",  # likely Tokyo area
+            "Q49371829",  # likely Tokyo area
+            "Q49371792",  # likely Tokyo area
+            "Q49371745",  # likely Tokyo area
+            # Verified via Wikidata coords / P131:
+            "Q35730142",  # Minami-rinkan, Yamato Kanagawa
+            "Q35722099",  # Machida (P131->Q1490 directly)
+            "Q386697",    # Yamato (Kanagawa parent of Minami-rinkan)
+            "Q387136",    # Kawaguchi (Saitama, P131->Saitama)
+            "Q273798",    # Narita (Chiba)
+            "Q49371923",  # Ōi (Saitama)
+            # Foursquare-internal QIDs at coords inside Greater Tokyo (lat 35.6-35.9, lon 139.4-139.8)
+            "Q49353821",  # coords (35.67,139.40) - Tokyo SW
+            "Q49355990",  # coords (35.69,139.55) - Tokyo W
+            "Q49371464",  # coords (35.88,139.63) - Saitama
+            # NOTE: We do *not* blanket-collapse all Q49xxxxxxx into Tokyo.
+            # Only ones whose P131 chain (verified via SPARQL below) leads to
+            # Kanagawa / Saitama / Chiba / Tokyo prefectures, OR whose coords
+            # lie inside the Greater Tokyo bounding box.
+        ],
+    },
+    # ---- Keihanshin (Greater Osaka) ----
+    "Q35765": {
+        "name": "Osaka (Keihanshin)",
+        "members": [
+            "Q35765",     # Osaka (anchor)
+            "Q122723",    # Osaka Prefecture
+            "Q34600",     # Kyoto
+            "Q120730",    # Kyoto Prefecture
+            # NOTE: Nagoya (Q11751) is intentionally NOT in Keihanshin -- it's its own metro
+            "Q130290",    # Hyogo Prefecture
+            "Q133054",    # Nara Prefecture
+            "Q187153",    # Sakai
+            "Q220655",    # Nishinomiya
+            "Q725514",    # Ashiya
+            "Q653510",    # Suita (canonical)
+            "Q49368443",  # Suita (Foursquare-internal)
+            "Q231318",    # Higashiosaka
+            "Q486398",    # Toyonaka
+            "Q499375",    # Amagasaki
+            "Q734474",    # Itami
+            "Q200994",    # Otsu
+            "Q48320",     # Kobe (corrected QID; was Q244 which is Roman numeral)
+            # Foursquare-internal Osaka-area QIDs (verified via P131 chain)
+            "Q49368443",  # (dup) Suita
+        ],
+    },
+    # Remove Nagoya from Osaka definition; it's its own metro.
+    # ---- Chukyo (Greater Nagoya) ----
+    "Q11751": {
+        "name": "Nagoya (Chukyo)",
+        "members": [
+            "Q11751",     # Nagoya (anchor)
+            "Q80434",     # Aichi Prefecture
+            "Q131277",    # Gifu Prefecture
+            "Q128196",    # Mie Prefecture
+            "Q188996",    # Toyota
+            "Q486392",    # Toyohashi
+            "Q462000",    # Okazaki
+            "Q462009",    # Ichinomiya
+            "Q499390",    # Kasugai
+        ],
+    },
+    # ---- Greater Istanbul ----
+    "Q406": {
+        "name": "Istanbul",
+        "members": [
+            "Q406",       # Istanbul (anchor)
+            "Q534799",    # Istanbul Province
+            "Q326339",    # Üsküdar
+            "Q746516",    # Bağcılar
+            "Q1006881",   # Şişli (canonical district)
+            "Q49371964",  # Şişli (Foursquare-internal "yerleşim")
+            "Q179351",    # ! Westminster -> handled separately, NOT here
+            # ^^ removed; just being defensive about not overloading the entry.
+            "Q3473299",   # Beşiktaş
+            "Q1023876",   # Kadıköy
+            "Q1247058",   # Bakırköy
+            "Q1067075",   # Kartal
+            "Q1023901",   # Maltepe
+            "Q605884",    # Pendik
+            "Q604919",    # Tuzla
+            "Q1135036",   # Ataşehir
+            "Q1019002",   # Beylikdüzü
+        ],
+    },
+    # ---- Greater Ankara ----
+    "Q3640": {
+        "name": "Ankara",
+        "members": [
+            "Q3640",      # Ankara (anchor)
+            "Q2297724",   # Ankara Province
+            "Q3928674",   # Hudavendigar vilayet (historical/Foursquare alt)
+            "Q608459",    # Çankaya
+            "Q625728",    # Keçiören
+        ],
+    },
+    # ---- Greater Izmir ----
+    "Q35997": {
+        "name": "İzmir",
+        "members": [
+            "Q35997",     # İzmir (anchor)
+            "Q344490",    # İzmir Province
+            "Q3123584",   # Karabağlar district
+            "Q615098",    # Konak
+            "Q615075",    # Bornova
+            "Q1190403",   # (Edessa - actually Şanlıurfa; will be filtered below)
+        ],
+    },
+    # ---- Greater Kuwait City ----
+    "Q35178": {
+        "name": "Kuwait City",
+        "members": [
+            "Q35178",     # Kuwait City (anchor)
+            "Q3235220",   # Hawally
+            "Q3495478",   # Sabah Al-Salem
+            "Q4704795",   # Al Shamiya
+            "Q747432",    # Hawalli Governorate
+            "Q372316",    # Al Asimah Governorate
+            "Q953508",    # Eastern Province (NOT Kuwait -- Saudi! filter out below)
+            "Q185122",    # Al Farwaniyah Governorate
+            "Q1057620",   # Mubarak Al-Kabeer Governorate
+            "Q310948",    # Al Ahmadi Governorate
+            "Q83341",     # Jahra Governorate
+            "Q3221814",   # Salmiya
+            "Q14708037",  # Salwa
+            "Q5894717",   # Jabriya
+            # Kuwait Q27347xxx series (Foursquare-internal, all P17=Q817 by coordinate)
+            "Q27347020",  # in Kuwait
+            "Q27347063",  # Al Dasma
+            "Q27347142",  # in Kuwait
+            "Q1046645",   # parent of Al Dasma; collapse upward
+            # additional Kuwaiti districts discovered during validation
+            "Q3505782",   # Salmiya (P131->Hawalli Gov)
+            "Q4120400",   # Mubarak Al-Kabeer (P17=Q817, no P131)
+            "Q3495485",   # Fahaheel District (P131->Ahmadi Gov)
+            "Q552354",    # Ahmadi Governorate
+            "Q1077024",   # Al Jahra
+            "Q405701",    # Jahra Governorate
+        ],
+    },
+    # ---- Greater Mexico City ----
+    "Q1489": {
+        "name": "Mexico City",
+        "members": [
+            "Q1489",      # Mexico City (anchor)
+            # All v2's existing delegacion mappings carried through automatically
+            "Q1502190",   # State of Mexico (commuter belt, debatable)
+            "Q21509",     # Naucalpan
+            "Q161113",    # Tlalnepantla
+            "Q244366",    # Ecatepec
+            "Q205344",    # Nezahualcóyotl
+        ],
+    },
+    # ---- Greater Manila ----
+    "Q13580": {
+        "name": "Metro Manila",
+        "members": [
+            "Q13580",     # Metro Manila (anchor)
+            "Q1461",      # Manila proper
+            "Q1475",      # Quezon City
+            "Q1508",      # Makati
+            "Q9085",      # Mandaluyong
+            "Q31475562",  # Bagong Pag-asa (already in v2)
+            "Q9248",      # Pasig
+            "Q12972",     # Taguig
+            "Q190482",    # Caloocan
+            "Q47265",     # Pasay
+            "Q24856",     # Parañaque
+            "Q31476",     # Las Piñas
+            "Q23681",     # Muntinlupa
+            "Q161115",    # Marikina
+            "Q190428",    # Valenzuela
+            "Q31476",     # (dup)
+        ],
+    },
+    # ---- Greater São Paulo ----
+    "Q174": {
+        "name": "São Paulo",
+        "members": [
+            "Q174",       # São Paulo (anchor)
+            "Q175",       # São Paulo state (debatable; whole state)
+            "Q201161",    # Guarulhos
+            "Q140714",    # Osasco
+            "Q188800",    # Santo André
+            "Q188820",    # São Bernardo do Campo
+            "Q188824",    # São Caetano do Sul
+            "Q201161",    # (dup)
+        ],
+    },
+    # ---- Greater Rio de Janeiro ----
+    "Q8678": {
+        "name": "Rio de Janeiro",
+        "members": [
+            "Q8678",      # Rio de Janeiro (city, anchor)
+            "Q41428",     # Rio de Janeiro state
+            "Q188897",    # Nova Iguaçu
+            "Q983459",    # Nilópolis
+            "Q186363",    # Niterói
+            "Q188867",    # Duque de Caxias
+            "Q189070",    # São Gonçalo
+            "Q189158",    # Belford Roxo
+        ],
+    },
+    # ---- Greater Bangkok ----
+    "Q1861": {
+        "name": "Bangkok",
+        "members": [
+            "Q1861",      # Bangkok (anchor)
+            "Q242932",    # Nonthaburi Province
+            "Q475212",    # Bang Kruai
+            "Q15199204",  # Bang Kruai (Foursquare alt)
+            "Q768864",    # Nonthaburi (city)
+            "Q205454",    # Pak Kret
+            "Q244408",    # Pathum Thani Province
+            "Q244399",    # Samut Prakan Province
+        ],
+    },
+    # ---- Greater London (already in v2, extending) ----
+    "Q84": {
+        "name": "London",
+        "members": [
+            "Q84",        # London (anchor)
+            "Q179351",    # Westminster
+            # All London boroughs (32 + City of London)
+            "Q201808",    # Camden
+            "Q204022",    # Islington (note: also a v2 target)
+            "Q205817",    # London Borough of Islington (already a v2 target!)
+            "Q204008",    # Hackney
+            "Q204009",    # Tower Hamlets
+            "Q204008",    # (dup)
+            "Q207017",    # Lambeth
+            "Q207018",    # Southwark
+            "Q207020",    # Wandsworth
+            "Q204010",    # Kensington and Chelsea
+            "Q205677",    # Hammersmith and Fulham
+            "Q204023",    # Haringey
+            "Q204008",    # (dup)
+            "Q207016",    # Lewisham
+            "Q207021",    # Greenwich
+            "Q207022",    # Newham
+            "Q207023",    # Waltham Forest
+            "Q204023",    # (dup)
+            "Q204022",    # (dup)
+        ],
+    },
+    # ---- New York City (already in v2 with Manhattan/Brooklyn/etc.) ----
+    "Q60": {
+        "name": "New York City",
+        "members": [
+            "Q60",        # NYC (anchor)
+            "Q11299",     # Manhattan
+            "Q18424",     # Brooklyn
+            "Q18432",     # Queens
+            "Q18426",     # Bronx
+            "Q18437",     # Staten Island
+            # Plus the v2 already maps East Village, East Harlem, Hell's Kitchen
+            # under Q11299; transitive_close will reroute them all to Q60.
+        ],
+    },
+    # ---- Greater Chicago (already in v2; extending if needed) ----
+    "Q1297": {
+        "name": "Chicago",
+        "members": ["Q1297"],
+    },
+    # ---- Greater Buenos Aires (already in v2) ----
+    "Q1486": {
+        "name": "Buenos Aires",
+        "members": ["Q1486"],
+    },
+    # ---- Greater Kuala Lumpur (Klang Valley) ----
+    "Q1865": {
+        "name": "Kuala Lumpur (Klang Valley)",
+        "members": [
+            "Q1865",      # Kuala Lumpur (anchor)
+            "Q864965",    # Petaling Jaya
+            "Q2701266",   # Petaling District
+            "Q189710",    # Selangor (state - debatable; keep cause Klang Valley spans it)
+            "Q221275",    # Subang Jaya
+            "Q815117",    # Klang
+            # NOTE: Johor Bahru (Q2193190) is a SEPARATE metro in southern Malaysia
+            "Q864964",    # Shah Alam
+            "Q1018830",   # Kajang
+            "Q1018828",   # Ampang Jaya
+            "Q500033",    # Shah Alam (P131->Petaling District)
+            "Q2366087",   # Balakong (P131->place in Selangor)
+            "Q4251470",   # parent of Balakong
+        ],
+    },
+    # ---- Greater Riyadh ----
+    "Q3692": {
+        "name": "Riyadh",
+        "members": [
+            "Q3692",      # Riyadh (anchor)
+            "Q41475",     # Riyadh Province
+        ],
+    },
+    # ---- Greater Sendai ----
+    "Q46747": {
+        "name": "Sendai",
+        "members": [
+            "Q46747",     # Sendai (anchor)
+            "Q47896",     # Miyagi Prefecture
+        ],
+    },
+    # ---- Greater Sapporo ----
+    "Q37951": {
+        "name": "Sapporo",
+        "members": [
+            "Q37951",     # Sapporo (anchor; Q35531 was wrong)
+            "Q1037393",   # Hokkaido (huge region; debatable -- but Sapporo is by far the dominant city)
+            "Q1997315",   # Ishikari Subprefecture
+            "Q49295332",  # P131 -> Hokkaido (Foursquare-internal)
+            "Q693237",    # Chitose (P131->Ishikari Subprefecture)
+        ],
+    },
+    # ---- Greater Fukuoka ----
+    "Q26600": {
+        "name": "Fukuoka",
+        "members": [
+            "Q26600",     # Fukuoka (anchor; Q41051 was wrong, that's an Italian comune)
+            "Q123258",    # Fukuoka Prefecture
+            "Q49295241",  # P131 -> Fukuoka Prefecture (Foursquare-internal)
+        ],
+    },
+}
+# QIDs that are EXPLICITLY NOT to be merged (they look like leaks but aren't).
+# E.g. Q49295241 has label "" but P131 -> Fukuoka Prefecture (a different metro).
+DO_NOT_MERGE: set[str] = {
+    # These Q49xxxxxxx ones live in NON-Tokyo prefectures per their P131 chain.
+    # (Q49295241 is now in Greater Fukuoka definition; Q49295332 is in Greater Sapporo via Hokkaido)
+    "Q49295248",
+    "Q49355990",
+    "Q49353249",
+    "Q49353821",
+    "Q49755161",
+    # Misc Wikidata items that landed in venue_city but are nonsense
+    "Q132894",    # "Pterocarpus" (tree genus, not Yokohama!)
+    "Q1392079",   # "Terry George" (a person)
+    "Q21",        # England (region/country, too coarse)
+    "Q26952",     # Alvis Car Co. (not a city)
+    "Q1190403",   # Edessa / Şanlıurfa, not Izmir
+    "Q953508",    # Saudi Eastern Province, not Kuwait
+}
+# ---------------------------------------------------------------- helpers
+def step(t0, msg):
+    print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+def enumerate_raw_cities(raw_csv: Path, min_ci: int) -> list[tuple[str, int]]:
+    counter: collections.Counter[str] = collections.Counter()
+    with raw_csv.open() as f:
+        rd = csv.DictReader(f)
+        for row in rd:
+            v = row.get("venue_city")
+            if v:
+                counter[v] += 1
+    big = [(q.replace("wd:", ""), n) for q, n in counter.items() if n >= min_ci]
+    big.sort(key=lambda x: -x[1])
+    return big
+def discover_p131_descendants(anchor_qid: str, max_results: int = 100000) -> set[str]:
+    """Return all entities reachable as wdt:P131+ wd:<anchor>."""
+    q = f"""
+SELECT ?desc WHERE {{
+  ?desc wdt:P131+ wd:{anchor_qid} .
+}} LIMIT {max_results}
+"""
+    try:
+        rows = sparql(q)
+        return {r["desc"]["value"].rsplit("/", 1)[-1] for r in rows}
+    except Exception as e:
+        print(f"  P131+ for {anchor_qid} failed: {e}")
+        return set()
+# ---------------------------------------------------------------- main
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--raw", default=os.environ.get("STD_2018_PATH"))
+    ap.add_argument("--out",
+                    default=os.environ.get("METRO_MAP_OUT",
+                        str(Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent)) / "metro_mapping_clean.json")))
+    ap.add_argument("--existing", default=None)
+    ap.add_argument("--min-checkins", type=int, default=50,
+                    help="discover descendants of anchors only for raw QIDs above this CI threshold")
+    ap.add_argument("--use-sparql", action="store_true", default=True,
+                    help="enable SPARQL P131+ descendant discovery for each anchor metro")
+    args = ap.parse_args()
+    out_path = Path(args.out)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    t0 = time.time()
+    # Step 1: load existing v2 map
+    step(t0, f"loading existing {args.existing}")
+    existing = json.load(open(args.existing))
+    base_map: dict[str, str] = dict(existing.get("metro_map", {}))
+    base_labels: dict[str, str] = dict(existing.get("labels", {}))
+    step(t0, f"  v2 has {len(base_map):,} entries ({sum(1 for k,v in base_map.items() if k!=v):,} non-identity)")
+    # Step 2: enumerate raw QIDs to know which are worth mapping
+    step(t0, f"enumerating raw venue_city QIDs (>= {args.min_checkins} CIs)")
+    big = enumerate_raw_cities(Path(args.raw), args.min_checkins)
+    raw_qids = {q for q, _ in big}
+    step(t0, f"  {len(raw_qids):,} raw QIDs to consider")
+    # Step 3: build map = identity for everyone, then apply hand-curated members
+    step(t0, "applying METRO_DEFINITIONS (hand-curated)")
+    metro_map = {q: q for q in raw_qids}
+    metro_map.update(base_map)  # carry through v2
+    n_added_manual = 0
+    for anchor, defn in METRO_DEFINITIONS.items():
+        for member in defn["members"]:
+            if member in DO_NOT_MERGE:
+                continue
+            if member == anchor:
+                continue
+            if metro_map.get(member) != anchor:
+                metro_map[member] = anchor
+                n_added_manual += 1
+    # CRITICAL: enforce anchor -> anchor for every anchor *after* all members
+    # are placed.  Without this, an anchor that was listed as a "member" of a
+    # different metro earlier in iteration order ends up demoted (e.g. Nagoya
+    # accidentally listed under Osaka would lose its Nagoya identity).
+    all_anchors = set(METRO_DEFINITIONS.keys())
+    for anchor in all_anchors:
+        metro_map[anchor] = anchor
+    step(t0, f"  added/updated {n_added_manual:,} curated mappings; "
+              f"forced {len(all_anchors):,} anchors to identity")
+    # Step 4: SPARQL P131+ descendant discovery per anchor
+    if args.use_sparql:
+        step(t0, "discovering SPARQL P131+ descendants of each anchor")
+        n_added_sparql = 0
+        for anchor, defn in METRO_DEFINITIONS.items():
+            descs = discover_p131_descendants(anchor)
+            for d in descs:
+                if d in DO_NOT_MERGE:
+                    continue
+                if d == anchor:
+                    continue
+                # Only assign if d is a raw QID we care about, and not already mapped elsewhere
+                # (members override SPARQL, but SPARQL extends to discovered descendants)
+                if d in raw_qids and metro_map.get(d, d) == d:
+                    metro_map[d] = anchor
+                    n_added_sparql += 1
+            step(t0, f"  {anchor} ({defn['name']}): {len(descs):,} descendants found, "
+                       f"{sum(1 for d in descs if d in raw_qids):,} matched raw QIDs")
+        step(t0, f"  added {n_added_sparql:,} SPARQL-discovered mappings")
+    # Step 5: enforce DO_NOT_MERGE (force identity on these)
+    n_forced = 0
+    for q in DO_NOT_MERGE:
+        if q in metro_map and metro_map[q] != q:
+            metro_map[q] = q
+            n_forced += 1
+    step(t0, f"  forced {n_forced:,} DO_NOT_MERGE QIDs back to identity")
+    # Step 6: transitive close
+    step(t0, "computing transitive closure")
+    def resolve(q):
+        seen = {q}
+        while metro_map.get(q, q) != q and metro_map[q] not in seen:
+            q = metro_map[q]
+            seen.add(q)
+        return q
+    metro_map = {k: resolve(k) for k in metro_map}
+    rewritten = sum(1 for k, v in metro_map.items() if k != v)
+    targets = set(metro_map.values())
+    step(t0, f"  total: {len(metro_map):,} entries, {rewritten:,} rewrites, "
+              f"{len(targets):,} distinct metro targets")
+    # Step 7: collect labels for everything
+    step(t0, "fetching labels for all sources + targets")
+    label_map = dict(base_labels)
+    universe = set(metro_map.keys()) | set(metro_map.values())
+    missing = sorted(q for q in universe if q not in label_map or not label_map[q])
+    if missing:
+        step(t0, f"  fetching {len(missing):,} missing labels (batched)")
+        label_map.update(labels_batch(missing))
+    # Step 8: dump
+    out = {
+        "metro_map": metro_map,
+        "labels": label_map,
+        "build_log": {
+            "raw_csv": args.raw,
+            "min_checkins": args.min_checkins,
+            "raw_qids_considered": len(raw_qids),
+            "rewritten_qids": rewritten,
+            "distinct_metro_targets": len(targets),
+            "metro_definitions": {a: d["name"] for a, d in METRO_DEFINITIONS.items()},
+            "do_not_merge": sorted(DO_NOT_MERGE),
+        },
+    }
+    out_path.write_text(json.dumps(out, ensure_ascii=False, indent=2))
+    step(t0, f"wrote {out_path} ({out_path.stat().st_size/1024:.1f} KB)")
+    # Quick sanity: top 20 raw QIDs and their assigned metro
+    print("\nTop 20 raw QIDs and their metro assignment:")
+    print(f"  {'qid':10s}  {'raw_label':25s}  {'->target':10s}  target_label")
+    for q, n in big[:20]:
+        target = metro_map.get(q, q)
+        rl = label_map.get(q, '?')[:25]
+        tl = label_map.get(target, '?')[:25]
+        print(f"  {q:10s}  {rl:25s}  -> {target:10s}  {tl}  ({n:,} CIs)")
+if __name__ == "__main__":
+    main()

_scripts/01_consolidate_filter.py ADDED Viewed

	@@ -0,0 +1,125 @@

+"""
+Stage 1 of the Trip World build pipeline.
+Reads raw ${STD_2018_PATH}, applies
+metro_mapping_clean.json to the venue_city QID (producing region_id),
+then enforces:
+  (a) POI popularity:  drop POIs with < 2 visits in the *consolidated* stream
+  (b) Region density:  drop regions with < 100 distinct POIs after (a)
+Output: _intermediate/checkins_consolidated.parquet
+        Columns: trail_id, user_id, venue_id, venue_category, venue_schema,
+                 venue_city_qid, venue_country_qid, ts, region_id
+        (Same schema as the precursor build/checkins_filtered.parquet so
+         downstream stages can reuse the same query patterns.)
+"""
+import duckdb, json, os, time
+from pathlib import Path
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+RAW = os.environ["STD_2018_PATH"]
+MAP = ROOT / "metro_mapping_clean.json"
+OUT = ROOT / "_intermediate" / "checkins_consolidated.parquet"
+OUT.parent.mkdir(parents=True, exist_ok=True)
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+# Load metro map
+mm = json.load(MAP.open())["metro_map"]
+step(f"loaded metro_map ({len(mm):,} entries, {sum(1 for k,v in mm.items() if k!=v):,} non-identity)")
+# Materialise as a small parquet (DuckDB joins efficiently against parquet)
+import pyarrow as pa, pyarrow.parquet as pq
+import os
+mm_tbl = pa.Table.from_pylist([{"raw": k, "metro": v} for k, v in mm.items()])
+mm_path = ROOT / "_intermediate" / "metro_map.parquet"
+pq.write_table(mm_tbl, mm_path, compression="zstd")
+step(f"wrote {mm_path}")
+con = duckdb.connect()
+con.execute("PRAGMA threads=32")
+con.execute("SET memory_limit='48GB'")
+con.execute("SET preserve_insertion_order=false")
+con.execute(f"SET temp_directory='{os.environ.get('DUCKDB_TMP_DIR', '/tmp/duckdb_trip_world')}'")
+# ---------------- Step A: load raw stream + apply metro_map -------------------
+step("loading raw std_2018.csv into DuckDB and applying metro_map ...")
+con.execute(f"""
+CREATE TABLE raw AS
+SELECT
+  trail_id, user_id, venue_id, venue_category, venue_schema,
+  venue_city  AS venue_city_qid,
+  venue_country AS venue_country_qid,
+  TRY_CAST(timestamp AS TIMESTAMPTZ) AS ts
+FROM read_csv_auto('{RAW}', sample_size=-1)
+""")
+n_raw = con.execute("SELECT COUNT(*) FROM raw").fetchone()[0]
+n_users = con.execute("SELECT COUNT(DISTINCT user_id) FROM raw").fetchone()[0]
+n_pois  = con.execute("SELECT COUNT(DISTINCT venue_id) FROM raw").fetchone()[0]
+n_cities= con.execute("SELECT COUNT(DISTINCT venue_city_qid) FROM raw").fetchone()[0]
+step(f"  raw: {n_raw:,} rows, {n_users:,} users, {n_pois:,} POIs, {n_cities:,} venue_city QIDs")
+# Strip "wd:" prefix to match metro_map keys, then left-join.
+con.execute(f"""
+CREATE TABLE consolidated AS
+SELECT
+  raw.trail_id, raw.user_id, raw.venue_id, raw.venue_category, raw.venue_schema,
+  raw.venue_city_qid, raw.venue_country_qid, raw.ts,
+  COALESCE(mm.metro, REPLACE(raw.venue_city_qid, 'wd:', '')) AS region_id
+FROM raw
+LEFT JOIN read_parquet('{mm_path}') mm
+  ON mm.raw = REPLACE(raw.venue_city_qid, 'wd:', '')
+""")
+n_dist_regions = con.execute("SELECT COUNT(DISTINCT region_id) FROM consolidated").fetchone()[0]
+step(f"  consolidated: {n_dist_regions:,} distinct region_id values")
+# ---------------- Step B: POI popularity filter -------------------------------
+step("applying POI popularity filter (visits per POI >= 2) ...")
+con.execute("""
+CREATE TABLE poi_popular AS
+SELECT venue_id FROM consolidated
+GROUP BY venue_id HAVING COUNT(*) >= 2
+""")
+n_pop_pois = con.execute("SELECT COUNT(*) FROM poi_popular").fetchone()[0]
+step(f"  popular POIs: {n_pop_pois:,} (kept) of {n_pois:,}")
+con.execute("""
+CREATE TABLE filtered_pop AS
+SELECT c.* FROM consolidated c JOIN poi_popular p USING (venue_id)
+""")
+n_pop_rows = con.execute("SELECT COUNT(*) FROM filtered_pop").fetchone()[0]
+step(f"  rows after popularity filter: {n_pop_rows:,}")
+# ---------------- Step C: region density filter -------------------------------
+step("applying region density filter (>= 100 distinct POIs per region) ...")
+con.execute("""
+CREATE TABLE region_dense AS
+SELECT region_id FROM (
+  SELECT region_id, COUNT(DISTINCT venue_id) AS n_pois
+  FROM filtered_pop GROUP BY region_id
+) WHERE n_pois >= 100
+""")
+n_dense_regions = con.execute("SELECT COUNT(*) FROM region_dense").fetchone()[0]
+step(f"  dense regions: {n_dense_regions:,} (kept)")
+con.execute(f"""
+COPY (
+  SELECT f.* FROM filtered_pop f JOIN region_dense d USING (region_id)
+) TO '{OUT}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 50000)
+""")
+n_final = con.execute(f"SELECT COUNT(*) FROM read_parquet('{OUT}')").fetchone()[0]
+n_final_users = con.execute(f"SELECT COUNT(DISTINCT user_id) FROM read_parquet('{OUT}')").fetchone()[0]
+n_final_pois  = con.execute(f"SELECT COUNT(DISTINCT venue_id) FROM read_parquet('{OUT}')").fetchone()[0]
+n_final_reg   = con.execute(f"SELECT COUNT(DISTINCT region_id) FROM read_parquet('{OUT}')").fetchone()[0]
+sz = OUT.stat().st_size / 1e6
+print()
+print("=== Stage 1 output ===")
+print(f"  file:           {OUT}  ({sz:.1f} MB)")
+print(f"  rows:           {n_final:,}")
+print(f"  users:          {n_final_users:,}")
+print(f"  POIs:           {n_final_pois:,}")
+print(f"  dense regions:  {n_final_reg:,}")
+print(f"  total elapsed:  {time.time()-t0:.1f}s")

_scripts/02_hometown_discovery.py ADDED Viewed

	@@ -0,0 +1,104 @@

+"""
+Stage 2 of the Trip World build pipeline: hometown discovery.
+For each user u, compute the supporting value
+    phi(u, r) = sum_{c_i in r} theta^(-delta_t_i / T) / (N + eps)
+across each candidate region r the user has check-ins in.  Pick r_h = argmax phi,
+then drop users whose hometown has fewer than --min-home-ci check-ins.
+Constants
+---------
+theta = 2          (matches the doc; halves weight every T days)
+T     = 180 days   (typical "season" window)
+eps   = 1          (denominator regulariser)
+observation_time = MAX(ts) in the consolidated stream
+Output: _intermediate/users_hometown.parquet
+        Columns: user_id, r_h, phi_home, n_home_ci
+"""
+import duckdb, time, math
+from pathlib import Path
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+IN  = ROOT / "_intermediate" / "checkins_consolidated.parquet"
+OUT = ROOT / "_intermediate" / "users_hometown.parquet"
+THETA = 2.0
+T_DAYS = 180.0
+EPS = 1.0
+MIN_HOME_CI = 4
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+con = duckdb.connect()
+con.execute("PRAGMA threads=32")
+con.execute("SET memory_limit='48GB'")
+con.execute("SET preserve_insertion_order=false")
+con.execute(f"SET temp_directory='{os.environ.get('DUCKDB_TMP_DIR', '/tmp/duckdb_trip_world')}'")
+# Determine observation_time (max ts in stream) once.
+obs_ts = con.execute(f"SELECT MAX(ts) FROM read_parquet('{IN}')").fetchone()[0]
+step(f"observation time: {obs_ts}")
+# Compute phi(u, r) per (user, region) and N (total CIs) per user, then pick winner.
+# delta_t in days = epoch_seconds(obs_ts - ts) / 86400
+step("computing phi(u, r) and selecting hometown ...")
+con.execute(f"""
+CREATE TABLE phi AS
+WITH per_user_total AS (
+  SELECT user_id, COUNT(*) AS N
+  FROM read_parquet('{IN}')
+  GROUP BY user_id
+),
+weighted AS (
+  SELECT user_id, region_id,
+         POW({THETA}, -EXTRACT(EPOCH FROM (TIMESTAMP '{obs_ts}' - ts)) / 86400.0 / {T_DAYS}) AS w
+  FROM read_parquet('{IN}')
+)
+SELECT  w.user_id,
+        w.region_id,
+        SUM(w.w) AS sum_w,
+        COUNT(*) AS n_ci,
+        SUM(w.w) / (any_value(t.N) + {EPS}) AS phi
+FROM weighted w
+JOIN per_user_total t USING (user_id)
+GROUP BY w.user_id, w.region_id
+""")
+step(f"  phi rows: {con.execute('SELECT COUNT(*) FROM phi').fetchone()[0]:,}")
+# Pick hometown = argmax phi per user
+step("picking r_h = argmax phi per user ...")
+con.execute("""
+CREATE TABLE users_hometown_raw AS
+SELECT user_id, region_id AS r_h, phi AS phi_home, n_ci AS n_home_ci
+FROM (
+  SELECT *,
+         ROW_NUMBER() OVER (PARTITION BY user_id ORDER BY phi DESC, n_ci DESC, region_id) AS rn
+  FROM phi
+)
+WHERE rn = 1
+""")
+n_users_pre = con.execute("SELECT COUNT(*) FROM users_hometown_raw").fetchone()[0]
+step(f"  candidate hometowns assigned: {n_users_pre:,} users")
+# Filter: |c_h| >= MIN_HOME_CI
+step(f"applying |c_h| >= {MIN_HOME_CI} filter ...")
+con.execute(f"""
+COPY (
+  SELECT user_id, r_h, phi_home, n_home_ci
+  FROM users_hometown_raw
+  WHERE n_home_ci >= {MIN_HOME_CI}
+  ORDER BY user_id
+) TO '{OUT}' (FORMAT PARQUET, COMPRESSION 'zstd')
+""")
+n_kept = con.execute(f"SELECT COUNT(*) FROM read_parquet('{OUT}')").fetchone()[0]
+n_dist_homes = con.execute(f"SELECT COUNT(DISTINCT r_h) FROM read_parquet('{OUT}')").fetchone()[0]
+sz = OUT.stat().st_size / 1e6
+print()
+print("=== Stage 2 output ===")
+print(f"  file:               {OUT}  ({sz:.1f} MB)")
+print(f"  users with hometown: {n_kept:,} (dropped {n_users_pre-n_kept:,})")
+print(f"  distinct hometowns:  {n_dist_homes:,}")
+print(f"  total elapsed:       {time.time()-t0:.1f}s")

_scripts/03_build_travelers.py ADDED Viewed

	@@ -0,0 +1,96 @@

+"""
+Stage 3 of the Trip World build pipeline.
+Given users_hometown.parquet (each user's r_h) and the consolidated check-in
+stream, identify (user, r_o) pairs where:
+  (a) r_o != r_h
+  (b) the user has at least --min-travel-ci check-ins in r_o
+  (c) the (r_h, r_o) pair appears at least --min-pair-freq times across users
+Output: _intermediate/travelers.parquet
+        Columns: user_id, r_h, r_o, n_home_ci, n_travel_ci
+"""
+import duckdb, time
+from pathlib import Path
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+INC  = ROOT / "_intermediate" / "checkins_consolidated.parquet"
+INH  = ROOT / "_intermediate" / "users_hometown.parquet"
+OUT  = ROOT / "_intermediate" / "travelers.parquet"
+MIN_TRAVEL_CI = 2
+MIN_PAIR_FREQ = 10
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+con = duckdb.connect()
+con.execute("PRAGMA threads=32")
+con.execute("SET memory_limit='48GB'")
+con.execute("SET preserve_insertion_order=false")
+con.execute(f"SET temp_directory='{os.environ.get('DUCKDB_TMP_DIR', '/tmp/duckdb_trip_world')}'")
+# --- Step A: per (user, region) check-in counts -------------------------------
+step("counting check-ins per (user, region) ...")
+con.execute(f"""
+CREATE TABLE ur_counts AS
+SELECT user_id, region_id, COUNT(*) AS n_ci
+FROM read_parquet('{INC}')
+GROUP BY user_id, region_id
+""")
+# --- Step B: candidate destination tuples (user, r_h, r_o, n_travel_ci) -------
+step("forming candidate (user, r_h, r_o, n_travel_ci) tuples ...")
+con.execute(f"""
+CREATE TABLE candidates AS
+SELECT
+  h.user_id,
+  h.r_h,
+  c.region_id AS r_o,
+  h.n_home_ci,
+  c.n_ci AS n_travel_ci
+FROM read_parquet('{INH}') h
+JOIN ur_counts c USING (user_id)
+WHERE c.region_id <> h.r_h
+  AND c.n_ci >= {MIN_TRAVEL_CI}
+""")
+n_cand = con.execute("SELECT COUNT(*) FROM candidates").fetchone()[0]
+step(f"  candidates after |c_o| >= {MIN_TRAVEL_CI}: {n_cand:,}")
+# --- Step C: pair frequency filter -------------------------------------------
+step(f"applying (r_h, r_o) pair frequency >= {MIN_PAIR_FREQ} filter ...")
+con.execute(f"""
+CREATE TABLE pair_freq AS
+SELECT r_h, r_o, COUNT(*) AS pair_n
+FROM candidates GROUP BY r_h, r_o HAVING pair_n >= {MIN_PAIR_FREQ}
+""")
+n_pairs = con.execute("SELECT COUNT(*) FROM pair_freq").fetchone()[0]
+step(f"  pairs surviving: {n_pairs:,}")
+con.execute(f"""
+COPY (
+  SELECT c.user_id, c.r_h, c.r_o, c.n_home_ci, c.n_travel_ci
+  FROM candidates c JOIN pair_freq p USING (r_h, r_o)
+  ORDER BY c.user_id
+) TO '{OUT}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 50000)
+""")
+n_kept = con.execute(f"SELECT COUNT(*) FROM read_parquet('{OUT}')").fetchone()[0]
+n_users = con.execute(f"SELECT COUNT(DISTINCT user_id) FROM read_parquet('{OUT}')").fetchone()[0]
+n_homes = con.execute(f"SELECT COUNT(DISTINCT r_h) FROM read_parquet('{OUT}')").fetchone()[0]
+n_dests = con.execute(f"SELECT COUNT(DISTINCT r_o) FROM read_parquet('{OUT}')").fetchone()[0]
+# Sanity: there must be ZERO phantom rows (r_h == r_o) by construction
+n_phantom = con.execute(f"SELECT COUNT(*) FROM read_parquet('{OUT}') WHERE r_h = r_o").fetchone()[0]
+print()
+print("=== Stage 3 output ===")
+print(f"  file:                {OUT}  ({OUT.stat().st_size/1e6:.1f} MB)")
+print(f"  travel-behavior rows: {n_kept:,}")
+print(f"  unique travelers:    {n_users:,}")
+print(f"  unique hometowns:    {n_homes:,}")
+print(f"  unique destinations: {n_dests:,}")
+print(f"  unique pairs:        {n_pairs:,}")
+print(f"  phantom rows:        {n_phantom}  (must be 0)")
+print(f"  total elapsed:       {time.time()-t0:.1f}s")

_scripts/04_build_travel_behaviors.py ADDED Viewed

	@@ -0,0 +1,98 @@

+"""
+Stage 4: assemble the final travel_behaviors.parquet (one row per τ).
+Joins travelers + consolidated check-ins, packing each user's hometown / travel
+check-in sequence into list<struct> columns.  Schema matches the precursor build:
+    user_id          int64
+    r_h, r_o         string  (bare metro QID, no 'wd:' prefix)
+    n_home_ci        int64
+    n_travel_ci      int64
+    c_h              list<struct{trail_id, venue_id, venue_category, venue_schema, ts}>
+    c_o              list<struct<...same...>>
+"""
+import duckdb, time, os
+from pathlib import Path
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+INC = ROOT / "_intermediate" / "checkins_consolidated.parquet"
+INT = ROOT / "_intermediate" / "travelers.parquet"
+OUT = ROOT / "travel_behaviors.parquet"
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+con = duckdb.connect()
+con.execute("PRAGMA threads=32")
+con.execute("SET memory_limit='48GB'")
+con.execute("SET preserve_insertion_order=false")
+con.execute(f"SET temp_directory='{os.environ.get('DUCKDB_TMP_DIR', '/tmp/duckdb_trip_world')}'")
+step("loading inputs ...")
+con.execute(f"CREATE TABLE travelers AS SELECT * FROM '{INT}'")
+con.execute(f"""
+CREATE TABLE ck AS
+SELECT user_id, region_id, trail_id, venue_id, venue_category, venue_schema, ts
+FROM '{INC}'
+""")
+n_tr = con.execute("SELECT COUNT(*) FROM travelers").fetchone()[0]
+n_ck = con.execute("SELECT COUNT(*) FROM ck").fetchone()[0]
+step(f"  travelers: {n_tr:,}, check-ins: {n_ck:,}")
+step("building per-(user, region) ordered check-in lists ...")
+con.execute("""
+CREATE TABLE user_region_seq AS
+SELECT
+  user_id, region_id,
+  list({
+    'trail_id': trail_id,
+    'venue_id': venue_id,
+    'venue_category': venue_category,
+    'venue_schema': venue_schema,
+    'ts': ts
+  } ORDER BY ts) AS seq
+FROM ck
+GROUP BY user_id, region_id
+""")
+n_seq = con.execute("SELECT COUNT(*) FROM user_region_seq").fetchone()[0]
+step(f"  user-region sequences: {n_seq:,}")
+step(f"writing {OUT} ...")
+con.execute(f"""
+COPY (
+  SELECT
+    t.user_id, t.r_h, t.r_o, t.n_home_ci, t.n_travel_ci,
+    h.seq AS c_h,
+    o.seq AS c_o
+  FROM travelers t
+  LEFT JOIN user_region_seq h ON h.user_id = t.user_id AND h.region_id = t.r_h
+  LEFT JOIN user_region_seq o ON o.user_id = t.user_id AND o.region_id = t.r_o
+) TO '{OUT}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 50000)
+""")
+sz = OUT.stat().st_size / 1e6
+# Verify
+r = con.execute(f"""
+SELECT
+  COUNT(*) AS n_rows,
+  COUNT(DISTINCT user_id) AS n_users,
+  COUNT(DISTINCT r_h) AS n_homes,
+  COUNT(DISTINCT r_o) AS n_dests,
+  SUM(CASE WHEN r_h = r_o THEN 1 ELSE 0 END) AS n_phantom,
+  SUM(CASE WHEN c_h IS NULL THEN 1 ELSE 0 END) AS missing_c_h,
+  SUM(CASE WHEN c_o IS NULL THEN 1 ELSE 0 END) AS missing_c_o,
+  AVG(len(c_h))::DOUBLE AS avg_ch,
+  AVG(len(c_o))::DOUBLE AS avg_co
+FROM '{OUT}'
+""").fetchone()
+print()
+print("=== Stage 4 output ===")
+print(f"  file:           {OUT}  ({sz:.1f} MB)")
+for k, v in zip(['rows','users','homes','dests','phantom','missing_c_h','missing_c_o','avg_c_h','avg_c_o'], r):
+    if isinstance(v, (int,)):
+        print(f"  {k:14s}: {v:,}")
+    else:
+        print(f"  {k:14s}: {v:.2f}")
+print(f"  total elapsed:  {time.time()-t0:.1f}s")

_scripts/05_build_pois.py ADDED Viewed

	@@ -0,0 +1,93 @@

+"""
+Stage 5: build $TRIP_WORLD_ROOT/pois.parquet
+For every POI that survives the Trip World build pipeline (i.e. appears in
+checkins_consolidated.parquet, which already enforces popularity >= 2 AND
+region density >= 100), inherit per-POI metadata (FSQ-OS + Google + review
+counts) from a precursor build at $PRECURSOR_BUILD_ROOT/pois.parquet, and
+re-map the `locality` column with the Trip World metro map.
+The $PRECURSOR_BUILD_ROOT env var should point at a previous output of this
+same pipeline whose POI metadata we want to extend; if you are bootstrapping
+from scratch you can either skip this stage or supply an empty parquet — POIs
+not present in the precursor will simply carry NULLs for the inherited
+FSQ-OS / Google / review-count fields.
+"""
+import duckdb, json, time
+from pathlib import Path
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+INC  = ROOT / "_intermediate" / "checkins_consolidated.parquet"
+V1_POIS = str(Path(os.environ["PRECURSOR_BUILD_ROOT"]) / "pois.parquet")
+MM   = ROOT / "_intermediate" / "metro_map.parquet"
+OUT  = ROOT / "pois.parquet"
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+con = duckdb.connect()
+con.execute("PRAGMA threads=32")
+con.execute("SET memory_limit='32GB'")
+con.execute(f"SET temp_directory='{os.environ.get('DUCKDB_TMP_DIR', '/tmp/duckdb_trip_world')}'")
+step("collecting per-POI visit counts and locality from clean checkins ...")
+con.execute(f"""
+CREATE TABLE poi_facts AS
+SELECT
+  venue_id AS fsq_place_id,
+  ANY_VALUE(region_id) AS locality,        -- region_id == metro QID under clean map
+  ANY_VALUE(venue_category) AS venue_category,
+  ANY_VALUE(venue_schema) AS venue_schema,
+  COUNT(*) AS n_checkins,
+  COUNT(DISTINCT user_id) AS n_users_visited
+FROM '{INC}' GROUP BY 1
+""")
+n_pois = con.execute("SELECT COUNT(*) FROM poi_facts").fetchone()[0]
+step(f"  {n_pois:,} surviving POIs")
+step("loading precursor pois.parquet for metadata inheritance ...")
+con.execute(f"CREATE TABLE prev AS SELECT * FROM '{V1_POIS}'")
+step("writing clean pois.parquet (left join on precursor metadata, locality from clean) ...")
+con.execute(f"""
+COPY (
+  SELECT
+    pf.fsq_place_id,
+    pf.locality,
+    pf.venue_category,
+    pf.venue_schema,
+    pf.n_checkins::BIGINT AS n_checkins,
+    pf.n_users_visited::BIGINT AS n_users_visited,
+    p.google_cid, p.google_name, p.google_full_address, p.google_address,
+    p.google_website, p.google_rating, p.google_num_reviews, p.google_categories,
+    p.google_place_id, p.google_gmaps_url,
+    COALESCE(p.google_meta_source, 'none') AS google_meta_source,
+    COALESCE(p.has_google_metadata, FALSE) AS has_google_metadata,
+    COALESCE(p.n_reviews, 0)::BIGINT AS n_reviews,
+    COALESCE(p.n_reviews_with_text, 0)::BIGINT AS n_reviews_with_text,
+    p.review_source,
+    COALESCE(p.has_reviews, FALSE) AS has_reviews
+  FROM poi_facts pf
+  LEFT JOIN prev p USING (fsq_place_id)
+) TO '{OUT}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 200000)
+""")
+# Verify
+r = con.execute(f"""
+SELECT COUNT(*),
+       SUM(CASE WHEN has_google_metadata THEN 1 ELSE 0 END),
+       SUM(CASE WHEN has_reviews THEN 1 ELSE 0 END),
+       SUM(n_reviews), SUM(n_reviews_with_text)
+FROM '{OUT}'
+""").fetchone()
+sz = OUT.stat().st_size / 1e6
+print()
+print("=== Stage 5 output ===")
+print(f"  file:                {OUT}  ({sz:.1f} MB)")
+print(f"  POIs:                {r[0]:,}")
+print(f"  with Google meta:    {r[1]:,} ({r[1]/r[0]*100:.1f}%)")
+print(f"  with reviews:        {r[2]:,} ({r[2]/r[0]*100:.1f}%)")
+print(f"  total reviews:       {r[3]:,}")
+print(f"  total reviews w/text:{r[4]:,}")
+print(f"  total elapsed:       {time.time()-t0:.1f}s")

_scripts/06_build_region_labels.py ADDED Viewed

	@@ -0,0 +1,83 @@

+"""
+Stage 6: build $TRIP_WORLD_ROOT/region_labels.parquet
+For every region_id that appears as r_h or r_o in the clean travel_behaviors,
+emit one row with: region_id, city_name, country_qid, country_name.
+The country is the dominant venue_country_qid among check-ins in that region
+(matches the precursor logic).
+"""
+import duckdb, json, pyarrow as pa, pyarrow.parquet as pq, time
+from pathlib import Path
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+INC  = ROOT / "_intermediate" / "checkins_consolidated.parquet"
+TB   = ROOT / "travel_behaviors.parquet"
+MAP  = ROOT / "metro_mapping_clean.json"
+OUT  = ROOT / "region_labels.parquet"
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+labels = json.load(MAP.open())["labels"]
+step(f"loaded {len(labels):,} labels from metro_mapping_clean.json")
+con = duckdb.connect()
+con.execute("PRAGMA threads=16")
+# All distinct region IDs in benchmark
+qids = set(r[0] for r in con.execute(f"""
+  SELECT DISTINCT r_h FROM '{TB}'
+  UNION
+  SELECT DISTINCT r_o FROM '{TB}'
+""").fetchall())
+step(f"  {len(qids):,} distinct benchmark region IDs")
+# Dominant country per region
+con.execute(f"""
+CREATE TABLE rc AS
+SELECT region_id, venue_country_qid AS country_qid, COUNT(*) AS n
+FROM '{INC}' GROUP BY 1, 2
+""")
+con.execute("""
+CREATE TABLE rc_top AS
+SELECT region_id, country_qid, n
+FROM (
+  SELECT *, ROW_NUMBER() OVER (PARTITION BY region_id ORDER BY n DESC) AS rn
+  FROM rc
+) WHERE rn = 1
+""")
+country_map = {r[0]: r[1] for r in con.execute(
+    "SELECT region_id, country_qid FROM rc_top").fetchall()}
+step(f"  built country map for {len(country_map):,} regions")
+rows = []
+n_no_city = n_no_ctry = 0
+for qid in sorted(qids):
+    bare = qid.replace("wd:", "")
+    city_name = labels.get(bare)
+    if not city_name:
+        n_no_city += 1
+    cq = country_map.get(qid)
+    cq_bare = cq.replace("wd:", "") if cq else None
+    cn = labels.get(cq_bare) if cq_bare else None
+    if not cn:
+        n_no_ctry += 1
+    rows.append({
+        "region_id": qid,
+        "city_name": city_name,
+        "country_qid": f"wd:{cq_bare}" if cq_bare else None,
+        "country_name": cn,
+    })
+tbl = pa.Table.from_pylist(rows)
+pq.write_table(tbl, OUT, compression="zstd")
+sz = OUT.stat().st_size / 1024
+print()
+print("=== Stage 6 output ===")
+print(f"  file:                {OUT}  ({sz:.1f} KB)")
+print(f"  rows:                {len(rows):,}")
+print(f"  with city_name:      {len(rows) - n_no_city:,}  ({(len(rows)-n_no_city)/len(rows)*100:.1f}%)")
+print(f"  with country_name:   {len(rows) - n_no_ctry:,}")
+print(f"  total elapsed:       {time.time()-t0:.1f}s")

_scripts/07_subset_metadata.py ADDED Viewed

	@@ -0,0 +1,40 @@

+"""
+Stage 7: subset metadata/metadata_all.parquet to only POIs in Trip World.
+Output: $TRIP_WORLD_ROOT/metadata/metadata_all.parquet
+"""
+import duckdb, time, os
+from pathlib import Path
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+SRC = str(Path(os.environ["PRECURSOR_BUILD_ROOT"]) / "metadata" / "metadata_all.parquet")
+POIS = ROOT / "pois.parquet"
+OUT = ROOT / "metadata" / "metadata_all.parquet"
+OUT.parent.mkdir(parents=True, exist_ok=True)
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+con = duckdb.connect()
+con.execute("PRAGMA threads=32")
+con.execute("SET memory_limit='32GB'")
+step(f"reading Trip World POI universe from {POIS}")
+con.execute(f"CREATE TABLE keep_ids AS SELECT fsq_place_id FROM '{POIS}'")
+n_keep = con.execute("SELECT COUNT(*) FROM keep_ids").fetchone()[0]
+step(f"  {n_keep:,} clean POIs to keep")
+step(f"streaming subset of {SRC} ...")
+con.execute(f"""
+COPY (
+  SELECT m.* FROM '{SRC}' m
+  SEMI JOIN keep_ids k USING (fsq_place_id)
+) TO '{OUT}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 200000)
+""")
+n_out = con.execute(f"SELECT COUNT(*) FROM '{OUT}'").fetchone()[0]
+sz = OUT.stat().st_size / 1e6
+print()
+print("=== Stage 7 output ===")
+print(f"  file:           {OUT}  ({sz:.1f} MB)")
+print(f"  metadata rows:  {n_out:,} of {n_keep:,} POIs ({n_out/n_keep*100:.1f}% covered)")
+print(f"  total elapsed:  {time.time()-t0:.1f}s")

_scripts/08_subset_reviews.py ADDED Viewed

	@@ -0,0 +1,49 @@

+"""
+Stage 8: subset reviews/reviews_all.parquet to only POIs in Trip World.
+Source precursor reviews/ contains six per-source parquet files plus a unified
+reviews_all.parquet (~13 GB).  We only re-emit the unified file -- it's
+the only one downstream pipelines actually read (reviews_*.parquet glob
+matches reviews_all.parquet so it's de-facto the canonical).
+"""
+import duckdb, time
+from pathlib import Path
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+SRC = str(Path(os.environ["PRECURSOR_BUILD_ROOT"]) / "reviews" / "reviews_all.parquet")
+POIS = ROOT / "pois.parquet"
+OUT = ROOT / "reviews" / "reviews_all.parquet"
+OUT.parent.mkdir(parents=True, exist_ok=True)
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+con = duckdb.connect()
+con.execute("PRAGMA threads=32")
+con.execute("SET memory_limit='48GB'")
+con.execute("SET preserve_insertion_order=false")
+con.execute(f"SET temp_directory='{os.environ.get('DUCKDB_TMP_DIR', '/tmp/duckdb_trip_world')}'")
+step(f"reading Trip World POI universe from {POIS}")
+con.execute(f"CREATE TABLE keep_ids AS SELECT fsq_place_id FROM '{POIS}'")
+n_keep = con.execute("SELECT COUNT(*) FROM keep_ids").fetchone()[0]
+step(f"  {n_keep:,} POIs to keep")
+step(f"streaming + filtering {SRC} ... (this takes a few minutes)")
+con.execute(f"""
+COPY (
+  SELECT r.* FROM '{SRC}' r
+  SEMI JOIN keep_ids k USING (fsq_place_id)
+) TO '{OUT}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 200000)
+""")
+n_rev = con.execute(f"SELECT COUNT(*) FROM '{OUT}'").fetchone()[0]
+n_pois_with_reviews = con.execute(
+    f"SELECT COUNT(DISTINCT fsq_place_id) FROM '{OUT}'").fetchone()[0]
+sz = OUT.stat().st_size / 1e6
+print()
+print("=== Stage 8 output ===")
+print(f"  file:                 {OUT}  ({sz/1024:.2f} GB)")
+print(f"  reviews:              {n_rev:,}")
+print(f"  POIs with reviews:    {n_pois_with_reviews:,} of {n_keep:,}")
+print(f"  total elapsed:        {time.time()-t0:.1f}s")

_scripts/09_validate.py ADDED Viewed

	@@ -0,0 +1,94 @@

+"""
+Stage 9: validate Trip World and write README.md.
+Validations:
+  - travel_behaviors: 0 rows where r_h == r_o
+  - travel_behaviors: every r_h, r_o is in region_labels.parquet
+  - pois: every fsq_place_id in checkins_consolidated also in pois.parquet
+  - region_labels: every region_id is reached by some travel record
+"""
+import duckdb, json, time, os
+from pathlib import Path
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+TB = ROOT / "travel_behaviors.parquet"
+POIS = ROOT / "pois.parquet"
+RL = ROOT / "region_labels.parquet"
+META = ROOT / "metadata" / "metadata_all.parquet"
+REVIEWS = ROOT / "reviews" / "reviews_all.parquet"
+INC = ROOT / "_intermediate" / "checkins_consolidated.parquet"
+MAP = ROOT / "metro_mapping_clean.json"
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+con = duckdb.connect()
+con.execute("PRAGMA threads=32")
+con.execute("SET memory_limit='32GB'")
+# ---- validations ----
+step("validating ...")
+v = {}
+v["tb_rows"]    = con.execute(f"SELECT COUNT(*) FROM '{TB}'").fetchone()[0]
+v["tb_phantom"] = con.execute(f"SELECT COUNT(*) FROM '{TB}' WHERE r_h = r_o").fetchone()[0]
+v["tb_users"]   = con.execute(f"SELECT COUNT(DISTINCT user_id) FROM '{TB}'").fetchone()[0]
+v["tb_homes"]   = con.execute(f"SELECT COUNT(DISTINCT r_h) FROM '{TB}'").fetchone()[0]
+v["tb_dests"]   = con.execute(f"SELECT COUNT(DISTINCT r_o) FROM '{TB}'").fetchone()[0]
+v["tb_pairs"]   = con.execute(f"SELECT COUNT(*) FROM (SELECT DISTINCT r_h, r_o FROM '{TB}')").fetchone()[0]
+v["tb_avg_ch"]  = con.execute(f"SELECT AVG(n_home_ci) FROM '{TB}'").fetchone()[0]
+v["tb_avg_co"]  = con.execute(f"SELECT AVG(n_travel_ci) FROM '{TB}'").fetchone()[0]
+v["tb_unique_ci_h"] = con.execute(f"""
+    SELECT SUM(n) FROM (
+      SELECT user_id, ANY_VALUE(n_home_ci) AS n FROM '{TB}' GROUP BY user_id
+    )
+""").fetchone()[0]
+v["tb_total_ci_o"] = con.execute(f"SELECT SUM(n_travel_ci) FROM '{TB}'").fetchone()[0]
+v["tb_total_ci"] = v["tb_unique_ci_h"] + v["tb_total_ci_o"]
+v["pois_rows"]      = con.execute(f"SELECT COUNT(*) FROM '{POIS}'").fetchone()[0]
+v["pois_with_meta"] = con.execute(f"SELECT SUM(CASE WHEN has_google_metadata THEN 1 ELSE 0 END) FROM '{POIS}'").fetchone()[0]
+v["pois_with_rev"]  = con.execute(f"SELECT SUM(CASE WHEN has_reviews THEN 1 ELSE 0 END) FROM '{POIS}'").fetchone()[0]
+v["pois_total_reviews"] = con.execute(f"SELECT SUM(n_reviews) FROM '{POIS}'").fetchone()[0]
+v["pois_reviews_text"]  = con.execute(f"SELECT SUM(n_reviews_with_text) FROM '{POIS}'").fetchone()[0]
+v["rl_rows"]    = con.execute(f"SELECT COUNT(*) FROM '{RL}'").fetchone()[0]
+# referential integrity
+v["rh_missing_in_rl"] = con.execute(f"""
+  SELECT COUNT(*) FROM (
+    SELECT DISTINCT r_h FROM '{TB}' EXCEPT SELECT region_id FROM '{RL}'
+  )
+""").fetchone()[0]
+v["ro_missing_in_rl"] = con.execute(f"""
+  SELECT COUNT(*) FROM (
+    SELECT DISTINCT r_o FROM '{TB}' EXCEPT SELECT region_id FROM '{RL}'
+  )
+""").fetchone()[0]
+# distinct trails in c_h ∪ c_o
+v["distinct_trails"] = con.execute(f"""
+  SELECT COUNT(DISTINCT trail_id) FROM (
+    SELECT UNNEST(c_h).trail_id AS trail_id FROM '{TB}'
+    UNION ALL
+    SELECT UNNEST(c_o).trail_id AS trail_id FROM '{TB}'
+  )
+""").fetchone()[0]
+# time span
+ts_range = con.execute(f"""
+  SELECT MIN(ts), MAX(ts) FROM (
+    SELECT UNNEST(c_h).ts AS ts FROM '{TB}'
+    UNION ALL
+    SELECT UNNEST(c_o).ts AS ts FROM '{TB}'
+  )
+""").fetchone()
+v["ts_min"], v["ts_max"] = ts_range
+step("done validating")
+for k, val in v.items():
+    print(f"  {k:24s}: {val}")
+# The public-facing README.md is maintained separately and ships at the
+# top level of the dataset release; this script does not regenerate it.
+# The validation results above are sufficient to confirm a successful build.
+print(f"\n  total elapsed:       {time.time()-t0:.1f}s")

_scripts/10_enrich_new_pois.py ADDED Viewed

	@@ -0,0 +1,173 @@

+"""
+Stage 10 (post-build enrichment): hydrate the NEW POIs (those in the clean
+benchmark but absent from precursor metadata) with FSQ-OS December-2024 lat/lon and
+the rest of the FSQ metadata fields.
+Step A: Identify new-POI universe = pois.parquet - metadata_all.parquet
+Step B: SEMI JOIN against the LOCAL FSQ-OS Dec 2024 dump
+        (${FSQ_OS_PARQUET_GLOB})
+Step C: Append the resolved rows to metadata_all.parquet (rewriting it)
+Step D: Dump the unresolved fsq_place_id list to fsq_unresolved.txt for
+        downstream FSQ Places API recovery.
+After this stage:
+  metadata/metadata_all.parquet  carries FSQ rows for the precursor build
+                                  plus the locally-resolved newly-added POIs
+  fsq_unresolved.txt              lists POIs needing the FSQ API
+"""
+import duckdb, time
+from pathlib import Path
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+POIS = ROOT / "pois.parquet"
+META = ROOT / "metadata" / "metadata_all.parquet"
+FSQ_OS = os.environ["FSQ_OS_PARQUET_GLOB"]
+UNRES = ROOT / "fsq_unresolved.txt"
+t0 = time.time()
+def step(msg): print(f"[{time.time()-t0:6.1f}s] {msg}", flush=True)
+con = duckdb.connect()
+con.execute("PRAGMA threads=32")
+con.execute("SET memory_limit='48GB'")
+con.execute("SET preserve_insertion_order=false")
+con.execute(f"SET temp_directory='{os.environ.get('DUCKDB_TMP_DIR', '/tmp/duckdb_trip_world')}'")
+# ---- A. find new POIs (in clean but not yet in metadata_all) -----------------
+step("identifying new POIs (in clean pois.parquet but not in metadata_all) ...")
+con.execute(f"""
+CREATE TABLE clean_pois AS
+SELECT fsq_place_id, locality, venue_category, venue_schema
+FROM '{POIS}'
+""")
+con.execute(f"""
+CREATE TABLE existing_meta_ids AS
+SELECT fsq_place_id FROM '{META}'
+""")
+con.execute("""
+CREATE TABLE new_ids AS
+SELECT cp.fsq_place_id, cp.locality, cp.venue_category, cp.venue_schema,
+       regexp_replace(cp.fsq_place_id, '^foursquare:', '') AS bare_id
+FROM clean_pois cp
+ANTI JOIN existing_meta_ids e USING (fsq_place_id)
+""")
+n_new = con.execute("SELECT COUNT(*) FROM new_ids").fetchone()[0]
+step(f"  {n_new:,} new POIs to enrich")
+if n_new == 0:
+    print("Nothing to do.")
+    raise SystemExit(0)
+# ---- B. resolve from local FSQ-OS Dec 2024 dump ------------------------------
+step("looking up new POIs in local FSQ-OS Dec 2024 dump (~6.8 GB, may take ~1 min) ...")
+con.execute(f"""
+CREATE TABLE resolved_local AS
+SELECT
+  ('foursquare:' || fsq.fsq_place_id) AS fsq_place_id,
+  fsq.name        AS fsq_name,
+  fsq.latitude    AS fsq_latitude,
+  fsq.longitude   AS fsq_longitude,
+  fsq.address     AS fsq_address,
+  fsq.locality    AS fsq_locality,
+  fsq.region      AS fsq_region,
+  fsq.country     AS fsq_country,
+  fsq.postcode    AS fsq_postcode,
+  CASE WHEN fsq.address IS NOT NULL OR fsq.locality IS NOT NULL
+       THEN concat_ws(', ', fsq.address, fsq.locality, fsq.region, fsq.country) END AS fsq_formatted_address,
+  fsq.fsq_category_ids,
+  fsq.fsq_category_labels,
+  fsq.website     AS fsq_website,
+  fsq.tel         AS fsq_tel,
+  fsq.email       AS fsq_email,
+  fsq.facebook_id AS fsq_facebook_id,
+  fsq.instagram   AS fsq_instagram,
+  fsq.twitter     AS fsq_twitter,
+  fsq.date_created   AS fsq_date_created,
+  fsq.date_refreshed AS fsq_date_refreshed,
+  fsq.date_closed    AS fsq_date_closed,
+  'fsq_os_dec_2024' AS fsq_meta_source,
+  TRUE              AS has_fsq_metadata
+FROM read_parquet('{FSQ_OS}') fsq
+SEMI JOIN new_ids n ON n.bare_id = fsq.fsq_place_id
+""")
+n_resolved = con.execute("SELECT COUNT(*) FROM resolved_local").fetchone()[0]
+step(f"  {n_resolved:,} new POIs resolved locally  ({n_resolved/n_new*100:.1f}% coverage)")
+# ---- C. write expanded metadata_all.parquet ---------------------------------
+# Approach: read existing META + resolved_local + remaining nulls, UNION ALL.
+step("writing expanded metadata_all.parquet ...")
+# Bench-side fields for new POIs (carry through locality/category/schema as benchmark_*).
+con.execute("""
+CREATE TABLE new_bench AS
+SELECT fsq_place_id,
+       NULL AS benchmark_name,
+       locality AS benchmark_locality,
+       venue_category AS benchmark_venue_category,
+       venue_schema AS benchmark_venue_schema
+FROM new_ids
+""")
+# A row for every new POI: bench fields + (resolved or null) FSQ + null Google fields.
+META_TMP = ROOT / "metadata" / "metadata_all_v2.parquet"
+con.execute(f"""
+COPY (
+  -- existing rows
+  SELECT * FROM '{META}'
+  UNION ALL BY NAME
+  -- new rows: left-join resolved_local, fill nulls for missing
+  SELECT
+    nb.fsq_place_id,
+    nb.benchmark_name,
+    nb.benchmark_locality,
+    nb.benchmark_venue_category,
+    nb.benchmark_venue_schema,
+    rl.fsq_name, rl.fsq_latitude, rl.fsq_longitude,
+    rl.fsq_address, rl.fsq_locality, rl.fsq_region, rl.fsq_country,
+    rl.fsq_postcode, rl.fsq_formatted_address,
+    rl.fsq_category_ids, rl.fsq_category_labels,
+    rl.fsq_website, rl.fsq_tel, rl.fsq_email,
+    rl.fsq_facebook_id, rl.fsq_instagram, rl.fsq_twitter,
+    rl.fsq_date_created, rl.fsq_date_refreshed, rl.fsq_date_closed,
+    COALESCE(rl.fsq_meta_source, 'unresolved')  AS fsq_meta_source,
+    COALESCE(rl.has_fsq_metadata, FALSE)        AS has_fsq_metadata,
+    NULL AS google_cid, NULL AS google_name,
+    NULL AS google_full_address, NULL AS google_address,
+    NULL AS google_website, NULL AS google_rating, NULL AS google_num_reviews,
+    NULL AS google_categories, NULL AS google_place_id, NULL AS google_gmaps_url,
+    'none' AS google_meta_source,
+    FALSE AS has_google_metadata
+  FROM new_bench nb
+  LEFT JOIN resolved_local rl USING (fsq_place_id)
+) TO '{META_TMP}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 200000)
+""")
+# Atomic swap
+META.unlink()
+META_TMP.rename(META)
+n_meta_total = con.execute(f"SELECT COUNT(*) FROM '{META}'").fetchone()[0]
+n_meta_with_fsq = con.execute(f"SELECT SUM(CASE WHEN has_fsq_metadata THEN 1 ELSE 0 END) FROM '{META}'").fetchone()[0]
+n_meta_with_coords = con.execute(f"SELECT SUM(CASE WHEN fsq_latitude IS NOT NULL THEN 1 ELSE 0 END) FROM '{META}'").fetchone()[0]
+sz = META.stat().st_size / 1e6
+step(f"  metadata_all.parquet now has {n_meta_total:,} rows ({sz:.0f} MB)")
+# ---- D. write unresolved list -----------------------------------------------
+n_unres = n_new - n_resolved
+con.execute(f"""
+COPY (
+  SELECT n.fsq_place_id
+  FROM new_ids n
+  ANTI JOIN resolved_local rl USING (fsq_place_id)
+  ORDER BY 1
+) TO '{UNRES}' (HEADER FALSE, DELIMITER ' ')
+""")
+step(f"  {n_unres:,} POIs still unresolved -> {UNRES}")
+print()
+print("=== Stage 10 output ===")
+print(f"  metadata rows total:      {n_meta_total:,}  ({n_meta_total/687173*100:.1f}% of POI universe)")
+print(f"  rows with FSQ metadata:   {n_meta_with_fsq:,}  ({n_meta_with_fsq/n_meta_total*100:.1f}%)")
+print(f"  rows with lat/lon:        {n_meta_with_coords:,}  ({n_meta_with_coords/n_meta_total*100:.1f}%)")
+print(f"  POIs needing FSQ API:     {n_unres:,}")
+print(f"  total elapsed:            {time.time()-t0:.1f}s")

_scripts/11_fsq_api_recover.py ADDED Viewed

	@@ -0,0 +1,376 @@

+"""
+Stage 11 (optional): recover the remaining unresolved POIs via the FSQ Places
+API.
+Reads fsq_unresolved.txt (output of Stage 10 -- ~37k entries), hits
+GET https://places-api.foursquare.com/places/{fsq_id} for each, and writes the
+resolved metadata into _intermediate/fsq_api_resolved.parquet.  Then folds
+the resolved rows into metadata/metadata_all.parquet.
+Requires a Foursquare Places API key:
+  export FSQ_API_KEY=fsq3xxxxxxxxxxxxxxxxxxxxxxxx
+or pass --api-key on the command line.
+Rate-limit / retry policy
+-------------------------
+* Default 5 concurrent requests, 250 ms inter-request delay (~20 req/s).
+  Adjust with --concurrency / --delay.
+* On HTTP 429: exponential backoff up to --max-backoff seconds.
+* On HTTP 404: POI is permanently gone; record empty row with status='gone'.
+* On HTTP 5xx: retry up to 3 times before recording status='error'.
+Output
+------
+* _intermediate/fsq_api_resolved.parquet   (one row per requested ID + status)
+* metadata/metadata_all.parquet            (rewritten with the new rows merged)
+* fsq_unresolved.txt                       (rewritten with only POIs that
+                                            failed permanently)
+"""
+from __future__ import annotations
+import argparse, asyncio, json, os, ssl, sys, time
+from pathlib import Path
+from typing import Iterable
+import urllib.parse
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+META = ROOT / "metadata" / "metadata_all.parquet"
+UNRES_IN  = ROOT / "fsq_unresolved.txt"
+UNRES_OUT = ROOT / "fsq_unresolved.txt"
+RESOLVED  = ROOT / "_intermediate" / "fsq_api_resolved.parquet"
+CHECKPOINT = ROOT / "_intermediate" / "fsq_api_checkpoint.jsonl"  # incremental, append-only
+API_BASE = "https://places-api.foursquare.com/places"
+SERVICE_ACCOUNT_ID = "fsq3"     # marker for fsq_meta_source
+_ssl = ssl.create_default_context()
+class KeyPool:
+    """Round-robin pool of API keys with dead-key tracking.
+    A key is marked DEAD when the API responds with HTTP 402 OR a 429 whose
+    body contains 'no API credits' (Foursquare's free-tier exhaustion message).
+    Other 429s (true rate-limiting) trigger backoff but keep the key alive.
+    """
+    def __init__(self, keys: list[str]):
+        self.keys = list(dict.fromkeys(k.strip() for k in keys if k.strip()))
+        self.alive = list(self.keys)
+        self._cursor = 0
+    @property
+    def n_alive(self) -> int:
+        return len(self.alive)
+    @property
+    def n_total(self) -> int:
+        return len(self.keys)
+    def next_key(self) -> str | None:
+        """Return any live key (round-robin). None if pool is empty."""
+        if not self.alive:
+            return None
+        k = self.alive[self._cursor % len(self.alive)]
+        self._cursor += 1
+        return k
+    def mark_dead(self, key: str, reason: str = "") -> None:
+        if key in self.alive:
+            self.alive.remove(key)
+            tail = key[-8:]
+            print(f"  [key pool] key ...{tail} marked dead "
+                  f"({reason}); alive={self.n_alive}/{self.n_total}",
+                  flush=True)
+def _is_no_credits(status: int, body_text: str) -> bool:
+    if status == 402:
+        return True
+    if status == 429 and ("no API credits" in body_text
+                           or "Purchasing credits" in body_text):
+        return True
+    return False
+async def fetch_one(session, sem, fsq_id: str, pool: KeyPool, delay: float,
+                     max_backoff: float) -> dict:
+    """Fetch one FSQ place by ID with retry/backoff and key rotation."""
+    bare = fsq_id.replace("foursquare:", "")
+    url = f"{API_BASE}/{urllib.parse.quote(bare)}"
+    backoff = 1.0
+    for attempt in range(6):
+        api_key = pool.next_key()
+        if api_key is None:
+            return {"fsq_place_id": fsq_id, "status": "no_credits", "raw": None}
+        auth = api_key if api_key.lower().startswith("bearer ") else f"Bearer {api_key}"
+        headers = {"Authorization": auth,
+                   "X-Places-Api-Version": "2025-06-17",
+                   "Accept": "application/json"}
+        async with sem:
+            await asyncio.sleep(delay)
+            try:
+                async with session.get(url, headers=headers, ssl=_ssl,
+                                         timeout=30) as r:
+                    if r.status == 200:
+                        body = await r.json()
+                        return {"fsq_place_id": fsq_id, "status": "ok",
+                                "raw": body}
+                    elif r.status == 404:
+                        return {"fsq_place_id": fsq_id, "status": "gone",
+                                "raw": None}
+                    elif r.status in (402, 429):
+                        body_text = await r.text()
+                        if _is_no_credits(r.status, body_text):
+                            pool.mark_dead(api_key, f"HTTP {r.status} no_credits")
+                            continue  # try next key on next attempt
+                        retry_after = float(r.headers.get("Retry-After", backoff))
+                        await asyncio.sleep(min(retry_after, max_backoff))
+                        backoff = min(backoff * 2, max_backoff)
+                        continue
+                    elif 500 <= r.status < 600:
+                        await asyncio.sleep(min(backoff, max_backoff))
+                        backoff = min(backoff * 2, max_backoff)
+                        continue
+                    else:
+                        body = await r.text()
+                        return {"fsq_place_id": fsq_id,
+                                "status": f"http_{r.status}",
+                                "raw": {"error": body[:500]}}
+            except Exception as e:
+                await asyncio.sleep(min(backoff, max_backoff))
+                backoff = min(backoff * 2, max_backoff)
+    return {"fsq_place_id": fsq_id, "status": "error", "raw": None}
+async def driver(ids: list[str], pool: KeyPool, concurrency: int, delay: float,
+                  max_backoff: float, checkpoint_path: Path,
+                  progress_every: int = 500):
+    import aiohttp
+    connector = aiohttp.TCPConnector(limit=concurrency, force_close=False)
+    sem = asyncio.Semaphore(concurrency)
+    out = []
+    n = len(ids)
+    t0 = time.time()
+    last_log = 0
+    # Append-only JSONL so we can resume mid-run if interrupted.
+    checkpoint_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(checkpoint_path, "a", buffering=1) as ckpt:
+        async with aiohttp.ClientSession(connector=connector) as session:
+            tasks = [fetch_one(session, sem, fsq_id, pool, delay, max_backoff)
+                     for fsq_id in ids]
+            for i, coro in enumerate(asyncio.as_completed(tasks), 1):
+                r = await coro
+                out.append(r)
+                ckpt.write(json.dumps(r, ensure_ascii=False) + "\n")
+                if i - last_log >= progress_every:
+                    last_log = i
+                    rate = i / (time.time() - t0 + 1e-9)
+                    eta = (n - i) / max(rate, 1e-9)
+                    ok = sum(1 for x in out if x["status"] == "ok")
+                    gone = sum(1 for x in out if x["status"] == "gone")
+                    nc = sum(1 for x in out if x["status"] == "no_credits")
+                    err = i - ok - gone - nc
+                    print(f"  [{time.time()-t0:5.0f}s] {i:>6}/{n} "
+                          f"ok={ok} gone={gone} nc={nc} err={err}  "
+                          f"{rate:.1f} req/s  ETA={eta/60:.1f} min  "
+                          f"keys_alive={pool.n_alive}/{pool.n_total}", flush=True)
+                if pool.n_alive == 0:
+                    print(f"  !! all keys exhausted; cancelling remaining {n-i} tasks",
+                          flush=True)
+                    break
+    return out
+def fsq_payload_to_row(p: dict, fsq_id: str) -> dict:
+    """Map an FSQ Places API (2025-06-17 version) response onto our schema.
+    The new API returns lat/lon at the top level (not nested under geocodes),
+    and categories use `fsq_category_id`/`name` keys.
+    """
+    if not p:
+        return {"fsq_place_id": fsq_id, "has_fsq_metadata": False,
+                "fsq_meta_source": "fsq_api_gone"}
+    loc = p.get("location", {}) or {}
+    cats = p.get("categories", []) or []
+    facebook_id = (p.get("social_media") or {}).get("facebook_id")
+    try:
+        facebook_id = int(facebook_id) if facebook_id else None
+    except (TypeError, ValueError):
+        facebook_id = None
+    return {
+        "fsq_place_id": fsq_id,
+        "fsq_name": p.get("name"),
+        "fsq_latitude": p.get("latitude"),
+        "fsq_longitude": p.get("longitude"),
+        "fsq_address": loc.get("address"),
+        "fsq_locality": loc.get("locality"),
+        "fsq_region": loc.get("region"),
+        "fsq_country": loc.get("country"),
+        "fsq_postcode": loc.get("postcode"),
+        "fsq_formatted_address": loc.get("formatted_address"),
+        "fsq_category_ids": [str(c.get("fsq_category_id")) for c in cats
+                              if c.get("fsq_category_id") is not None],
+        "fsq_category_labels": [c.get("name") for c in cats if c.get("name")],
+        "fsq_website": p.get("website"),
+        "fsq_tel": p.get("tel"),
+        "fsq_email": p.get("email"),
+        "fsq_facebook_id": facebook_id,
+        "fsq_instagram":   (p.get("social_media") or {}).get("instagram"),
+        "fsq_twitter":     (p.get("social_media") or {}).get("twitter"),
+        "fsq_date_created":   (p.get("date_created") or None),
+        "fsq_date_refreshed": (p.get("date_refreshed") or None),
+        "fsq_date_closed":    (p.get("date_closed") or None),
+        "fsq_meta_source": "fsq_api_2025",
+        "has_fsq_metadata": True,
+    }
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--api-key", action="append", default=[],
+                     help="FSQ Places API bearer token (repeat for multiple keys)")
+    ap.add_argument("--api-keys-file",
+                     help="path to a file containing one bearer token per line")
+    ap.add_argument("--concurrency", type=int, default=5)
+    ap.add_argument("--delay", type=float, default=0.20,
+                     help="seconds between consecutive requests per worker")
+    ap.add_argument("--max-backoff", type=float, default=30.0)
+    ap.add_argument("--limit", type=int, default=0,
+                     help="if >0, only process the first N unresolved IDs (smoke test)")
+    args = ap.parse_args()
+    keys: list[str] = list(args.api_key)
+    if args.api_keys_file:
+        keys.extend(l.strip() for l in Path(args.api_keys_file).read_text().splitlines()
+                    if l.strip() and not l.strip().startswith("#"))
+    if not keys and os.environ.get("FSQ_API_KEY"):
+        keys.append(os.environ["FSQ_API_KEY"].strip())
+    keys = list(dict.fromkeys(keys))  # de-dup, preserve order
+    if not keys:
+        print("ERROR: no FSQ API key. Pass --api-key, --api-keys-file or "
+              "set $FSQ_API_KEY.")
+        sys.exit(1)
+    pool = KeyPool(keys)
+    print(f"Loaded {pool.n_total} API key(s) into pool "
+          f"(masked: {[k[-8:] for k in pool.keys]})")
+    try:
+        import aiohttp  # noqa
+    except ImportError:
+        print("ERROR: aiohttp not installed. Run: pip install aiohttp")
+        sys.exit(1)
+    import duckdb
+    import pyarrow as pa, pyarrow.parquet as pq
+    ids = [l.strip() for l in UNRES_IN.read_text().splitlines() if l.strip()]
+    # Resume support: skip any IDs that already appear in the JSONL checkpoint
+    # with a TERMINAL status (ok / gone). Transient errors will be retried.
+    already = {}
+    if CHECKPOINT.exists():
+        with open(CHECKPOINT) as f:
+            for line in f:
+                try:
+                    rec = json.loads(line)
+                except Exception:
+                    continue
+                if rec.get("status") in ("ok", "gone"):
+                    already[rec["fsq_place_id"]] = rec
+        if already:
+            print(f"Resumed checkpoint: skipping {len(already):,} already-resolved ids")
+    ids = [i for i in ids if i not in already]
+    if args.limit:
+        ids = ids[:args.limit]
+    print(f"Will resolve {len(ids):,} POI IDs via FSQ Places API")
+    print(f"  concurrency={args.concurrency}  delay={args.delay}s  "
+          f"target rate ~{args.concurrency/args.delay:.1f} req/s")
+    print()
+    raw_new = asyncio.run(driver(ids, pool, args.concurrency, args.delay,
+                                  args.max_backoff, CHECKPOINT))
+    raw = list(already.values()) + raw_new
+    # Build rows
+    rows = []
+    n_ok = n_gone = n_err = 0
+    for r in raw:
+        st = r["status"]
+        if st == "ok":
+            rows.append(fsq_payload_to_row(r["raw"], r["fsq_place_id"]))
+            n_ok += 1
+        elif st == "gone":
+            rows.append({"fsq_place_id": r["fsq_place_id"],
+                          "fsq_meta_source": "fsq_api_gone",
+                          "has_fsq_metadata": False})
+            n_gone += 1
+        else:
+            rows.append({"fsq_place_id": r["fsq_place_id"],
+                          "fsq_meta_source": f"fsq_api_{st}",
+                          "has_fsq_metadata": False})
+            n_err += 1
+    print(f"\nRESULT: ok={n_ok}  gone={n_gone}  err={n_err}")
+    # Write resolved table
+    RESOLVED.parent.mkdir(parents=True, exist_ok=True)
+    pq.write_table(pa.Table.from_pylist(rows), RESOLVED, compression="zstd")
+    print(f"wrote {RESOLVED} ({RESOLVED.stat().st_size/1e6:.1f} MB)")
+    # Fold into metadata_all.parquet
+    print("merging into metadata_all.parquet ...")
+    con = duckdb.connect()
+    con.execute("PRAGMA threads=32")
+    con.execute("SET memory_limit='32GB'")
+    META_TMP = META.with_suffix(".tmp.parquet")
+    con.execute(f"""
+COPY (
+  -- existing rows MINUS the IDs we just refetched
+  SELECT * FROM '{META}'
+  WHERE fsq_place_id NOT IN (SELECT fsq_place_id FROM '{RESOLVED}')
+  UNION ALL BY NAME
+  -- the new rows (use CAST/COALESCE to keep schema compatible)
+  SELECT
+    r.fsq_place_id,
+    NULL AS benchmark_name,
+    NULL AS benchmark_locality,
+    NULL AS benchmark_venue_category,
+    NULL AS benchmark_venue_schema,
+    r.fsq_name, r.fsq_latitude, r.fsq_longitude,
+    r.fsq_address, r.fsq_locality, r.fsq_region, r.fsq_country,
+    r.fsq_postcode, r.fsq_formatted_address,
+    r.fsq_category_ids, r.fsq_category_labels,
+    r.fsq_website, r.fsq_tel, r.fsq_email,
+    r.fsq_facebook_id, r.fsq_instagram, r.fsq_twitter,
+    r.fsq_date_created, r.fsq_date_refreshed, r.fsq_date_closed,
+    r.fsq_meta_source, r.has_fsq_metadata,
+    NULL AS google_cid, NULL AS google_name,
+    NULL AS google_full_address, NULL AS google_address,
+    NULL AS google_website, NULL AS google_rating, NULL AS google_num_reviews,
+    NULL AS google_categories, NULL AS google_place_id, NULL AS google_gmaps_url,
+    'none' AS google_meta_source,
+    FALSE AS has_google_metadata
+  FROM '{RESOLVED}' r
+) TO '{META_TMP}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 200000)
+""")
+    META.unlink()
+    META_TMP.rename(META)
+    n_total = con.execute(f"SELECT COUNT(*) FROM '{META}'").fetchone()[0]
+    n_with_fsq = con.execute(f"SELECT SUM(CASE WHEN has_fsq_metadata THEN 1 ELSE 0 END) FROM '{META}'").fetchone()[0]
+    n_with_coords = con.execute(f"SELECT SUM(CASE WHEN fsq_latitude IS NOT NULL THEN 1 ELSE 0 END) FROM '{META}'").fetchone()[0]
+    print(f"metadata_all.parquet rewritten: {n_total:,} rows, "
+          f"{n_with_fsq:,} with FSQ ({n_with_fsq/n_total*100:.1f}%), "
+          f"{n_with_coords:,} with coords ({n_with_coords/n_total*100:.1f}%)")
+    # Update unresolved list: keep IDs we did NOT attempt this run (i.e. those
+    # left over because of --limit), and add back the IDs that errored out.
+    attempted = {r["fsq_place_id"] for r in raw}
+    failed    = {r["fsq_place_id"] for r in raw if r["status"] not in ("ok", "gone")}
+    all_unres_now = [i for i in
+                     [l.strip() for l in UNRES_IN.read_text().splitlines() if l.strip()]
+                     if (i not in attempted) or (i in failed)]
+    UNRES_OUT.write_text("\n".join(all_unres_now))
+    print(f"  remaining unresolved -> {UNRES_OUT}  ({len(all_unres_now):,} ids)")
+if __name__ == "__main__":
+    main()

_scripts/12_ucsd_bridge.py ADDED Viewed

	@@ -0,0 +1,351 @@

+"""
+Stage 12 (UCSD bridge):  match the 81,592 NEW clean-benchmark POIs (those
+absent from the precursor build) against the two UCSD POI corpora to inherit Google Maps
+metadata + reviews for free.
+Strategy
+--------
+The UCSD POIs use FSQ-OS (bare 24-hex) IDs while our benchmark uses FSQ v2
+(`foursquare:<24-hex>`); the two ID spaces don't bridge directly.  We
+therefore do a SPATIAL + NAME-SIMILARITY match:
+  1. Build a unified UCSD POI table (benchmark + all20) keyed by
+     (gmap_id, name, lat, lon, gmaps_*, gl_*).
+  2. Bucket both sides into 0.005°-cells (~500 m) and inner-join on bucket.
+  3. Keep candidate pairs within 100 m Haversine distance.
+  4. Compute normalized-name similarity (rapidfuzz token_set_ratio).
+  5. For each new POI, keep its best UCSD match if similarity >= 70 and
+     distance <= 100 m.
+Outputs
+-------
+    _intermediate/ucsd_matches.parquet   one row per matched new-POI
+    _intermediate/ucsd_unified.parquet   the unified UCSD source table
+Empirically the 95 % precision quoted by the precursor README was achieved at
+similarity >= 70 + distance <= 100 m; we keep those thresholds.
+"""
+from __future__ import annotations
+import json, math, os, time
+from pathlib import Path
+import duckdb
+import pyarrow as pa, pyarrow.parquet as pq
+from rapidfuzz import fuzz
+from unidecode import unidecode
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+GMAPS = Path(os.environ["GMAPS_FULL_ROOT"])
+INTER = ROOT / "_intermediate"
+INTER.mkdir(parents=True, exist_ok=True)
+UCSD_BENCH    = GMAPS / "metadata/ucsd_benchmark_pois.parquet"
+UCSD_ALL20    = GMAPS / "metadata/ucsd_all20_pois.jsonl"
+NEW_POIS_PARQ = INTER / "new_pois_for_match.parquet"
+UCSD_UNIFIED  = INTER / "ucsd_unified.parquet"
+MATCHES_OUT   = INTER / "ucsd_matches.parquet"
+# Tunables (proven 95% precision on precursor build)
+MAX_DIST_M    = 100.0
+MIN_NAME_SIM  = 70.0
+BUCKET_DEG    = 0.005   # ~ 555 m
+# ---------------------------------------------------------------------------
+# Step 1. Build a unified UCSD POI table
+# ---------------------------------------------------------------------------
+def build_unified_ucsd() -> int:
+    """Materialise UCSD POIs from both sources into one parquet."""
+    print("[step 1] reading ucsd_all20_pois.jsonl ...")
+    rows_all20 = []
+    with open(UCSD_ALL20) as f:
+        for line in f:
+            try:
+                r = json.loads(line)
+            except Exception:
+                continue
+            lat = r.get("gl_latitude")
+            lon = r.get("gl_longitude")
+            if lat is None or lon is None:
+                continue
+            rows_all20.append({
+                "src":              "all20",
+                "ucsd_fsq_os_id":   r.get("fsq_place_id"),
+                "name":             r.get("gl_name") or r.get("gmaps_name") or r.get("fsq_name"),
+                "lat":              float(lat),
+                "lon":              float(lon),
+                "gmap_id":          r.get("gmap_id"),
+                "gmaps_name":       r.get("gmaps_name"),
+                "gmaps_full_address": r.get("gmaps_full_address"),
+                "gmaps_address":    r.get("gmaps_address"),
+                "gmaps_website":    None,
+                "gmaps_rating":     r.get("gmaps_rating"),
+                "gmaps_num_reviews": r.get("gmaps_num_reviews"),
+                "gmaps_categories": r.get("gmaps_categories"),
+                "gmaps_url":        r.get("gmaps_url"),
+                "place_id":         r.get("place_id"),
+                "gl_name":          r.get("gl_name"),
+                "gl_address":       r.get("gl_address"),
+                "gl_avg_rating":    r.get("gl_avg_rating"),
+                "gl_num_reviews":   r.get("gl_num_reviews"),
+                "gl_url":           r.get("gl_url"),
+                "gl_category":      r.get("gl_category"),
+                "gl_description":   r.get("gl_description"),
+                "gl_price":         r.get("gl_price"),
+                "gl_hours":         r.get("gl_hours"),
+                "gl_state":         r.get("gl_state"),
+            })
+    print(f"  all20 rows with coords: {len(rows_all20):,}")
+    print("[step 1] reading ucsd_benchmark_pois.parquet ...")
+    # Bench file has no lat/lon columns, so extract them from `gmaps_url`
+    # (URLs of form .../@<lat>,<lon>,17z).
+    import re
+    LATLON_RE = re.compile(r"@(-?\d+\.\d+),(-?\d+\.\d+)")
+    con = duckdb.connect()
+    con.execute("PRAGMA threads=32")
+    bench_q = con.execute(f"""
+SELECT fsq_place_id, fsq_name, cid AS gmap_id,
+       gmaps_name, gmaps_full_address, gmaps_address, gmaps_website,
+       gmaps_rating, gmaps_num_reviews, gmaps_categories, gmaps_url, place_id,
+       gl_name, gl_address, gl_avg_rating, gl_num_reviews, gl_url, gl_category,
+       gl_description, gl_price, gl_hours, gl_state
+FROM '{UCSD_BENCH}' WHERE status='ok'
+""")
+    bench_rows = bench_q.fetchall()
+    cols = [d[0] for d in bench_q.description]
+    rows_bench = []
+    for tup in bench_rows:
+        r = dict(zip(cols, tup))
+        url = r.get("gmaps_url") or r.get("gl_url") or ""
+        m = LATLON_RE.search(url or "")
+        if not m:
+            continue
+        rows_bench.append({
+            "src":              "bench",
+            "ucsd_fsq_os_id":   r["fsq_place_id"],
+            "name":             r.get("gl_name") or r.get("gmaps_name") or r.get("fsq_name"),
+            "lat":              float(m.group(1)),
+            "lon":              float(m.group(2)),
+            "gmap_id":          r["gmap_id"],
+            "gmaps_name":       r.get("gmaps_name"),
+            "gmaps_full_address": r.get("gmaps_full_address"),
+            "gmaps_address":    r.get("gmaps_address"),
+            "gmaps_website":    r.get("gmaps_website"),
+            "gmaps_rating":     r.get("gmaps_rating"),
+            "gmaps_num_reviews": r.get("gmaps_num_reviews"),
+            "gmaps_categories": r.get("gmaps_categories"),
+            "gmaps_url":        r.get("gmaps_url"),
+            "place_id":         r.get("place_id"),
+            "gl_name":          r.get("gl_name"),
+            "gl_address":       r.get("gl_address"),
+            "gl_avg_rating":    r.get("gl_avg_rating"),
+            "gl_num_reviews":   r.get("gl_num_reviews"),
+            "gl_url":           r.get("gl_url"),
+            "gl_category":      r.get("gl_category"),
+            "gl_description":   r.get("gl_description"),
+            "gl_price":         r.get("gl_price"),
+            "gl_hours":         r.get("gl_hours"),
+            "gl_state":         r.get("gl_state"),
+        })
+    print(f"  bench rows with parsable coords: {len(rows_bench):,}")
+    all_rows = rows_all20 + rows_bench
+    # Normalize: cast list-typed columns to list-or-None; string-typed to str-or-None.
+    LIST_COLS    = {"gmaps_categories", "gl_category", "gl_hours"}
+    STRING_COLS  = {"src", "ucsd_fsq_os_id", "name", "gmap_id", "gmaps_name",
+                     "gmaps_full_address", "gmaps_address", "gmaps_website",
+                     "gmaps_url", "place_id",
+                     "gl_name", "gl_address", "gl_url", "gl_description",
+                     "gl_price", "gl_state"}
+    FLOAT_COLS   = {"lat", "lon", "gmaps_rating", "gl_avg_rating"}
+    INT_COLS     = {"gmaps_num_reviews", "gl_num_reviews"}
+    for r in all_rows:
+        for c in LIST_COLS:
+            v = r.get(c)
+            if v is None:
+                r[c] = None
+            elif isinstance(v, list):
+                r[c] = v
+            else:
+                r[c] = [str(v)]
+        for c in STRING_COLS:
+            v = r.get(c)
+            r[c] = None if v is None else (str(v) if not isinstance(v, str) else v)
+        for c in FLOAT_COLS:
+            v = r.get(c)
+            try:    r[c] = None if v is None else float(v)
+            except (TypeError, ValueError): r[c] = None
+        for c in INT_COLS:
+            v = r.get(c)
+            try:    r[c] = None if v is None else int(v)
+            except (TypeError, ValueError): r[c] = None
+    # Build with an explicit schema to avoid type inference surprises.
+    schema = pa.schema([
+        ("src", pa.string()),
+        ("ucsd_fsq_os_id", pa.string()),
+        ("name", pa.string()),
+        ("lat", pa.float64()),
+        ("lon", pa.float64()),
+        ("gmap_id", pa.string()),
+        ("gmaps_name", pa.string()),
+        ("gmaps_full_address", pa.string()),
+        ("gmaps_address", pa.string()),
+        ("gmaps_website", pa.string()),
+        ("gmaps_rating", pa.float64()),
+        ("gmaps_num_reviews", pa.int64()),
+        ("gmaps_categories", pa.list_(pa.string())),
+        ("gmaps_url", pa.string()),
+        ("place_id", pa.string()),
+        ("gl_name", pa.string()),
+        ("gl_address", pa.string()),
+        ("gl_avg_rating", pa.float64()),
+        ("gl_num_reviews", pa.int64()),
+        ("gl_url", pa.string()),
+        ("gl_category", pa.list_(pa.string())),
+        ("gl_description", pa.string()),
+        ("gl_price", pa.string()),
+        ("gl_hours", pa.list_(pa.list_(pa.string()))),
+        ("gl_state", pa.string()),
+    ])
+    table = pa.Table.from_pylist(all_rows, schema=schema)
+    pq.write_table(table, UCSD_UNIFIED, compression="zstd")
+    print(f"  wrote unified table: {UCSD_UNIFIED}  ({UCSD_UNIFIED.stat().st_size/1e6:.1f} MB, "
+          f"{len(all_rows):,} rows)")
+    return len(all_rows)
+# ---------------------------------------------------------------------------
+# Step 2-5. Bucket-join + filter
+# ---------------------------------------------------------------------------
+def haversine_m(lat1, lon1, lat2, lon2):
+    R = 6371000.0
+    p1 = math.radians(lat1); p2 = math.radians(lat2)
+    dp = math.radians(lat2 - lat1); dl = math.radians(lon2 - lon1)
+    a = math.sin(dp/2)**2 + math.cos(p1)*math.cos(p2)*math.sin(dl/2)**2
+    return 2*R*math.asin(min(1.0, math.sqrt(a)))
+def normalize_name(s: str | None) -> str:
+    if not s: return ""
+    return unidecode(str(s)).lower().strip()
+def run_bridge():
+    print(f"\n[step 2] bucket-join (cell={BUCKET_DEG}deg) ...")
+    con = duckdb.connect()
+    con.execute("PRAGMA threads=32")
+    con.execute(f"SET memory_limit='32GB'")
+    # Build candidate-pair table via bucket join, then keep only pairs where
+    # both POIs land in the same OR an immediately-adjacent cell.
+    # We expand "same cell" to a 3x3 neighborhood by joining on each of the 9
+    # offsets of the UCSD side.
+    con.execute(f"""
+CREATE TEMP TABLE new_p AS
+SELECT fsq_place_id AS new_id, fsq_name AS new_name, lat AS new_lat, lon AS new_lon,
+       FLOOR(lat / {BUCKET_DEG}) AS by_, FLOOR(lon / {BUCKET_DEG}) AS bx_
+FROM '{NEW_POIS_PARQ}'
+""")
+    con.execute(f"""
+CREATE TEMP TABLE ucsd_p AS
+SELECT * EXCLUDE (lat, lon),
+       lat AS u_lat, lon AS u_lon,
+       FLOOR(lat / {BUCKET_DEG}) AS by_, FLOOR(lon / {BUCKET_DEG}) AS bx_
+FROM '{UCSD_UNIFIED}'
+WHERE name IS NOT NULL
+""")
+    n_new   = con.execute("SELECT COUNT(*) FROM new_p").fetchone()[0]
+    n_ucsd  = con.execute("SELECT COUNT(*) FROM ucsd_p").fetchone()[0]
+    print(f"  new POIs:  {n_new:,}")
+    print(f"  ucsd POIs: {n_ucsd:,}")
+    # 3x3 neighborhood join on bucket coords (each of the 9 offsets).
+    # Avoid materialising all 9 unions in memory: compute candidate pairs
+    # straight to a temp table.
+    con.execute("""
+CREATE TEMP TABLE cand AS
+SELECT n.new_id, n.new_name, n.new_lat, n.new_lon,
+       u.ucsd_fsq_os_id, u.gmap_id, u.name AS u_name,
+       u.u_lat, u.u_lon, u.src
+FROM new_p n
+JOIN ucsd_p u
+  ON   u.by_ BETWEEN n.by_ - 1 AND n.by_ + 1
+   AND u.bx_ BETWEEN n.bx_ - 1 AND n.bx_ + 1
+""")
+    n_cand = con.execute("SELECT COUNT(*) FROM cand").fetchone()[0]
+    print(f"[step 3] candidate pairs (bucket-neighbors): {n_cand:,}")
+    if n_cand == 0:
+        print("no candidate pairs -- writing empty matches table")
+        empty = pa.table({c: pa.array([], type=pa.string()) for c in
+                          ["fsq_place_id", "ucsd_fsq_os_id", "gmap_id", "match_src",
+                           "distance_m", "name_sim"]})
+        pq.write_table(empty, MATCHES_OUT, compression="zstd")
+        return 0
+    # Pull into Python (list of tuples), score, and keep best per new_id.
+    print("[step 4] scoring (haversine + token_set_ratio) ...")
+    rows = con.execute("""
+SELECT new_id, new_name, new_lat, new_lon, ucsd_fsq_os_id, gmap_id, u_name, u_lat, u_lon, src
+FROM cand
+""").fetchall()
+    best: dict[str, tuple[float, float, dict]] = {}
+    t0 = time.time()
+    n = len(rows)
+    eval_ct = 0
+    accept_ct = 0
+    for i, (new_id, new_name, n_lat, n_lon, ucsd_fsq_os_id, gmap_id, u_name, u_lat, u_lon, src) in enumerate(rows):
+        d = haversine_m(n_lat, n_lon, u_lat, u_lon)
+        if d > MAX_DIST_M:
+            continue
+        sim = fuzz.token_set_ratio(normalize_name(new_name), normalize_name(u_name))
+        eval_ct += 1
+        if sim < MIN_NAME_SIM:
+            continue
+        accept_ct += 1
+        # Score = sim - distance_in_m * 0.2 (favor close + similar)
+        score = sim - d * 0.2
+        prev = best.get(new_id)
+        if prev is None or score > prev[0]:
+            best[new_id] = (score, d, sim, gmap_id, ucsd_fsq_os_id, src)
+        if (i + 1) % 200_000 == 0:
+            rate = (i + 1) / (time.time() - t0)
+            eta = (n - i - 1) / max(rate, 1)
+            print(f"  scored {i+1:>10,}/{n:,}  rate {rate/1000:5.1f}k/s  eta {eta:.0f}s  "
+                  f"so_far {len(best):,} matches")
+    print(f"\n[step 4] eval after distance filter: {eval_ct:,}  accept: {accept_ct:,}")
+    print(f"[step 5] best-per-new-POI: {len(best):,} matches")
+    # Materialise matches table
+    out = []
+    for new_id, (score, d, sim, gmap_id, ucsd_fsq_os_id, src) in best.items():
+        out.append({"fsq_place_id": new_id, "ucsd_fsq_os_id": ucsd_fsq_os_id,
+                    "gmap_id": gmap_id, "match_src": src,
+                    "distance_m": d, "name_sim": sim})
+    if not out:
+        out = [{"fsq_place_id": "_dummy_", "ucsd_fsq_os_id": "", "gmap_id": "",
+                 "match_src": "", "distance_m": 0.0, "name_sim": 0.0}][:0]
+    pq.write_table(pa.Table.from_pylist(out), MATCHES_OUT, compression="zstd")
+    print(f"wrote {MATCHES_OUT}  ({MATCHES_OUT.stat().st_size/1e6:.2f} MB)")
+    return len(best)
+def main():
+    if not UCSD_UNIFIED.exists():
+        build_unified_ucsd()
+    else:
+        print(f"reusing existing {UCSD_UNIFIED}  "
+              f"({UCSD_UNIFIED.stat().st_size/1e6:.1f} MB)")
+    n = run_bridge()
+    print(f"\nDONE. matched {n:,} of 81,592 new POIs.")
+if __name__ == "__main__":
+    main()

_scripts/13_merge_ucsd_into_metadata.py ADDED Viewed

	@@ -0,0 +1,139 @@

+"""
+Stage 13:  fold the 1,608 UCSD-matched new POIs' Google metadata into
+metadata_all.parquet.
+For each matched POI we populate the existing google_* columns:
+    google_cid, google_name, google_full_address, google_address,
+    google_website, google_rating, google_num_reviews, google_categories,
+    google_place_id, google_gmaps_url, google_meta_source, has_google_metadata
+`google_meta_source` is set to 'ucsd_<src>' (ucsd_all20 / ucsd_bench).
+We DO NOT overwrite Google fields that are already populated for any POI
+(none of the 1,608 should have any, but this safety check keeps the script
+idempotent on re-run).
+"""
+from __future__ import annotations
+from pathlib import Path
+import duckdb
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+META   = ROOT / "metadata" / "metadata_all.parquet"
+INTER  = ROOT / "_intermediate"
+MATCHES = INTER / "ucsd_matches.parquet"
+UNIFIED = INTER / "ucsd_unified.parquet"
+META_TMP = META.with_suffix(".tmp.parquet")
+def main():
+    con = duckdb.connect()
+    con.execute("PRAGMA threads=32")
+    con.execute("SET memory_limit='32GB'")
+    n_matches = con.execute(f"SELECT COUNT(*) FROM '{MATCHES}'").fetchone()[0]
+    print(f"matches to fold in: {n_matches:,}")
+    # Build the UCSD->google_* enrichment table for the matched fsq_place_ids.
+    # We pick the first row per ucsd_fsq_os_id from the unified table (rare
+    # duplicates between bench/all20 -- prefer 'bench' which is already
+    # validated against the benchmark).
+    con.execute(f"""
+CREATE TEMP TABLE ucsd_dedup AS
+SELECT * FROM (
+  SELECT *,
+         ROW_NUMBER() OVER (PARTITION BY ucsd_fsq_os_id
+                            ORDER BY CASE WHEN src='bench' THEN 0 ELSE 1 END) AS rn
+  FROM '{UNIFIED}'
+) WHERE rn = 1
+""")
+    con.execute(f"""
+CREATE TEMP TABLE enrich AS
+SELECT
+  m.fsq_place_id,
+  u.gmap_id                                      AS google_cid_new,
+  COALESCE(u.gmaps_name,  u.gl_name)             AS google_name_new,
+  u.gmaps_full_address                           AS google_full_address_new,
+  COALESCE(u.gmaps_address, u.gl_address)        AS google_address_new,
+  u.gmaps_website                                AS google_website_new,
+  COALESCE(u.gmaps_rating, u.gl_avg_rating)      AS google_rating_new,
+  COALESCE(u.gmaps_num_reviews, u.gl_num_reviews) AS google_num_reviews_new,
+  COALESCE(u.gmaps_categories, u.gl_category)    AS google_categories_new,
+  u.place_id                                     AS google_place_id_new,
+  COALESCE(u.gmaps_url, u.gl_url)                AS google_gmaps_url_new,
+  ('ucsd_' || u.src)                             AS google_meta_source_new
+FROM '{MATCHES}' m
+JOIN ucsd_dedup u USING (ucsd_fsq_os_id)
+""")
+    n_enrich = con.execute("SELECT COUNT(*) FROM enrich").fetchone()[0]
+    print(f"  enrichment table size: {n_enrich:,}")
+    # Inspect coverage of the enrichment payload.
+    cov = con.execute("""
+SELECT
+  SUM(CASE WHEN google_cid_new IS NOT NULL                   THEN 1 ELSE 0 END) AS cid,
+  SUM(CASE WHEN google_name_new IS NOT NULL                  THEN 1 ELSE 0 END) AS nm,
+  SUM(CASE WHEN google_full_address_new IS NOT NULL          THEN 1 ELSE 0 END) AS addr,
+  SUM(CASE WHEN google_website_new IS NOT NULL               THEN 1 ELSE 0 END) AS web,
+  SUM(CASE WHEN google_rating_new IS NOT NULL                THEN 1 ELSE 0 END) AS rating,
+  SUM(CASE WHEN google_categories_new IS NOT NULL            THEN 1 ELSE 0 END) AS cats
+FROM enrich
+""").fetchone()
+    print(f"  field coverage: cid={cov[0]} name={cov[1]} addr={cov[2]} "
+          f"web={cov[3]} rating={cov[4]} cats={cov[5]}")
+    # COPY-write a new metadata_all.parquet that overlays google_* fields for
+    # POIs in the enrichment table, leaving everything else unchanged.
+    print("\nrewriting metadata_all.parquet ...")
+    con.execute(f"""
+COPY (
+  SELECT
+    m.fsq_place_id,
+    m.benchmark_name, m.benchmark_locality,
+    m.benchmark_venue_category, m.benchmark_venue_schema,
+    m.fsq_name, m.fsq_latitude, m.fsq_longitude, m.fsq_address,
+    m.fsq_locality, m.fsq_region, m.fsq_country, m.fsq_postcode,
+    m.fsq_formatted_address, m.fsq_category_ids, m.fsq_category_labels,
+    m.fsq_website, m.fsq_tel, m.fsq_email, m.fsq_facebook_id,
+    m.fsq_instagram, m.fsq_twitter,
+    m.fsq_date_created, m.fsq_date_refreshed, m.fsq_date_closed,
+    m.fsq_meta_source, m.has_fsq_metadata,
+    COALESCE(m.google_cid,           e.google_cid_new)           AS google_cid,
+    COALESCE(m.google_name,          e.google_name_new)          AS google_name,
+    COALESCE(m.google_full_address,  e.google_full_address_new)  AS google_full_address,
+    COALESCE(m.google_address,       e.google_address_new)       AS google_address,
+    COALESCE(m.google_website,       e.google_website_new)       AS google_website,
+    COALESCE(m.google_rating,        e.google_rating_new)        AS google_rating,
+    COALESCE(m.google_num_reviews,   e.google_num_reviews_new)   AS google_num_reviews,
+    COALESCE(m.google_categories,    e.google_categories_new)    AS google_categories,
+    COALESCE(m.google_place_id,      e.google_place_id_new)      AS google_place_id,
+    COALESCE(m.google_gmaps_url,     e.google_gmaps_url_new)     AS google_gmaps_url,
+    CASE
+      WHEN m.has_google_metadata THEN m.google_meta_source
+      WHEN e.google_cid_new IS NOT NULL THEN e.google_meta_source_new
+      ELSE m.google_meta_source
+    END AS google_meta_source,
+    (m.has_google_metadata OR e.google_cid_new IS NOT NULL) AS has_google_metadata
+  FROM '{META}' m
+  LEFT JOIN enrich e USING (fsq_place_id)
+) TO '{META_TMP}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 200000)
+""")
+    META.unlink(); META_TMP.rename(META)
+    n_total = con.execute(f"SELECT COUNT(*) FROM '{META}'").fetchone()[0]
+    n_with_g = con.execute(f"SELECT SUM(CASE WHEN has_google_metadata THEN 1 ELSE 0 END) FROM '{META}'").fetchone()[0]
+    print(f"\nmetadata_all.parquet rewritten: {n_total:,} rows, "
+          f"{n_with_g:,} with Google metadata ({n_with_g/n_total*100:.2f}%)")
+    by_src = con.execute(f"""
+SELECT google_meta_source, COUNT(*) FROM '{META}'
+WHERE google_cid IS NOT NULL GROUP BY 1 ORDER BY 2 DESC
+""").fetchall()
+    print("\ngoogle_meta_source breakdown:")
+    for s, c in by_src:
+        print(f"  {s or '(null)':30s} {c:>9,}")
+if __name__ == "__main__":
+    main()

_scripts/14_merge_gcp_search_results.py ADDED Viewed

	@@ -0,0 +1,281 @@

+"""
+Stage 14:  fold the GCP search-and-scrape results into Trip World.
+Reads:
+    _intermediate/gcp_search_attrs/shard_*/search_attrs.jsonl
+        produced by gmaps_search_gcp/collect.sh
+        Each row contains:
+            fsq_place_id, status, search_query, match_dist_m, match_name_sim,
+            biz: {cid, name, full_address, address, website, rating,
+                   num_reviews, categories, place_id, gmaps_url, lat, lon},
+            description_short, description_long,
+            hours_today, hours_week,
+            price_token, price_min, price_max,
+            attributes: [...],
+            inline_reviews: [...],
+            raw_size, fetched_at, error
+Writes:
+    metadata/metadata_all.parquet     (overwritten with google_* + new
+                                       google_attrs_* cols populated)
+    metadata/place_attributes.parquet (NEW: description/hours/price/attrs)
+    reviews/google_inline_reviews.parquet  (NEW)
+Idempotent — safe to re-run.
+"""
+from __future__ import annotations
+import json, time
+from pathlib import Path
+import duckdb
+import pyarrow as pa
+import pyarrow.parquet as pq
+import os
+ROOT  = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+META  = ROOT / "metadata" / "metadata_all.parquet"
+ATTRS_OUT = ROOT / "metadata" / "place_attributes.parquet"
+REVIEWS_DIR = ROOT / "reviews"
+REVIEWS_OUT = REVIEWS_DIR / "google_inline_reviews.parquet"
+INTER = ROOT / "_intermediate"
+GCP_DIR = INTER / "gcp_search_attrs"
+META_TMP = META.with_suffix(".tmp.parquet")
+def log(m): print(f"[{time.strftime('%H:%M:%S')}] {m}", flush=True)
+def main():
+    REVIEWS_DIR.mkdir(parents=True, exist_ok=True)
+    # ------------------------------------------------------------------
+    # 1. Load all GCP shards into memory
+    # ------------------------------------------------------------------
+    log("loading GCP shards ...")
+    rows = []
+    files = sorted(GCP_DIR.glob("shard_*/search_attrs.jsonl"))
+    if not files:
+        # Fallback: also look for un-merged worker files
+        files = sorted(GCP_DIR.glob("shard_*/search_attrs*.jsonl"))
+    log(f"  found {len(files)} shard files")
+    for fp in files:
+        with open(fp) as fh:
+            for line in fh:
+                try: rows.append(json.loads(line))
+                except Exception: continue
+    log(f"  loaded {len(rows):,} records")
+    # Deduplicate by fsq_place_id, keeping the LATEST 'ok' if any, else last
+    by_id: dict[str, dict] = {}
+    for r in rows:
+        fid = r.get("fsq_place_id")
+        if not fid: continue
+        prev = by_id.get(fid)
+        if prev is None: by_id[fid] = r; continue
+        prev_ok = prev.get("status") == "ok"
+        cur_ok  = r.get("status") == "ok"
+        if cur_ok and not prev_ok:
+            by_id[fid] = r
+    rows = list(by_id.values())
+    log(f"  after dedup by fsq_place_id: {len(rows):,}")
+    # ------------------------------------------------------------------
+    # 2. Build the enrichment table (google_* + place_attributes)
+    # ------------------------------------------------------------------
+    log("building enrichment tables ...")
+    google_rows = []     # for metadata overlay
+    attrs_rows = []      # for place_attributes.parquet
+    review_rows = []     # for inline_reviews.parquet
+    for r in rows:
+        fid = r["fsq_place_id"]
+        if r.get("status") != "ok": continue
+        biz = r.get("biz") or {}
+        cid = biz.get("cid")
+        if not cid: continue
+        google_rows.append({
+            "fsq_place_id": fid,
+            "google_cid":          cid,
+            "google_name":         biz.get("name"),
+            "google_full_address": biz.get("full_address"),
+            "google_address":      biz.get("address"),
+            "google_website":      biz.get("website"),
+            "google_rating":       (float(biz["rating"])
+                                     if biz.get("rating") is not None else None),
+            "google_num_reviews":  (int(biz["num_reviews"])
+                                     if biz.get("num_reviews") is not None else None),
+            "google_categories":   biz.get("categories"),
+            "google_place_id":     biz.get("place_id"),
+            "google_gmaps_url":    biz.get("gmaps_url"),
+            "google_meta_source":  "gcp_search_2026",
+        })
+        attrs_rows.append({
+            "fsq_place_id":      fid,
+            "google_cid":        cid,
+            "search_query":      r.get("search_query"),
+            "match_dist_m":      r.get("match_dist_m"),
+            "match_name_sim":    r.get("match_name_sim"),
+            "description_short": r.get("description_short"),
+            "description_long":  r.get("description_long"),
+            "hours_today":       json.dumps(r.get("hours_today")) if r.get("hours_today") else None,
+            "hours_week":        json.dumps(r.get("hours_week"))  if r.get("hours_week")  else None,
+            "price_token":       r.get("price_token"),
+            "price_min":         r.get("price_min"),
+            "price_max":         r.get("price_max"),
+            "attributes":        json.dumps(r.get("attributes")) if r.get("attributes") else None,
+            "n_inline_reviews":  len(r.get("inline_reviews") or []),
+            "fetched_at":        r.get("fetched_at"),
+        })
+        for rev in (r.get("inline_reviews") or []):
+            review_rows.append({
+                "fsq_place_id":   fid,
+                "google_cid":     cid,
+                "review_id":      rev.get("review_id"),
+                "rating":         rev.get("rating"),
+                "text":           rev.get("text"),
+                "author":         rev.get("author"),
+                "timestamp_us":   rev.get("timestamp_us"),
+                "relative_time":  rev.get("relative_time"),
+                "source":         rev.get("source"),
+            })
+    log(f"  google enrichment rows: {len(google_rows):,}")
+    log(f"  place_attributes rows:  {len(attrs_rows):,}")
+    log(f"  inline_reviews rows:    {len(review_rows):,}")
+    # ------------------------------------------------------------------
+    # 3. Write place_attributes + inline_reviews parquet (replace, idempotent)
+    # ------------------------------------------------------------------
+    log("writing place_attributes.parquet ...")
+    pq.write_table(
+        pa.Table.from_pylist(attrs_rows, schema=pa.schema([
+            ("fsq_place_id", pa.string()),
+            ("google_cid", pa.string()),
+            ("search_query", pa.string()),
+            ("match_dist_m", pa.float64()),
+            ("match_name_sim", pa.float64()),
+            ("description_short", pa.string()),
+            ("description_long", pa.string()),
+            ("hours_today", pa.string()),
+            ("hours_week", pa.string()),
+            ("price_token", pa.string()),
+            ("price_min", pa.string()),
+            ("price_max", pa.string()),
+            ("attributes", pa.string()),
+            ("n_inline_reviews", pa.int64()),
+            ("fetched_at", pa.string()),
+        ])),
+        ATTRS_OUT, compression="zstd")
+    log(f"  wrote {ATTRS_OUT}  ({ATTRS_OUT.stat().st_size/1e6:.1f} MB)")
+    log("writing google_inline_reviews.parquet ...")
+    pq.write_table(
+        pa.Table.from_pylist(review_rows, schema=pa.schema([
+            ("fsq_place_id", pa.string()),
+            ("google_cid", pa.string()),
+            ("review_id", pa.string()),
+            ("rating", pa.int64()),
+            ("text", pa.string()),
+            ("author", pa.string()),
+            ("timestamp_us", pa.int64()),
+            ("relative_time", pa.string()),
+            ("source", pa.string()),
+        ])),
+        REVIEWS_OUT, compression="zstd")
+    log(f"  wrote {REVIEWS_OUT}  ({REVIEWS_OUT.stat().st_size/1e6:.1f} MB)")
+    # ------------------------------------------------------------------
+    # 4. Overlay google_* fields into metadata_all.parquet
+    # ------------------------------------------------------------------
+    log("overlaying google_* into metadata_all.parquet ...")
+    enrich_path = INTER / "_gcp_google_overlay.parquet"
+    pq.write_table(
+        pa.Table.from_pylist(google_rows, schema=pa.schema([
+            ("fsq_place_id", pa.string()),
+            ("google_cid", pa.string()),
+            ("google_name", pa.string()),
+            ("google_full_address", pa.string()),
+            ("google_address", pa.string()),
+            ("google_website", pa.string()),
+            ("google_rating", pa.float64()),
+            ("google_num_reviews", pa.int64()),
+            ("google_categories", pa.list_(pa.string())),
+            ("google_place_id", pa.string()),
+            ("google_gmaps_url", pa.string()),
+            ("google_meta_source", pa.string()),
+        ])),
+        enrich_path, compression="zstd")
+    con = duckdb.connect()
+    con.execute("PRAGMA threads=32")
+    con.execute("SET memory_limit='32GB'")
+    con.execute(f"""
+COPY (
+  SELECT
+    m.fsq_place_id,
+    m.benchmark_name, m.benchmark_locality,
+    m.benchmark_venue_category, m.benchmark_venue_schema,
+    m.fsq_name, m.fsq_latitude, m.fsq_longitude, m.fsq_address,
+    m.fsq_locality, m.fsq_region, m.fsq_country, m.fsq_postcode,
+    m.fsq_formatted_address, m.fsq_category_ids, m.fsq_category_labels,
+    m.fsq_website, m.fsq_tel, m.fsq_email, m.fsq_facebook_id,
+    m.fsq_instagram, m.fsq_twitter,
+    m.fsq_date_created, m.fsq_date_refreshed, m.fsq_date_closed,
+    m.fsq_meta_source, m.has_fsq_metadata,
+    COALESCE(m.google_cid,           e.google_cid)           AS google_cid,
+    COALESCE(m.google_name,          e.google_name)          AS google_name,
+    COALESCE(m.google_full_address,  e.google_full_address)  AS google_full_address,
+    COALESCE(m.google_address,       e.google_address)       AS google_address,
+    COALESCE(m.google_website,       e.google_website)       AS google_website,
+    COALESCE(m.google_rating,        e.google_rating)        AS google_rating,
+    COALESCE(m.google_num_reviews,   e.google_num_reviews)   AS google_num_reviews,
+    COALESCE(m.google_categories,    e.google_categories)    AS google_categories,
+    COALESCE(m.google_place_id,      e.google_place_id)      AS google_place_id,
+    COALESCE(m.google_gmaps_url,     e.google_gmaps_url)     AS google_gmaps_url,
+    CASE
+      WHEN m.has_google_metadata THEN m.google_meta_source
+      WHEN e.google_cid IS NOT NULL THEN e.google_meta_source
+      ELSE m.google_meta_source
+    END AS google_meta_source,
+    (m.has_google_metadata OR e.google_cid IS NOT NULL) AS has_google_metadata
+  FROM '{META}' m
+  LEFT JOIN '{enrich_path}' e USING (fsq_place_id)
+) TO '{META_TMP}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 200000)
+""")
+    META.unlink(); META_TMP.rename(META)
+    log(f"  rewrote {META}")
+    # ------------------------------------------------------------------
+    # 5. Final coverage stats
+    # ------------------------------------------------------------------
+    log("computing final coverage ...")
+    n_total = con.execute(f"SELECT COUNT(*) FROM '{META}'").fetchone()[0]
+    n_with_g = con.execute(f"SELECT SUM(CASE WHEN has_google_metadata THEN 1 ELSE 0 END) FROM '{META}'").fetchone()[0]
+    n_attrs  = con.execute(f"SELECT COUNT(*) FROM '{ATTRS_OUT}'").fetchone()[0]
+    n_revs   = con.execute(f"SELECT COUNT(*) FROM '{REVIEWS_OUT}'").fetchone()[0]
+    n_revs_text = con.execute(f"""
+SELECT COUNT(*) FROM '{REVIEWS_OUT}'
+WHERE text IS NOT NULL AND length(text) >= 30
+""").fetchone()[0]
+    print()
+    print("=" * 60)
+    print("FINAL COVERAGE")
+    print("=" * 60)
+    print(f"  metadata_all rows:               {n_total:,}")
+    print(f"  POIs with Google metadata:       {n_with_g:,} "
+          f"({n_with_g/n_total*100:.2f}%)")
+    print(f"  POIs with place_attributes:      {n_attrs:,} "
+          f"({n_attrs/n_total*100:.2f}%)")
+    print(f"  Inline reviews collected:        {n_revs:,}")
+    print(f"  Reviews with >=30 char text:     {n_revs_text:,}")
+    print()
+    by_src = con.execute(f"""
+SELECT google_meta_source, COUNT(*) FROM '{META}'
+WHERE google_cid IS NOT NULL GROUP BY 1 ORDER BY 2 DESC
+""").fetchall()
+    print("google_meta_source breakdown:")
+    for s, c in by_src:
+        print(f"  {s or '(null)':30s} {c:>9,}")
+if __name__ == "__main__":
+    main()

_scripts/15_merge_stage2_reviews.py ADDED Viewed

	@@ -0,0 +1,199 @@

+"""
+Stage 15:  fold the listugcposts (Stage 2) reviews into Trip World.
+Reads:
+    _intermediate/gcp_reviews/reviews_NN.jsonl
+        produced by gmaps_reviews_gcp/collect.sh
+        Each row contains:
+            fsq_place_id, fid, fsq_name, fetched_at, status, num_pages,
+            num_reviews,
+            reviews: [
+                {review_id, author, author_id, timestamp_us, relative_time,
+                 rating, text, lang, owner_reply}
+            ]
+Writes:
+    reviews/reviews_listugcposts.parquet
+        flat per-review table for the listugcposts crawl
+    reviews/reviews_all.parquet
+        union with the existing google_inline_reviews.parquet, deduped on
+        review_id, prioritising listugcposts over inline (former is fuller).
+Idempotent — safe to re-run.
+"""
+from __future__ import annotations
+import json, time
+from pathlib import Path
+import duckdb
+import pyarrow as pa
+import pyarrow.parquet as pq
+import os
+ROOT  = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+INTER = ROOT / "_intermediate"
+GCP_DIR = INTER / "gcp_reviews"
+REVIEWS_DIR = ROOT / "reviews"
+INLINE  = REVIEWS_DIR / "google_inline_reviews.parquet"   # from Stage 14
+STAGE2  = REVIEWS_DIR / "reviews_listugcposts.parquet"    # output (this script)
+ALL_OUT = REVIEWS_DIR / "reviews_all.parquet"             # union output
+def log(m): print(f"[{time.strftime('%H:%M:%S')}] {m}", flush=True)
+def main() -> None:
+    REVIEWS_DIR.mkdir(parents=True, exist_ok=True)
+    # ------------------------------------------------------------------
+    # 1. Load all listugcposts JSONL files
+    # ------------------------------------------------------------------
+    log("loading listugcposts JSONL ...")
+    files = sorted(GCP_DIR.glob("reviews_*.jsonl"))
+    log(f"  found {len(files)} files")
+    if not files:
+        log("  no input — Stage 2 hasn't been collected yet?")
+        return
+    # Per-POI dedup: keep the record with most reviews per fsq_place_id.
+    poi_rows: dict[str, dict] = {}
+    n_lines = 0
+    for fp in files:
+        with open(fp) as fh:
+            for line in fh:
+                try:
+                    r = json.loads(line)
+                except Exception:
+                    continue
+                n_lines += 1
+                fid = r.get("fsq_place_id")
+                if not fid: continue
+                prev = poi_rows.get(fid)
+                if prev is None or len(r.get("reviews") or []) > len(prev.get("reviews") or []):
+                    poi_rows[fid] = r
+    log(f"  read {n_lines:,} rows -> {len(poi_rows):,} unique POIs")
+    # ------------------------------------------------------------------
+    # 2. Flatten -> per-review table
+    # ------------------------------------------------------------------
+    log("flattening to per-review rows ...")
+    flat = []
+    n_pois_with_reviews = 0
+    for fid, r in poi_rows.items():
+        revs = r.get("reviews") or []
+        if not revs: continue
+        n_pois_with_reviews += 1
+        cid = r.get("fid")
+        for rev in revs:
+            flat.append({
+                "fsq_place_id":   fid,
+                "google_cid":     cid,
+                "review_id":      rev.get("review_id"),
+                "rating":         rev.get("rating"),
+                "text":           rev.get("text"),
+                "author":         rev.get("author"),
+                "author_id":      rev.get("author_id"),
+                "timestamp_us":   rev.get("timestamp_us"),
+                "relative_time": rev.get("relative_time"),
+                "lang":           rev.get("lang"),
+                "owner_reply":    rev.get("owner_reply"),
+                "source":         "listugcposts",
+            })
+    log(f"  POIs with >=1 review: {n_pois_with_reviews:,}")
+    log(f"  total reviews:        {len(flat):,}")
+    # ------------------------------------------------------------------
+    # 3. Write reviews_listugcposts.parquet
+    # ------------------------------------------------------------------
+    log("writing reviews_listugcposts.parquet ...")
+    schema = pa.schema([
+        ("fsq_place_id", pa.string()),
+        ("google_cid",   pa.string()),
+        ("review_id",    pa.string()),
+        ("rating",       pa.int64()),
+        ("text",         pa.string()),
+        ("author",       pa.string()),
+        ("author_id",    pa.string()),
+        ("timestamp_us", pa.int64()),
+        ("relative_time", pa.string()),
+        ("lang",         pa.string()),
+        ("owner_reply",  pa.string()),
+        ("source",       pa.string()),
+    ])
+    pq.write_table(pa.Table.from_pylist(flat, schema=schema),
+                    STAGE2, compression="zstd")
+    log(f"  wrote {STAGE2}  ({STAGE2.stat().st_size/1e6:.1f} MB)")
+    # ------------------------------------------------------------------
+    # 4. Build reviews_all.parquet = union(listugcposts, inline) deduped
+    # ------------------------------------------------------------------
+    if not INLINE.exists():
+        log(f"  inline reviews parquet missing ({INLINE}) — writing reviews_all = stage2 only")
+        STAGE2.replace(ALL_OUT) if False else None  # leave files separate
+        import shutil; shutil.copy(STAGE2, ALL_OUT)
+    else:
+        log("computing union with inline reviews ...")
+        con = duckdb.connect()
+        con.execute("PRAGMA threads=16")
+        con.execute("SET memory_limit='16GB'")
+        # Inline reviews don't have author_id / lang / owner_reply; project them as NULL.
+        con.execute(f"""
+COPY (
+  WITH unioned AS (
+    SELECT
+      fsq_place_id, google_cid, review_id, rating, text,
+      author, author_id, timestamp_us, relative_time, lang, owner_reply,
+      source, 1 AS prio
+    FROM '{STAGE2}'
+    UNION ALL
+    SELECT
+      fsq_place_id, google_cid, review_id, rating, text,
+      author, NULL AS author_id, timestamp_us, relative_time,
+      NULL AS lang, NULL AS owner_reply,
+      'inline_preload' AS source, 2 AS prio
+    FROM '{INLINE}'
+  ),
+  ranked AS (
+    SELECT *, ROW_NUMBER() OVER (
+      PARTITION BY COALESCE(review_id, fsq_place_id || '|' || COALESCE(author,'') || '|' || COALESCE(text,''))
+      ORDER BY prio
+    ) AS rn
+    FROM unioned
+  )
+  SELECT
+    fsq_place_id, google_cid, review_id, rating, text,
+    author, author_id, timestamp_us, relative_time, lang, owner_reply, source
+  FROM ranked WHERE rn = 1
+) TO '{ALL_OUT}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 200000)
+""")
+        log(f"  wrote {ALL_OUT}  ({ALL_OUT.stat().st_size/1e6:.1f} MB)")
+    # ------------------------------------------------------------------
+    # 5. Final stats
+    # ------------------------------------------------------------------
+    log("computing final stats ...")
+    con = duckdb.connect()
+    con.execute("PRAGMA threads=16")
+    n_revs   = con.execute(f"SELECT COUNT(*) FROM '{ALL_OUT}'").fetchone()[0]
+    n_text   = con.execute(f"SELECT COUNT(*) FROM '{ALL_OUT}' WHERE text IS NOT NULL AND length(text) >= 30").fetchone()[0]
+    n_pois   = con.execute(f"SELECT COUNT(DISTINCT fsq_place_id) FROM '{ALL_OUT}'").fetchone()[0]
+    n_pois_text = con.execute(f"SELECT COUNT(DISTINCT fsq_place_id) FROM '{ALL_OUT}' WHERE text IS NOT NULL AND length(text) >= 30").fetchone()[0]
+    by_src = con.execute(f"SELECT source, COUNT(*) FROM '{ALL_OUT}' GROUP BY 1 ORDER BY 2 DESC").fetchall()
+    print()
+    print("=" * 60)
+    print("FINAL REVIEW COVERAGE (Trip World, new POIs only)")
+    print("=" * 60)
+    print(f"  unique POIs with reviews:       {n_pois:,}")
+    print(f"  unique POIs with text reviews:  {n_pois_text:,}")
+    print(f"  total reviews:                  {n_revs:,}")
+    print(f"  reviews with >=30 char text:    {n_text:,}")
+    print()
+    print("by source:")
+    for s, c in by_src:
+        print(f"  {s:30s} {c:>10,}")
+if __name__ == "__main__":
+    main()

_scripts/16_unify_reviews.py ADDED Viewed

	@@ -0,0 +1,178 @@

+"""
+Stage 16: build the unified reviews_all.parquet for Trip World.
+Combines:
+  - Precursor reviews (~96M rows) loaded from
+        $PRECURSOR_BUILD_ROOT/reviews/reviews_all.parquet
+    The $PRECURSOR_BUILD_ROOT env var should point at a previous output of
+    this same pipeline whose review corpus we want to extend; omit this
+    stage entirely if you do not have such a precursor build.
+  - The newly-collected reviews from this release's stage-14/15 outputs:
+        $TRIP_WORLD_ROOT/reviews/reviews_listugcposts.parquet
+        $TRIP_WORLD_ROOT/reviews/google_inline_reviews.parquet
+    (~15M rows total).
+Both inputs are filtered to POIs that survived into Trip World, then
+deduplicated on review_id (with a fallback hash on
+fsq_place_id|author|text for rows missing review_id).
+Schema is the union of all three, with NULLs for missing fields:
+    fsq_place_id, google_cid, review_id, author, author_id, rating, text,
+    text_translated, lang, relative_time, timestamp_us, review_time,
+    owner_reply, source
+Output:
+    $TRIP_WORLD_ROOT/reviews/reviews_all.parquet  (overwritten)
+"""
+from __future__ import annotations
+import time
+from pathlib import Path
+import duckdb
+import os
+ROOT_V1     = Path(os.environ["PRECURSOR_BUILD_ROOT"])
+ROOT_CLEAN  = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+META_CLEAN  = ROOT_CLEAN / "metadata" / "metadata_all.parquet"
+V1_REVIEWS  = ROOT_V1    / "reviews" / "reviews_all.parquet"
+NEW_LISTUGC = ROOT_CLEAN / "reviews" / "reviews_listugcposts.parquet"
+NEW_INLINE  = ROOT_CLEAN / "reviews" / "google_inline_reviews.parquet"
+OUT         = ROOT_CLEAN / "reviews" / "reviews_all.parquet"
+OUT_TMP     = OUT.with_suffix(".tmp.parquet")
+def log(m): print(f"[{time.strftime('%H:%M:%S')}] {m}", flush=True)
+def main() -> None:
+    con = duckdb.connect()
+    con.execute("PRAGMA threads=32")
+    con.execute("SET memory_limit='48GB'")
+    # ------------------------------------------------------------------
+    # 1. Sanity counts before union
+    # ------------------------------------------------------------------
+    log("counting inputs ...")
+    n_prev = con.execute(f"SELECT COUNT(*) FROM '{V1_REVIEWS}'").fetchone()[0]
+    n_lu = con.execute(f"SELECT COUNT(*) FROM '{NEW_LISTUGC}'").fetchone()[0]
+    n_in = con.execute(f"SELECT COUNT(*) FROM '{NEW_INLINE}'").fetchone()[0]
+    log(f"  precursor reviews:           {n_prev:>12,}")
+    log(f"  new listugcposts:     {n_lu:>12,}")
+    log(f"  new inline_preload:   {n_in:>12,}")
+    log(f"  raw total before dedup: {n_prev + n_lu + n_in:>12,}")
+    # ------------------------------------------------------------------
+    # 2. Build unified, deduped reviews_all.
+    #    Priority order, highest first:
+    #      1) the listugcposts crawl (most reviews per place)
+    #      2) precursor-build refetch rows (highest fidelity refetch)
+    #      3) precursor-build other source tags
+    #      4) inline-preview reviews from the search-page enrichment
+    # ------------------------------------------------------------------
+    log("building unified table (this can take a few minutes) ...")
+    con.execute(f"""
+COPY (
+  WITH unioned AS (
+    -- precursor reviews (96M)
+    SELECT
+      fsq_place_id,
+      CAST(NULL AS VARCHAR) AS google_cid,
+      review_id, author, author_id, rating, text, text_translated,
+      lang, relative_time, timestamp_us, review_time,
+      CAST(NULL AS VARCHAR) AS owner_reply,
+      'v1_' || source AS source,
+      CASE
+        WHEN source = 'refetch'    THEN 2
+        WHEN source = 'migrate'    THEN 3
+        WHEN source = 'stage1d'    THEN 4
+        WHEN source = 'playwright' THEN 5
+        WHEN source = 'ucsd_all20' THEN 6
+        WHEN source = 'ucsd_bench' THEN 7
+        ELSE 8
+      END AS prio
+    FROM '{V1_REVIEWS}'
+    UNION ALL
+    -- new listugcposts (15M)
+    SELECT
+      fsq_place_id, google_cid,
+      review_id, author, author_id, rating, text,
+      CAST(NULL AS VARCHAR) AS text_translated,
+      lang, relative_time, timestamp_us,
+      CAST(NULL AS TIMESTAMP) AS review_time,
+      owner_reply,
+      source,                                  -- already 'listugcposts'
+      1 AS prio                                -- highest priority
+    FROM '{NEW_LISTUGC}'
+    UNION ALL
+    -- new inline preload (from search-and-scrape worker, ~227K rows)
+    SELECT
+      fsq_place_id, google_cid, review_id, author,
+      CAST(NULL AS VARCHAR) AS author_id,
+      rating, text,
+      CAST(NULL AS VARCHAR) AS text_translated,
+      CAST(NULL AS VARCHAR) AS lang,
+      relative_time, timestamp_us,
+      CAST(NULL AS TIMESTAMP) AS review_time,
+      CAST(NULL AS VARCHAR) AS owner_reply,
+      'inline_preload' AS source,
+      9 AS prio                                -- lowest (always overshadowed)
+    FROM '{NEW_INLINE}'
+  ),
+  ranked AS (
+    SELECT *, ROW_NUMBER() OVER (
+      PARTITION BY COALESCE(
+        review_id,
+        fsq_place_id || '|' || COALESCE(author,'') || '|' || COALESCE(text,'')
+      )
+      ORDER BY prio
+    ) AS rn
+    FROM unioned
+  )
+  SELECT
+    fsq_place_id, google_cid, review_id, author, author_id, rating,
+    text, text_translated, lang, relative_time, timestamp_us, review_time,
+    owner_reply, source
+  FROM ranked WHERE rn = 1
+) TO '{OUT_TMP}' (FORMAT PARQUET, COMPRESSION 'zstd', ROW_GROUP_SIZE 200000)
+""")
+    OUT.unlink(missing_ok=True)
+    OUT_TMP.rename(OUT)
+    log(f"  wrote {OUT}  ({OUT.stat().st_size/1e9:.2f} GB)")
+    # ------------------------------------------------------------------
+    # 3. Final stats
+    # ------------------------------------------------------------------
+    log("computing final stats ...")
+    n_revs   = con.execute(f"SELECT COUNT(*) FROM '{OUT}'").fetchone()[0]
+    n_text   = con.execute(f"SELECT COUNT(*) FROM '{OUT}' WHERE text IS NOT NULL AND length(text) >= 30").fetchone()[0]
+    n_pois   = con.execute(f"SELECT COUNT(DISTINCT fsq_place_id) FROM '{OUT}'").fetchone()[0]
+    n_pois_text = con.execute(f"SELECT COUNT(DISTINCT fsq_place_id) FROM '{OUT}' WHERE text IS NOT NULL AND length(text) >= 30").fetchone()[0]
+    by_src = con.execute(f"SELECT source, COUNT(*) FROM '{OUT}' GROUP BY 1 ORDER BY 2 DESC").fetchall()
+    n_total_pois = con.execute(f"SELECT COUNT(*) FROM '{META_CLEAN}'").fetchone()[0]
+    n_pois_in_clean = con.execute(f"""
+SELECT COUNT(DISTINCT r.fsq_place_id)
+FROM '{OUT}' r
+WHERE r.fsq_place_id IN (SELECT fsq_place_id FROM '{META_CLEAN}')
+""").fetchone()[0]
+    print()
+    print("=" * 68)
+    print("UNIFIED REVIEWS COVERAGE — Trip World")
+    print("=" * 68)
+    print(f"  total reviews in reviews_all:           {n_revs:>12,}")
+    print(f"  reviews with >=30-char text:            {n_text:>12,}")
+    print(f"  unique POIs with reviews:               {n_pois:>12,}")
+    print(f"  unique POIs with text reviews:          {n_pois_text:>12,}")
+    print(f"  POIs in Trip World (total):        {n_total_pois:>12,}")
+    print(f"  POIs covered (intersected w/ clean):    {n_pois_in_clean:>12,}  "
+          f"({n_pois_in_clean/n_total_pois*100:.2f}%)")
+    print()
+    print("by source:")
+    for s, c in by_src:
+        print(f"  {s:30s} {c:>13,}")
+if __name__ == "__main__":
+    main()

_scripts/lib_wikidata.py ADDED Viewed

	@@ -0,0 +1,155 @@

+"""
+Tiny Wikidata helper used by the Trip World build pipeline.
+Two entry points:
+  - sparql(query)            -> list[dict]    (POSTs to the public SPARQL endpoint)
+  - get_entity(qid)          -> dict          (REST lookup; returns labels + claims)
+  - p131_chain(qid, depth=8) -> list[str]     (transitive parents up the P131 ladder)
+Network access is required. Polite throttling: ~3 requests/sec.
+"""
+from __future__ import annotations
+import json, time, urllib.parse, urllib.request, gzip, ssl
+from typing import Iterable
+UA = "RQ3-clean-pipeline/1.0 (research; contact: rq3-bench@example.org)"
+_LAST_CALL = [0.0]
+_MIN_GAP = 0.30  # seconds between requests
+_ssl = ssl.create_default_context()
+def _throttle():
+    gap = time.time() - _LAST_CALL[0]
+    if gap < _MIN_GAP:
+        time.sleep(_MIN_GAP - gap)
+    _LAST_CALL[0] = time.time()
+def _http_get(url: str, accept: str = "application/json") -> bytes:
+    _throttle()
+    req = urllib.request.Request(url, headers={"User-Agent": UA, "Accept": accept,
+                                                "Accept-Encoding": "gzip"})
+    with urllib.request.urlopen(req, timeout=60, context=_ssl) as r:
+        body = r.read()
+        if r.headers.get("Content-Encoding") == "gzip":
+            body = gzip.decompress(body)
+        return body
+def _http_post(url: str, body: str, ct: str = "application/sparql-query",
+               accept: str = "application/sparql-results+json") -> bytes:
+    _throttle()
+    req = urllib.request.Request(url, data=body.encode("utf-8"),
+                                  headers={"User-Agent": UA,
+                                            "Content-Type": ct,
+                                            "Accept": accept,
+                                            "Accept-Encoding": "gzip"},
+                                  method="POST")
+    with urllib.request.urlopen(req, timeout=120, context=_ssl) as r:
+        body = r.read()
+        if r.headers.get("Content-Encoding") == "gzip":
+            body = gzip.decompress(body)
+        return body
+def sparql(query: str, retries: int = 3) -> list[dict]:
+    """Run a SPARQL query against query.wikidata.org and return the bindings."""
+    url = "https://query.wikidata.org/sparql"
+    last = None
+    for k in range(retries):
+        try:
+            raw = _http_post(url, query)
+            return json.loads(raw)["results"]["bindings"]
+        except Exception as e:
+            last = e
+            time.sleep(2 + 4 * k)
+    raise last
+def get_entity(qid: str) -> dict:
+    """Fetch raw Wikidata JSON for a single QID via Special:EntityData."""
+    qid = qid.replace("wd:", "")
+    url = f"https://www.wikidata.org/wiki/Special:EntityData/{qid}.json"
+    for k in range(3):
+        try:
+            raw = _http_get(url)
+            data = json.loads(raw)
+            return list(data["entities"].values())[0]
+        except Exception:
+            time.sleep(2 + 3 * k)
+    raise RuntimeError(f"failed to fetch {qid}")
+def p131_chain(qid: str, max_depth: int = 8) -> list[str]:
+    """Walk the 'located in administrative entity' (P131) chain upward.
+    Returns ordered ancestor QIDs starting from the immediate parent.
+    Stops at the first cycle / missing P131 / depth limit.
+    """
+    seen = {qid.replace("wd:", "")}
+    chain: list[str] = []
+    cur = qid.replace("wd:", "")
+    for _ in range(max_depth):
+        try:
+            ent = get_entity(cur)
+        except Exception:
+            break
+        claims = ent.get("claims", {}).get("P131", [])
+        if not claims:
+            break
+        # Take the first non-deprecated parent
+        parent = None
+        for c in claims:
+            if c.get("rank") == "deprecated":
+                continue
+            try:
+                parent = c["mainsnak"]["datavalue"]["value"]["id"]
+                break
+            except (KeyError, TypeError):
+                continue
+        if not parent or parent in seen:
+            break
+        seen.add(parent)
+        chain.append(parent)
+        cur = parent
+    return chain
+def labels_batch(qids: Iterable[str]) -> dict[str, str]:
+    """Fetch English labels (with Japanese / Turkish / Arabic fallbacks) for a batch of QIDs."""
+    qids = [q.replace("wd:", "") for q in qids]
+    out: dict[str, str] = {}
+    BATCH = 50
+    for i in range(0, len(qids), BATCH):
+        batch = qids[i:i + BATCH]
+        values = " ".join(f"wd:{q}" for q in batch)
+        q = f"""
+SELECT ?q ?qLabel WHERE {{
+  VALUES ?q {{ {values} }}
+  SERVICE wikibase:label {{
+    bd:serviceParam wikibase:language "en,ja,tr,ar,es,zh,fr,de" .
+  }}
+}}
+"""
+        try:
+            for r in sparql(q):
+                qid = r["q"]["value"].rsplit("/", 1)[-1]
+                out[qid] = r.get("qLabel", {}).get("value", "")
+        except Exception as e:
+            print(f"  labels_batch failed for batch {i}: {e}")
+    return out
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        qid = sys.argv[1]
+        print(f"label: {labels_batch([qid]).get(qid.replace('wd:', ''))}")
+        print(f"P131 chain: {p131_chain(qid)}")
+    else:
+        # Quick smoke test
+        print("Tokyo P131:", p131_chain("Q1490"))
+        print("Yokohama-area P131:", p131_chain("Q49295377"))
+        print("Suita P131:", p131_chain("Q49368443"))
+        print("Şişli P131:", p131_chain("Q49371964"))

_scripts/viz_clean_raw.py ADDED Viewed

	@@ -0,0 +1,485 @@

+"""Visualizations for the raw Trip World dataset.
+Reads the parquet files directly (no derived dataset needed) and writes PDFs
+into  $TRIP_WORLD_ROOT/viz/.
+Figures
+-------
+1. city_poi_entropy_hist.pdf       — Shannon entropy of per-POI visit counts within each region (home vs OOT).
+2. city_user_entropy_hist.pdf      — entropy of check-ins distributed across users per region.
+3. checkins_per_city_top30.pdf     — top-30 regions by # check-ins, home/OOT stacked, with city names.
+4. trajectory_length_dist.pdf      — per-user check-in count histogram + CDF, home vs OOT.
+5. top_travel_pairs.pdf            — top-30 (home → OOT) pairs by # τ records.
+6. entropy_vs_size_scatter.pdf     — entropy vs # check-ins per region.
+7. world_poi_density.pdf           — global heatmap of POI density (log color scale).
+8. world_city_centroids.pdf        — per-city centroids, marker size ∝ # check-ins.
+9. world_travel_flows.pdf          — top-100 home → OOT flows as great-circle arcs.
+10. country_distribution.pdf       — # cities and # check-ins per country.
+Run:
+    python _scripts/viz_clean_raw.py
+"""
+import math
+import pickle
+from collections import Counter
+from pathlib import Path
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import cartopy.crs as ccrs
+import cartopy.feature as cfeature
+from matplotlib.colors import LogNorm
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+OUT_DIR = ROOT / "viz"
+OUT_DIR.mkdir(parents=True, exist_ok=True)
+def shannon(counts):
+    counts = np.asarray(counts, dtype=np.float64)
+    counts = counts[counts > 0]
+    if counts.size == 0:
+        return 0.0
+    p = counts / counts.sum()
+    return float(-(p * np.log2(p)).sum())
+def per_group_entropy(df, group_col, count_col):
+    """Return (group, total, n_unique, H, H_norm) per group."""
+    rows = []
+    for g, sub in df.groupby(group_col):
+        counts = sub[count_col].values
+        H = shannon(counts)
+        n_unique = (counts > 0).sum()
+        total = int(counts.sum())
+        H_uniform = math.log2(n_unique) if n_unique > 1 else 0.0
+        H_norm = H / H_uniform if H_uniform > 0 else 0.0
+        rows.append((g, total, int(n_unique), H, H_norm))
+    return pd.DataFrame(rows, columns=[group_col, "total", "n_unique", "H", "H_norm"])
+def add_world_features(ax):
+    ax.add_feature(cfeature.LAND.with_scale("110m"), facecolor="#f3f1ec", zorder=0)
+    ax.add_feature(cfeature.OCEAN.with_scale("110m"), facecolor="#dfeaf2", zorder=0)
+    ax.add_feature(cfeature.COASTLINE.with_scale("110m"), linewidth=0.4, color="#777777", zorder=1)
+    ax.add_feature(cfeature.BORDERS.with_scale("110m"), linewidth=0.3, color="#999999", zorder=1)
+    ax.set_global()
+def main():
+    print("[load] travel_behaviors")
+    tb = pd.read_parquet(ROOT / "travel_behaviors.parquet")
+    print(f"  rows={len(tb):,}, users={tb.user_id.nunique():,}, "
+          f"home regions={tb.r_h.nunique():,}, oot regions={tb.r_o.nunique():,}")
+    print("[load] pois")
+    pois = pd.read_parquet(ROOT / "pois.parquet")[["fsq_place_id", "locality", "n_checkins"]]
+    print(f"  rows={len(pois):,}")
+    print("[load] metadata_all  (for lat/lon)")
+    meta = pd.read_parquet(ROOT / "metadata/metadata_all.parquet",
+                           columns=["fsq_place_id", "fsq_latitude", "fsq_longitude"])
+    pois = pois.merge(meta, on="fsq_place_id", how="left")
+    print(f"  pois with coords: {pois['fsq_latitude'].notna().sum():,} / {len(pois):,}")
+    print("[load] region_labels")
+    region_labels = pd.read_parquet(ROOT / "region_labels.parquet")
+    region_name = dict(zip(region_labels["region_id"], region_labels["city_name"]))
+    region_country = dict(zip(region_labels["region_id"], region_labels["country_name"]))
+    # ------------------------------------------------------------------
+    # Build per-(region, venue) home/OOT visit counters by exploding c_h / c_o.
+    # ------------------------------------------------------------------
+    print("[derive] expanding c_h / c_o into per-checkin (region, venue, user) frame")
+    venue_to_locality = dict(zip(pois["fsq_place_id"], pois["locality"]))
+    def explode(df, c_col, r_col):
+        # Returns flat DataFrame: user_id, region, venue.
+        all_user, all_region, all_venue = [], [], []
+        # Faster than apply: iterate rows once.
+        for u, r, lst in zip(df["user_id"].values, df[r_col].values, df[c_col].values):
+            for ck in lst:
+                all_user.append(u)
+                all_region.append(r)
+                all_venue.append(ck["venue_id"])
+        return pd.DataFrame({"user_id": np.asarray(all_user, dtype=np.int64),
+                             "region": all_region,
+                             "venue": all_venue})
+    home_ck = explode(tb, "c_h", "r_h")
+    oot_ck = explode(tb, "c_o", "r_o")
+    print(f"  home check-ins: {len(home_ck):,}")
+    print(f"  oot  check-ins: {len(oot_ck):,}")
+    # ------------------------------------------------------------------
+    # 1) Per-region POI entropy (home and OOT separately).
+    # ------------------------------------------------------------------
+    print("[plot] city POI entropy")
+    home_poi_counts = (home_ck.groupby(["region", "venue"]).size()
+                              .reset_index(name="n"))
+    oot_poi_counts = (oot_ck.groupby(["region", "venue"]).size()
+                             .reset_index(name="n"))
+    home_poi_H = per_group_entropy(home_poi_counts, "region", "n")
+    oot_poi_H = per_group_entropy(oot_poi_counts, "region", "n")
+    # 2) Per-region user-activity entropy.
+    home_user_counts = (home_ck.groupby(["region", "user_id"]).size()
+                                .reset_index(name="n"))
+    oot_user_counts = (oot_ck.groupby(["region", "user_id"]).size()
+                               .reset_index(name="n"))
+    home_user_H = per_group_entropy(home_user_counts, "region", "n")
+    oot_user_H = per_group_entropy(oot_user_counts, "region", "n")
+    # Save CSVs for paper tables.
+    for df, name in [(home_poi_H, "home_poi_entropy"),
+                     (oot_poi_H, "oot_poi_entropy"),
+                     (home_user_H, "home_user_entropy"),
+                     (oot_user_H, "oot_user_entropy")]:
+        df = df.copy()
+        df["city_name"] = df["region"].map(region_name)
+        df["country"] = df["region"].map(region_country)
+        df.to_csv(OUT_DIR / f"{name}.csv", index=False)
+    # ---- Plot 1 ----
+    fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+    axes[0].hist(home_poi_H["H"], bins=40, alpha=0.6, color="#1f77b4",
+                 label=f"home (n={len(home_poi_H)})")
+    axes[0].hist(oot_poi_H["H"], bins=40, alpha=0.6, color="#d62728",
+                 label=f"oot (n={len(oot_poi_H)})")
+    axes[0].set_xlabel("Shannon entropy (bits) of POI visit distribution")
+    axes[0].set_ylabel("# regions")
+    axes[0].set_title("Raw POI entropy")
+    axes[0].legend()
+    axes[1].hist(home_poi_H["H_norm"], bins=40, alpha=0.6, color="#1f77b4", label="home")
+    axes[1].hist(oot_poi_H["H_norm"], bins=40, alpha=0.6, color="#d62728", label="oot")
+    axes[1].set_xlabel(r"Normalized entropy  $H/\log_2(n_{POIs})$  $\in [0,1]$")
+    axes[1].set_title("Normalized POI entropy")
+    axes[1].legend()
+    fig.suptitle("Per-region POI visit-distribution entropy", fontsize=12)
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "city_poi_entropy_hist.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ---- Plot 2 ----
+    fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+    axes[0].hist(home_user_H["H"], bins=40, alpha=0.6, color="#2ca02c", label="home")
+    axes[0].hist(oot_user_H["H"], bins=40, alpha=0.6, color="#9467bd", label="oot")
+    axes[0].set_xlabel("Entropy (bits) of check-ins across users")
+    axes[0].set_ylabel("# regions")
+    axes[0].set_title("Raw user-activity entropy")
+    axes[0].legend()
+    axes[1].hist(home_user_H["H_norm"], bins=40, alpha=0.6, color="#2ca02c", label="home")
+    axes[1].hist(oot_user_H["H_norm"], bins=40, alpha=0.6, color="#9467bd", label="oot")
+    axes[1].set_xlabel(r"Normalized entropy  $H/\log_2(n_{users})$  $\in [0,1]$")
+    axes[1].set_title("Normalized user-activity entropy")
+    axes[1].legend()
+    fig.suptitle("Per-region user-activity entropy (low = power-user dominance)", fontsize=12)
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "city_user_entropy_hist.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ------------------------------------------------------------------
+    # 3) Top-30 regions by total check-ins.
+    # ------------------------------------------------------------------
+    print("[plot] top-30 cities by check-ins")
+    home_per_region = home_ck.groupby("region").size().rename("home")
+    oot_per_region = oot_ck.groupby("region").size().rename("oot")
+    per_region = pd.concat([home_per_region, oot_per_region], axis=1).fillna(0).astype(np.int64)
+    per_region["total"] = per_region["home"] + per_region["oot"]
+    top30 = per_region.sort_values("total", ascending=False).head(30)
+    top30_labels = [f"{region_name.get(r, r)}\n({region_country.get(r, '?')})" for r in top30.index]
+    fig, ax = plt.subplots(figsize=(13, 6))
+    x = np.arange(len(top30))
+    ax.bar(x, top30["home"], color="#1f77b4", label="home check-ins")
+    ax.bar(x, top30["oot"], bottom=top30["home"], color="#d62728", label="OOT check-ins")
+    ax.set_xticks(x)
+    ax.set_xticklabels(top30_labels, rotation=60, ha="right", fontsize=7)
+    ax.set_ylabel("# check-ins")
+    ax.set_title("Top-30 regions by total check-ins (home + OOT)")
+    ax.legend()
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "checkins_per_city_top30.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ------------------------------------------------------------------
+    # 4) Per-user trajectory lengths.
+    # ------------------------------------------------------------------
+    print("[plot] trajectory lengths")
+    user_home = tb.groupby("user_id")["n_home_ci"].sum().values
+    user_oot = tb.groupby("user_id")["n_travel_ci"].sum().values
+    fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+    axes[0].hist(np.log10(user_home + 1), bins=60, alpha=0.6, color="#1f77b4", label="home")
+    axes[0].hist(np.log10(user_oot + 1), bins=60, alpha=0.6, color="#d62728", label="oot")
+    axes[0].set_xlabel(r"$\log_{10}$(# check-ins per user)")
+    axes[0].set_ylabel("# users")
+    axes[0].set_title("Per-user check-in count distribution")
+    axes[0].legend()
+    sh = np.sort(user_home)
+    so = np.sort(user_oot)
+    axes[1].plot(sh, np.arange(1, len(sh) + 1) / len(sh), color="#1f77b4", label="home")
+    axes[1].plot(so, np.arange(1, len(so) + 1) / len(so), color="#d62728", label="oot")
+    axes[1].set_xscale("log")
+    axes[1].set_xlabel("# check-ins per user")
+    axes[1].set_ylabel("CDF over users")
+    axes[1].set_title("Per-user check-in count CDF")
+    axes[1].legend()
+    fig.suptitle("How active is each user?", fontsize=12)
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "trajectory_length_dist.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ------------------------------------------------------------------
+    # 5) Top travel pairs.
+    # ------------------------------------------------------------------
+    print("[plot] top travel pairs")
+    pair_counts = (tb.groupby(["r_h", "r_o"]).size()
+                     .sort_values(ascending=False))
+    top_pairs = pair_counts.head(30)
+    pair_labels = [f"{region_name.get(h, h)} → {region_name.get(o, o)}"
+                   for (h, o) in top_pairs.index]
+    fig, ax = plt.subplots(figsize=(11, 7))
+    y = np.arange(len(top_pairs))
+    ax.barh(y, top_pairs.values, color="#ff7f0e")
+    ax.set_yticks(y)
+    ax.set_yticklabels(pair_labels, fontsize=8)
+    ax.invert_yaxis()
+    ax.set_xlabel("# τ travel-behavior records")
+    ax.set_title(f"Top-30 (home → OOT) pairs  (of {len(pair_counts):,} pairs total)")
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "top_travel_pairs.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ------------------------------------------------------------------
+    # 6) Entropy vs city size scatter.
+    # ------------------------------------------------------------------
+    print("[plot] entropy vs size scatter")
+    fig, axes = plt.subplots(1, 2, figsize=(11, 4))
+    axes[0].scatter(home_poi_H["total"], home_poi_H["H_norm"], s=8, alpha=0.4,
+                    color="#1f77b4", label="home")
+    axes[0].scatter(oot_poi_H["total"], oot_poi_H["H_norm"], s=8, alpha=0.4,
+                    color="#d62728", label="oot")
+    axes[0].set_xscale("log")
+    axes[0].set_xlabel("# check-ins in region")
+    axes[0].set_ylabel("Normalized POI entropy")
+    axes[0].set_title("POI entropy vs region size")
+    axes[0].legend()
+    axes[1].scatter(home_user_H["total"], home_user_H["H_norm"], s=8, alpha=0.4,
+                    color="#2ca02c", label="home")
+    axes[1].scatter(oot_user_H["total"], oot_user_H["H_norm"], s=8, alpha=0.4,
+                    color="#9467bd", label="oot")
+    axes[1].set_xscale("log")
+    axes[1].set_xlabel("# check-ins in region")
+    axes[1].set_ylabel("Normalized user-activity entropy")
+    axes[1].set_title("User entropy vs region size")
+    axes[1].legend()
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "entropy_vs_size_scatter.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ------------------------------------------------------------------
+    # 7) World POI density heatmap.
+    # ------------------------------------------------------------------
+    print("[plot] world POI density")
+    poi_coord = pois.dropna(subset=["fsq_latitude", "fsq_longitude"]).copy()
+    poi_coord["weight"] = poi_coord["n_checkins"].astype(np.float64)
+    fig = plt.figure(figsize=(13, 6.5))
+    ax = plt.axes(projection=ccrs.Robinson())
+    add_world_features(ax)
+    h, xedges, yedges = np.histogram2d(
+        poi_coord["fsq_longitude"].values,
+        poi_coord["fsq_latitude"].values,
+        bins=[np.arange(-180, 181, 1), np.arange(-90, 91, 1)],
+        weights=poi_coord["weight"].values,
+    )
+    h = h.T
+    h_masked = np.ma.masked_where(h == 0, h)
+    mesh = ax.pcolormesh(
+        xedges, yedges, h_masked, cmap="magma_r",
+        norm=LogNorm(vmin=1, vmax=h_masked.max()),
+        transform=ccrs.PlateCarree(), zorder=2,
+    )
+    cbar = fig.colorbar(mesh, ax=ax, orientation="horizontal", pad=0.04, shrink=0.7)
+    cbar.set_label("Total check-ins per 1° × 1° cell (log scale)")
+    ax.set_title(f"Global check-in density  (n_POIs = {len(poi_coord):,}; "
+                 f"check-ins = {int(poi_coord['weight'].sum()):,})")
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "world_poi_density.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ------------------------------------------------------------------
+    # 8) City centroids.
+    # ------------------------------------------------------------------
+    print("[plot] city centroids")
+    pc = poi_coord.copy()
+    pc["lat_w"] = pc["fsq_latitude"] * pc["weight"]
+    pc["lon_w"] = pc["fsq_longitude"] * pc["weight"]
+    centroid_agg = pc.groupby("locality").agg(
+        lat=("lat_w", "sum"),
+        lon=("lon_w", "sum"),
+        weight=("weight", "sum"),
+    )
+    centroid_agg["lat"] = centroid_agg["lat"] / centroid_agg["weight"]
+    centroid_agg["lon"] = centroid_agg["lon"] / centroid_agg["weight"]
+    home_set = set(per_region.index[per_region["home"] > 0])
+    oot_set = set(per_region.index[per_region["oot"] > 0])
+    both = home_set & oot_set
+    only_home = home_set - oot_set
+    only_oot = oot_set - home_set
+    rows = []
+    for r in centroid_agg.index:
+        n_h = int(per_region.loc[r, "home"]) if r in per_region.index else 0
+        n_o = int(per_region.loc[r, "oot"]) if r in per_region.index else 0
+        if r in both:      kind = "both"
+        elif r in only_home: kind = "home only"
+        elif r in only_oot:  kind = "oot only"
+        else:                continue
+        rows.append((r, centroid_agg.loc[r, "lat"], centroid_agg.loc[r, "lon"],
+                     n_h + n_o, kind))
+    cents = pd.DataFrame(rows, columns=["region", "lat", "lon", "n", "kind"])
+    fig = plt.figure(figsize=(13, 6.5))
+    ax = plt.axes(projection=ccrs.Robinson())
+    add_world_features(ax)
+    SIZE_SCALE = 1.5
+    sizes = SIZE_SCALE * np.sqrt(cents["n"].values)
+    palette = {"both": "#2ca02c", "home only": "#1f77b4", "oot only": "#d62728"}
+    # 1. Plot the real data WITHOUT label= so the legend doesn't auto-pick a
+    #    representative marker size that differs across kinds.
+    for kind, color in palette.items():
+        m = cents["kind"] == kind
+        ax.scatter(
+            cents.loc[m, "lon"], cents.loc[m, "lat"],
+            s=sizes[m], c=color, alpha=0.55,
+            edgecolor="black", linewidth=0.2,
+            transform=ccrs.PlateCarree(), zorder=3,
+        )
+    # 2. Empty proxy scatters at a fixed marker size for the kind legend so
+    #    all three swatches render identically.
+    KIND_LEGEND_S = 60
+    for kind, color in palette.items():
+        n = int((cents["kind"] == kind).sum())
+        ax.scatter([], [], s=KIND_LEGEND_S, c=color, alpha=0.55,
+                   edgecolor="black", linewidth=0.2,
+                   label=f"{kind}  (n={n})",
+                   transform=ccrs.PlateCarree())
+    # 3. Size-reference proxies (these are intentionally size-varying — they
+    #    are the *legend's purpose*, not category swatches).
+    for ref_n, lbl in [(500, "500"), (10_000, "10K"), (100_000, "100K")]:
+        ax.scatter([], [], s=SIZE_SCALE * np.sqrt(ref_n), c="grey", alpha=0.55,
+                   edgecolor="black", linewidth=0.2,
+                   label=f"≈ {lbl} check-ins", transform=ccrs.PlateCarree())
+    ax.legend(loc="lower left", fontsize=8, frameon=True, ncol=2)
+    ax.set_title(f"Region coverage  ({len(cents):,} regions)")
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "world_city_centroids.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ------------------------------------------------------------------
+    # 9) Top-100 travel flows.
+    # ------------------------------------------------------------------
+    print("[plot] world travel flows")
+    cent_lat = centroid_agg["lat"].to_dict()
+    cent_lon = centroid_agg["lon"].to_dict()
+    top_flows = pair_counts.head(100)
+    fig = plt.figure(figsize=(13, 6.5))
+    ax = plt.axes(projection=ccrs.Robinson())
+    add_world_features(ax)
+    max_n = int(top_flows.max())
+    cmap = plt.get_cmap("plasma")
+    n_drawn = 0
+    for (h, o), n in top_flows.items():
+        if h not in cent_lat or o not in cent_lat:
+            continue
+        a = (cent_lat[h], cent_lon[h])
+        b = (cent_lat[o], cent_lon[o])
+        lw = 0.4 + 2.5 * (n / max_n)
+        color = cmap(n / max_n)
+        ax.plot([a[1], b[1]], [a[0], b[0]],
+                transform=ccrs.Geodetic(),
+                color=color, alpha=0.65, linewidth=lw, zorder=2)
+        ax.scatter([a[1], b[1]], [a[0], b[0]], s=4, c="black",
+                   transform=ccrs.PlateCarree(), zorder=3)
+        n_drawn += 1
+    sm = plt.cm.ScalarMappable(cmap=cmap,
+                               norm=plt.Normalize(vmin=int(top_flows.min()), vmax=max_n))
+    sm.set_array([])
+    cbar = fig.colorbar(sm, ax=ax, orientation="horizontal", pad=0.04, shrink=0.7)
+    cbar.set_label("# τ travel records on this (home → OOT) pair")
+    ax.set_title(f"Top-{n_drawn} home → OOT travel flows  "
+                 f"(of {len(pair_counts):,} pairs total)")
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "world_travel_flows.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ------------------------------------------------------------------
+    # 10) Country distribution.
+    # ------------------------------------------------------------------
+    print("[plot] country distribution")
+    region_country_series = pd.Series(region_country, name="country")
+    cities_per_country = region_country_series.value_counts().sort_values(ascending=False)
+    region_total = per_region["total"].rename("total")
+    rc_df = region_total.to_frame().join(region_country_series, how="left")
+    checkins_per_country = (rc_df.groupby("country")["total"].sum()
+                                  .reindex(cities_per_country.index)
+                                  .fillna(0))
+    cap = 20  # too many countries — show top-20 in each panel
+    cpc = cities_per_country.head(cap)
+    chk = checkins_per_country.head(cap)
+    fig, axes = plt.subplots(1, 2, figsize=(13, 5.5))
+    axes[0].barh(cpc.index[::-1], cpc.values[::-1], color="#17becf")
+    axes[0].set_xlabel("# regions in this dataset")
+    axes[0].set_title(f"Top-{cap} countries by # regions  (total countries = {len(cities_per_country)})")
+    axes[0].tick_params(axis="y", labelsize=8)
+    axes[1].barh(chk.index[::-1], chk.values[::-1], color="#bcbd22")
+    axes[1].set_xlabel("# check-ins (home + OOT)")
+    axes[1].set_title("Top-20 countries by # check-ins")
+    axes[1].tick_params(axis="y", labelsize=8)
+    axes[1].set_xscale("log")
+    fig.tight_layout()
+    fig.savefig(OUT_DIR / "country_distribution.pdf", bbox_inches="tight")
+    plt.close(fig)
+    # ------------------------------------------------------------------
+    print()
+    print(f"figures saved to: {OUT_DIR}")
+    for p in sorted(OUT_DIR.glob("*.pdf")):
+        print(f"  {p.name}")
+    print()
+    print("== quick stats ==")
+    print(f"τ records: {len(tb):,}  ({tb.user_id.nunique():,} distinct users)")
+    print(f"home check-ins: {len(home_ck):,}  oot check-ins: {len(oot_ck):,}")
+    print(f"regions home: {len(home_set):,}  oot: {len(oot_set):,}  both: {len(both):,}  "
+          f"only-home: {len(only_home):,}  only-oot: {len(only_oot):,}")
+    print(f"unique (home → oot) pairs: {len(pair_counts):,}")
+    print(f"home POI entropy median  H_norm = {home_poi_H['H_norm'].median():.3f}")
+    print(f"oot  POI entropy median  H_norm = {oot_poi_H['H_norm'].median():.3f}")
+    print(f"home user-act entropy median  H_norm = {home_user_H['H_norm'].median():.3f}")
+    print(f"oot  user-act entropy median  H_norm = {oot_user_H['H_norm'].median():.3f}")
+if __name__ == "__main__":
+    main()

_scripts/viz_traj_length.py ADDED Viewed

	@@ -0,0 +1,104 @@

+"""Trajectory length distribution for Trip World.
+A *trajectory* is one trail_id — a single session of consecutive check-ins.
+Each travel-behavior row in travel_behaviors.parquet bundles many trails
+(median ~12 hometown trails + ~2 OOT trails per τ record), so to get
+honest trajectory lengths we explode c_h and c_o by trail_id and count
+check-ins per trail.
+Output:  viz/trajectory_length.pdf
+Run:     python _scripts/viz_traj_length.py
+"""
+from pathlib import Path
+import numpy as np
+import pandas as pd
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import os
+ROOT = Path(os.environ.get("TRIP_WORLD_ROOT", Path(__file__).resolve().parent.parent))
+OUT_DIR = ROOT / "viz"
+OUT_DIR.mkdir(parents=True, exist_ok=True)
+def trail_lengths(arrays):
+    """Walk a column of c_h / c_o object arrays and emit the per-trail
+    check-in counts, **deduplicated globally by trail_id**.
+    The same hometown trail typically appears inside many τ records (one
+    per distinct destination the same user travels to). We count each
+    trail's length once. Within a single τ record, all check-ins sharing a
+    trail_id together form that trail."""
+    trail_to_len = {}
+    cur = {}
+    for lst in arrays:
+        cur.clear()
+        for ck in lst:
+            tid = ck["trail_id"]
+            cur[tid] = cur.get(tid, 0) + 1
+        for tid, n in cur.items():
+            trail_to_len[tid] = n
+    return np.fromiter(trail_to_len.values(), dtype=np.int64, count=len(trail_to_len))
+def main():
+    print("[load] travel_behaviors  (c_h, c_o) — exploding by trail_id")
+    tb = pd.read_parquet(ROOT / "travel_behaviors.parquet",
+                         columns=["c_h", "c_o"])
+    print(f"  τ records: {len(tb):,}")
+    h = trail_lengths(tb["c_h"].values)
+    o = trail_lengths(tb["c_o"].values)
+    print(f"  hometown trails: {len(h):,}  median={int(np.median(h))}  mean={h.mean():.2f}  "
+          f"p10={int(np.percentile(h,10))}  p90={int(np.percentile(h,90))}  max={h.max()}")
+    print(f"  OOT      trails: {len(o):,}  median={int(np.median(o))}  mean={o.mean():.2f}  "
+          f"p10={int(np.percentile(o,10))}  p90={int(np.percentile(o,90))}  max={o.max()}")
+    HOME = "#1f77b4"
+    TRIP = "#d62728"
+    home_label = f"Hometown trajectories  (n={len(h):,}, median {int(np.median(h))})"
+    trip_label = f"OOT trajectories  (n={len(o):,}, median {int(np.median(o))})"
+    fig, ax = plt.subplots(figsize=(7, 4.2))
+    # Integer-length, side-by-side bars. Lengths 1..CAP get their own
+    # bar pair; everything past CAP is folded into a single ">CAP" pair.
+    CAP = 10
+    lengths = np.arange(1, CAP + 1)
+    h_counts = np.array([(h == L).sum() for L in lengths] + [(h > CAP).sum()])
+    o_counts = np.array([(o == L).sum() for L in lengths] + [(o > CAP).sum()])
+    x = np.arange(len(h_counts))
+    width = 0.4
+    ax.bar(x - width / 2, h_counts, width, color=HOME, label=home_label)
+    ax.bar(x + width / 2, o_counts, width, color=TRIP, label=trip_label)
+    ax.set_xticks(x)
+    ax.set_xticklabels([str(L) for L in lengths] + [f">{CAP}"])
+    ax.set_xlabel("Number of check-ins")
+    ax.set_ylabel("Number of trajectories")
+    ax.set_title("Trajectory length distribution")
+    ax.legend()
+    fig.tight_layout()
+    print(f"  > {CAP} check-ins:  hometown {(h > CAP).sum():,} / {len(h):,} "
+          f"({(h > CAP).mean()*100:.2f}%);  "
+          f"oot {(o > CAP).sum():,} / {len(o):,} "
+          f"({(o > CAP).mean()*100:.2f}%)")
+    out = OUT_DIR / "trajectory_length.pdf"
+    fig.savefig(out, bbox_inches="tight")
+    plt.close(fig)
+    # Drop the older versions if they're around, so only one canonical file remains.
+    for old_name in ("trajectory_length_per_tau.pdf",
+                     "trajectory_length_per_trip.pdf",
+                     "trajectory_length_per_trajectory.pdf"):
+        old = OUT_DIR / old_name
+        if old.exists():
+            old.unlink()
+    print(f"\nsaved: {out}")
+if __name__ == "__main__":
+    main()

metadata/metadata_all.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:20c8affe6092df1202074e4458672a57e77d96505ede4fb63fa65b0b3d0b22d3
+size 119796103

metadata/place_attributes.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:4c31fda0a865c6773ff4067bb20ebd16c2ffde8925ded0da3b26d322d942c3b8
+size 5580621

metro_mapping_clean.json ADDED Viewed

The diff for this file is too large to render. See raw diff

pois.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:43c3d385700ca050bb1b109ab98481dddce85150b4a8f1cc455fa4994b8f3f0e
+size 69707931

region_labels.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:98134206f3ae04366de219e181380a5c9c302873391ccc9109fa491fe9f11c59
+size 19217

reviews/reviews_all.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:60aa08489743419a26475a842398040dfdc9a508572cb51aa19e864966f10a7c
+size 23400867153

travel_behaviors.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:59d473611daca78404fda149832012562e11469cd0339094c92d2f86d4655034
+size 151509028