geodb-rs 0.1.4__tar.gz → 0.1.5__tar.gz

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/Cargo.lock

@@ -165,9 +165,9 @@ checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 
 [[package]]
 name = "borsh"
-version = "1.5.7"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad8646f98db542e39fc66e68a20b2144f6a732636df7c2354e74645faaa433ce"
+checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f"
 dependencies = [
  "cfg_aliases",
 ]
@@ -224,9 +224,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.47"
+version = "1.2.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd405d82c84ff7f35739f175f67d8b9fb7687a0e84ccdc78bd3568839827cf07"
+checksum = "90583009037521a116abf44494efecd645ba48b6622457080f080b85544e2215"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -461,12 +461,6 @@ dependencies = [
  "miniz_oxide",
 ]
 
-[[package]]
-name = "fnv"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
 [[package]]
 name = "form_urlencoded"
 version = "1.2.2"
@@ -537,7 +531,7 @@ dependencies = [
 
 [[package]]
 name = "geodb-cli"
-version = "0.1.4"
+version = "0.1.5"
 dependencies = [
  "anyhow",
  "clap",
@@ -546,7 +540,7 @@ dependencies = [
 
 [[package]]
 name = "geodb-core"
-version = "0.1.4"
+version = "0.1.5"
 dependencies = [
  "bincode",
  "criterion",
@@ -562,7 +556,7 @@ dependencies = [
 
 [[package]]
 name = "geodb-ffi"
-version = "0.1.4"
+version = "0.1.5"
 dependencies = [
  "bincode",
  "flate2",
@@ -574,7 +568,7 @@ dependencies = [
 
 [[package]]
 name = "geodb-py"
-version = "0.1.4"
+version = "0.1.5"
 dependencies = [
  "geodb-core",
  "pyo3",
@@ -585,14 +579,14 @@ dependencies = [
 
 [[package]]
 name = "geodb-rs"
-version = "0.1.4"
+version = "0.1.5"
 dependencies = [
  "geodb-core",
 ]
 
 [[package]]
 name = "geodb-wasm"
-version = "0.1.4"
+version = "0.1.5"
 dependencies = [
  "bincode",
  "console_error_panic_hook",
@@ -676,12 +670,11 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "http"
-version = "1.3.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
 dependencies = [
  "bytes",
- "fnv",
  "itoa",
 ]
 
@@ -754,9 +747,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-util"
-version = "0.1.18"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52e9a2a24dc5c6821e71a7030e1e14b7b632acac55c40e9d2e082c621261bb56"
+checksum = "727805d60e7938b76b826a6ef209eb70eaa1812794f9424d4a4e2d740662df5f"
 dependencies = [
  "base64",
  "bytes",
@@ -948,9 +941,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.177"
+version = "0.2.178"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
 
 [[package]]
 name = "linux-raw-sys"
@@ -966,9 +959,9 @@ checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
 
 [[package]]
 name = "log"
-version = "0.4.28"
+version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lru-slab"
@@ -993,9 +986,9 @@ dependencies = [
 
 [[package]]
 name = "minicov"
-version = "0.3.7"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f27fe9f1cc3c22e1687f9446c2083c4c5fc7f0bcf1c7a86bdbded14985895b4b"
+checksum = "4869b6a491569605d66d3952bcdf03df789e5b536e5f0cf7758a7f08a55ae24d"
 dependencies = [
  "cc",
  "walkdir",
@@ -1019,9 +1012,9 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
 dependencies = [
  "libc",
  "wasi",
@@ -1450,9 +1443,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.13.0"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94182ad936a0c91c324cd46c6511b9510ed16af436d7b5bab34beab0afd55f7a"
+checksum = "708c0f9d5f54ba0272468c1d306a52c495b31fa155e91bc25371e6df7996908c"
 dependencies = [
  "web-time",
  "zeroize",
@@ -1603,9 +1596,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "simd-adler32"
-version = "0.3.7"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[package]]
 name = "siphasher"
@@ -1677,9 +1670,9 @@ checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
 name = "syn"
-version = "2.0.110"
+version = "2.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1889,9 +1882,9 @@ dependencies = [
 
 [[package]]
 name = "tower-http"
-version = "0.6.6"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adc82fd73de2a9722ac5da747f12383d2bfdb93591ee6c58486e0097890f05f2"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
 dependencies = [
  "bitflags",
  "bytes",
@@ -1919,9 +1912,9 @@ checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
 
 [[package]]
 name = "tracing"
-version = "0.1.41"
+version = "0.1.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "784e0ac535deb450455cbfa28a6f0df145ea1bb7ae51b821cf5e7927fdcfbdd0"
+checksum = "2d15d90a0b5c19378952d479dc858407149d7bb45a14de0142f6c534b16fc647"
 dependencies = [
  "pin-project-lite",
  "tracing-core",
@@ -1929,9 +1922,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-core"
-version = "0.1.34"
+version = "0.1.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d12581f227e93f094d3af2ae690a574abb8a2b9b7a96e7cfe9647b2b617678"
+checksum = "7a04e24fab5c89c6a36eb8558c9656f30d81de51dfa4d3b45f26b21d61fa0a6c"
 dependencies = [
  "once_cell",
 ]
@@ -2444,9 +2437,9 @@ checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
 
 [[package]]
 name = "winnow"
-version = "0.7.13"
+version = "0.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
 dependencies = [
  "memchr",
 ]
@@ -2488,18 +2481,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.28"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43fa6694ed34d6e57407afbccdeecfa268c470a7d2a5b0cf49ce9fcc345afb90"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.28"
+version = "0.8.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c640b22cd9817fae95be82f0d2f90b11f7605f6c319d16705c459b27ac2cbc26"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
 dependencies = [
  "proc-macro2",
  "quote",

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/Cargo.toml

@@ -1,17 +1,25 @@
+
 [package]
 name = "geodb-rs"
-version = "0.1.4"
-edition = "2021"
+version.workspace = true
+edition.workspace = true
 publish = false
-license = "MIT"
+license.workspace = true
 description = "Workspace crate for geodb-core and geodb-wasm; hosts examples and dev tooling."
-repository = "https://github.com/holg/geodb-rs"
+repository.workspace = true
 readme = "README.md"
 [workspace]
 members = ["crates/geodb-py"]
 
 resolver = "2"
 
+[workspace.package]
+version = "0.1.5"
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/holg/geodb-rs"
+authors = ["Holger Trahe"]
+
 [workspace.dependencies]
 bincode = "1"
 deunicode = "1.6"
@@ -22,7 +30,7 @@ serde = { version = "1", features = ["derive"] }
 serde-wasm-bindgen = "0.6"
 serde_json = { version = "1" }
 thiserror = "1"
-wasm-bindgen = "0.2"
+wasm-bindgen = "=0.2.105"  # Pinned to match trunk 0.21.14's bundled wasm-bindgen-cli
 web-sys = { version = "0.3", features = ["console"] }
 
 [dependencies]

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geodb-rs
-Version: 0.1.4
+Version: 0.1.5
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/crates/geodb-core/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "geodb-core"
-version = "0.1.4"
-edition = "2021"
-authors = ["Holger Trahe"]
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
 license = "MIT OR Apache-2.0"
 description = "A high-performance geographic database with countries, states, cities, and more"
-repository = "https://github.com/holg/geodb-rs"
+repository.workspace = true
 readme = "README.md"
 documentation = "https://docs.rs/geodb-core"
 keywords = ["geography", "database", "countries", "cities", "geo"]

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/crates/geodb-core/src/legacy_model/search.rs

@@ -1,12 +1,12 @@
 // crates/geodb-core/src/legacy_model/search.rs
 
-use crate::traits::CityContext;
 use crate::alias::CityMetaIndex;
 use crate::common::{DbStats, SmartHitGeneric};
 use crate::legacy_model::nested::{City, Country, GeoDb, State};
-use crate::spatial::{decode_geoid, haversine_distance, distance_squared};
+use crate::spatial::{decode_geoid, distance_squared, haversine_distance};
 #[allow(unused_imports)]
 use crate::text::{fold_key, match_score};
+use crate::traits::CityContext;
 use crate::traits::{GeoBackend, GeoSearch};
 use std::collections::HashSet;
 type MySmartHit<'a, B> = SmartHitGeneric<'a, Country<B>, State<B>, City<B>>;
@@ -525,7 +525,11 @@ impl<B: GeoBackend> GeoSearch<B> for GeoDb<B> {
 
     // crates/geodb-core/src/legacy_model/search.rs
 
-    fn find_cities_in_radius_by_geoid(&self, geoid: u64, radius_km: f64) -> Vec<CityContext<'_, B>> {
+    fn find_cities_in_radius_by_geoid(
+        &self,
+        geoid: u64,
+        radius_km: f64,
+    ) -> Vec<CityContext<'_, B>> {
         let (center_lat, center_lng) = decode_geoid(geoid);
 
         // BBox calc (Same as above)
@@ -556,8 +560,12 @@ impl<B: GeoBackend> GeoSearch<B> for GeoDb<B> {
             }
         }
 
-        candidates.sort_unstable_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
-        candidates.into_iter().map(|(_, city, state, country)| (city, state, country)).collect()
+        candidates
+            .sort_unstable_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
+        candidates
+            .into_iter()
+            .map(|(_, city, state, country)| (city, state, country))
+            .collect()
     }
 
     // ... (Ensure enrich_with_city_meta is present as a no-op or todo) ...

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/crates/geodb-core/src/model/convert.rs

@@ -1,7 +1,7 @@
 // crates/geodb-core/src/model/convert.rs
-use crate::spatial::generate_geoid;
 use crate::alias::CityMetaIndex;
 use crate::common::raw::CountryRaw;
+use crate::spatial::generate_geoid;
 // Import CountryTimezone so we can construct it
 use crate::model::flat::{City, Country, CountryTimezone, GeoDb, State};
 use crate::traits::GeoBackend;
@@ -20,7 +20,7 @@ pub fn from_raw<B: GeoBackend>(
         countries: Vec::new(),
         states: Vec::new(),
         cities: Vec::new(),
-        spatial_index: Vec::new()
+        spatial_index: Vec::new(),
     };
 
     for c_raw in raw_countries {
@@ -138,8 +138,16 @@ pub fn from_raw<B: GeoBackend>(
                 // ---------------------------------------------------------
                 // SPATIAL INDEX LOGIC
                 // ---------------------------------------------------------
-                let lat = city_raw.latitude.as_deref().and_then(|s| s.parse::<f64>().ok()).unwrap_or(0.0);
-                let lng = city_raw.longitude.as_deref().and_then(|s| s.parse::<f64>().ok()).unwrap_or(0.0);
+                let lat = city_raw
+                    .latitude
+                    .as_deref()
+                    .and_then(|s| s.parse::<f64>().ok())
+                    .unwrap_or(0.0);
+                let lng = city_raw
+                    .longitude
+                    .as_deref()
+                    .and_then(|s| s.parse::<f64>().ok())
+                    .unwrap_or(0.0);
 
                 // Only index valid coordinates (0.0 is technically valid but "Null Island", acceptable)
                 let geoid = generate_geoid(lat, lng);
@@ -156,11 +164,19 @@ pub fn from_raw<B: GeoBackend>(
                     search_blob: city_search_blob,
                     aliases,
                     regions,
-                    lat: if lat != 0.0 { Some(B::float_from(lat)) } else { None },
-                    lng: if lng != 0.0 { Some(B::float_from(lng)) } else { None },
+                    lat: if lat != 0.0 {
+                        Some(B::float_from(lat))
+                    } else {
+                        None
+                    },
+                    lng: if lng != 0.0 {
+                        Some(B::float_from(lng))
+                    } else {
+                        None
+                    },
                     population: city_raw.id.map(|p| p as u32),
                     timezone: city_raw.timezone.map(|s| B::str_from(&s)),
-                    geoid
+                    geoid,
                 });
             }
 

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/crates/geodb-core/src/model/search.rs

@@ -1,12 +1,12 @@
 // crates/geodb-core/src/model/search.rs
-use crate::traits::CityContext;
-use crate::spatial::{generate_geoid, decode_geoid, haversine_distance};
 use crate::alias::CityMetaIndex;
 use crate::common::{DbStats, SmartHitGeneric};
 use crate::model::flat::{City, Country, GeoDb, State};
+use crate::spatial::{decode_geoid, generate_geoid, haversine_distance};
 use crate::text::fold_key;
 #[cfg(not(feature = "search_blobs"))]
 use crate::text::match_score;
+use crate::traits::CityContext;
 use crate::traits::{CitiesIter, GeoBackend, GeoSearch};
 
 type MySmartHit<'a, B> = SmartHitGeneric<'a, Country<B>, State<B>, City<B>>;
@@ -26,10 +26,10 @@ impl<B: GeoBackend> GeoSearch<B> for GeoDb<B> {
 
     fn cities<'a>(&'a self) -> CitiesIter<'a, B> {
         // Reconstruct hierarchy on the fly using IDs
-        let iter = self.cities.iter().map(move |city| {
-            let state = &self.states[city.state_id as usize];
-            let country = &self.countries[city.country_id as usize];
-            (city, state, country)
+        let iter = self.cities.iter().filter_map(move |city| {
+            let state = self.states.get(city.state_id as usize)?;
+            let country = self.countries.get(city.country_id as usize)?;
+            Some((city, state, country))
         });
         Box::new(iter)
     }
@@ -57,7 +57,7 @@ impl<B: GeoBackend> GeoSearch<B> for GeoDb<B> {
         }
     }
 
-     fn find_country_by_iso2(&self, iso2: &str) -> Option<&Country<B>> {
+    fn find_country_by_iso2(&self, iso2: &str) -> Option<&Country<B>> {
         self.countries
             .iter()
             .find(|c| c.iso2.as_ref().eq_ignore_ascii_case(iso2))
@@ -371,7 +371,8 @@ impl<B: GeoBackend> GeoSearch<B> for GeoDb<B> {
                 (dist_metric, city)
             })
             .collect();
-        candidates.sort_unstable_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
+        candidates
+            .sort_unstable_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
         // candidates.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
         candidates
             .into_iter()
@@ -385,7 +386,11 @@ impl<B: GeoBackend> GeoSearch<B> for GeoDb<B> {
     }
     // crates/geodb-core/src/model/search.rs
 
-    fn find_cities_in_radius_by_geoid(&self, geoid: u64, radius_km: f64) -> Vec<CityContext<'_, B>> {
+    fn find_cities_in_radius_by_geoid(
+        &self,
+        geoid: u64,
+        radius_km: f64,
+    ) -> Vec<CityContext<'_, B>> {
         // 1. Decode Center
         let (center_lat, center_lng) = decode_geoid(geoid);
 
@@ -411,7 +416,6 @@ impl<B: GeoBackend> GeoSearch<B> for GeoDb<B> {
 
             // BBox Filter (Fast float comparisons)
             if lat >= min_lat && lat <= max_lat && lng >= min_lng && lng <= max_lng {
-
                 // Precise Distance (Expensive Trig)
                 let dist = haversine_distance(center_lat, center_lng, lat, lng);
 
@@ -425,9 +429,13 @@ impl<B: GeoBackend> GeoSearch<B> for GeoDb<B> {
         }
 
         // 4. Sort by Distance
-        candidates.sort_unstable_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
+        candidates
+            .sort_unstable_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
 
         // 5. Strip distance and return context
-        candidates.into_iter().map(|(_, city, s, c)| (city, s, c)).collect()
+        candidates
+            .into_iter()
+            .map(|(_, city, s, c)| (city, s, c))
+            .collect()
     }
 }

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/crates/geodb-core/src/spatial.rs

@@ -34,9 +34,8 @@ pub fn haversine_distance(lat1: f64, lng1: f64, lat2: f64, lng2: f64) -> f64 {
     let lat1_rad = lat1.to_radians();
     let lat2_rad = lat2.to_radians();
 
-    let a = (d_lat / 2.0).sin().powi(2) +
-        lat1_rad.cos() * lat2_rad.cos() *
-            (d_lng / 2.0).sin().powi(2);
+    let a =
+        (d_lat / 2.0).sin().powi(2) + lat1_rad.cos() * lat2_rad.cos() * (d_lng / 2.0).sin().powi(2);
 
     let c = 2.0 * a.sqrt().atan2((1.0 - a).sqrt());
     r * c
@@ -100,8 +99,14 @@ mod tests {
 
         // Precision loss is expected due to u32 quantization, but should be small
         let epsilon = 0.0001;
-        assert!((lat - lat_out).abs() < epsilon, "Lat mismatch: {lat} vs {lat_out}");
-        assert!((lng - lng_out).abs() < epsilon, "Lng mismatch: {lng} vs {lng_out}");
+        assert!(
+            (lat - lat_out).abs() < epsilon,
+            "Lat mismatch: {lat} vs {lat_out}"
+        );
+        assert!(
+            (lng - lng_out).abs() < epsilon,
+            "Lng mismatch: {lng} vs {lng_out}"
+        );
     }
 
     #[test]
@@ -116,6 +121,9 @@ mod tests {
         let diff_near = berlin.abs_diff(potsdam);
         let diff_far = berlin.abs_diff(nyc);
 
-        assert!(diff_near < diff_far, "Nearby cities should have closer IDs in general");
+        assert!(
+            diff_near < diff_far,
+            "Nearby cities should have closer IDs in general"
+        );
     }
-}
+}

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/crates/geodb-core/src/traits.rs

@@ -175,7 +175,8 @@ pub trait GeoSearch<B: GeoBackend> {
     ///
     /// 1. Decodes the GeoID to find the center.
     /// 2. Scans for cities within the radius.
-    fn find_cities_in_radius_by_geoid(&self, geoid: u64, radius_km: f64) -> Vec<CityContext<'_, B>>;
+    fn find_cities_in_radius_by_geoid(&self, geoid: u64, radius_km: f64)
+        -> Vec<CityContext<'_, B>>;
 }
 
 pub trait CountryTimezone<B: GeoBackend> {}

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/crates/geodb-py/Cargo.toml

@@ -1,11 +1,13 @@
 [package]
 name = "geodb-py"
-version = "0.1.4"
-edition = "2021"
+# NOTE: Maturin uses this version directly for PyPI, so we keep it explicit
+# rather than using workspace inheritance to avoid any maturin compatibility issues
+version = "0.1.5"
+edition.workspace = true
 description = "Python bindings for geodb-rs"
-license = "MIT"
-authors = ["Holger Trahe"]
-repository = "https://github.com/holg/geodb-rs"
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
 homepage = "https://github.com/holg/geodb-rs"
 readme = "README.md"
 keywords = ["geodb", "geo", "countries", "regions", "cities"]

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/crates/geodb-py/src/lib.rs

@@ -77,8 +77,13 @@ impl PyGeoDb {
     }
 
     #[staticmethod]
-    pub fn load_from_path(path: &str, filter:Option<&[&str]>) -> PyResult<Self> {
-        let db = GeoDb::<DefaultBackend>::load_from_path(&path, filter).into_py()?;
+    #[pyo3(signature = (path, filter=None))]
+    pub fn load_from_path(path: &str, filter: Option<Vec<String>>) -> PyResult<Self> {
+        let filter_refs: Option<Vec<&str>> = filter
+            .as_ref()
+            .map(|v| v.iter().map(|s| s.as_str()).collect());
+        let filter_slice: Option<&[&str]> = filter_refs.as_deref();
+        let db = GeoDb::<DefaultBackend>::load_from_path(path, filter_slice).into_py()?;
         Ok(Self { inner: db })
     }
 
@@ -87,7 +92,9 @@ impl PyGeoDb {
         // Try bundled data first
         match find_bundled_data() {
             Ok(path) => {
-                let path_str = path.to_str().ok_or_else(|| PyRuntimeError::new_err("Invalid path"))?;
+                let path_str = path
+                    .to_str()
+                    .ok_or_else(|| PyRuntimeError::new_err("Invalid path"))?;
                 // Note: load_raw_json builds cache automatically if 'builder' enabled
                 // load_from_path handles both .json and .bin
                 let db = GeoDb::<DefaultBackend>::load_from_path(path_str, None).into_py()?;
@@ -103,7 +110,10 @@ impl PyGeoDb {
 
     #[staticmethod]
     pub fn load_filtered(iso2_list: Vec<String>) -> PyResult<Self> {
-        let tmp: Vec<String> = iso2_list.into_iter().map(|s| s.trim().to_string()).collect();
+        let tmp: Vec<String> = iso2_list
+            .into_iter()
+            .map(|s| s.trim().to_string())
+            .collect();
         let refs: Vec<&str> = tmp.iter().map(String::as_str).collect();
         let db = GeoDb::<DefaultBackend>::load_filtered_by_iso2(&refs).into_py()?;
         Ok(Self { inner: db })
@@ -121,7 +131,11 @@ impl PyGeoDb {
     }
 
     /// Find a country by ISO2/ISO3/code and return as dict (or None)
-    pub fn find_country<'py>(&self, py: Python<'py>, code: &str) -> PyResult<Option<Bound<'py, PyAny>>> {
+    pub fn find_country<'py>(
+        &self,
+        py: Python<'py>,
+        code: &str,
+    ) -> PyResult<Option<Bound<'py, PyAny>>> {
         if let Some(c) = self.inner.find_country_by_code(code) {
             let v = to_py(py, &CountryView(c))?;
             Ok(Some(v))
@@ -131,10 +145,16 @@ impl PyGeoDb {
     }
 
     /// List all states for a given country ISO2 as dicts
-    pub fn states_in_country<'py>(&self, py: Python<'py>, iso2: &str) -> PyResult<Option<Bound<'py, PyAny>>> {
+    pub fn states_in_country<'py>(
+        &self,
+        py: Python<'py>,
+        iso2: &str,
+    ) -> PyResult<Option<Bound<'py, PyAny>>> {
         if let Some(country) = self.inner.find_country_by_iso2(iso2) {
             // FIX: Use Trait method
-            let items: Vec<_> = self.inner.states_for_country(country)
+            let items: Vec<_> = self
+                .inner
+                .states_for_country(country)
                 .iter()
                 .map(|s| StateView { country, state: s })
                 .collect();
@@ -146,14 +166,25 @@ impl PyGeoDb {
     }
 
     /// List all cities for a given state code (in a country)
-    pub fn cities_in_state<'py>(&self, py: Python<'py>, iso2: &str, state_code: &str) -> PyResult<Option<Bound<'py, PyAny>>> {
+    pub fn cities_in_state<'py>(
+        &self,
+        py: Python<'py>,
+        iso2: &str,
+        state_code: &str,
+    ) -> PyResult<Option<Bound<'py, PyAny>>> {
         if let Some(country) = self.inner.find_country_by_iso2(iso2) {
             let states = self.inner.states_for_country(country);
             if let Some(state) = states.iter().find(|s| s.state_code() == state_code) {
                 // FIX: Use Trait method
-                let items: Vec<_> = self.inner.cities_for_state(state)
+                let items: Vec<_> = self
+                    .inner
+                    .cities_for_state(state)
                     .iter()
-                    .map(|city| CityView { country, state, city })
+                    .map(|city| CityView {
+                        country,
+                        state,
+                        city,
+                    })
                     .collect();
                 let obj = to_py(py, &items)?;
                 return Ok(Some(obj));
@@ -163,9 +194,15 @@ impl PyGeoDb {
     }
 
     /// Find countries by phone code (e.g. "+49", "1")
-    pub fn search_countries_by_phone<'py>(&self, py: Python<'py>, phone: &str) -> PyResult<Bound<'py, PyAny>> {
+    pub fn search_countries_by_phone<'py>(
+        &self,
+        py: Python<'py>,
+        phone: &str,
+    ) -> PyResult<Bound<'py, PyAny>> {
         // Trait method already handles trimming
-        let items: Vec<_> = self.inner.find_countries_by_phone_code(phone)
+        let items: Vec<_> = self
+            .inner
+            .find_countries_by_phone_code(phone)
             .iter()
             .map(|c| CountryView(*c))
             .collect();
@@ -173,11 +210,17 @@ impl PyGeoDb {
     }
 
     /// Find countries containing a substring
-    pub fn search_country_substring<'py>(&self, py: Python<'py>, substr: &str) -> PyResult<Bound<'py, PyAny>> {
+    pub fn search_country_substring<'py>(
+        &self,
+        py: Python<'py>,
+        substr: &str,
+    ) -> PyResult<Bound<'py, PyAny>> {
         // Assuming find_countries_by_substring is exposed in GeoSearch trait now
         // (If not, use smart_search filtering)
         // Let's assume we exposed it in the trait as discussed.
-        let items: Vec<_> = self.inner.find_countries_by_substring(substr)
+        let items: Vec<_> = self
+            .inner
+            .find_countries_by_substring(substr)
             .iter()
             .map(|c| CountryView(*c))
             .collect();
@@ -185,8 +228,14 @@ impl PyGeoDb {
     }
 
     /// Find states containing a substring
-    pub fn find_states_by_substring<'py>(&self, py: Python<'py>, substr: &str) -> PyResult<Bound<'py, PyAny>> {
-        let items: Vec<_> = self.inner.find_states_by_substring(substr)
+    pub fn find_states_by_substring<'py>(
+        &self,
+        py: Python<'py>,
+        substr: &str,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let items: Vec<_> = self
+            .inner
+            .find_states_by_substring(substr)
             .into_iter()
             .map(|(state, country)| StateView { country, state })
             .collect();
@@ -194,10 +243,20 @@ impl PyGeoDb {
     }
 
     /// Find cities containing a substring
-    pub fn find_cities_by_substring<'py>(&self, py: Python<'py>, substr: &str) -> PyResult<Bound<'py, PyAny>> {
-        let items: Vec<_> = self.inner.find_cities_by_substring(substr)
+    pub fn find_cities_by_substring<'py>(
+        &self,
+        py: Python<'py>,
+        substr: &str,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let items: Vec<_> = self
+            .inner
+            .find_cities_by_substring(substr)
             .into_iter()
-            .map(|(city, state, country)| CityView { country, state, city })
+            .map(|(city, state, country)| CityView {
+                country,
+                state,
+                city,
+            })
             .collect();
         to_py(py, &items)
     }
@@ -205,22 +264,46 @@ impl PyGeoDb {
     // --- SPATIAL SEARCH ---
 
     /// Find nearest cities to a location (Lat, Lng)
-    pub fn find_nearest<'py>(&self, py: Python<'py>, lat: f64, lng: f64, count: usize) -> PyResult<Bound<'py, PyAny>> {
-        let items: Vec<_> = self.inner.find_nearest(lat, lng, count)
+    pub fn find_nearest<'py>(
+        &self,
+        py: Python<'py>,
+        lat: f64,
+        lng: f64,
+        count: usize,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let items: Vec<_> = self
+            .inner
+            .find_nearest(lat, lng, count)
             .into_iter()
-            .map(|(city, state, country)| CityView { country, state, city })
+            .map(|(city, state, country)| CityView {
+                country,
+                state,
+                city,
+            })
             .collect();
         to_py(py, &items)
     }
 
     /// Find cities within radius (km)
-    pub fn find_in_radius<'py>(&self, py: Python<'py>, lat: f64, lng: f64, radius_km: f64) -> PyResult<Bound<'py, PyAny>> {
+    pub fn find_in_radius<'py>(
+        &self,
+        py: Python<'py>,
+        lat: f64,
+        lng: f64,
+        radius_km: f64,
+    ) -> PyResult<Bound<'py, PyAny>> {
         // We need to generate the ID first because the trait expects GeoID
         let geoid = geodb_core::spatial::generate_geoid(lat, lng);
 
-        let items: Vec<_> = self.inner.find_cities_in_radius_by_geoid(geoid, radius_km)
+        let items: Vec<_> = self
+            .inner
+            .find_cities_in_radius_by_geoid(geoid, radius_km)
             .into_iter()
-            .map(|(city, state, country)| CityView { country, state, city })
+            .map(|(city, state, country)| CityView {
+                country,
+                state,
+                city,
+            })
             .collect();
         to_py(py, &items)
     }
@@ -234,9 +317,20 @@ impl PyGeoDb {
             // Serialize the View based on the Enum variant
             let v = match hit.item {
                 SmartItem::Country(c) => serde_json::to_value(CountryView(c)),
-                SmartItem::State { country, state } => serde_json::to_value(&StateView { country, state }),
-                SmartItem::City { country, state, city } => serde_json::to_value(&CityView { country, state, city }),
-            }.map_err(|e| PyRuntimeError::new_err(format!("serde error: {e}")))?;
+                SmartItem::State { country, state } => {
+                    serde_json::to_value(&StateView { country, state })
+                }
+                SmartItem::City {
+                    country,
+                    state,
+                    city,
+                } => serde_json::to_value(&CityView {
+                    country,
+                    state,
+                    city,
+                }),
+            }
+            .map_err(|e| PyRuntimeError::new_err(format!("serde error: {e}")))?;
 
             out.push(v);
         }
@@ -249,4 +343,4 @@ impl PyGeoDb {
 fn geodb_rs(_py: Python, m: &Bound<PyModule>) -> PyResult<()> {
     m.add_class::<PyGeoDb>()?;
     Ok(())
-}
+}

{geodb_rs-0.1.4 → geodb_rs-0.1.5}/crates/geodb-core/src/lib.rs

@@ -9,9 +9,9 @@ pub mod loader;
 #[cfg(not(feature = "legacy_model"))]
 pub mod model; // The NEW model folder
 pub mod prelude;
+pub mod spatial;
 pub mod text;
 pub mod traits;
-pub mod spatial;
 
 pub use crate::error::{GeoDbError, GeoError, Result};