Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+location.csv filter=lfs diff=lfs merge=lfs -text
+place.csv filter=lfs diff=lfs merge=lfs -text
+place_tag.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,33 @@
+# Claude Code configuration
+.claude/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp
+*.log
+
+# Backup files
+*_backup_*
+*.bak

README.md

@@ -1,3 +1,369 @@
----
-license: cc-by-4.0
----
+---
+license: cc-by-4.0
+task_categories:
+- text-generation
+- text-classification
+language:
+- en
+tags:
+- geospatial
+- places
+- points of interest (poi)
+- location-data
+- activities
+pretty_name: Places
+size_categories:
+- 10K<n<100K
+---
+
+# Places Dataset
+
+### Dataset Summary
+
+This dataset contains information of roughly 70,000 places with associated metadata including locations, attribution tags, and some contact details. The data includes geographic coordinates, place descriptions, categorization through attribution tags, and some social media presence information.
+
+### LLM Applications
+
+This dataset is particularly valuable for training and fine-tuning Large Language Models (LLMs) for geospatial understanding:
+
+- **Geospatial Question Answering**: Train LLMs to answer location-based queries like "What coffee shops are near Central Park?" or "Find museums in Paris"
+- **Location-Aware Text Generation**: Enable LLMs to generate contextually relevant descriptions that incorporate local geography, landmarks, and spatial relationships
+- **Address Parsing and Normalization**: The cleaned address formats provide training data for LLMs to understand and standardize various address formats from different countries
+- **Multilingual Geographic Entity Recognition**: With places from multiple countries, LLMs can learn to recognize and disambiguate location names across languages
+- **Spatial Reasoning**: Train models to understand spatial relationships, distances, and geographic hierarchies (neighborhood → city → state → country)
+- **Travel and Tourism Assistants**: Build LLMs that can provide recommendations based on location, tags, and place descriptions
+- **Local Business Understanding**: Help LLMs understand business categories, operating contexts, and location-specific services
+
+### Supported Tasks and Leaderboards
+
+This dataset can be used for various tasks including:
+- **Location-based recommendation systems**
+- **Geographic information retrieval**
+- **Place categorization and tagging**
+- **Spatial analysis and clustering**
+- **Geospatial NLP and language understanding**
+- **Cross-lingual location entity linking**
+
+### Languages
+
+The dataset is primarily in English, with place names and descriptions being in English.
+
+## Structure
+
+### Data Instances
+
+The dataset consists of 5 CSV files with relational structure:
+
+1. **place.csv** - Main places table
+2. **location.csv** - Geographic coordinates
+3. **place_contact.csv** - Contact and social media information
+4. **tag.csv** - Categorization tags
+5. **place_tag.csv** - Many-to-many relationship between places and tags
+
+### Data Fields
+
+#### place.csv
+- `id`: Unique identifier (UUID)
+- `created_at`, `updated_at`: Timestamps
+- `name`: Place name
+- `description`: Place description
+- `address`, `address_formatted`: Street address information
+- `locality`, `administrative_area`, `postal_code`, `country_code`: Location details
+- `verified`, `flagged`: Boolean status flags
+- Various foreign keys linking to other tables
+
+#### location.csv
+- `id`: Unique identifier (UUID)
+- `latitude`, `longitude`: GPS coordinates (WGS84/EPSG:4326 coordinate system)
+- `horizontal_accuracy`, `vertical_accuracy`: Accuracy metrics in meters
+- `altitude`: Elevation data in meters above sea level
+- `geom`: PostGIS geometry column (projected coordinates, likely Web Mercator EPSG:3857)
+- `geog`: PostGIS geography column (unprojected lat/lon coordinates for accurate distance calculations)
+
+#### place_contact.csv
+- `id`: Unique identifier (UUID)
+- `instagram`, `x`: Social media handles
+- `website`: website URLs
+
+### Data Splits
+
+This dataset is provided as a single collection without predefined train/validation/test splits. Users should create their own splits based on their specific use case.
+
+## Dataset Creation
+
+### Curation Rationale
+
+This dataset was created to provide a comprehensive collection of place information with rich metadata for location-based applications and AI research.
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+This dataset can be used to build geographically aware LLMs, location-based services, and improve geographic information systems. Consider the impact on local businesses and communities when using this data.
+
+### Discussion of Biases
+
+The dataset may have geographic biases based on where data was collected. Urban areas may be overrepresented compared to rural areas.
+
+### Other Known Limitations
+
+- The dataset represents a snapshot in time and place information may be outdated
+- Not all places have complete information across all fields
+- Geographic coverage may be limited to specific regions
+
+## Additional Information
+
+### Data Quality Notes
+
+- **Address Formatting**: All addresses have been cleaned and normalized to a consistent format: `{"street address", "city state/province postal", "country"}`
+- **Country Standardization**: Country names have been standardized to English (e.g., Deutschland → Germany, États-Unis → United States)
+- **Coordinate Accuracy**: Location coordinates include accuracy metrics to help filter by precision requirements
+
+### Licensing Information
+
+This dataset is licensed under the Creative Commons Attribution 4.0 International (CC BY 4.0) license.
+
+### Citation Information
+
+```bibtex
+@dataset{places_dataset_2025,
+  title={Places Dataset},
+  author={[patrick piemonte]},
+  year={2025},
+  publisher={Hugging Face}
+}
+```
+
+## Usage
+
+### Loading the Dataset
+
+```python
+from datasets import load_dataset
+
+# Load all tables
+dataset = load_dataset("path/to/places_dataset.py", "all")
+
+# Load individual tables
+places = load_dataset("path/to/places_dataset.py", "place")
+locations = load_dataset("path/to/places_dataset.py", "location")
+tags = load_dataset("path/to/places_dataset.py", "tag")
+place_tags = load_dataset("path/to/places_dataset.py", "place_tag")
+contacts = load_dataset("path/to/places_dataset.py", "place_contact")
+
+# Load denormalized view (easier to use!)
+denormalized = load_dataset("path/to/places_dataset.py", "denormalized")
+```
+
+### Working with the Data
+
+#### LLM-Specific Examples
+
+##### Training Data Preparation for Geospatial QA
+```python
+# Prepare training examples for location-based Q&A
+def create_qa_examples(dataset):
+    examples = []
+    for place in dataset:
+        # Create various question-answer pairs
+        examples.extend([
+            {
+                "question": f"What is the address of {place['name']}?",
+                "answer": place['address_formatted']
+            },
+            {
+                "question": f"Where is {place['name']} located?",
+                "answer": f"{place['name']} is located at {place['address']} in {place['locality']}, {place['administrative_area']}, {place['country']}."
+            },
+            {
+                "question": f"What type of place is {place['name']}?",
+                "answer": f"{place['name']} is a {place['primary_tag_name']}." if place['primary_tag_name'] else f"Information about the type of {place['name']} is not available."
+            }
+        ])
+        
+        if place['description']:
+            examples.append({
+                "question": f"Tell me about {place['name']}",
+                "answer": place['description']
+            })
+    
+    return examples
+
+# Load denormalized data for easy access to all fields
+dataset = load_dataset("path/to/places_dataset.py", "denormalized")['train']
+qa_examples = create_qa_examples(dataset)
+```
+
+##### Spatial Context Generation
+```python
+# Generate spatial context descriptions for LLM training
+def generate_spatial_context(place, nearby_places):
+    context = f"{place['name']} is located at {place['address']} in {place['locality']}."
+    
+    if nearby_places:
+        context += f" Nearby places include: "
+        nearby_names = [f"{p['name']} ({p['distance_km']:.1f}km)" for p in nearby_places[:5]]
+        context += ", ".join(nearby_names) + "."
+    
+    if place['primary_tag_name']:
+        context += f" It is categorized as a {place['primary_tag_name']}."
+    
+    return context
+
+# Example usage
+center_place = dataset[0]
+nearby = find_nearby_places(dataset, center_place['latitude'], center_place['longitude'], 2)
+spatial_description = generate_spatial_context(center_place, nearby)
+```
+
+#### Basic Place Information
+```python
+# Load places with their basic information
+places = load_dataset("path/to/places_dataset.py", "place")['train']
+
+# Access place data
+for place in places.select(range(5)):
+    print(f"Name: {place['name']}")
+    print(f"Address: {place['address_formatted']}")
+    print(f"Locality: {place['locality']}, {place['administrative_area']}")
+    print("---")
+```
+
+#### Using the Denormalized View (Recommended)
+```python
+# Load denormalized data - includes places, locations, primary tags, and contacts
+dataset = load_dataset("path/to/places_dataset.py", "denormalized")['train']
+
+# Now you have everything in one table!
+for place in dataset.select(range(5)):
+    print(f"Name: {place['name']}")
+    print(f"Location: {place['latitude']}, {place['longitude']}")
+    print(f"Primary Tag: {place['primary_tag_name']}")
+    print(f"Website: {place['website']}")
+    print("---")
+
+# Easy filtering with coordinates
+import pandas as pd
+df = pd.DataFrame(dataset)
+# Find verified places with coordinates
+verified_with_coords = df[
+    (df['verified'] == True) & 
+    (df['latitude'].notna()) & 
+    (df['longitude'].notna())
+]
+```
+
+#### Joining Tables (Places with Locations)
+```python
+import pandas as pd
+
+# Load as pandas DataFrames for easier joining
+places_df = pd.DataFrame(places)
+locations = load_dataset("path/to/places_dataset.py", "location")['train']
+locations_df = pd.DataFrame(locations)
+
+# Join places with their locations
+places_with_coords = places_df.merge(
+    locations_df, 
+    left_on='location_id', 
+    right_on='id', 
+    suffixes=('', '_loc')
+)
+
+# Filter places in a specific area (e.g., within a bounding box)
+def filter_by_bbox(df, min_lat, max_lat, min_lon, max_lon):
+    return df[
+        (df['latitude'] >= min_lat) & 
+        (df['latitude'] <= max_lat) &
+        (df['longitude'] >= min_lon) & 
+        (df['longitude'] <= max_lon)
+    ]
+
+# Example: Find places in San Francisco area
+sf_places = filter_by_bbox(places_with_coords, 37.7, 37.8, -122.5, -122.4)
+```
+
+#### Working with Tags
+```python
+# Load all necessary tables
+places_df = pd.DataFrame(load_dataset("path/to/places_dataset.py", "place")['train'])
+tags_df = pd.DataFrame(load_dataset("path/to/places_dataset.py", "tag")['train'])
+place_tags_df = pd.DataFrame(load_dataset("path/to/places_dataset.py", "place_tag")['train'])
+
+# Get all tags for a specific place
+def get_place_tags(place_id):
+    # Find all tag relationships for this place
+    tag_ids = place_tags_df[place_tags_df['place_id'] == place_id]['tag_id']
+    # Get tag details
+    return tags_df[tags_df['id'].isin(tag_ids)]
+
+# Find all places with a specific tag
+def find_places_by_tag(tag_name):
+    # Find the tag
+    tag = tags_df[tags_df['name'] == tag_name]
+    if tag.empty:
+        return pd.DataFrame()
+    
+    tag_id = tag.iloc[0]['id']
+    # Find all places with this tag
+    place_ids = place_tags_df[place_tags_df['tag_id'] == tag_id]['place_id']
+    return places_df[places_df['id'].isin(place_ids)]
+
+# Example: Find all coffee shops
+coffee_shops = find_places_by_tag('Coffee Shop')
+```
+
+### Using the Alternative Loading Function
+
+```python
+from places_dataset import load_places_as_dict
+
+# Load all tables as a dictionary
+data = load_places_as_dict('/path/to/data/directory')
+
+# Access individual tables
+places = data['place']
+locations = data['location']
+tags = data['tag']
+```
+
+### Working with Geospatial Data
+
+#### Coordinate System Information
+- **Latitude/Longitude**: WGS84 (EPSG:4326) - Standard GPS coordinates
+- **Geom column**: Projected geometry, useful for visualization and area calculations
+- **Geog column**: Geography type for accurate distance and spatial calculations
+
+#### Example: Distance Calculations
+```python
+import math
+
+def haversine_distance(lat1, lon1, lat2, lon2):
+    """Calculate distance between two points on Earth in kilometers."""
+    R = 6371  # Earth's radius in kilometers
+    
+    lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])
+    dlat = lat2 - lat1
+    dlon = lon2 - lon1
+    
+    a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
+    c = 2 * math.asin(math.sqrt(a))
+    
+    return R * c
+
+# Find places near a specific coordinate
+def find_nearby_places(places_with_coords, center_lat, center_lon, radius_km):
+    nearby = []
+    for _, place in places_with_coords.iterrows():
+        distance = haversine_distance(
+            center_lat, center_lon,
+            place['latitude'], place['longitude']
+        )
+        if distance <= radius_km:
+            nearby.append({**place.to_dict(), 'distance_km': distance})
+    
+    return pd.DataFrame(nearby).sort_values('distance_km')
+
+# Example: Find places within 5km of a location
+nearby = find_nearby_places(places_with_coords, 37.7749, -122.4194, 5)
+```

location.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab6c673d136b465570f4b8d37c699c4596f2810e28bd18a75f723f3d38111cd1
+size 13902040

place.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9403f683f5d52f5c6f3740188ad5164677aea8dbc509d8a09fee7dcb41f3dff
+size 33321971

place_tag.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f20bed97bc0300596de6605d95cc231199ec9d651c64608bb371900ab37b3e49
+size 26521057

places_dataset.py

@@ -0,0 +1,393 @@
+"""Places Dataset Loading Script for Hugging Face"""
+
+import csv
+import json
+import os
+import datasets
+from typing import Dict, List, Any
+
+
+_CITATION = """\
+@dataset{places_dataset_2025,
+  title={Places Dataset},
+  author={patrick piemonte},
+  year={2025},
+  publisher={Hugging Face}
+}
+"""
+
+_DESCRIPTION = """\
+This dataset contains information about close to 70,000 places with associated metadata including 
+locations, attribution tags, and contact details. The data includes geographic coordinates, 
+place descriptions, categorization through attribution tags, and social media presence information.
+"""
+
+_HOMEPAGE = ""
+_LICENSE = "cc-by-4.0"
+
+_URLS = {
+    "place": "place.csv",
+    "location": "location.csv",
+    "place_contact": "place_contact.csv",
+    "tag": "tag.csv",
+    "place_tag": "place_tag.csv",
+}
+
+
+class PlacesDataset(datasets.GeneratorBasedBuilder):
+    """Places dataset with multiple related tables."""
+
+    VERSION = datasets.Version("1.0.0")
+
+    BUILDER_CONFIGS = [
+        datasets.BuilderConfig(name="all", version=VERSION, description="Load all tables"),
+        datasets.BuilderConfig(name="place", version=VERSION, description="Main places table"),
+        datasets.BuilderConfig(name="location", version=VERSION, description="Geographic coordinates"),
+        datasets.BuilderConfig(name="place_contact", version=VERSION, description="Contact information"),
+        datasets.BuilderConfig(name="tag", version=VERSION, description="Categorization tags"),
+        datasets.BuilderConfig(name="place_tag", version=VERSION, description="Place-tag relationships"),
+        datasets.BuilderConfig(name="denormalized", version=VERSION, description="Denormalized view with places, locations, and primary tags"),
+    ]
+
+    DEFAULT_CONFIG_NAME = "all"
+
+    def _info(self):
+        if self.config.name == "place":
+            features = datasets.Features({
+                "id": datasets.Value("string"),
+                "created_at": datasets.Value("string"),
+                "name": datasets.Value("string"),
+                "description": datasets.Value("string"),
+                "address": datasets.Value("string"),
+                "address_formatted": datasets.Value("string"),
+                "cross_street": datasets.Value("string"),
+                "locality": datasets.Value("string"),
+                "administrative_area": datasets.Value("string"),
+                "postal_code": datasets.Value("string"),
+                "country_code": datasets.Value("string"),
+                "verified": datasets.Value("bool"),
+                "flagged": datasets.Value("bool"),
+                "place_contact_id": datasets.Value("string"),
+                "location_id": datasets.Value("string"),
+                "author_id": datasets.Value("string"),
+                "owner_id": datasets.Value("string"),
+                "locale_id": datasets.Value("string"),
+                "primary_tag_id": datasets.Value("string"),
+                "country": datasets.Value("string"),
+                "sublocality": datasets.Value("string"),
+                "subadministrative_area": datasets.Value("string"),
+                "updated_at": datasets.Value("string"),
+                "radius_in_meters": datasets.Value("int32"),
+                "stamp_id": datasets.Value("string"),
+                "z_priority": datasets.Value("int32"),
+                "clustering_category": datasets.Value("string"),
+                "places_token_id": datasets.Value("string"),
+                "nano_id": datasets.Value("string"),
+                "slug": datasets.Value("string"),
+            })
+        elif self.config.name == "location":
+            features = datasets.Features({
+                "id": datasets.Value("string"),
+                "latitude": datasets.Value("float64"),
+                "longitude": datasets.Value("float64"),
+                "horizontal_accuracy": datasets.Value("float32"),
+                "altitude": datasets.Value("float32"),
+                "vertical_accuracy": datasets.Value("float32"),
+                "geom": datasets.Value("string"),
+                "geog": datasets.Value("string"),
+            })
+        elif self.config.name == "place_contact":
+            features = datasets.Features({
+                "id": datasets.Value("string"),
+                "instagram": datasets.Value("string"),
+                "x": datasets.Value("string"),
+                "website": datasets.Value("string"),
+            })
+        elif self.config.name == "tag":
+            features = datasets.Features({
+                "id": datasets.Value("string"),
+                "created_at": datasets.Value("string"),
+                "name": datasets.Value("string"),
+                "slug": datasets.Value("string"),
+                "private_tag": datasets.Value("bool"),
+                "tag_type": datasets.Value("string"),
+                "image_asset_id": datasets.Value("string"),
+                "theme_asset_id": datasets.Value("string"),
+                "search_tokens": datasets.Value("string"),
+                "keywords": datasets.Value("string"),
+                "radius_in_meters": datasets.Value("int32"),
+                "content_rating": datasets.Value("string"),
+                "stamp_id": datasets.Value("string"),
+                "hidden_tag": datasets.Value("bool"),
+            })
+        elif self.config.name == "place_tag":
+            features = datasets.Features({
+                "id": datasets.Value("string"),
+                "tag_id": datasets.Value("string"),
+                "place_id": datasets.Value("string"),
+                "created_at": datasets.Value("string"),
+            })
+        elif self.config.name == "denormalized":
+            features = datasets.Features({
+                # Place fields
+                "place_id": datasets.Value("string"),
+                "name": datasets.Value("string"),
+                "description": datasets.Value("string"),
+                "address": datasets.Value("string"),
+                "address_formatted": datasets.Value("string"),
+                "locality": datasets.Value("string"),
+                "administrative_area": datasets.Value("string"),
+                "postal_code": datasets.Value("string"),
+                "country_code": datasets.Value("string"),
+                "country": datasets.Value("string"),
+                "verified": datasets.Value("bool"),
+                # Location fields
+                "latitude": datasets.Value("float64"),
+                "longitude": datasets.Value("float64"),
+                "horizontal_accuracy": datasets.Value("float32"),
+                "altitude": datasets.Value("float32"),
+                # Primary tag fields
+                "primary_tag_name": datasets.Value("string"),
+                "primary_tag_slug": datasets.Value("string"),
+                "primary_tag_type": datasets.Value("string"),
+                # Contact fields
+                "website": datasets.Value("string"),
+                "instagram": datasets.Value("string"),
+                "twitter": datasets.Value("string"),
+            })
+        else:  # "all" config
+            features = datasets.Features({
+                "table_name": datasets.Value("string"),
+                "data": datasets.Value("string"),  # JSON string
+            })
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        if self.config.name == "denormalized":
+            downloaded_files = dl_manager.download_and_extract(_URLS)
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={
+                        "filepaths": downloaded_files,
+                    },
+                ),
+            ]
+        elif self.config.name != "all":
+            downloaded_file = dl_manager.download_and_extract(_URLS[self.config.name])
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={
+                        "filepath": downloaded_file,
+                        "table_name": self.config.name,
+                    },
+                ),
+            ]
+        else:
+            downloaded_files = dl_manager.download_and_extract(_URLS)
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={
+                        "filepaths": downloaded_files,
+                    },
+                ),
+            ]
+
+    def _generate_examples(self, filepath=None, table_name=None, filepaths=None):
+        if self.config.name == "denormalized":
+            # Load all necessary tables for denormalized view
+            places = {}
+            locations = {}
+            tags = {}
+            contacts = {}
+            
+            # Load places
+            with open(filepaths["place"], encoding="utf-8") as f:
+                reader = csv.DictReader(f)
+                for row in reader:
+                    places[row["id"]] = row
+            
+            # Load locations
+            with open(filepaths["location"], encoding="utf-8") as f:
+                reader = csv.DictReader(f)
+                for row in reader:
+                    locations[row["id"]] = row
+            
+            # Load tags
+            with open(filepaths["tag"], encoding="utf-8") as f:
+                reader = csv.DictReader(f)
+                for row in reader:
+                    tags[row["id"]] = row
+            
+            # Load contacts
+            with open(filepaths["place_contact"], encoding="utf-8") as f:
+                reader = csv.DictReader(f)
+                for row in reader:
+                    contacts[row["id"]] = row
+            
+            # Generate denormalized rows
+            idx = 0
+            for place_id, place in places.items():
+                result = {
+                    "place_id": place_id,
+                    "name": place.get("name"),
+                    "description": place.get("description"),
+                    "address": place.get("address"),
+                    "address_formatted": place.get("address_formatted"),
+                    "locality": place.get("locality"),
+                    "administrative_area": place.get("administrative_area"),
+                    "postal_code": place.get("postal_code"),
+                    "country_code": place.get("country_code"),
+                    "country": place.get("country"),
+                    "verified": place.get("verified") == "true" if place.get("verified") else False,
+                }
+                
+                # Add location data
+                if place.get("location_id") and place["location_id"] in locations:
+                    loc = locations[place["location_id"]]
+                    # Parse and validate coordinates
+                    lat = None
+                    lon = None
+                    if loc.get("latitude"):
+                        try:
+                            lat = float(loc["latitude"])
+                            if not (-90 <= lat <= 90):
+                                print(f"Warning: Invalid latitude {lat} for place {place_id}")
+                                lat = None
+                        except ValueError:
+                            pass
+                    if loc.get("longitude"):
+                        try:
+                            lon = float(loc["longitude"])
+                            if not (-180 <= lon <= 180):
+                                print(f"Warning: Invalid longitude {lon} for place {place_id}")
+                                lon = None
+                        except ValueError:
+                            pass
+                    
+                    result.update({
+                        "latitude": lat,
+                        "longitude": lon,
+                        "horizontal_accuracy": float(loc["horizontal_accuracy"]) if loc.get("horizontal_accuracy") else None,
+                        "altitude": float(loc["altitude"]) if loc.get("altitude") else None,
+                    })
+                else:
+                    result.update({
+                        "latitude": None,
+                        "longitude": None,
+                        "horizontal_accuracy": None,
+                        "altitude": None,
+                    })
+                
+                # Add primary tag data
+                if place.get("primary_tag_id") and place["primary_tag_id"] in tags:
+                    tag = tags[place["primary_tag_id"]]
+                    result.update({
+                        "primary_tag_name": tag.get("name"),
+                        "primary_tag_slug": tag.get("slug"),
+                        "primary_tag_type": tag.get("tag_type"),
+                    })
+                else:
+                    result.update({
+                        "primary_tag_name": None,
+                        "primary_tag_slug": None,
+                        "primary_tag_type": None,
+                    })
+                
+                # Add contact data
+                if place.get("place_contact_id") and place["place_contact_id"] in contacts:
+                    contact = contacts[place["place_contact_id"]]
+                    result.update({
+                        "website": contact.get("website"),
+                        "instagram": contact.get("instagram"),
+                        "twitter": contact.get("twitter"),
+                    })
+                else:
+                    result.update({
+                        "website": None,
+                        "instagram": None,
+                        "twitter": None,
+                    })
+                
+                yield idx, result
+                idx += 1
+                
+        elif self.config.name != "all":
+            with open(filepath, encoding="utf-8") as f:
+                reader = csv.DictReader(f)
+                for idx, row in enumerate(reader):
+                    # Convert boolean strings to actual booleans
+                    for key, value in row.items():
+                        if value in ["true", "false"]:
+                            row[key] = value == "true"
+                        elif value == "":
+                            row[key] = None
+                        # Convert numeric strings
+                        elif key in ["radius_in_meters", "z_priority"]:
+                            try:
+                                row[key] = int(value) if value else None
+                            except ValueError:
+                                row[key] = None
+                        elif key in ["latitude", "longitude", "horizontal_accuracy", "altitude", "vertical_accuracy"]:
+                            try:
+                                if value:
+                                    val = float(value)
+                                    # Validate coordinates
+                                    if key == "latitude" and not (-90 <= val <= 90):
+                                        print(f"Warning: Invalid latitude {val} in row {idx}")
+                                        row[key] = None
+                                    elif key == "longitude" and not (-180 <= val <= 180):
+                                        print(f"Warning: Invalid longitude {val} in row {idx}")
+                                        row[key] = None
+                                    else:
+                                        row[key] = val
+                                else:
+                                    row[key] = None
+                            except ValueError:
+                                row[key] = None
+                    
+                    yield idx, row
+        else:
+            # Load all tables
+            idx = 0
+            for table_name, filepath in filepaths.items():
+                with open(filepath, encoding="utf-8") as f:
+                    reader = csv.DictReader(f)
+                    rows = list(reader)
+                    yield idx, {
+                        "table_name": table_name,
+                        "data": json.dumps(rows)
+                    }
+                    idx += 1
+
+
+# Alternative simple loading function for users who prefer pandas
+def load_places_as_dict(data_dir: str) -> Dict[str, List[Dict[str, Any]]]:
+    """
+    Load all CSV files from the directory into a dictionary of tables.
+    
+    Args:
+        data_dir: Directory containing the CSV files
+        
+    Returns:
+        Dictionary where keys are table names and values are lists of row dictionaries
+    """
+    tables = {}
+    
+    for table_name, filename in _URLS.items():
+        filepath = os.path.join(data_dir, filename)
+        if os.path.exists(filepath):
+            with open(filepath, encoding="utf-8") as f:
+                reader = csv.DictReader(f)
+                tables[table_name] = list(reader)
+    
+    return tables