diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..ae4a351 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,12 @@ +# Jupyter notebook handling with jupytext +# +# Strategy: Pair .ipynb with .py companions +# - .py files are git-diffable and Claude Code friendly +# - .ipynb files contain outputs for local use +# - Only .py files are meaningfully diffed in PRs + +# Use jupytext for notebook diffs (if available) +*.ipynb diff=jupytext + +# Filter for showing clean diffs +# (requires: git config diff.jupytext.command 'jupytext --to md --set-formats - -o -') diff --git a/.gitignore b/.gitignore index 68bc17f..b6398bd 100644 --- a/.gitignore +++ b/.gitignore @@ -99,7 +99,7 @@ ipython_config.py # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control -#poetry.lock +poetry.lock # pdm # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. @@ -158,3 +158,28 @@ cython_debug/ # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ + +# mac +.DS_Store + +# Node.js dependencies +node_modules/ +npm-debug.log* +yarn-debug.log* +yarn-error.log* + +# Claude Code temporary files +.claude/ + +# Office temporary files +~$*.xlsx +~$*.docx +~$*.pptx + + +# DuckDB temporary storage +.tmp/ +duckdb_temp_storage*.tmp + +# Large data files (use remote parquet instead) +*.parquet diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..b086ebc --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,160 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Development Commands + +### Python Environment Management +- **Poetry** is the primary dependency manager (`pyproject.toml` manages dependencies) +- Install dependencies: `poetry install` +- Install with examples dependencies: `poetry install --with examples` +- Activate virtual environment: `poetry shell` +- Run Python scripts: `poetry run python ` + +### Testing +- Run Python tests: `poetry run pytest tests/` +- Run single test: `poetry run pytest tests/test_isbclient.py::test_field_names` +- Test files are in `tests/` directory + +### Playwright Testing (Web Scraping) +- Playwright tests located in `playwright/tests/` +- Run Playwright tests: `cd playwright && npx playwright test` +- View test reports: `cd playwright && npx playwright show-report` +- Configuration: `playwright/playwright.config.js` + +### Docker Development +- Build and run Jupyter environment: `./run_docker.sh [port]` +- Default port is 8890, custom port can be specified as first argument +- Dockerfile creates a Jupyter environment with all dependencies installed + +## Current Status & Issues ⚠️ + +**IMPORTANT**: As of September 2025, the iSamples central API at `https://central.isample.xyz/isamples_central/` is offline. This affects all three client classes below. The repository is transitioning to **offline-first geoparquet workflows** - see examples in `examples/basic/geoparquet.ipynb` and `examples/basic/isample-archive.ipynb` for working patterns. + +## Architecture Overview + +### Core Python Client (`src/isamples_client/`) +The main Python package provides three client classes for interacting with the iSamples API: + +1. **`IsbClient`** (`isbclient.py:232-339`): Basic HTTP client using httpx + - Direct API interaction with `/thing/select` endpoint + - Methods: `field_names()`, `record_count()`, `facets()`, `pivot()` + +2. **`IsbClient2`** (`isbclient.py:341-586`): Enhanced Solr client using pysolr + - Extends IsbClient with more sophisticated search capabilities + - Supports complex filter queries (`_fq_from_kwargs()`) + - Default search parameters in `default_search_params()` + - Faceting and pivot table functionality + +3. **`ISamplesBulkHandler`** (`isbclient.py:588-683`): Bulk data operations + - Handles large dataset exports via authentication + - Methods: `create_download()`, `get_status()`, `download_file()` + - Loads bulk data into pandas DataFrames + +### Key Configuration Constants +- `ISB_SERVER`: Default iSamples API endpoint +- `FL_DEFAULT`: Default field list for search results +- `FACET_FIELDS_DEFAULT`: Default faceting fields +- `MAJOR_FIELDS`: UI field mappings +- `ISAMPLES_SOURCES`: Available data sources (SESAR, OPENCONTEXT, GEOME, SMITHSONIAN) + +### Examples Structure +- **`examples/basic/`**: Basic API usage examples and Jupyter notebooks +- **`examples/spatial/`**: Geospatial data analysis with geoparquet, DuckDB +- **`examples/opencontext/`**: OpenContext-specific examples +- **`javascript/`**: JavaScript/Node.js integration examples + +### Jupyter Notebook Integration +Heavy emphasis on Jupyter notebook examples for data exploration: +- Interactive data analysis with pandas, xarray +- Geospatial analysis using geopandas, folium, cartopy +- **Lonboard WebGL visualization**: High-performance point cloud rendering +- **DuckDB integration**: Efficient remote parquet processing via HTTP range requests +- **API-independent workflows**: Examples that work without central API access + +#### Notebook Editing & Version Control Tools +**For Claude Code and Git Workflows**: + +1. **jupytext pairing** (recommended for active development): + - Pair `.ipynb` with `.py` companions: `~/bin/nb_pair.sh notebook.ipynb` + - Edit `.py` files to avoid token limits (no outputs in source) + - Auto-sync changes between `.ipynb` ↔ `.py` + - Commit `.py` files for clean git diffs + - See: `JUPYTEXT_WORKFLOW.md` for full guide + +2. **nb_source_diff.py** (for quick diffs): + - Diff notebooks without output noise: `nb-diff notebook.ipynb HEAD` + - Use for one-off comparisons or unpaired notebooks + - Tool location: `~/bin/nb_source_diff.py` + +**Quick Reference**: See `QUICKREF_NOTEBOOKS.md` for command cheatsheet + +**Recommended Workflow**: +- When Claude Code hits token limits on `.ipynb` files → Edit the `.py` companion instead +- Pair new notebooks immediately: `~/bin/nb_pair.sh notebook.ipynb` +- **Commit BOTH files** to git (`.ipynb` for outputs, `.py` for clean diffs) +- Review `.py` diffs for code changes, `.ipynb` for output changes +- Sync after Claude edits: `~/bin/nb_pair.sh --sync notebook.ipynb` + +### Dependencies Architecture +- **Core dependencies**: httpx, requests, pandas, xarray, pysolr +- **Spatial analysis**: geopandas, duckdb, polars, ibis-framework, shapely +- **Visualization**: matplotlib, folium, cartopy, ipyleaflet, lonboard +- **Jupyter ecosystem**: ipywidgets, ipydatagrid, sidecar + +## Development Patterns + +### Search Parameter Building +The codebase uses a sophisticated parameter building system: +- `_fq_from_kwargs()` builds Solr filter queries from keyword arguments +- Uses `multidict.MultiDict` for handling multiple values for same parameter +- Supports date range queries, source filtering, and complex boolean logic + +### Error Handling and Logging +- Uses Python `logging` module (configured at INFO level) +- Request URLs are logged for debugging +- HTTP status codes checked with appropriate error raising + +### Monkey Patching for Large Queries +- `monkey_patch_select()` modifies pysolr to handle large queries via POST +- `SWITCH_TO_POST` threshold (10000 bytes) determines GET vs POST usage +- Critical for handling complex search queries that exceed URL limits + +## Known Issues & Troubleshooting + +### API Connectivity Issues +- **Central API offline**: If you see connection errors to `https://central.isample.xyz/isamples_central/`, the API is currently offline +- **Workaround**: Use the geoparquet examples in `examples/basic/geoparquet.ipynb` and `examples/basic/isample-archive.ipynb` which work without API access +- **Alternative data sources**: The examples demonstrate accessing iSamples data via Zenodo archives and remote parquet files + +### Lonboard Visualization Issues + +**⚠️ CRITICAL: Lonboard 0.12+ API Breaking Change** + +Lonboard 0.12+ changed how map initialization works. The old `zoom` and `center` parameters cause `TypeError`. + +**OLD (BROKEN)**: +```python +viz(result, map_kwargs={"zoom": 1, "center": {"lat": 0, "lon": 0}}) +``` + +**NEW (CORRECT for 0.12+)**: +```python +viz(result, map_kwargs={"view_state": {"zoom": 1, "latitude": 0, "longitude": 0}}) +``` + +**Key changes**: +- `zoom` and `center` must be nested inside `view_state` +- `center: {lat, lon}` becomes flat `latitude` and `longitude` keys +- Dynamic updates: `m.set_view_state(longitude=..., latitude=..., zoom=...)` +- Animation: `m.fly_to(...)` + +**Other considerations**: +- **Memory usage**: Always use `LIMIT` clauses when visualizing parquet data (e.g., `LIMIT 100000`) +- **Performance**: For 6M+ row datasets, querying without LIMIT can cause 5+ minute hangs +- **CRS warnings**: "No CRS exists on data" warnings are expected and can be ignored if lon/lat are WGS84 +- **Deprecated**: The `con` parameter to `viz()` is deprecated in newer versions + +### Environment Setup +- **Node.js conflicts**: Multiple `package.json` files exist; use `poetry install --with examples` for Python dependencies +- **Jupyter extensions**: Some notebooks require ipywidgets and sidecar extensions for full functionality \ No newline at end of file diff --git a/CROSS_REPO_ALIGNMENT.md b/CROSS_REPO_ALIGNMENT.md new file mode 100644 index 0000000..3acb143 --- /dev/null +++ b/CROSS_REPO_ALIGNMENT.md @@ -0,0 +1,215 @@ +# Cross-Repository Alignment Strategy + +**Date**: 2025-09-05 +**Repositories**: `isamples-python` ↔ `isamplesorg.github.io` +**Status**: Both repos have successfully pivoted to offline-first geoparquet workflows + +## Repository Relationship Overview + +Both repositories are complementary components of the iSamples ecosystem that have independently evolved toward the same strategic direction: **geoparquet + DuckDB workflows** replacing central API dependencies. + +### Parallel Evolution + +Both repos experienced the **same critical event**: iSamples Central API going offline +- **isamples-python**: Contains sophisticated lonboard visualization patterns but needs API-independent examples +- **isamplesorg.github.io**: Successfully migrated to browser-based DuckDB-WASM + geoparquet tutorials + +## Repository Roles & Complementary Functions + +### `isamples-python` - Development & Analysis Environment +**Role**: Local development, sophisticated analysis, reusable Python patterns + +**Strengths**: +- ⭐ **Excellent lonboard visualization** - `geoparquet.ipynb` contains zoom-layered rendering, interactive controls +- **Rich Python ecosystem** - GeoPandas, DuckDB, Polars, Ibis integration +- **Jupyter development** - Interactive analysis with full Python scientific stack +- **Local data processing** - High-memory, CPU-intensive analysis capabilities + +**Current Focus**: +- Advanced WebGL point cloud visualization with lonboard +- Multi-backend data processing (DuckDB, pandas, polars) +- Complex geospatial analysis workflows +- Python client library (currently broken due to API offline) + +### `isamplesorg.github.io` - Public Documentation & Tutorials +**Role**: Public-facing education, browser-based demos, universal access + +**Strengths**: +- ✅ **Proven geoparquet migration** - Complete transition from API to browser-based analysis +- **Universal browser access** - Zero installation, works on any device +- **Interactive tutorials** - Observable JavaScript + DuckDB-WASM +- **Performance optimized** - HTTP range requests, memory efficient +- **Educational focus** - Clear learning paths, comprehensive documentation + +**Current Focus**: +- Browser-based data analysis tutorials (Quarto + Observable JS) +- Public-facing documentation and vocabulary system +- Performance demonstrations (300MB datasets in <100MB memory) +- SKOS vocabulary management and generation + +## Data Flow & Technical Architecture Alignment + +### Shared Technology Stack +Both repositories use identical core technologies: +- **DuckDB**: SQL analytical database (Python vs WASM versions) +- **Geoparquet**: Efficient geospatial data format +- **HTTP range requests**: Selective data access from large files +- **Zenodo archives**: Same data sources and URLs + +### Data Access Patterns +```mermaid +graph TB + Z[Zenodo iSamples Archive
300MB geoparquet] + + subgraph "isamples-python" + P[Python DuckDB] + L[Lonboard WebGL] + J[Jupyter Analysis] + end + + subgraph "isamplesorg.github.io" + W[DuckDB-WASM] + O[Observable Plot] + Q[Quarto Tutorials] + end + + Z -->|HTTP range requests| P + Z -->|HTTP range requests| W + P --> L + P --> J + W --> O + W --> Q +``` + +### Performance Characteristics +**Common Benefits**: +- 5-10x faster than traditional pandas workflows +- 99% reduction in data transfer via selective queries +- Memory efficient analysis of large datasets +- Offline-capable once data is cached + +## Strategic Alignment Opportunities + +### 1. Pattern Standardization ⭐ **HIGH PRIORITY** + +**Opportunity**: The lonboard visualization patterns in `isamples-python/examples/basic/geoparquet.ipynb` could be adapted for the website tutorials. + +**Actions**: +- Extract reusable lonboard patterns from Python notebook +- Create Observable JS equivalents using lonboard's WebGL approach +- Standardize color mapping, zoom layering, and interaction patterns +- Document shared visualization vocabulary + +**Benefits**: +- Consistent user experience across local/web environments +- Leverage excellent lonboard work for public tutorials +- Reduce duplication of visualization research + +### 2. Data Source Coordination + +**Current State**: Both repos access same Zenodo archives independently +**Opportunity**: Coordinate data source management and updates + +**Actions**: +- Centralize data source URLs and metadata +- Create shared validation scripts for data integrity +- Coordinate data updates and versioning +- Document data access patterns for both environments + +**File Location**: Both repos could reference shared `DATA_SOURCES.md` + +### 3. Cross-Referencing & Learning Paths + +**Opportunity**: Create clear pathways between browser demos and local development + +**Website → Python Transitions**: +- "Try this analysis locally" links from tutorials → Jupyter notebooks +- Environment setup guidance for deeper analysis +- Advanced analysis patterns requiring Python ecosystem + +**Python → Website References**: +- Link to browser demos from Python examples +- Reference interactive tutorials for concept explanations +- Point to website documentation for context + +### 4. Testing & Validation Alignment + +**Shared Challenge**: Both repos need robust testing for geoparquet workflows +**Opportunity**: Coordinate test data and validation approaches + +**Actions**: +- Share test datasets and expected results +- Coordinate data quality validation scripts +- Create cross-platform compatibility tests +- Document known data issues and workarounds + +## Implementation Strategy + +### Phase 1: Documentation Alignment (Immediate) +1. **Create shared DATA_SOURCES.md** - Centralized data access documentation +2. **Cross-link repositories** - Clear navigation between repos in READMEs +3. **Align terminology** - Consistent language for geoparquet workflows +4. **Document handoff patterns** - When to use browser vs local analysis + +### Phase 2: Pattern Extraction (Near-term) +1. **Extract lonboard visualization library** from Python notebooks +2. **Create Observable JS visualization equivalents** +3. **Standardize interaction patterns** - zoom, filtering, color mapping +4. **Document reusable components** for both environments + +### Phase 3: Infrastructure Sharing (Medium-term) +1. **Shared data validation scripts** +2. **Coordinated data source updates** +3. **Cross-platform testing framework** +4. **Performance benchmarking tools** + +## Recommended File Locations + +### In `isamples-python/`: +- `CROSS_REPO_ALIGNMENT.md` (this document) +- `DATA_SOURCES.md` - Shared data source documentation +- `docs/website-integration.md` - Links and transitions to website +- Enhanced `examples/README.md` with website cross-references + +### In `isamplesorg.github.io/`: +- `about.qmd` updates - Link to Python development environment +- `tutorials/index.qmd` - "Advanced Analysis" section pointing to Python repo +- `design/architecture.md` - Multi-repository ecosystem documentation + +## Success Metrics + +### Short-term (1-2 weeks) +- ✅ Clear documentation linking both repositories +- ✅ Shared data source documentation +- ✅ Coordinated terminology and concepts + +### Medium-term (1-2 months) +- ✅ Extracted reusable visualization patterns +- ✅ Observable JS adaptations of lonboard techniques +- ✅ Consistent user experience across environments + +### Long-term (3-6 months) +- ✅ Shared infrastructure components +- ✅ Coordinated data updates and validation +- ✅ Seamless workflow transitions between repos + +## Cross-Project Learning Insights + +### Successful Independent Evolution +- Both teams arrived at same technical solution independently +- Validates geoparquet + DuckDB as optimal approach +- Shows strength of distributed development model + +### Complementary Strengths +- Python repo: Deep analysis capabilities, rich ecosystem +- Website repo: Universal access, educational focus, performance optimization +- Together: Complete workflow from exploration to publication + +### Technical Innovation Leadership +- Combined repositories demonstrate cutting-edge browser + local analysis +- Show how modern web platform capabilities enable "big data in the browser" +- Position iSamples as leader in accessible scientific computing + +--- + +*This alignment strategy leverages the successful independent evolution of both repositories while maximizing their complementary strengths.* \ No newline at end of file diff --git a/DATA_SOURCES.md b/DATA_SOURCES.md new file mode 100644 index 0000000..cc642d8 --- /dev/null +++ b/DATA_SOURCES.md @@ -0,0 +1,187 @@ +# Shared Data Sources - iSamples Ecosystem + +**Maintained by**: Both `isamples-python` and `isamplesorg.github.io` repositories +**Last Updated**: 2025-09-05 + +## Primary Data Sources + +### Zenodo iSamples Archive ⭐ **PRIMARY** +- **URL**: `https://z.rslv.xyz/10.5281/zenodo.15278210/isamples_export_2025_04_21_16_23_46_geo.parquet` +- **Size**: ~300 MB, 6+ million records +- **Format**: Geoparquet with spatial indexing +- **Sources**: SESAR, OpenContext, GEOME, Smithsonian (all federated sources) +- **Update Frequency**: Periodic (check Zenodo for latest versions) +- **Access Method**: HTTP range requests for efficient querying +- **CORS Status**: ⚠️ Check current accessibility for browser use + +**Data Quality Notes**: +- Comprehensive geological sample metadata +- Spatial coordinates available for most records +- Some records may have missing or incomplete fields +- Quality varies by source system + +### OpenContext Collections +- **Base URL Pattern**: Various URLs for specific archaeological collections +- **Format**: Parquet files with domain-specific schemas +- **Access**: HTTP range requests supported +- **Usage**: Domain-specific analysis, educational examples + +### Local Sample Data (Both Repos) + +#### In `isamples-python/examples/spatial/`: +- `cities.geoparquet` - Sample cities data for testing +- `bay_area_cities.parquet` - Regional subset for performance testing +- Purpose: Development and testing without external dependencies + +#### In `isamplesorg.github.io` tutorials: +- Embedded fallback datasets for CORS-restricted environments +- Demo datasets demonstrating same analytical techniques +- Smaller scale data for educational purposes + +## Data Access Patterns + +### Python Environment (`isamples-python`) +```python +import duckdb + +# Connect to DuckDB and query remote parquet +conn = duckdb.connect() +result = conn.sql(""" + SELECT source, COUNT(*) as sample_count + FROM 'https://z.rslv.xyz/10.5281/zenodo.15278210/isamples_export_2025_04_21_16_23_46_geo.parquet' + GROUP BY source +""") +df = result.to_df() +``` + +### Browser Environment (`isamplesorg.github.io`) +```javascript +// DuckDB-WASM with automatic CORS fallback +const conn = await duckdb.connect(); + +// Primary data source with fallback +const dataUrl = "https://z.rslv.xyz/10.5281/zenodo.15278210/isamples_export_2025_04_21_16_23_46_geo.parquet"; + +try { + const result = await conn.query(` + SELECT source, COUNT(*) as sample_count + FROM '${dataUrl}' + GROUP BY source + `); +} catch (e) { + // Fallback to demo dataset + console.log("CORS blocked, using demo data"); + // ... fallback logic +} +``` + +## Performance Characteristics + +### HTTP Range Request Benefits +- **Metadata queries**: <1KB transfer for table statistics +- **Sampling**: ~1-10KB for representative samples +- **Filtered queries**: Only transfers matching data rows +- **Aggregations**: Minimal data transfer for GROUP BY operations + +### Memory Usage +- **Browser**: Analyze 300MB datasets in <100MB memory +- **Python**: Full dataset can be loaded for complex operations +- **Streaming**: Both environments support streaming for larger-than-memory analysis + +## Data Update Coordination + +### Version Management +1. **Check Zenodo** regularly for updated iSamples exports +2. **Test compatibility** in both Python and browser environments +3. **Update URLs** in both repositories simultaneously +4. **Verify data quality** with standard validation queries + +### Validation Queries +```sql +-- Basic quality checks (run in both environments) +SELECT + source, + COUNT(*) as total_records, + COUNT(latitude) as records_with_coords, + MIN(collection_date) as earliest_date, + MAX(collection_date) as latest_date +FROM parquet_file +GROUP BY source; +``` + +### Update Process +1. **Identify new data source** on Zenodo or other archives +2. **Test in Python environment** first (full DuckDB capabilities) +3. **Test in browser environment** (check CORS, performance) +4. **Update both repositories** with new URLs and documentation +5. **Verify examples still work** in both environments + +## Known Issues & Workarounds + +### CORS Restrictions +- **Problem**: Some data sources block browser access +- **Detection**: Try HEAD request first in browser tutorials +- **Workaround**: Automatic fallback to demo datasets +- **Solution**: Host CORS-enabled mirrors when possible + +### Data Quality Issues +- **Missing coordinates**: ~5-10% of records may lack spatial data +- **Encoding issues**: Some text fields may have inconsistent encoding +- **Date formats**: Multiple date formats across source systems +- **Null values**: Handle missing data gracefully in all queries + +### Performance Considerations +- **Large queries**: Use LIMIT in initial development/testing +- **Memory limits**: Browser environment more constrained than Python +- **Network timeouts**: Implement retry logic for large HTTP range requests + +## Cross-Repository Testing + +### Shared Test Queries +Both repositories should validate these standard queries work: + +```sql +-- Test 1: Basic connectivity and record count +SELECT COUNT(*) FROM parquet_file; + +-- Test 2: Source distribution +SELECT source, COUNT(*) FROM parquet_file GROUP BY source; + +-- Test 3: Spatial data availability +SELECT + COUNT(*) as total, + COUNT(latitude) as with_coords, + ROUND(100.0 * COUNT(latitude) / COUNT(*), 2) as coord_percentage +FROM parquet_file; + +-- Test 4: Date range analysis +SELECT + source, + MIN(collection_date) as earliest, + MAX(collection_date) as latest +FROM parquet_file +WHERE collection_date IS NOT NULL +GROUP BY source; +``` + +### Expected Results (as of 2025-04-21 export) +- Total records: ~6+ million +- Sources: SESAR, OpenContext, GEOME, Smithsonian +- Spatial coverage: Global with concentrations in North America, Europe +- Date range: Historical to present (varies by source) + +## Contact & Coordination + +### Data Issues +- Report data quality issues in both repository issue trackers +- Tag issues with `data-quality` label for visibility +- Include specific queries and expected vs actual results + +### New Data Sources +- Propose new data sources in `isamples-python` issues +- Test compatibility in both environments before adoption +- Document access patterns and any special considerations + +--- + +*This document is maintained collaboratively between both repositories to ensure consistency and coordination.* \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..09855ca --- /dev/null +++ b/Dockerfile @@ -0,0 +1,46 @@ +FROM quay.io/jupyter/minimal-notebook:2024-10-03 + +# Set environment variables to avoid prompts during package installation +ENV DEBIAN_FRONTEND=noninteractive + +# Make sure the contents of our repo are in ${HOME} +COPY . ${HOME} +USER root +RUN chown -R ${NB_UID} ${HOME} + +# Update package list and install required dependencies +RUN apt-get update && \ + apt-get install -y software-properties-common libdb-dev libzmq3-dev curl libssl-dev zlib1g-dev jq jupyter-console pkg-config default-libmysqlclient-dev && \ + apt-get clean && \ + rm -rf /var/lib/apt/lists/* + +# Install pipx and add its binary directory to PATH +RUN pip install pipx && \ + pipx ensurepath +ENV PATH="/home/jovyan/.local/bin:$PATH" + +# Use pipx to install Poetry +RUN pipx install poetry + +# Copy pyproject.toml and poetry.lock if it exists +COPY pyproject.toml poetry.lock* ./ + +# Install project dependencies using Poetry +RUN poetry config virtualenvs.create false && \ + poetry install --no-interaction --no-ansi --with examples + +# Install dependencies from requirements.in if it exists +# COPY requirements.in ./ +# RUN if [ -f requirements.in ]; then pip install --upgrade -r requirements.in; fi + +# Create necessary directories and set permissions +RUN mkdir -p /home/jovyan/.local/share/jupyter && \ + chown -R jovyan:users /home/jovyan/.local + +VOLUME ["/home/jovyan/work", "/data"] + +# Switch back to jovyan to avoid accidental container runs as root +USER ${NB_UID} + +# Verify permissions +RUN ls -la /home/jovyan/.local/share diff --git a/ISAMPLES_MODEL_ACTION_PLAN.md b/ISAMPLES_MODEL_ACTION_PLAN.md new file mode 100644 index 0000000..8390191 --- /dev/null +++ b/ISAMPLES_MODEL_ACTION_PLAN.md @@ -0,0 +1,133 @@ +# iSamples Model Correction Action Plan + +## Overview +This action plan addresses the correction needed after discovering that the iSamples metadata model is **domain-agnostic**, not archaeology-specific as previously documented in our notebooks and code. + +## Key Understanding Update + +### Previous (Incorrect) Understanding +- Treated `MaterialSampleRecord`, `SamplingEvent`, `GeospatialCoordLocation`, `SamplingSite` as archaeology-specific entity types +- Documented predicates like `produced_by`, `sample_location` as OpenContext-specific +- Suggested the model was customized for archaeological data + +### Corrected Understanding +1. **PQG Framework**: Generic property graph representation (s/p/o/n) +2. **iSamples Model**: Domain-agnostic metadata standard for ALL scientific material samples +3. **Domain Data**: OpenContext, SESAR, GEOME populate the model with domain-specific VALUES + +## Phase 1: Documentation Updates (Immediate) + +### Notebooks to Update +- [ ] `examples/basic/oc_parquet_analysis_enhanced.ipynb` + - Fix section "Key Distinction: Generic PQG vs OpenContext-Specific" + - Update all comments suggesting entity types are archaeology-specific + - Clarify that OpenContext uses standard iSamples model with archaeological data + +- [ ] `examples/basic/oc_parquet_analysis.ipynb` + - Update introductory documentation + - Fix inline comments about entity types + +- [ ] `examples/basic/geoparquet.ipynb` + - Verify no misleading archaeology-specific claims + - Add note about cross-domain capabilities + +### Documentation Files +- [x] `README.md` - Updated to reflect domain-agnostic nature +- [ ] `examples/README.md` - Update notebook descriptions +- [ ] `STATUS.md` - Add note about model understanding correction +- [ ] `CROSS_REPO_ALIGNMENT.md` - Ensure consistency with new understanding + +## Phase 2: Code Comment Updates + +### Priority Files +- [ ] All notebooks with SQL/Ibis queries + - Change comments from "OpenContext-specific entity" to "iSamples entity" + - Update "OpenContext predicate" to "iSamples predicate" + - Fix variable names like `archaeological_sites` → `sampling_sites` + +### Example Changes Needed +```python +# OLD (incorrect): +samples = oc_pqg.filter(_.otype == 'MaterialSampleRecord') # OpenContext entity + +# NEW (correct): +samples = oc_pqg.filter(_.otype == 'MaterialSampleRecord') # iSamples entity (archaeological data) +``` + +## Phase 3: Enhanced Cross-Domain Examples + +### New Notebooks/Sections to Create +- [ ] Add section showing how same queries work across domains +- [ ] Create comparison: archaeological vs geological samples using same model +- [ ] Document which fields are domain-universal vs domain-specific values + +### Query Pattern Documentation +- [ ] Document universal graph traversal patterns +- [ ] Show how predicates work across domains +- [ ] Create reference table: Entity Type → Example Values by Domain + +## Phase 4: Testing & Validation + +### Verification Tasks +- [ ] Test existing queries still work correctly +- [ ] Verify no functional breaks from documentation changes +- [ ] If available, test with non-archaeological iSamples data +- [ ] Validate cross-domain query capabilities + +### Performance Testing +- [ ] Ensure query performance unchanged +- [ ] Document any optimization opportunities from new understanding + +## Phase 5: Communication & Education + +### Internal Documentation +- [x] Dev journal entry (2025-09-26) documenting discovery +- [x] Project journal update with correction +- [ ] Add "Model Clarification" section to main docs + +### External Communication +- [ ] Consider blog post or documentation update for iSamples community +- [ ] Update any presentations or tutorials +- [ ] Notify collaborators of corrected understanding + +## Implementation Priority + +1. **Immediate** (Today): + - [x] Document discovery in dev journal + - [x] Update main README + - [x] Create this action plan + +2. **High Priority** (This Week): + - [ ] Fix oc_parquet_analysis_enhanced.ipynb documentation + - [ ] Update all notebook comments + - [ ] Test for any functional impacts + +3. **Medium Priority** (Next 2 Weeks): + - [ ] Create cross-domain examples + - [ ] Enhance documentation with domain comparisons + - [ ] Update all secondary documentation + +4. **Low Priority** (As Time Permits): + - [ ] Refactor variable names for clarity + - [ ] Create educational materials + - [ ] Consider broader community communication + +## Success Criteria + +- All documentation accurately reflects domain-agnostic nature of iSamples +- No misleading references to "archaeology-specific" entity types +- Clear explanation of the three-layer architecture (PQG → iSamples → Domain Data) +- Examples demonstrate cross-domain capabilities +- Community understanding aligned with correct model + +## Notes + +- This correction actually makes the iSamples model MORE powerful - it's a universal framework +- Emphasize the positive: enables cross-domain discovery and integration +- Use this as an opportunity to showcase the model's flexibility + +## References + +- iSamples LinkML Schema: https://isamplesorg.github.io/metadata/ +- PQG Documentation: `/Users/raymondyee/C/src/iSamples/pqg/isamples/README.md` +- Eric Kansa discussion: 2025-09-26 (clarified domain-agnostic nature) \ No newline at end of file diff --git a/JUPYTEXT_WORKFLOW.md b/JUPYTEXT_WORKFLOW.md new file mode 100644 index 0000000..af52fa3 --- /dev/null +++ b/JUPYTEXT_WORKFLOW.md @@ -0,0 +1,315 @@ +# Jupytext Workflow for iSamples Notebooks + +This guide explains how to use **jupytext** to pair `.ipynb` notebooks with `.py` companion files for better git diffing and Claude Code editing. + +## The Problem + +1. **Git diffs of `.ipynb` files are messy**: Execution outputs, cell metadata, and JSON noise obscure actual code changes +2. **Claude Code file size limits**: Large notebooks with outputs can exceed token limits +3. **Merge conflicts**: Notebooks with outputs create unnecessary conflicts + +## The Solution: Jupytext Pairing + +**Jupytext** creates a two-file system: +- **`.ipynb`** - Full notebook with outputs (local development, `.gitignore`'d or committed) +- **`.py`** - Clean Python representation (version controlled, diffed, edited) + +### Benefits + +✅ **For Git**: Diff/review `.py` files with clean code (no output noise) +✅ **For Claude Code**: Edit `.py` files directly (no token limit issues) +✅ **For Humans**: Keep `.ipynb` with outputs for local Jupyter development +✅ **Auto-sync**: Changes to either file automatically update the other + +--- + +## Quick Start + +### 1. Pair a Notebook + +```bash +# Pair single notebook +~/bin/nb_pair.sh examples/basic/my_notebook.ipynb + +# Pair all notebooks in directory +~/bin/nb_pair.sh examples/**/*.ipynb +``` + +This creates: +- `my_notebook.ipynb` (original, with outputs) +- `my_notebook.py` (new, clean code with `# %%` cell markers) + +### 2. Update .gitignore (Usually NOT Needed!) + +**Recommended: Commit BOTH files** +```bash +# No .gitignore changes needed +# Commit both .ipynb (with outputs) and .py (clean code) +git add notebook.ipynb notebook.py +``` + +**Why commit both?** +- ✅ Outputs are valuable (show results without re-running) +- ✅ Reviewers can see both code and results +- ✅ `.py` file provides clean diffs for code review +- ✅ `.ipynb` provides rendered outputs on GitHub +- ✅ Best of both worlds! + +**Only ignore .ipynb if:** +- Outputs are huge (>10MB) or contain sensitive data +- Notebooks change frequently with trivial output differences +- CI/CD regenerates outputs automatically + +```gitignore +# Only if you have a specific reason: +# *.ipynb +``` + +### 3. Normal Workflow + +**Option A: Edit in Jupyter (recommended)** +```bash +# Edit notebook in Jupyter as usual +jupyter lab + +# Jupytext auto-syncs .ipynb ↔ .py on save +# Commit BOTH files +git add examples/basic/my_notebook.ipynb examples/basic/my_notebook.py +git commit -m "Update analysis query" +``` + +**Option B: Edit .py directly (for Claude Code)** +```bash +# Claude edits the .py file +# Then sync back to .ipynb: +~/bin/nb_pair.sh --sync examples/basic/my_notebook.py + +# Or use jupytext directly: +jupytext --sync examples/basic/my_notebook.py +``` + +--- + +## Detailed Usage + +### Pairing Commands + +```bash +# Pair notebook (creates .py companion) +~/bin/nb_pair.sh notebook.ipynb + +# Sync after editing either file +~/bin/nb_pair.sh --sync notebook.ipynb + +# Remove pairing (keeps .py file) +~/bin/nb_pair.sh --unpair notebook.ipynb +``` + +### Manual Jupytext Commands + +```bash +# Pair with percent format (# %% cell markers) +jupytext --set-formats ipynb,py:percent notebook.ipynb + +# Sync changes between files +jupytext --sync notebook.ipynb + +# Convert without pairing +jupytext --to py:percent notebook.ipynb +``` + +### Understanding the .py Format + +The `.py` companion uses **percent format**: + +```python +# %% [markdown] +# # My Notebook Title +# This is a markdown cell + +# %% +import pandas as pd +print("This is a code cell") + +# %% +# Another code cell +result = pd.DataFrame({'a': [1, 2, 3]}) +``` + +**Benefits of percent format**: +- Valid Python file (can run with `python notebook.py`) +- Clear cell boundaries (`# %%`) +- Claude Code can edit directly +- Git diffs show actual code changes + +--- + +## Git Configuration (Optional) + +Enable better notebook diffs in git: + +```bash +# Configure jupytext as diff driver +git config diff.jupytext.command 'jupytext --to md --set-formats - -o -' + +# Add to .gitattributes (already done) +echo '*.ipynb diff=jupytext' >> .gitattributes +``` + +--- + +## Recommended Workflows + +### Workflow 1: Development (Jupyter + Pairing) + +1. **Pair notebook**: `~/bin/nb_pair.sh notebook.ipynb` +2. **Edit in Jupyter**: Work normally, outputs saved to `.ipynb` +3. **Commit .py**: Auto-synced on save, commit this file +4. **Review**: Git diffs show clean code changes + +**Best for**: Active development with outputs + +### Workflow 2: Claude Code Editing + +1. **Pair notebook**: `~/bin/nb_pair.sh notebook.ipynb` +2. **Claude edits .py**: No token limits, clean diffs +3. **Sync back**: `~/bin/nb_pair.sh --sync notebook.ipynb` +4. **Run in Jupyter**: Execute to generate outputs + +**Best for**: Large refactoring, architecture changes + +### Workflow 3: Existing Notebooks + +```bash +# Pair all existing notebooks +find examples -name "*.ipynb" -exec ~/bin/nb_pair.sh {} \; + +# Add to git +git add examples/**/*.py +git commit -m "Add jupytext pairing for all notebooks" + +# Optionally ignore .ipynb files +echo "*.ipynb" >> .gitignore +``` + +--- + +## Troubleshooting + +### Q: Changes not syncing? + +**A**: Manually sync: +```bash +~/bin/nb_pair.sh --sync notebook.ipynb +# or +jupytext --sync notebook.ipynb +``` + +### Q: Want to stop pairing? + +**A**: Unpair and delete .py: +```bash +~/bin/nb_pair.sh --unpair notebook.ipynb +rm notebook.py +``` + +### Q: Merge conflict in .ipynb? + +**A**: Resolve in .py file, then sync: +```bash +# Fix conflict in notebook.py +git add notebook.py +~/bin/nb_pair.sh --sync notebook.ipynb +``` + +### Q: Claude Code still hits token limits? + +**A**: Edit the `.py` file directly: +- Claude reads `notebook.py` (clean, no outputs) +- Makes changes +- Sync: `~/bin/nb_pair.sh --sync notebook.py` +- Run in Jupyter to regenerate outputs + +--- + +## Integration with Existing Tools + +### With nb_source_diff.py + +Both tools complement each other: +- **nb_source_diff.py**: Diff `.ipynb` files without outputs (one-off) +- **jupytext pairing**: Permanent `.py` companions (ongoing) + +Use **jupytext** for: +- Claude Code editing (avoids token limits) +- Normal git workflow (commit .py, diff .py) +- Long-term maintenance + +Use **nb_source_diff.py** for: +- Quick diffs of unpaired notebooks +- Legacy notebooks you don't want to pair +- Ad-hoc comparisons + +### With Git Hooks (Advanced) + +Auto-sync on commit: + +```bash +# .git/hooks/pre-commit +#!/bin/bash +for ipynb in $(git diff --cached --name-only | grep '.ipynb$'); do + jupytext --sync "$ipynb" + git add "${ipynb%.ipynb}.py" +done +``` + +--- + +## Examples in This Repository + +### Paired Notebooks (After Setup) + +``` +examples/basic/ +├── oc_parquet_analysis_enhanced.ipynb (full notebook with outputs) +└── oc_parquet_analysis_enhanced.py (clean code, version controlled) +``` + +**Git workflow**: +```bash +# Edit in Jupyter +jupyter lab examples/basic/oc_parquet_analysis_enhanced.ipynb + +# Auto-synced to .py on save +# Commit clean code +git add examples/basic/oc_parquet_analysis_enhanced.py +git commit -m "Add geographic classification analysis" + +# PR reviewers see clean Python diff, not JSON noise +``` + +--- + +## Best Practices + +1. **✅ DO**: Pair notebooks you actively develop +2. **✅ DO**: Commit BOTH `.ipynb` and `.py` files (usually!) +3. **✅ DO**: Review `.py` diffs in PRs for code changes +4. **✅ DO**: Check `.ipynb` diffs for output changes +5. **✅ DO**: Let Claude Code edit `.py` files directly +6. **⚠️ CONSIDER**: Ignoring `.ipynb` files if outputs are huge/sensitive +7. **❌ DON'T**: Manually edit both files separately (sync instead) +8. **❌ DON'T**: Commit `.ipynb` AND `.py` with conflicting changes + +--- + +## References + +- **Jupytext docs**: https://jupytext.readthedocs.io/ +- **Helper script**: `~/bin/nb_pair.sh` +- **Diff tool**: `~/bin/nb_source_diff.py` +- **This guide**: `/Users/raymondyee/C/src/iSamples/isamples-python/JUPYTEXT_WORKFLOW.md` + +--- + +**Last Updated**: 2025-10-15 by Claude Code diff --git a/PQG_INTEGRATION_PLAN.md b/PQG_INTEGRATION_PLAN.md new file mode 100644 index 0000000..0dcc285 --- /dev/null +++ b/PQG_INTEGRATION_PLAN.md @@ -0,0 +1,448 @@ +# PQG Integration Plan for oc_parquet_analysis_enhanced.ipynb + +**Date**: 2025-11-11 +**Goal**: Integrate the `pqg` library to simplify graph operations while preserving domain-specific logic + +--- + +## Executive Summary + +The notebook currently has **100 cells** with **29 recursive CTEs** and complex SQL joins for property graph traversal. The `pqg` library can simplify many of these operations while maintaining performance for OpenContext-specific analysis. + +**Strategy**: Hybrid approach +- ✅ Use PQG for: Node retrieval, edge traversal, entity queries +- ✅ Keep custom SQL for: Visualization aggregations, bulk operations, performance-critical queries +- ✅ Add comparison sections showing both approaches + +--- + +## Current State Analysis + +### 🔍 What the Notebook Does + +**Core Functions (11 custom query functions)**: +1. `get_sample_locations_for_viz()` - Extract samples with coordinates for mapping +2. `get_sample_geo_context_via_sample_pid()` - Get all geographic context for a sample +3. `get_samples_for_geo_pid()` - Reverse: get samples at a geographic location +4. `export_site_subgraph()` - Export all data for a site pattern +5. **Eric's 4 authoritative queries** (already implemented in SQL): + - `get_sample_data_via_sample_pid()` + - `get_sample_data_agents_sample_pid()` + - `get_sample_types_and_keywords_via_sample_pid()` + - `get_samples_at_geo_cord_location_via_sample_event()` +6. `get_sampling_sites_by_name()` - Site search by name pattern +7. `ark_to_url()` - URL conversion utility + +**Heavy SQL Patterns**: +- **29 cells** use CTEs/recursive queries for graph traversal +- **35 cells** use multi-table joins +- **20 cells** use aggregation (GROUP BY) +- **15 cells** filter by entity type (WHERE otype=...) + +**Domain-Specific Logic**: +- Path 1 vs Path 2 geographic traversal patterns +- Three-category geo classification (both paths, Path 1 only, Path 2 only) +- Site-level vs event-level coordinate analysis +- Material type categorization +- Data quality checks (orphaned nodes, location quality) + +--- + +## Integration Strategy + +### Phase 1: Setup & Basic Queries (Easy Wins) + +**Replace simple entity queries with PQG methods** + +#### 1.1 Entity Type Counts +**Current** (Cell 10): +```python +# SQL +SELECT otype, COUNT(*) as count FROM pqg +WHERE otype != '_edge_' +GROUP BY otype +``` + +**With PQG**: +```python +from pqg import PQG + +# Load parquet as PQG instance +pqg_instance = PQG(conn) +pqg_instance._table = 'pqg' +pqg_instance._isparquet = True + +# Get entity type distribution +entity_counts = {} +for pid, otype in pqg_instance.getIds(maxrows=100000): + entity_counts[otype] = entity_counts.get(otype, 0) + 1 + +# Or use SQL for performance on large datasets (keep current approach) +``` + +**Recommendation**: Keep SQL for aggregations (faster), use PQG for learning/examples + +#### 1.2 Edge Predicate Exploration +**Current** (Cell 12): +```python +SELECT p, COUNT(*) FROM pqg WHERE otype='_edge_' GROUP BY p +``` + +**With PQG**: +```python +# Get all relationships +predicates = {} +for subject, predicate, obj in pqg_instance.getRelations(): + predicates[predicate] = predicates.get(predicate, 0) + 1 +``` + +**Recommendation**: Keep SQL (much faster for 9M+ edges) + +#### 1.3 Node Retrieval by PID +**Current**: Direct SQL SELECT +**With PQG**: +```python +# Get a single node with all properties +sample_node = pqg_instance.getNode("ark:/28722/k2wq0b20z", max_depth=0) +print(sample_node) + +# With depth=1, automatically expands related nodes +sample_with_relations = pqg_instance.getNode("ark:/28722/k2wq0b20z", max_depth=1) +``` + +**Recommendation**: ✅ **USE PQG** - Simpler API, handles row_id conversion automatically + +--- + +### Phase 2: Graph Traversal Functions (Medium Complexity) + +**Replace custom recursive CTEs with PQG traversal methods** + +#### 2.1 `get_sample_geo_context_via_sample_pid()` + +**Current approach**: Multi-hop SQL join +```sql +-- Find event +SELECT e.o[1] as event_pid +FROM pqg e +WHERE e.s = (SELECT row_id FROM pqg WHERE pid = sample_pid) + AND e.p = 'produced_by' + +-- Find geo via event +SELECT g.pid FROM pqg g +JOIN pqg e ON g.row_id = e.o[1] +WHERE e.s = event_row_id AND e.p = 'sample_location' +``` + +**With PQG**: +```python +def get_sample_geo_context_via_sample_pid_pqg(pqg_instance, sample_pid): + """Get geographic context using PQG graph traversal""" + + # Get sample node with edges expanded (depth=1 gets immediate neighbors) + sample = pqg_instance.getNode(sample_pid, max_depth=1) + + # Navigate to event via produced_by edge + event_pid = sample.get('produced_by') # Auto-expanded by max_depth=1 + if not event_pid: + return None + + # Get event with its edges + event = pqg_instance.getNode(event_pid, max_depth=1) + + # Extract geographic context + geo_context = { + 'sample_location': event.get('sample_location'), # Path 1 + 'sampling_site': event.get('sampling_site') # Path 2 (site) + } + + return geo_context +``` + +**Comparison**: +- PQG: More readable, handles row_id conversion, 3 API calls +- SQL: Faster for bulk, single query, but complex +- **Recommendation**: ✅ **Show both** - PQG for clarity, SQL for performance + +#### 2.2 `get_samples_for_geo_pid()` - Reverse Traversal + +**Current**: Complex SQL with UNION for Path 1 + Path 2 +**With PQG**: +```python +def get_samples_for_geo_pid_pqg(pqg_instance, geo_pid, mode='either_or'): + """Find samples connected to a geographic location (reverse traversal)""" + + # Path 1: geo <- sample_location <- event <- produced_by <- sample + path1_samples = [] + for subj, pred, obj in pqg_instance.getRelations(obj=geo_pid, predicate='sample_location'): + event_pid = subj # Event that has this geo as sample_location + event = pqg_instance.getNode(event_pid, max_depth=1) + + # Find samples produced by this event + for s2, p2, o2 in pqg_instance.getRelations(obj=event_pid, predicate='produced_by'): + sample_pid = s2 + path1_samples.append(sample_pid) + + # Path 2: geo <- site_location <- site <- sampling_site <- event <- produced_by <- sample + # (Similar pattern, more hops) + + return path1_samples +``` + +**Comparison**: +- PQG: Clear step-by-step traversal +- SQL: Single query with joins, much faster +- **Recommendation**: ✅ **Show both** - PQG for learning, SQL for production + +--- + +### Phase 3: Domain-Specific Optimizations (Keep Custom) + +**These should remain as custom SQL - they're OpenContext-specific and performance-critical** + +#### 3.1 Visualization Queries +**Keep as SQL**: +- `get_sample_locations_for_viz()` - Optimized for 10K+ samples, specific column selection +- Geographic classification queries (3-category analysis) +- Coordinate extraction for mapping + +**Reason**: Need bulk aggregation, specific projections, performance-critical + +#### 3.2 Eric's Authoritative Queries +**Keep as SQL**: +- All 4 of Eric's queries are already optimized and tested +- They use specific column selections not available in PQG API +- Performance-critical for web UI + +**Reason**: Production-tested, web application integration + +#### 3.3 Data Quality Analysis +**Keep as SQL**: +- Orphaned node detection +- Location quality checks +- Summary statistics + +**Reason**: Require full table scans and aggregations + +--- + +## Implementation Plan + +### Step 1: Add PQG Setup Section (New Cell) + +Insert after Cell 6 (data loading): + +```python +# === PQG Integration Setup === + +from pqg import PQG + +# Create PQG instance from loaded parquet +def create_pqg_instance(conn, table_name='pqg'): + """Initialize PQG wrapper around parquet data""" + pqg_instance = PQG(dbinstance=conn) + pqg_instance._table = table_name + pqg_instance._isparquet = True # Read-only mode + pqg_instance._node_pk = 'pid' # Primary lookup field + return pqg_instance + +pqg_instance = create_pqg_instance(conn) + +print("✅ PQG instance created") +print(f"Table: {pqg_instance._table}") +print(f"Read-only mode: {pqg_instance._isparquet}") +``` + +### Step 2: Add Comparison Sections (Incremental) + +For each major query pattern, add a comparison cell: + +```markdown +### Example: Node Retrieval - SQL vs PQG + +**SQL Approach** (current): +```python +# [existing SQL query] +``` + +**PQG Approach** (alternative): +```python +# [PQG equivalent] +``` + +**Performance Comparison**: +- SQL: X seconds +- PQG: Y seconds +- **Use SQL for**: Bulk operations, aggregations +- **Use PQG for**: Single node traversal, learning, prototyping +``` + +### Step 3: Rewrite 3 Key Functions with PQG (Examples) + +Choose 3 representative functions to show PQG alternative: + +1. ✅ `get_sample_geo_context_via_sample_pid()` - Forward traversal +2. ✅ `get_samples_for_geo_pid()` - Reverse traversal +3. ✅ `export_site_subgraph()` - Subgraph extraction + +**Implementation**: +- Create `_pqg` suffixed versions alongside originals +- Add timing comparisons +- Document when to use each + +### Step 4: Add "PQG Learning Section" (New) + +New section at end of notebook: + +```markdown +## Using PQG for Interactive Exploration + +This section demonstrates using the PQG library for interactive graph exploration. +Use these patterns for prototyping and learning. For production queries, use the +optimized SQL versions shown earlier. + +### Basic Operations +- Node retrieval: `pqg_instance.getNode(pid)` +- Edge queries: `pqg_instance.getRelations(subject=..., predicate=...)` +- Entity search: `pqg_instance.getIds(otype="MaterialSampleRecord")` + +### Graph Traversal +[Examples of multi-hop traversal] + +### When to Use PQG vs SQL +[Decision matrix] +``` + +--- + +## Decision Matrix: PQG vs Custom SQL + +| Use Case | PQG | Custom SQL | Rationale | +|----------|-----|------------|-----------| +| Single node lookup | ✅ | ⚠️ | PQG handles row_id conversion, cleaner API | +| Multi-hop traversal (1-3 hops) | ✅ | ⚠️ | PQG more readable, acceptable performance | +| Reverse graph traversal | ⚠️ | ✅ | SQL more efficient for finding "what points to X" | +| Bulk aggregations (10K+ rows) | ❌ | ✅ | SQL dramatically faster | +| Visualization queries | ❌ | ✅ | Need specific projections, performance-critical | +| Data quality analysis | ❌ | ✅ | Requires full table scans | +| Learning/prototyping | ✅ | ⚠️ | PQG clearer for understanding graph structure | +| Production web queries | ❌ | ✅ | Eric's queries already optimized and tested | + +**Legend**: +- ✅ Recommended +- ⚠️ Works but not optimal +- ❌ Not recommended + +--- + +## Expected Benefits + +### Code Clarity +**Before**: +```sql +-- 30 lines of recursive CTE SQL +WITH RECURSIVE traverse AS (...) +SELECT ... FROM traverse JOIN ... +``` + +**After**: +```python +# 5 lines of PQG +sample = pqg_instance.getNode(sample_pid, max_depth=1) +event = pqg_instance.getNode(sample['produced_by'], max_depth=1) +geo = event['sample_location'] +``` + +### Learning Value +- **New users** can understand graph structure via PQG API +- **SQL experts** can see equivalent SQL for optimization +- **Comparison sections** show tradeoffs + +### Maintainability +- Less SQL to maintain for simple queries +- PQG handles schema changes (row_id conversion) +- Clear separation: PQG for exploration, SQL for production + +--- + +## Risks & Mitigations + +### Risk 1: Performance Regression +**Concern**: PQG might be slower for large queries +**Mitigation**: +- ✅ Keep all existing SQL queries as primary +- ✅ Add PQG as **alternative** in comparison sections +- ✅ Benchmark and document performance differences + +### Risk 2: API Limitations +**Concern**: PQG might not support all OpenContext-specific patterns +**Mitigation**: +- ✅ Use hybrid approach - PQG for basics, SQL for advanced +- ✅ Document gaps in "When to Use PQG vs SQL" section +- ✅ Contribute improvements back to pqg library if needed + +### Risk 3: Notebook Complexity +**Concern**: Adding PQG might make notebook harder to follow +**Mitigation**: +- ✅ Use collapsible sections for alternatives +- ✅ Clear headers: "SQL Approach" vs "PQG Approach" +- ✅ Summary tables showing when to use each + +--- + +## Success Criteria + +After integration, the notebook should: + +1. ✅ **Preserve all existing functionality** - Every query still works +2. ✅ **Show PQG alternatives** for 5-10 common patterns +3. ✅ **Include performance comparisons** - Clear benchmarks +4. ✅ **Have clear guidance** - Decision matrix for when to use each +5. ✅ **Be more accessible** - New users can learn via PQG, then optimize with SQL +6. ✅ **Maintain performance** - Production queries unchanged + +--- + +## Next Steps + +### Immediate (30 minutes) +1. ✅ Add PQG setup cell (Step 1) +2. ✅ Test basic operations (`getNode()`, `getRelations()`) +3. ✅ Verify row_id conversion works correctly + +### Short-term (2-3 hours) +4. ✅ Rewrite 1 function with PQG: `get_sample_geo_context_via_sample_pid()` +5. ✅ Add comparison section with timing +6. ✅ Document findings + +### Medium-term (1-2 sessions) +7. ✅ Add 2 more PQG function examples +8. ✅ Create "PQG Learning Section" at end +9. ✅ Add decision matrix to README + +### Long-term (optional) +10. ⏭️ Extract common patterns into helper module +11. ⏭️ Contribute enhancements back to pqg library +12. ⏭️ Create tutorial notebook: "Graph Queries with PQG" + +--- + +## Questions to Resolve + +1. **Performance baseline**: What's acceptable slowdown for PQG clarity benefits? + - Suggestion: 2-3x slower OK for single-node queries, not for bulk + +2. **API gaps**: Does PQG support reverse traversal efficiently? + - Need to test `getRelations(obj=geo_pid)` performance + +3. **Integration pattern**: Separate notebook or integrated sections? + - **Recommendation**: Integrated comparison sections (more useful) + +4. **Documentation location**: Where to put "When to use PQG" guide? + - **Recommendation**: Both in notebook AND in isamples-python README + +--- + +**Prepared by**: Claude Code (Sonnet 4.5) +**Date**: 2025-11-11 +**Next Action**: Discuss this plan, then implement Step 1 (PQG setup) diff --git a/QUICKREF_NOTEBOOKS.md b/QUICKREF_NOTEBOOKS.md new file mode 100644 index 0000000..484b221 --- /dev/null +++ b/QUICKREF_NOTEBOOKS.md @@ -0,0 +1,167 @@ +# Quick Reference: Notebook Workflows + +## Two Tools for Different Needs + +### 1. **nb_source_diff.py** - Quick Diffs Without Outputs +```bash +# One-off diff of any notebook vs git history +nb-diff notebook.ipynb HEAD +nb-diff notebook.ipynb HEAD~5 +``` +**Use when**: Quick comparison, unpaired notebooks, legacy files + +--- + +### 2. **jupytext pairing** - Permanent .py Companions +```bash +# Pair notebook (creates .py file) +~/bin/nb_pair.sh notebook.ipynb + +# Sync after editing +~/bin/nb_pair.sh --sync notebook.ipynb +``` +**Use when**: Active development, Claude Code editing, clean git workflow + +--- + +## Decision Tree + +``` +Need to diff a notebook? +├─ One-time comparison → nb-diff +└─ Ongoing development → jupytext pair + +Claude Code hitting token limits? +└─ Pair with jupytext, edit .py file + +Want clean git diffs? +├─ Quick → nb-diff +└─ Permanent → jupytext pair + commit .py + +Collaborating on notebooks? +└─ Pair all notebooks, commit .py files +``` + +--- + +## Setup New Notebook (Recommended) + +```bash +# 1. Create notebook in Jupyter +jupyter lab + +# 2. Pair immediately +~/bin/nb_pair.sh examples/basic/my_analysis.ipynb + +# 3. Add to git +git add examples/basic/my_analysis.py + +# 4. Develop normally - changes auto-sync +``` + +--- + +## Quick Commands Cheat Sheet + +```bash +# DIFF TOOLS +nb-diff notebook.ipynb # vs HEAD +nb-diff notebook.ipynb HEAD~3 # vs 3 commits ago + +# PAIRING +~/bin/nb_pair.sh notebook.ipynb # Pair (create .py) +~/bin/nb_pair.sh --sync notebook.ipynb # Sync changes +~/bin/nb_pair.sh examples/**/*.ipynb # Pair all + +# JUPYTEXT DIRECT +jupytext --set-formats ipynb,py:percent notebook.ipynb # Pair +jupytext --sync notebook.ipynb # Sync +``` + +--- + +## Claude Code Editing Workflow + +### Problem: Large notebook with outputs exceeds token limits + +### Solution: Edit .py companion + +```bash +# 1. Pair notebook (if not already paired) +~/bin/nb_pair.sh notebook.ipynb + +# 2. Tell Claude to edit: notebook.py (NOT .ipynb) +# Claude edits clean .py file without output noise + +# 3. Sync back to notebook +~/bin/nb_pair.sh --sync notebook.ipynb + +# 4. Run in Jupyter to regenerate outputs +jupyter lab +``` + +--- + +## Git Workflow with Pairing + +```bash +# Development +jupyter lab my_notebook.ipynb # Edit in Jupyter +# Changes auto-sync to my_notebook.py on save + +# Commit BOTH files (recommended!) +git status # Shows both files changed +git diff my_notebook.py # Review code changes (clean!) +git diff my_notebook.ipynb # Review output changes (optional) +git add my_notebook.ipynb my_notebook.py +git commit -m "Add new analysis" + +# PR Review +# Reviewers can: +# - Check .py for code changes (clean diffs) +# - Check .ipynb for output changes (rendered on GitHub) +# - Best of both worlds! +``` + +--- + +## Migration: Existing Notebooks + +```bash +# Pair all notebooks in project +find examples -name "*.ipynb" -exec ~/bin/nb_pair.sh {} \; + +# Commit BOTH .ipynb and .py files (recommended) +git add examples/**/*.ipynb examples/**/*.py +git commit -m "Add jupytext pairing to all notebooks" + +# Or if outputs are problematic (less common): +# git add examples/**/*.py +# echo "*.ipynb" >> .gitignore +# git commit -m "Add .py companions, ignore .ipynb" +``` + +--- + +## Troubleshooting + +| Problem | Solution | +|---------|----------| +| Changes not syncing | `~/bin/nb_pair.sh --sync notebook.ipynb` | +| Claude hits token limit | Edit `notebook.py` instead of `notebook.ipynb` | +| Git diff too noisy | Use `nb-diff` or pair with jupytext | +| Want to stop pairing | `~/bin/nb_pair.sh --unpair notebook.ipynb` | +| Merge conflict | Resolve in `.py`, then `--sync` | + +--- + +## Files & Docs + +- **Helper script**: `~/bin/nb_pair.sh` +- **Diff tool**: `~/bin/nb_source_diff.py` +- **Full guide**: `JUPYTEXT_WORKFLOW.md` +- **This quickref**: `QUICKREF_NOTEBOOKS.md` + +--- + +**Last Updated**: 2025-10-15 diff --git a/README.md b/README.md index b620f86..e85d68d 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,114 @@ -# examples -Examples of interacting with iSamples API +# isamples-python + +Python client library and examples for working with iSamples material sample data across scientific domains (geology, biology, archaeology, etc.), with a focus on high-performance geoparquet analysis and visualization. + +## Quick Start + +```bash +# Install dependencies +poetry install --with examples + +# Activate environment +poetry shell + +# Launch Jupyter for examples +jupyter lab examples/ +``` + +## Overview + +This repository provides Python tools for analyzing material sample data from the iSamples project. The iSamples metadata model is **domain-agnostic**, supporting samples from geology, biology, archaeology, environmental science, and other fields. Originally designed to work with the iSamples API, it has evolved to focus on **offline-first, geoparquet-centric workflows** using modern spatial data tools. + +### Key Capabilities + +- **High-performance visualization** with [Lonboard](https://github.com/developmentseed/lonboard) WebGL mapping +- **Efficient spatial queries** using DuckDB on remote parquet files +- **Interactive Jupyter notebooks** for cross-domain sample data exploration +- **API-independent workflows** accessing data via HTTP range requests + +## Architecture + +### Python Client Library (`src/isamples_client/`) + +Three client classes for different use cases: + +1. **`IsbClient`**: Basic HTTP client using httpx +2. **`IsbClient2`**: Enhanced Solr client with complex query support +3. **`ISamplesBulkHandler`**: Bulk data operations with authentication + +**Note**: API clients currently target `https://central.isample.xyz/isamples_central/` which may be offline. See [STATUS.md](STATUS.md) for current issues and workarounds. + +### Key Examples + +- **`examples/basic/geoparquet.ipynb`** ⭐ - Advanced lonboard visualization with zoom-layered rendering +- **`examples/basic/oc_parquet_analysis_enhanced.ipynb`** ⭐ - **NEW**: iSamples property graph analysis using OpenContext archaeological data with Ibis and DuckDB +- **`examples/basic/isample-archive.ipynb`** - Remote parquet analysis via DuckDB +- **`examples/basic/record_counts.ipynb`** - Quick visualization patterns +- **`examples/basic/oc_parquet_analysis.ipynb`** - Basic OpenContext parquet exploration + +The enhanced OpenContext notebook demonstrates: +- **Property graph traversal** through complex multi-hop joins +- **Ibis vs raw SQL** comparison for readable query construction +- **Corrected relationship paths** for sample-to-location queries +- **Performance optimization** techniques for 11M+ row datasets + +See [examples/README.md](examples/README.md) for detailed notebook descriptions. + +## Technology Stack + +- **Spatial Analysis**: GeoPandas, DuckDB, Shapely, **Ibis** (new) +- **Visualization**: Lonboard, Matplotlib, Folium, Cartopy +- **Data Processing**: Pandas, Polars, PyArrow +- **Jupyter Ecosystem**: IPyWidgets, IPyDatagrid, Sidecar + +## Development + +### Commands + +```bash +# Install with examples dependencies +poetry install --with examples + +# Run tests +poetry run pytest tests/ + +# Run Playwright tests (web scraping) +cd playwright && npx playwright test + +# Docker Jupyter environment +./run_docker.sh [port] # default port 8890 +``` + +### Current Focus: Geoparquet Workflows + +This repository is transitioning from API-dependent to **offline-first geoparquet analysis**: + +- ✅ Remote parquet processing via DuckDB HTTP range requests +- ✅ High-performance WebGL visualization with Lonboard +- ✅ Interactive cross-domain sample data exploration notebooks +- 🚧 API fallback mechanisms and error handling +- 🚧 Consolidated development environment + +See [STATUS.md](STATUS.md) for detailed WIP status and loose ends. + +## Ecosystem Integration + +### Companion Repository: [isamplesorg.github.io](https://github.com/isamplesorg/isamplesorg.github.io) +**Public website with browser-based tutorials and documentation** + +**Complementary roles**: +- 🔗 **This repo (`isamples-python`)**: Local development, advanced analysis, Python ecosystem +- 🌐 **Website repo**: Public tutorials, universal browser access, educational content + +**Shared technology**: Both use DuckDB + geoparquet for efficient data analysis +- Same data sources (Zenodo archives, HTTP range requests) +- Compatible visualization approaches (lonboard ↔ Observable Plot) +- Coordinated development patterns + +See [CROSS_REPO_ALIGNMENT.md](CROSS_REPO_ALIGNMENT.md) for detailed integration strategy. + +## Related Projects + +- [iSamples](https://www.isamples.org/) - Internet of Samples project (domain-agnostic material sample metadata) +- [Lonboard](https://github.com/developmentseed/lonboard) - Fast geospatial visualization +- [DuckDB](https://duckdb.org/) - High-performance analytical database diff --git a/SESSION_SUMMARY.md b/SESSION_SUMMARY.md new file mode 100644 index 0000000..07593ec --- /dev/null +++ b/SESSION_SUMMARY.md @@ -0,0 +1,364 @@ +# iSamples Session Summary + +**Date**: 2025-11-13 +**Status**: ✅ **READY** - PQG Demo Notebook Complete, Next Phase Planning + +--- + +## ✅ What We Accomplished + +### 1. Created PQG Demo Notebook +- **File**: `examples/basic/pqg_demo.ipynb` +- **Action**: Built comprehensive working notebook demonstrating PQG library with OpenContext data +- **Testing**: All examples run successfully with 11.6M record parquet file +- **Content**: 5 examples comparing PQG vs SQL approaches +- **Result**: Working foundation for exploring PQG capabilities + +### 2. Debugged Initial Implementation +- **Problem**: Initial notebook had critical errors (missing `source` parameter, misunderstood `max_depth` behavior) +- **User Fixed**: Corrected in VSCode with proper PQG initialization +- **Key Learning**: `max_depth=1` returns fully expanded dictionaries, not PIDs +- **Result**: Claude now understands PQG's relationship expansion feature correctly + +### 3. Committed and Pushed Work +- **Commit**: `d5dc75d` on `exploratory` branch +- **Files**: `pqg_demo.ipynb`, `PQG_INTEGRATION_PLAN.md`, `SESSION_SUMMARY.md` +- **Status**: Pushed to `origin/exploratory` + +--- + +## 🔍 Key Findings + +### 1. PQG Demo Is Too SQL-Heavy +**Discovery**: Notebook became "SQL vs PQG comparison" instead of "PQG in action" showcase. + +**User Feedback**: "what is a bit sad about this demo is that the pqg module isn't used that much, right? Lots of custom SQL?" + +**Why it matters**: +- Integration plan's defensive tone ("use SQL for real work") influenced design +- Should celebrate PQG's strengths first, comparisons second +- Current approach feels apologetic rather than exploratory + +**Decision**: Keep current notebook as working baseline, use it to push PQG harder + +### 2. `max_depth` Is More Powerful Than Expected +**Discovery**: When `max_depth=1`, PQG returns **fully expanded dictionaries** for related nodes. + +**What Claude got wrong initially**: +```python +# Claude's broken code: +event_pid = sample.get('produced_by') # Thought this was a PID string +event = pqg_instance.getNode(event_pid) # Unnecessary fetch! + +# Correct usage: +produced_by = sample.get('produced_by') # This is ALREADY a full dict! +event = produced_by # Just use it directly +``` + +**Impact**: PQG's relationship expansion is actually quite powerful - one API call gives you entire neighborhood + +### 3. PQG Initialization for Parquet Files +**Discovery**: Parquet files require explicit `source` parameter: +```python +parquet_source = f"read_parquet('{parquet_path}')" +pqg_instance = pqg.PQG(dbinstance=conn, source=parquet_source) +``` + +**Also needed**: Manual `_types` initialization when parquet lacks PQG metadata + +### 4. Identified PQG Enhancement Opportunities +**Areas where PQG could improve**: +1. Bulk relationship queries (current: manual iteration) +2. Reverse traversal optimization (Example 4 returned 0 results) +3. Subgraph extraction (no built-in method) +4. Pattern matching (declarative queries vs manual loops) + +**Next Phase Goal**: Push PQG to its limits to identify concrete enhancement targets for contributing back to pqg library + +--- + +## 📁 Files Generated This Session + +### Keep (Committed to Git) + +#### isamples-python repository +- ✅ `examples/basic/pqg_demo.ipynb` - **NEW** Working PQG demonstration notebook + - 5 examples: single node, relationships, traversal, reverse lookup, aggregations + - Performance comparisons with SQL + - Decision matrix for when to use each approach + - ~30 cells, fully tested + +- ✅ `PQG_INTEGRATION_PLAN.md` - Strategic integration plan (from Nov 11 session) + - 400+ lines analyzing hybrid PQG/SQL approach + - Decision matrix and 4-phase implementation strategy + - Referenced in current work but not modified today + +- ✅ `SESSION_SUMMARY.md` - This file (updated from Nov 11 version) + +**Commit**: `d5dc75d` - "Add PQG demonstration notebook and integration planning" +**Branch**: `exploratory` +**Status**: ✅ Pushed to origin + +### Not Modified (Still Uncommitted from Previous Session) + +- ⏸️ `examples/basic/oc_parquet_analysis_enhanced.ipynb` - Modified but not committed +- ⏸️ `pyproject.toml` - Modified (added seaborn) but not committed +- ⏸️ `examples/basic/isamples_explore.py` - Untracked file + +--- + +## 🎯 Next Steps (Prioritized) + +### 🟢 HIGH Priority (Ready to Execute) + +#### 1. Push PQG to Its Limits (30-60 min) 🟡 MEDIUM RISK +**Action**: Modify `pqg_demo.ipynb` to explore PQG's boundaries + +**What to try**: +- Large-scale relationship queries (10K+ nodes) +- Complex multi-hop traversals (4-5 hops) +- Subgraph extraction patterns +- Pattern matching (find all samples with coords + keywords) +- Reverse traversal deep dive (why did Example 4 return 0 results?) + +**Risk**: May discover significant API gaps or performance issues +**Mitigation**: Document limitations as potential enhancement targets + +**Goal**: Generate concrete list of "PQG should be able to do X but can't/struggles" + +#### 2. Decide on Enhancement Strategy (15 min) 🔴 LOW RISK +**Action**: After pushing PQG hard, decide together: + +**Option A**: Contribute enhancements back to pqg library +- Requires: Fork, implement, test, PR +- Timeline: Multi-session effort +- Impact: Benefits entire PQG community + +**Option B**: Create iSamples-specific helper layer +- Requires: New module in isamples-python +- Timeline: Single session +- Impact: Immediate value for iSamples users + +**Option C**: Document patterns and workarounds +- Requires: Update integration plan with "PQG recipes" +- Timeline: Current session +- Impact: Knowledge sharing without code + +### 🟡 MEDIUM Priority (This Week) + +#### 3. Create "PQG Exploration" Notebook (1-2 hours) 🟡 MEDIUM RISK +**Action**: New notebook focused on **discovery workflow**, not comparisons + +**Structure**: +1. "Exploring an Unknown Graph" - Use PQG to understand structure +2. "Cool Graph Queries" - Show off PQG's strengths +3. "Complex Relationships" - Where PQG shines vs SQL pain +4. "When to Switch to SQL" - Honest but at the end + +**Deliverable**: `examples/basic/pqg_exploration.ipynb` + +#### 4. Commit Remaining Uncommitted Changes (10 min) 🔴 LOW RISK +**Action**: Review and commit `oc_parquet_analysis_enhanced.ipynb`, `pyproject.toml` + +**Why delayed**: Focus on PQG demo first, clean up after + +### 🔵 LOW Priority (Future) + +#### 5. Extract Visualization Patterns (2-3 hours) +**Action**: Create reusable viz module from notebook patterns +**Reference**: Lonboard patterns from `oc_parquet_analysis_enhanced.ipynb` + +#### 6. Cross-Domain Examples (TBD) +**Action**: Create examples with SESAR/GEOME data (not just OpenContext) +**Goal**: Demonstrate domain-agnostic nature of iSamples model + +--- + +## 🚫 Current Blockers + +**None** ✅ + +All technical work completed successfully: +- ✅ Notebook runs without errors +- ✅ PQG initialization working +- ✅ Git commit and push successful + +**Waiting on**: +- Your decision on how hard to push PQG (in current notebook vs new one) +- Your preference on enhancement strategy (contribute vs helper layer vs document) + +--- + +## 🔧 Technical Setup Notes + +### Repository States + +#### isamples-python +**Location**: `/Users/raymondyee/C/src/iSamples/isamples-python` +**Branch**: `exploratory` +**Remote**: `origin = git@github.com:rdhyee/isamples-python.git` + +**Status**: +``` +✅ Latest commit: d5dc75d (PQG demo + integration plan) +✅ Pushed to origin/exploratory +⏸️ Uncommitted: oc_parquet_analysis_enhanced.ipynb, pyproject.toml, isamples_explore.py +``` + +**Virtual env**: Managed by Poetry +**Activate**: `cd isamples-python && poetry shell` + +#### pqg +**Location**: `/Users/raymondyee/C/src/iSamples/pqg` +**Branch**: `claude/improve-documentation-011CV19CYZTUTA2CZL5msSTr` (from Nov 11 session) +**Status**: ✅ PR #5 ready for review, all work from Nov 11 complete +**Virtual env**: `.venv/` (uv-managed, Python 3.12.9) + +### Data Files + +#### OpenContext Parquet +**Location**: `~/Data/iSample/pqg_refining/oc_isamples_pqg.parquet` +**Size**: 691MB +**Records**: 11,637,144 total (9.2M edges, 2.4M nodes) +**Schema**: INTEGER row_id (validated against PR #4) +**Status**: ✅ Working with PQG demo notebook + +### Key Commands + +**Launch notebook**: +```bash +cd /Users/raymondyee/C/src/iSamples/isamples-python +poetry shell +jupyter lab examples/basic/pqg_demo.ipynb +``` + +**Test PQG with parquet** (standalone): +```bash +cd /Users/raymondyee/C/src/iSamples/pqg +source .venv/bin/activate +python3 << 'EOF' +import duckdb +from pqg import pqg_singletable as pqg + +conn = duckdb.connect() +parquet_path = "~/Data/iSample/pqg_refining/oc_isamples_pqg.parquet" +pqg_instance = pqg.PQG(conn, source=f"read_parquet('{parquet_path}')") +print("✅ PQG loaded") +EOF +``` + +--- + +## 📊 Session Statistics + +**Duration**: ~1.5 hours (13:00-14:30 estimated) +**Repositories touched**: 1 (isamples-python) +**Files created**: 1 (pqg_demo.ipynb) +**Files updated**: 1 (SESSION_SUMMARY.md) +**Commits**: 1 (d5dc75d) +**Lines added**: ~850 (notebook content) +**Key insight**: PQG demo too defensive, need to push boundaries + +--- + +## 🎓 Lessons Learned + +### 1. "Comparison" != "Demonstration" +**Lesson**: The integration plan's hybrid approach led to a notebook that apologizes for PQG instead of showcasing it. + +**Why it matters**: When building demos, lead with strengths. Comparisons belong at the end or in separate documentation. + +**Apply next time**: Start with "what can this do?" before "when should you use something else?" + +### 2. Read the Actual Object Behavior +**Lesson**: Claude assumed `max_depth=1` returned PIDs to fetch. User's debugging revealed it returns full dicts. + +**Why it matters**: API assumptions without testing lead to unnecessarily complex code. + +**Apply next time**: When demonstrating a library, run simple experiments first to understand actual behavior. + +### 3. Parquet-Based PQG Requires Different Initialization +**Lesson**: PQG needs `source=read_parquet(...)` for parquet files, not just a view name. + +**Why it matters**: Different data sources have different initialization patterns. + +**Apply next time**: Check library docs for format-specific initialization requirements. + +### 4. User Feedback Reveals True Intent +**Lesson**: User's "a bit sad" comment revealed the notebook missed the mark on being a PQG showcase. + +**Why it matters**: Honest feedback helps course-correct before investing more time in wrong direction. + +**Action taken**: Shifted strategy to "push PQG hard to find real boundaries" + +--- + +## 🔗 Related Resources + +**Notebooks**: +- Current: `/Users/raymondyee/C/src/iSamples/isamples-python/examples/basic/pqg_demo.ipynb` +- Reference: `examples/basic/oc_parquet_analysis_enhanced.ipynb` (production SQL patterns) + +**Documentation**: +- Integration Plan: `PQG_INTEGRATION_PLAN.md` (Nov 11) +- PQG Repo: https://github.com/isamplesorg/pqg +- PQG Docs: https://github.com/isamplesorg/pqg/tree/main/docs + +**Previous Work**: +- Nov 11 Session: PR #4 merged, PR #5 updated, integration plan created +- Commit history: `git log --oneline exploratory` + +**Dev Journal**: +- Today: `~/dev-journal/daily/2025-11-13.md` +- Project: `~/dev-journal/projects/isamples.md` + +--- + +## Quick Resume Checklist + +**Next session, start here:** + +1. [ ] Read this SESSION_SUMMARY.md +2. [ ] **DECISION**: How to push PQG boundaries? + - Modify existing `pqg_demo.ipynb` OR + - Create new `pqg_exploration.ipynb` OR + - Run experiments in REPL first +3. [ ] Try these PQG challenges: + - Large-scale relationship queries (10K+ nodes) + - Multi-hop traversals (4-5 hops deep) + - Subgraph extraction patterns + - Pattern matching ("find samples with X AND Y") + - Debug why Example 4 returned 0 results +4. [ ] Document limitations discovered +5. [ ] **DECISION**: Enhancement strategy? + - Contribute to PQG library + - Create iSamples helper layer + - Document patterns/workarounds + +--- + +## 📍 Context for Others + +**What was delivered**: +- ✅ PQG demo notebook: Working examples with OpenContext data (11.6M records) +- ✅ All code tested and committed to exploratory branch +- ✅ Claude learned PQG initialization and `max_depth` behavior +- ✅ Identified next phase: Push PQG boundaries to find enhancement opportunities + +**Current state**: +- Repository clean (uncommitted files are pre-existing from Nov 11) +- Notebook runs successfully +- PQG library integration understood +- Ready for exploration phase + +**Next session can immediately**: +- Run notebook and start experimenting with PQG limits +- Try complex graph queries to stress-test API +- Document enhancement opportunities +- Decide on contribution strategy + +--- + +**Last Updated**: 2025-11-13 by Claude Code (Sonnet 4.5) +**Session Duration**: ~1.5 hours +**Session Status**: ✅ **READY - Foundation Complete, Exploration Phase Next** diff --git a/STATUS.md b/STATUS.md new file mode 100644 index 0000000..4789259 --- /dev/null +++ b/STATUS.md @@ -0,0 +1,116 @@ +# Project Status - iSamples Python + +**Last Updated**: 2025-09-05 +**Branch**: `exploratory` +**Status**: Heavy WIP transitioning from API-dependent to geoparquet-focused workflows + +## Current State Overview + +This repository is in active development, pivoting from iSamples API integration to **offline-first geoparquet analysis** due to the central API being offline. The codebase contains excellent foundations for geological data visualization but has several loose ends that need resolution. + +## 🚨 Critical Issues + +### API Dependency Problems +- **Offline API**: `ISB_SERVER = "https://central.isample.xyz/isamples_central/"` is currently unreachable +- **No fallback mechanisms**: All three client classes (`IsbClient`, `IsbClient2`, `ISamplesBulkHandler`) will fail +- **Authentication workflows broken**: Bulk handler requires tokens from offline service + +### Code Issues +- **lonboard parameter error** in `examples/basic/record_counts.ipynb:69`: Incorrect `zoom`/`center` parameters for Map constructor +- **Hardcoded paths**: Several notebooks contain user-specific paths that need generalization + +## 🚧 Work In Progress Areas + +### 1. Development Environment Inconsistencies +- **Mixed package managers**: Poetry (main) + npm scattered in multiple locations + - Root: `package.json`, `package-lock.json` + - `examples/basic/`: Node.js setup + - `playwright/`: Separate npm environment +- **Node modules duplication**: `node_modules/` in multiple directories + +### 2. JavaScript Integration Experiments +- **Incomplete experiments**: + - `examples/basic/hello_encode.js` - partial implementation + - `examples/spatial/cesium_points.ipynb` - 3D visualization experiments + - `javascript/stream.ipynb` - streaming data experiments +- **Playwright infrastructure**: Web scraping setup but unclear integration purpose + +### 3. Incomplete Example Files +``` +examples/basic/ +├── bone.xlsx + ~$bone.xlsx (Excel temp file - should be cleaned) +├── subset.py (basic operations, undocumented) +├── zenodo_metadata.json (archival metadata, good for offline workflows) +└── hello_encode.js (incomplete JavaScript experiment) +``` + +### 4. Testing Infrastructure Gaps +- **Minimal test coverage**: Only basic structure in `tests/` +- **No integration tests**: For the core client classes +- **Playwright tests**: Present but targeting demo todo app, not iSamples functionality + +## ✅ Working Well (Build On These) + +### Excellent Visualization Patterns +- **`examples/basic/geoparquet.ipynb`** contains sophisticated lonboard code: + - Zoom-layered rendering with `create_zoom_layers()` + - Interactive color mapping by geological source + - Efficient WebGL point cloud visualization + - Well-documented functions for reuse + +### Successful API-Free Workflows +- **`examples/basic/isample-archive.ipynb`** demonstrates: + - Remote parquet access via HTTP range requests + - DuckDB efficient spatial queries + - Zenodo archive integration + - No API dependencies + +### Robust Technology Stack +- **Core dependencies** properly managed in `pyproject.toml` +- **Spatial analysis tools**: GeoPandas, DuckDB, Shapely all working +- **Jupyter integration**: ipywidgets, sidecar, etc. functional + +## 🎯 Recommended Next Steps + +### Priority 1: API Issues +1. **Add offline detection** to client classes with graceful fallbacks +2. **Document workarounds** for API-dependent examples +3. **Create mock data** for testing without API access + +### Priority 2: Environment Consolidation +1. **Standardize Node.js usage**: Single package.json or eliminate if unnecessary +2. **Clean up temp files**: Remove `~$bone.xlsx` and similar artifacts +3. **Generalize paths**: Remove user-specific hardcoded paths from notebooks + +### Priority 3: Documentation & Testing +1. **Complete examples/README.md**: Document each notebook's purpose and data requirements +2. **Add integration tests**: For successful offline workflows +3. **Create troubleshooting guide**: Common issues and solutions + +### Priority 4: Code Quality +1. **Fix lonboard parameter errors** in record_counts notebook +2. **Extract reusable functions** from geoparquet.ipynb visualization code +3. **Add error handling** throughout the codebase + +## 🔄 Strategic Direction + +**From**: API-dependent geological data analysis +**To**: Offline-first geoparquet workflows with modern spatial tools + +**Key Success Metrics**: +- All examples run without API dependencies +- Clear documentation for new users +- Reusable visualization patterns +- Robust error handling + +## Files Needing Immediate Attention + +1. `examples/basic/record_counts.ipynb` - Fix lonboard Map parameters +2. `src/isamples_client/isbclient.py` - Add offline detection +3. `examples/basic/` - Clean up temporary/experimental files +4. Root directory - Consolidate Node.js dependencies +5. `tests/` - Add meaningful test coverage + +--- + +*This status document should be updated as issues are resolved and new ones discovered.* \ No newline at end of file diff --git a/basic/record_counts.ipynb b/basic/record_counts.ipynb deleted file mode 100644 index 9f22cd1..0000000 --- a/basic/record_counts.ipynb +++ /dev/null @@ -1,630 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "ExecuteTime": { - "end_time": "2023-10-28T13:01:34.491834Z", - "start_time": "2023-10-28T13:01:34.342886Z" - }, - "collapsed": false - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:httpx:HTTP Request: GET https://central.isample.xyz/isamples_central/thing/select?rows=0&q=%2A%3A%2A \"HTTP/1.1 200 OK\"\n", - "INFO:root:url = https://central.isample.xyz/isamples_central/thing/select?rows=0&q=%2A%3A%2A\n" - ] - }, - { - "data": { - "text/plain": [ - "6347967" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import json\n", - "import logging\n", - "import typing\n", - "import urllib.parse\n", - "import httpx\n", - "import xarray\n", - "\n", - "ISB_SERVER = \"https://central.isample.xyz/isamples_central/\"\n", - "TIMEOUT = 10 #seconds\n", - "USER_AGENT = \"Python/3.11 isamples.examples\"\n", - "\n", - "logging.basicConfig(level=logging.INFO)\n", - "L = logging.getLogger()\n", - "\n", - "class IsbClient:\n", - " \"\"\"A client for iSamples.\n", - " \"\"\"\n", - "\n", - " def __init__(self, isb_server:str=None):\n", - " self.isb_server = ISB_SERVER if isb_server is None else isb_server\n", - " self.isb_server = self.isb_server.strip(\" /\") + \"/\"\n", - " self.session = httpx.Client()\n", - "\n", - " def _request(self, path:str, params=None)->typing.Any:\n", - " headers = {\n", - " \"Accept\": \"application/json\",\n", - " \"User-Agent\": USER_AGENT\n", - " }\n", - " url = urllib.parse.urljoin(self.isb_server, path)\n", - " response = self.session.get(url, params=params, headers=headers, timeout=TIMEOUT)\n", - " L.info(\"url = %s\", response.url)\n", - " return response.json()\n", - "\n", - " def field_names(self)->typing.List[str]:\n", - " \"\"\"Return a list of field names available in the Solr endpoint.\n", - " \"\"\"\n", - " response = self._request(\"thing/select/info\")\n", - " fields = [k for k in response.get(\"schema\",{}).get(\"fields\", {}).keys()]\n", - " return fields\n", - "\n", - " def record_count(self, q:str)->int:\n", - " \"\"\"Number of records matching query q\n", - " \"\"\"\n", - " params = httpx.QueryParams(rows=0, q=q)\n", - " response = self._request(\"thing/select\", params)\n", - " return response.get(\"response\", {}).get(\"numFound\", -1)\n", - "\n", - " def facets(self, q:str, fields:typing.List[str]) -> typing.Dict[str, typing.Dict[str, int]]:\n", - " \"\"\"Get facet values and counts for the records matching query q and specified fields.\n", - "\n", - " Response is a dict of dicts:\n", - " {\n", - " field_name: {\n", - " facet_value: count,\n", - " ...\n", - " },\n", - " ...\n", - " }\n", - " \"\"\"\n", - " params = httpx.QueryParams(rows=0, q=q, facet=\"true\")\n", - " params = params.add(\"facet.mincount\", 0)\n", - " for field in fields:\n", - " params = params.add(\"facet.field\", field)\n", - " response = self._request(\"thing/select\", params)\n", - " res = {}\n", - " for field in fields:\n", - " counts = {}\n", - " vals = response.get(\"facet_counts\",{}).get(\"facet_fields\",{}).get(field, [])\n", - " for i in range(0, len(vals), 2):\n", - " k = vals[i]\n", - " v = vals[i+1]\n", - " counts[k] = v\n", - " res[field] = counts\n", - " return res\n", - "\n", - "\n", - " def pivot(self, q:str, dimensions:typing.List[str])-> xarray.DataArray:\n", - " \"\"\"Return an n-dimensional xarray of counts for specified fields\n", - " \"\"\"\n", - "\n", - " def _normalize_facet(v:str):\n", - " return v.strip().lower()\n", - "\n", - " def _get_coordinates(data, dimensions, coordinates):\n", - " \"\"\"Get the coordinate index values from the facet response. \n", - " \"\"\"\n", - " for entry in data:\n", - " v = _normalize_facet(entry.get(\"value\"))\n", - " f = entry.get(\"field\")\n", - " if f is not None and v not in coordinates[f]:\n", - " coordinates[f].append(v)\n", - " _get_coordinates(entry.get(\"pivot\", []), dimensions, coordinates)\n", - "\n", - " def _value_structure(dimensions, coordinates, cdim=0):\n", - " \"\"\"Populate an empty value structure for holding the facet counts\n", - " \"\"\"\n", - " nvalues = len(coordinates[dimensions[cdim]])\n", - " if cdim >= len(dimensions)-1:\n", - " return [0,]*nvalues\n", - " return [_value_structure(dimensions, coordinates, cdim=cdim+1)]*nvalues\n", - "\n", - " def _set_values(values, data, coord):\n", - " \"\"\"Populate the xarray with the facet count values.\n", - " \"\"\"\n", - " for entry in data:\n", - " coord[entry.get(\"field\")] = _normalize_facet(entry.get(\"value\"))\n", - " p = entry.get(\"pivot\", None)\n", - " if p is None:\n", - " values.loc[coord] = values.loc[coord] + entry.get(\"count\")\n", - " else:\n", - " _set_values(values, p, coord)\n", - " coord.popitem()\n", - "\n", - " if len(dimensions) < 2:\n", - " raise ValueError(\"At least two dimensions required for pivot.\")\n", - " params = httpx.QueryParams(rows=0, q=q)\n", - " params = params.add(\"facet\", \"true\")\n", - " params = params.add(\"facet.mincount\", 0)\n", - " params = params.add(\"facet.pivot\", \",\".join(dimensions))\n", - " response = self._request(\"thing/select\", params)\n", - " fkey = \",\".join(dimensions)\n", - " data = response.get(\"facet_counts\", {}).get(\"facet_pivot\", {}).get(fkey, [])\n", - " coordinates = {k:[] for k in dimensions}\n", - " _get_coordinates(data, dimensions, coordinates)\n", - " values = _value_structure(dimensions, coordinates)\n", - " xd = xarray.DataArray(values, coords=coordinates, dims=dimensions)\n", - " _set_values(xd, data, {})\n", - " return xd\n", - "\n", - "\n", - "cli = IsbClient()\n", - "cli.record_count(\"*:*\")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:httpx:HTTP Request: GET https://central.isample.xyz/isamples_central/thing/select?rows=0&q=%2A%3A%2A&facet=true&facet.mincount=0&facet.field=source&facet.field=hasMaterialCategory&facet.field=hasContextCategory \"HTTP/1.1 200 OK\"\n", - "INFO:root:url = https://central.isample.xyz/isamples_central/thing/select?rows=0&q=%2A%3A%2A&facet=true&facet.mincount=0&facet.field=source&facet.field=hasMaterialCategory&facet.field=hasContextCategory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{\n", - " \"source\": {\n", - " \"SESAR\": 4688386,\n", - " \"OPENCONTEXT\": 853229,\n", - " \"GEOME\": 554320,\n", - " \"SMITHSONIAN\": 213411\n", - " },\n", - " \"hasMaterialCategory\": {\n", - " \"Natural Solid Material\": 2233939,\n", - " \"Organic material\": 1108614,\n", - " \"Rock\": 913127,\n", - " \" rock\": 838805,\n", - " \" sediment\": 838805,\n", - " \"Mixed soil\": 838805,\n", - " \"Biogenic non organic material\": 484858,\n", - " \"Material\": 462472,\n", - " \"Mineral\": 391088,\n", - " \"Biogenic non-organic material\": 346242,\n", - " \"Anthropogenic metal\": 184888,\n", - " \"Natural solid material\": 182909,\n", - " \"Not Provided\": 181260,\n", - " \"Anthropogenic material\": 177576,\n", - " \"Sediment\": 94084,\n", - " \"Soil\": 37153,\n", - " \"Liquid water\": 25777,\n", - " \"Gaseous material\": 1225,\n", - " \"Particulate\": 124,\n", - " \"Non-aqueous liquid material\": 46,\n", - " \"Ice\": 8\n", - " },\n", - " \"hasContextCategory\": {\n", - " \"Not Provided\": 3984022,\n", - " \"Site of past human activities\": 853229,\n", - " \"Earth interior\": 665766,\n", - " \"Animalia\": 391453,\n", - " \"Subaerial surface environment\": 108123,\n", - " \"Marine water body\": 56520,\n", - " \"Marine water body bottom\": 53641,\n", - " \"Lake river or stream bottom\": 14582,\n", - " \"Terrestrial water body\": 10792,\n", - " \"Plantae\": 9417,\n", - " \"Active human occupation site\": 4040,\n", - " \"Fungi\": 3793,\n", - " \"Lake, river or stream bottom\": 1697,\n", - " \"Subsurface fluid reservoir\": 1680,\n", - " \"Marine biome\": 1661,\n", - " \"Chromista\": 1184,\n", - " \"Subaerial terrestrial biome\": 133,\n", - " \"Bacteria\": 4,\n", - " \"Protozoa\": 4\n", - " }\n", - "}\n" - ] - } - ], - "source": [ - "fields = [\"source\", \"hasMaterialCategory\", \"hasContextCategory\"]\n", - "facets = cli.facets(\"*:*\", fields)\n", - "print(json.dumps(facets, indent=2))" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:httpx:HTTP Request: GET https://central.isample.xyz/isamples_central/thing/select?rows=0&q=%2A%3A%2A&facet=true&facet.mincount=0&facet.pivot=source%2ChasMaterialCategory%2ChasContextCategory \"HTTP/1.1 200 OK\"\n", - "INFO:root:url = https://central.isample.xyz/isamples_central/thing/select?rows=0&q=%2A%3A%2A&facet=true&facet.mincount=0&facet.pivot=source%2ChasMaterialCategory%2ChasContextCategory\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "array(4)\n", - "Coordinates:\n", - " source \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
sourcesesaropencontextgeomesmithsonian
hasMaterialCategory
natural solid material223393918290900
rock175252027200
sediment932889000
mixed soil838805000
material462472000
mineral39079729100
biogenic non-organic material346242000
organic material28183459049405855213411
not provided4717313408700
soil37153000
liquid water25777000
gaseous material1225000
anthropogenic material30117727500
particulate124000
non-aqueous liquid material46000
ice8000
biogenic non organic material048485800
anthropogenic metal018488800
\n", - "" - ], - "text/plain": [ - "source sesar opencontext geome smithsonian\n", - "hasMaterialCategory \n", - "natural solid material 2233939 182909 0 0\n", - "rock 1752520 272 0 0\n", - "sediment 932889 0 0 0\n", - "mixed soil 838805 0 0 0\n", - "material 462472 0 0 0\n", - "mineral 390797 291 0 0\n", - "biogenic non-organic material 346242 0 0 0\n", - "organic material 281834 59049 405855 213411\n", - "not provided 47173 134087 0 0\n", - "soil 37153 0 0 0\n", - "liquid water 25777 0 0 0\n", - "gaseous material 1225 0 0 0\n", - "anthropogenic material 301 177275 0 0\n", - "particulate 124 0 0 0\n", - "non-aqueous liquid material 46 0 0 0\n", - "ice 8 0 0 0\n", - "biogenic non organic material 0 484858 0 0\n", - "anthropogenic metal 0 184888 0 0" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Sum by axis 2 (hasContextCategory) and print\n", - "df = xd.sum(axis=2).to_pandas()\n", - "# display transposed\n", - "display(df.T)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "array(1752520)\n", - "Coordinates:\n", - " source =0.10.0 +ipydatagrid +geopandas +duckdb +pandas>=2.0.0 +numpy +ipywidgets +pyarrow>=12.0.0 diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..e69de29 diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..e69de29 diff --git a/docs/usage.rst b/docs/usage.rst new file mode 100644 index 0000000..e69de29 diff --git a/examples/README.md b/examples/README.md new file mode 100644 index 0000000..cb98473 --- /dev/null +++ b/examples/README.md @@ -0,0 +1,208 @@ +# iSamples Examples + +This directory contains Jupyter notebooks and scripts demonstrating different approaches to working with geological sample data from the iSamples project. + +## 🌟 Key Notebooks (Start Here) + +### `basic/geoparquet.ipynb` ⭐ **PRIMARY VISUALIZATION EXAMPLE** +**Status**: ✅ Working (API-independent) +**Focus**: Advanced lonboard WebGL visualization + +**What it does**: +- Loads geological sample data from geoparquet files +- Creates sophisticated WebGL point cloud visualizations using Lonboard +- Implements zoom-layered rendering for performance with large datasets +- Provides interactive controls for filtering by geological source collections +- Demonstrates advanced color mapping and styling techniques + +**Key patterns to reuse**: +```python +# Zoom-layered visualization +layers = create_zoom_layers(gdf, zoom_levels, color_map) + +# Interactive filtering +layer = update_layer_colors(gdf_data, selected_collections) + +# Efficient color mapping +colors = create_color_map(data, color_map, selected_collections) +``` + +### `basic/isample-archive.ipynb` +**Status**: ✅ Working (API-independent) +**Focus**: Remote parquet analysis with DuckDB + +**What it does**: +- Accesses iSamples data via Zenodo archives using HTTP range requests +- Demonstrates efficient spatial queries using DuckDB on remote parquet files +- Shows how to work with geological data without API dependencies +- Examples of spatial filtering, aggregation, and analysis + +**Key pattern**: +```python +# Remote parquet access +conn = duckdb.connect() +result = conn.sql("SELECT * FROM 'https://zenodo.org/.../data.parquet'") +``` + +### `basic/record_counts.ipynb` +**Status**: ⚠️ Has issues (lonboard parameter errors) +**Focus**: Quick visualization patterns + +**What it does**: +- Demonstrates rapid prototyping with `lonboard.viz()` +- Shows basic DuckDB operations on local data +- Quick visualization of record counts and distributions + +**Known issues**: +- Line 69: Incorrect `zoom`/`center` parameters for `Map()` constructor +- Needs parameter fixes for lonboard compatibility + +## 📁 Directory Structure + +``` +examples/ +├── basic/ # Core examples and tutorials +│ ├── geoparquet.ipynb ⭐ Main visualization notebook +│ ├── isample-archive.ipynb ✅ Remote parquet analysis +│ ├── record_counts.ipynb ⚠️ Quick patterns (has issues) +│ ├── pgp.ipynb 🧪 Additional lonboard experiments +│ ├── subset.py 📝 Basic Python subset operations +│ ├── bone.xlsx 📊 Sample Excel data +│ └── zenodo_metadata.json 📋 Archive metadata +│ +├── spatial/ # Advanced spatial analysis +│ ├── cesium_points.ipynb 🌐 3D visualization experiments +│ ├── cities.geoparquet 🗺️ Sample spatial data +│ └── bay_area_cities.parquet +│ +├── opencontext/ # OpenContext-specific examples +└── javascript/ # Node.js integration experiments + └── stream.ipynb 🔄 Streaming data patterns +``` + +## 🚀 Getting Started + +### Prerequisites +```bash +# Install dependencies +poetry install --with examples + +# Activate environment +poetry shell + +# Launch Jupyter +jupyter lab +``` + +### Recommended Learning Path + +1. **Start with `basic/geoparquet.ipynb`** - Learn advanced lonboard visualization +2. **Try `basic/isample-archive.ipynb`** - Understand remote data access +3. **Explore `spatial/cesium_points.ipynb`** - See 3D visualization options +4. **Check `basic/pgp.ipynb`** - Additional lonboard patterns + +## 📊 Data Sources + +### Working Data Sources (API-independent) +- **Zenodo archives**: Remote parquet files accessible via HTTP +- **Local geoparquet files**: Sample data in `spatial/` directory +- **Excel samples**: `bone.xlsx` for testing data import + +### API-dependent Sources ⚠️ +- **iSamples Central API**: Currently offline (`https://central.isample.xyz/isamples_central/`) +- **Bulk export endpoints**: Require authentication from offline API + +## 🛠️ Common Patterns + +### Lonboard Visualization +```python +from lonboard import Map, ScatterplotLayer +from lonboard.colormap import apply_continuous_cmap + +# Basic pattern +layer = ScatterplotLayer.from_geopandas( + gdf, + get_fill_color=colors, + get_radius=300, + radius_units='meters', + pickable=True +) +map_widget = Map(layers=[layer]) +``` + +### DuckDB Remote Access +```python +import duckdb + +# Connect and query remote parquet +conn = duckdb.connect() +result = conn.sql("SELECT * FROM 'remote_file.parquet' WHERE condition") +gdf = result.to_df() +``` + +### Error Handling for API Issues +```python +try: + # API-dependent code + client = IsbClient() + data = client.search() +except requests.exceptions.ConnectionError: + # Fallback to local/remote parquet + print("API unavailable, using local data") + data = pd.read_parquet('backup_data.parquet') +``` + +## 🐛 Troubleshooting + +### Common Issues + +1. **"No CRS exists on data" warning** + - Usually harmless for visualization + - Add explicit CRS if needed: `gdf.set_crs('EPSG:4326')` + +2. **Lonboard Map parameter errors** + - Don't use `zoom` and `center` directly in `Map()` constructor + - Use layer-specific parameters instead + +3. **Memory issues with large datasets** + - Use the zoom-layered approach from `geoparquet.ipynb` + - Sample data before visualization: `gdf.sample(n=10000)` + +4. **API connection errors** + - Expected behavior - API is currently offline + - Use geoparquet examples for working patterns + +### Performance Tips + +- **Large datasets**: Use DuckDB for filtering before loading into memory +- **Interactive maps**: Implement zoom-based level-of-detail rendering +- **Memory usage**: Sample data for initial exploration, full dataset for final analysis + +## 🌐 Try These Patterns in Your Browser + +Many of the analysis patterns demonstrated in these notebooks have **browser-based equivalents** in our companion website: + +**[iSamples Interactive Tutorials](https://smrgeoinfo.github.io/isamplesorg.github.io/tutorials/)** +- Same datasets, zero installation required +- Observable JS + DuckDB-WASM for in-browser analysis +- Perfect for sharing analyses or trying concepts quickly +- **Performance**: Analyze 300MB datasets in <100MB browser memory + +**Learning Path**: +1. **Start here** for deep analysis and Python ecosystem power +2. **Share results** via website tutorials for broader accessibility +3. **Rapid prototyping** in browser, then **advanced analysis** locally + +## 🔗 Related Documentation + +- [Main README](../README.md) - Repository overview +- [STATUS.md](../STATUS.md) - Current issues and WIP areas +- [CLAUDE.md](../CLAUDE.md) - Development guidance +- [CROSS_REPO_ALIGNMENT.md](../CROSS_REPO_ALIGNMENT.md) - Website integration strategy +- [DATA_SOURCES.md](../DATA_SOURCES.md) - Shared data documentation +- [Lonboard Documentation](https://github.com/developmentseed/lonboard) +- [DuckDB Spatial Extension](https://duckdb.org/docs/extensions/spatial) + +--- + +*This README is updated as new examples are added and issues are resolved.* \ No newline at end of file diff --git a/examples/basic/PQG_WIDE_EXPLORATION.md b/examples/basic/PQG_WIDE_EXPLORATION.md new file mode 100644 index 0000000..75bdd7f --- /dev/null +++ b/examples/basic/PQG_WIDE_EXPLORATION.md @@ -0,0 +1,86 @@ +# PQG Wide Schema Exploration Summary + +**Date**: 2025-12-01 +**Context**: Eric Kansa created an experimental "wide" serialization of PQG data + +## Key Insight + +**The 14 ISamplesEdgeType values define the GRAMMAR (semantics) of iSamples relationships.** + +Narrow vs Wide = different SERIALIZATIONS of the same grammar: + +| Aspect | Narrow Schema | Wide Schema | +|--------|---------------|-------------| +| Storage | Edge rows (`otype='_edge_'`, `s`, `p`, `o`) | Predicate columns (`p__produced_by`, etc.) | +| Same 14 edge types? | ✅ Yes | ✅ Yes | +| Query pattern | 7 joins (3 edge + 4 entity tables) | 3 joins (entity tables only) | +| Optimized for | Write flexibility | Read performance | + +## Performance Comparison (Local Files) + +| Metric | Narrow | Wide | Improvement | +|--------|--------|------|-------------| +| File size | 690.9 MB | 275.3 MB | **60% smaller** | +| Row count | 11.6M | 2.5M | **79% fewer** (no edge rows) | +| Geolocation query | 142ms | 54ms | **2.6x faster** | + +## Files + +- **Narrow**: `oc_isamples_pqg.parquet` (690.9 MB) +- **Wide**: `oc_isamples_pqg_wide.parquet` (275.3 MB) +- **Wide source**: `https://storage.googleapis.com/opencontext-parquet/oc_isamples_pqg_wide.parquet` + +## Edge Type → Column Mapping + +10 of 14 edge types exist in OpenContext data: + +| Edge Type | p__* Column | Has Data? | +|-----------|-------------|-----------| +| MSR_PRODUCED_BY | `p__produced_by` | ✅ 1.1M | +| MSR_REGISTRANT | `p__registrant` | ✅ 422K | +| MSR_KEYWORDS | `p__keywords` | ✅ 1.1M | +| MSR_HAS_CONTEXT_CATEGORY | `p__has_context_category` | ✅ 1.1M | +| MSR_HAS_MATERIAL_CATEGORY | `p__has_material_category` | ✅ 1.1M | +| MSR_HAS_SAMPLE_OBJECT_TYPE | `p__has_sample_object_type` | ✅ 1.1M | +| EVENT_SAMPLING_SITE | `p__sampling_site` | ✅ 1.1M | +| EVENT_SAMPLE_LOCATION | `p__sample_location` | ✅ 1.1M | +| EVENT_RESPONSIBILITY | `p__responsibility` | ✅ 1.1M | +| SITE_LOCATION | `p__site_location` | ✅ 18K | +| MSR_CURATION | `p__curation` | ❌ Not in OC | +| MSR_RELATED_RESOURCE | `p__related_resource` | ❌ Not in OC | +| EVENT_HAS_CONTEXT_CATEGORY | (shares `p__has_context_category`) | ❌ Not in OC | +| CURATION_RESPONSIBILITY | (shares `p__responsibility`) | ❌ Not in OC | + +## Example Queries + +### Wide Schema (simpler) +```sql +SELECT samp.pid, geo.latitude, geo.longitude +FROM pqg_wide AS samp +JOIN pqg_wide AS se ON se.row_id = ANY(samp.p__produced_by) +JOIN pqg_wide AS geo ON geo.row_id = ANY(se.p__sample_location) +WHERE samp.otype = 'MaterialSampleRecord' +``` + +### Narrow Schema (more joins) +```sql +SELECT samp.pid, geo.latitude, geo.longitude +FROM pqg AS samp +JOIN pqg AS e1 ON e1.s = samp.row_id AND e1.p = 'produced_by' +JOIN pqg AS se ON se.row_id = ANY(e1.o) +JOIN pqg AS e2 ON e2.s = se.row_id AND e2.p = 'sample_location' +JOIN pqg AS geo ON geo.row_id = ANY(e2.o) +WHERE samp.otype = 'MaterialSampleRecord' AND e1.otype = '_edge_' AND e2.otype = '_edge_' +``` + +## Next Steps + +1. **TypedEdgeQueries dual-mode**: Add schema detection + wide query paths +2. **Conversion function**: Port Eric's `create_pqg_wide_table()` to pqg repo +3. **CLI commands**: `pqg convert --to-wide` / `--to-narrow` + +## References + +- Eric's code: `https://github.com/ekansa/open-context-py/.../isamples_pqg.py` +- PQG PR #6 (typed edges): `https://github.com/isamplesorg/pqg/pull/6` (still open) +- Plan file: `~/.claude/plans/parsed-yawning-knuth.md` diff --git a/examples/basic/archive/geoparquet0.ipynb b/examples/basic/archive/geoparquet0.ipynb new file mode 100644 index 0000000..f999cfd --- /dev/null +++ b/examples/basic/archive/geoparquet0.ipynb @@ -0,0 +1,1176 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "70614b0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time for database connection: 0.00 seconds\n", + "Time for creating view: 0.00 seconds\n", + "Time for getting column names: 0.01 seconds\n", + "\n", + "Available columns:\n", + "- sample_identifier\n", + "- label\n", + "- description\n", + "- source_collection\n", + "- has_sample_object_type\n", + "- has_material_category\n", + "- has_context_category\n", + "- informal_classification\n", + "- keywords\n", + "- produced_by\n", + "- curation\n", + "- registrant\n", + "- related_resource\n", + "- sampling_purpose\n", + "- sample_location_longitude\n", + "- sample_location_latitude\n", + "- geometry\n", + "\n", + "Total number of rows: 6,494,541\n", + "Time for counting rows: 0.00 seconds\n", + "Time for querying sample rows: 0.29 seconds\n", + "\n", + "First 5 rows:\n", + " sample_identifier label description \\\n", + "0 ark:/21547/DSz2757 757 basisOfRecord: PreservedSpecimen \n", + "1 ark:/21547/DSz2779 779 basisOfRecord: PreservedSpecimen \n", + "2 ark:/21547/DSz2806 806 basisOfRecord: PreservedSpecimen \n", + "3 ark:/21547/DSz2807 807 basisOfRecord: PreservedSpecimen \n", + "4 ark:/21547/DSz2759 759 basisOfRecord: PreservedSpecimen \n", + "\n", + " source_collection has_sample_object_type \\\n", + "0 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "1 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "2 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "3 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "4 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "\n", + " has_material_category \\\n", + "0 [{'identifier': 'https://w3id.org/isample/voca... \n", + "1 [{'identifier': 'https://w3id.org/isample/voca... \n", + "2 [{'identifier': 'https://w3id.org/isample/voca... \n", + "3 [{'identifier': 'https://w3id.org/isample/voca... \n", + "4 [{'identifier': 'https://w3id.org/isample/voca... \n", + "\n", + " has_context_category informal_classification \\\n", + "0 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "1 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "2 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "3 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "4 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "\n", + " keywords \\\n", + "0 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "1 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "2 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "3 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "4 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "\n", + " produced_by curation registrant \\\n", + "0 {'description': 'expeditionCode: newts | proje... \n", + "1 {'description': 'expeditionCode: newts | proje... \n", + "2 {'description': 'expeditionCode: newts | proje... \n", + "3 {'description': 'expeditionCode: newts | proje... \n", + "4 {'description': 'expeditionCode: newts | proje... \n", + "\n", + " related_resource sampling_purpose sample_location_longitude \\\n", + "0 -122.578610 \n", + "1 -122.373055 \n", + "2 -122.117050 \n", + "3 -122.117050 \n", + "4 -122.578610 \n", + "\n", + " sample_location_latitude geometry \n", + "0 38.578888 [1, 1, 0, 0, 0, 222, 200, 60, 242, 7, 165, 94,... \n", + "1 37.385277 [1, 1, 0, 0, 0, 254, 38, 20, 34, 224, 151, 94,... \n", + "2 37.365490 [1, 1, 0, 0, 0, 204, 127, 72, 191, 125, 135, 9... \n", + "3 37.365490 [1, 1, 0, 0, 0, 204, 127, 72, 191, 125, 135, 9... \n", + "4 38.578888 [1, 1, 0, 0, 0, 222, 200, 60, 242, 7, 165, 94,... \n", + "Time for querying sample rows: 0.29 seconds\n", + "\n", + "First 5 rows:\n", + " sample_identifier label description \\\n", + "0 ark:/21547/DSz2757 757 basisOfRecord: PreservedSpecimen \n", + "1 ark:/21547/DSz2779 779 basisOfRecord: PreservedSpecimen \n", + "2 ark:/21547/DSz2806 806 basisOfRecord: PreservedSpecimen \n", + "3 ark:/21547/DSz2807 807 basisOfRecord: PreservedSpecimen \n", + "4 ark:/21547/DSz2759 759 basisOfRecord: PreservedSpecimen \n", + "\n", + " source_collection has_sample_object_type \\\n", + "0 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "1 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "2 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "3 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "4 GEOME [{'identifier': 'https://w3id.org/isample/voca... \n", + "\n", + " has_material_category \\\n", + "0 [{'identifier': 'https://w3id.org/isample/voca... \n", + "1 [{'identifier': 'https://w3id.org/isample/voca... \n", + "2 [{'identifier': 'https://w3id.org/isample/voca... \n", + "3 [{'identifier': 'https://w3id.org/isample/voca... \n", + "4 [{'identifier': 'https://w3id.org/isample/voca... \n", + "\n", + " has_context_category informal_classification \\\n", + "0 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "1 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "2 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "3 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "4 [{'identifier': 'https://w3id.org/isample/biol... [Taricha, granulosa] \n", + "\n", + " keywords \\\n", + "0 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "1 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "2 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "3 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "4 [{'keyword': 'California'}, {'keyword': 'USA'}] \n", + "\n", + " produced_by curation registrant \\\n", + "0 {'description': 'expeditionCode: newts | proje... \n", + "1 {'description': 'expeditionCode: newts | proje... \n", + "2 {'description': 'expeditionCode: newts | proje... \n", + "3 {'description': 'expeditionCode: newts | proje... \n", + "4 {'description': 'expeditionCode: newts | proje... \n", + "\n", + " related_resource sampling_purpose sample_location_longitude \\\n", + "0 -122.578610 \n", + "1 -122.373055 \n", + "2 -122.117050 \n", + "3 -122.117050 \n", + "4 -122.578610 \n", + "\n", + " sample_location_latitude geometry \n", + "0 38.578888 [1, 1, 0, 0, 0, 222, 200, 60, 242, 7, 165, 94,... \n", + "1 37.385277 [1, 1, 0, 0, 0, 254, 38, 20, 34, 224, 151, 94,... \n", + "2 37.365490 [1, 1, 0, 0, 0, 204, 127, 72, 191, 125, 135, 9... \n", + "3 37.365490 [1, 1, 0, 0, 0, 204, 127, 72, 191, 125, 135, 9... \n", + "4 38.578888 [1, 1, 0, 0, 0, 222, 200, 60, 242, 7, 165, 94,... \n", + "Data loading and sampling time: 1.31 seconds\n", + "Data loading and sampling time: 1.31 seconds\n", + "Total execution time: 2.93 seconds\n", + "Total execution time: 2.93 seconds\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total rows: 6494541\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d45b2709ed6346469199bcb576c2a674", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "FloatProgress(value=0.0, layout=Layout(width='auto'), style=ProgressStyle(bar_color='black'))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "ename": "TypeError", + "evalue": "count(): incompatible function arguments. The following argument types are supported:\n 1. (self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> duckdb.duckdb.DuckDBPyRelation\n\nInvoked with: ┌─────────────────────────┬──────────┬──────────────────────────────────────────────────┬───────────────────┬──────────────────────────────────────────────────────────────────────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────────┬───────────────────────────────────────────────────────────────────────────────────┬────────────────────────────┬────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬────────────────────────┬───────────────────────────────────────┬────────────────────┬───────────────────────────┬──────────────────────────┬───────────────────────────────┐\n│ sample_identifier │ label │ description │ source_collection │ has_sample_object_type │ has_material_category │ has_context_category │ informal_classification │ keywords │ produced_by │ curation │ registrant │ related_resource │ sampling_purpose │ sample_location_longitude │ sample_location_latitude │ geometry │\n│ varchar │ varchar │ varchar │ varchar │ struct(identifier varchar)[] │ struct(identifier varchar)[] │ struct(identifier varchar)[] │ varchar[] │ struct(keyword varchar)[] │ struct(description varchar, has_feature_of_interest varchar, identifier varchar, \"label\" varchar, responsibility struct(\"name\" varchar, \"role\" varchar)[], result_time varchar, sampling_site struct(description varchar, \"label\" varchar, place_name varchar[], sample_location struct(elevation double, latitude double, longitude double))) │ struct(access_constraints varchar[], curation_location varchar, description varchar, \"label\" varchar, responsibility struct(\"name\" varchar, \"role\" varchar)[]) │ struct(\"name\" varchar) │ struct(target varchar)[] │ varchar[] │ double │ double │ geometry │\n├─────────────────────────┼──────────┼──────────────────────────────────────────────────┼───────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────────┼───────────────────────────────────────────────────────────────────────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼────────────────────────┼───────────────────────────────────────┼────────────────────┼───────────────────────────┼──────────────────────────┼───────────────────────────────┤\n│ ark:/21547/DSz2757 │ 757 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2757, 'label': a22d568d303a95c622a9409871e562d7 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.578888, 'longitude': -122.57861}}} │ NULL │ NULL │ NULL │ NULL │ -122.57861 │ 38.578888 │ POINT (-122.57861 38.578888) │\n│ ark:/21547/DSz2779 │ 779 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2779, 'label': 096c166b0c23c8823678eb43e4c00802 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1893-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 37.385277, 'longitude': -122.373055}}} │ NULL │ NULL │ NULL │ NULL │ -122.373055 │ 37.385277 │ POINT (-122.373055 37.385277) │\n│ ark:/21547/DSz2806 │ 806 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2806, 'label': 4824d73db4a747e634637f1a3c2978cb newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1893-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 37.36549, 'longitude': -122.11705}}} │ NULL │ NULL │ NULL │ NULL │ -122.11705 │ 37.36549 │ POINT (-122.11705 37.36549) │\n│ ark:/21547/DSz2807 │ 807 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2807, 'label': 4824d73db4a747e634637f1a3c2978cb newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1893-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 37.36549, 'longitude': -122.11705}}} │ NULL │ NULL │ NULL │ NULL │ -122.11705 │ 37.36549 │ POINT (-122.11705 37.36549) │\n│ ark:/21547/DSz2759 │ 759 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2759, 'label': a22d568d303a95c622a9409871e562d7 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.578888, 'longitude': -122.57861}}} │ NULL │ NULL │ NULL │ NULL │ -122.57861 │ 38.578888 │ POINT (-122.57861 38.578888) │\n│ ark:/21547/DSz2761 │ 761 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2761, 'label': a22d568d303a95c622a9409871e562d7 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.578888, 'longitude': -122.57861}}} │ NULL │ NULL │ NULL │ NULL │ -122.57861 │ 38.578888 │ POINT (-122.57861 38.578888) │\n│ ark:/21547/DSz2967 │ 967 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, torosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2967, 'label': 1b092798b61f72c79ff6df1f361b8705 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.669395, 'longitude': -122.63218}}} │ NULL │ NULL │ NULL │ NULL │ -122.63218 │ 38.669395 │ POINT (-122.63218 38.669395) │\n│ ark:/21547/DSz2763 │ 763 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2763, 'label': a22d568d303a95c622a9409871e562d7 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.578888, 'longitude': -122.57861}}} │ NULL │ NULL │ NULL │ NULL │ -122.57861 │ 38.578888 │ POINT (-122.57861 38.578888) │\n│ ark:/21547/DSz2979 │ 979 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, torosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2979, 'label': ac6f9b6dd20fd04e411c2db0348524e3 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 34.147778, 'longitude': -118.14361}}} │ NULL │ NULL │ NULL │ NULL │ -118.14361 │ 34.147778 │ POINT (-118.14361 34.147778) │\n│ ark:/21547/DSz21792 │ 1792 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, torosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz21792, 'label': ed5754fe295e377d6da2add6748fb7c0 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1896-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 37.87103, 'longitude': -122.27711}}} │ NULL │ NULL │ NULL │ NULL │ -122.27711 │ 37.87103 │ POINT (-122.27711 37.87103) │\n│ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │\n│ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │\n│ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │\n│ ark:/21547/BNt2CmMQ0005 │ CmMQ0005 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2CmMQ0005}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2ANMQ0165 │ ANMQ0165 │ previousIdentifications: Acanthurus nigricans │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2ANMQ0165, 'label': a8b1f9fa321073f72f9a7881747ab592 IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': Marquesas, 'place_name': [French Polynesia, Marquesas], 'sample_location': {'elevation': NULL, 'latitude': -9.0, 'longitude': -139.3}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2ANMQ0165}] │ NULL │ -139.3 │ -9.0 │ POINT (-139.3 -9) │\n│ ark:/21547/BNt2ANMQ0165 │ ANMQ0165 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2ANMQ0165}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2CmMQ0004 │ CmMQ0004 │ previousIdentifications: Ctenochaetus marginatus │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2CmMQ0004, 'label': c8e4608b0409567824c8badfbaef685f IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': ua-huka, 'place_name': [French Polynesia, Marquesas, Ua Huka, ua-huka], 'sample_location': {'elevation': NULL, 'latitude': -8.90864, 'longitude': -139.55984}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2CmMQ0004}] │ NULL │ -139.55984 │ -8.90864 │ POINT (-139.55984 -8.90864) │\n│ ark:/21547/BNt2CmMQ0004 │ CmMQ0004 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2CmMQ0004}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2CmMQ0007 │ CmMQ0007 │ previousIdentifications: Ctenochaetus marginatus │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2CmMQ0007, 'label': c8e4608b0409567824c8badfbaef685f IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': ua-huka, 'place_name': [French Polynesia, Marquesas, Ua Huka, ua-huka], 'sample_location': {'elevation': NULL, 'latitude': -8.90864, 'longitude': -139.55984}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2CmMQ0007}] │ NULL │ -139.55984 │ -8.90864 │ POINT (-139.55984 -8.90864) │\n│ ark:/21547/BNt2CmMQ0007 │ CmMQ0007 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2CmMQ0007}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2ANMQ0136 │ ANMQ0136 │ previousIdentifications: Acanthurus nigricans │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2ANMQ0136, 'label': a8b1f9fa321073f72f9a7881747ab592 IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': Marquesas, 'place_name': [French Polynesia, Marquesas], 'sample_location': {'elevation': NULL, 'latitude': -9.0, 'longitude': -139.3}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2ANMQ0136}] │ NULL │ -139.3 │ -9.0 │ POINT (-139.3 -9) │\n│ ark:/21547/BNt2ANMQ0136 │ ANMQ0136 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2ANMQ0136}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2ANMQ0137 │ ANMQ0137 │ previousIdentifications: Acanthurus nigricans │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2ANMQ0137, 'label': a8b1f9fa321073f72f9a7881747ab592 IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': Marquesas, 'place_name': [French Polynesia, Marquesas], 'sample_location': {'elevation': NULL, 'latitude': -9.0, 'longitude': -139.3}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2ANMQ0137}] │ NULL │ -139.3 │ -9.0 │ POINT (-139.3 -9) │\n├─────────────────────────┴──────────┴──────────────────────────────────────────────────┴───────────────────┴──────────────────────────────────────────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────────┴───────────────────────────────────────────────────────────────────────────────────┴────────────────────────────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴────────────────────────┴───────────────────────────────────────┴────────────────────┴───────────────────────────┴──────────────────────────┴───────────────────────────────┤\n│ ? rows (>9999 rows, 20 shown) 17 columns │\n└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 138\u001b[0m\n\u001b[1;32m 135\u001b[0m query \u001b[38;5;241m=\u001b[39m conn\u001b[38;5;241m.\u001b[39mtable(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124misamples_export_2025_02_20_10_30_49_geo.parquet\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 137\u001b[0m \u001b[38;5;66;03m# Queries stay lazy until you need results\u001b[39;00m\n\u001b[0;32m--> 138\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTotal rows: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[43mquery\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcount\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 140\u001b[0m \u001b[38;5;66;03m# You can chain operations naturally\u001b[39;00m\n\u001b[1;32m 141\u001b[0m filtered \u001b[38;5;241m=\u001b[39m query\u001b[38;5;241m.\u001b[39mfilter(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msome_condition\u001b[39m\u001b[38;5;124m\"\u001b[39m)\u001b[38;5;241m.\u001b[39mlimit(\u001b[38;5;241m5\u001b[39m)\n", + "\u001b[0;31mTypeError\u001b[0m: count(): incompatible function arguments. The following argument types are supported:\n 1. (self: duckdb.duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> duckdb.duckdb.DuckDBPyRelation\n\nInvoked with: ┌─────────────────────────┬──────────┬──────────────────────────────────────────────────┬───────────────────┬──────────────────────────────────────────────────────────────────────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────────┬───────────────────────────────────────────────────────────────────────────────────┬────────────────────────────┬────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬────────────────────────┬───────────────────────────────────────┬────────────────────┬───────────────────────────┬──────────────────────────┬───────────────────────────────┐\n│ sample_identifier │ label │ description │ source_collection │ has_sample_object_type │ has_material_category │ has_context_category │ informal_classification │ keywords │ produced_by │ curation │ registrant │ related_resource │ sampling_purpose │ sample_location_longitude │ sample_location_latitude │ geometry │\n│ varchar │ varchar │ varchar │ varchar │ struct(identifier varchar)[] │ struct(identifier varchar)[] │ struct(identifier varchar)[] │ varchar[] │ struct(keyword varchar)[] │ struct(description varchar, has_feature_of_interest varchar, identifier varchar, \"label\" varchar, responsibility struct(\"name\" varchar, \"role\" varchar)[], result_time varchar, sampling_site struct(description varchar, \"label\" varchar, place_name varchar[], sample_location struct(elevation double, latitude double, longitude double))) │ struct(access_constraints varchar[], curation_location varchar, description varchar, \"label\" varchar, responsibility struct(\"name\" varchar, \"role\" varchar)[]) │ struct(\"name\" varchar) │ struct(target varchar)[] │ varchar[] │ double │ double │ geometry │\n├─────────────────────────┼──────────┼──────────────────────────────────────────────────┼───────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────────┼───────────────────────────────────────────────────────────────────────────────────┼────────────────────────────┼────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼────────────────────────┼───────────────────────────────────────┼────────────────────┼───────────────────────────┼──────────────────────────┼───────────────────────────────┤\n│ ark:/21547/DSz2757 │ 757 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2757, 'label': a22d568d303a95c622a9409871e562d7 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.578888, 'longitude': -122.57861}}} │ NULL │ NULL │ NULL │ NULL │ -122.57861 │ 38.578888 │ POINT (-122.57861 38.578888) │\n│ ark:/21547/DSz2779 │ 779 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2779, 'label': 096c166b0c23c8823678eb43e4c00802 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1893-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 37.385277, 'longitude': -122.373055}}} │ NULL │ NULL │ NULL │ NULL │ -122.373055 │ 37.385277 │ POINT (-122.373055 37.385277) │\n│ ark:/21547/DSz2806 │ 806 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2806, 'label': 4824d73db4a747e634637f1a3c2978cb newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1893-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 37.36549, 'longitude': -122.11705}}} │ NULL │ NULL │ NULL │ NULL │ -122.11705 │ 37.36549 │ POINT (-122.11705 37.36549) │\n│ ark:/21547/DSz2807 │ 807 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2807, 'label': 4824d73db4a747e634637f1a3c2978cb newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1893-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 37.36549, 'longitude': -122.11705}}} │ NULL │ NULL │ NULL │ NULL │ -122.11705 │ 37.36549 │ POINT (-122.11705 37.36549) │\n│ ark:/21547/DSz2759 │ 759 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2759, 'label': a22d568d303a95c622a9409871e562d7 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.578888, 'longitude': -122.57861}}} │ NULL │ NULL │ NULL │ NULL │ -122.57861 │ 38.578888 │ POINT (-122.57861 38.578888) │\n│ ark:/21547/DSz2761 │ 761 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2761, 'label': a22d568d303a95c622a9409871e562d7 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.578888, 'longitude': -122.57861}}} │ NULL │ NULL │ NULL │ NULL │ -122.57861 │ 38.578888 │ POINT (-122.57861 38.578888) │\n│ ark:/21547/DSz2967 │ 967 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, torosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2967, 'label': 1b092798b61f72c79ff6df1f361b8705 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.669395, 'longitude': -122.63218}}} │ NULL │ NULL │ NULL │ NULL │ -122.63218 │ 38.669395 │ POINT (-122.63218 38.669395) │\n│ ark:/21547/DSz2763 │ 763 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, granulosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2763, 'label': a22d568d303a95c622a9409871e562d7 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 38.578888, 'longitude': -122.57861}}} │ NULL │ NULL │ NULL │ NULL │ -122.57861 │ 38.578888 │ POINT (-122.57861 38.578888) │\n│ ark:/21547/DSz2979 │ 979 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, torosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz2979, 'label': ac6f9b6dd20fd04e411c2db0348524e3 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1894-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 34.147778, 'longitude': -118.14361}}} │ NULL │ NULL │ NULL │ NULL │ -118.14361 │ 34.147778 │ POINT (-118.14361 34.147778) │\n│ ark:/21547/DSz21792 │ 1792 │ basisOfRecord: PreservedSpecimen │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Taricha, torosa] │ [{'keyword': California}, {'keyword': USA}] │ {'description': expeditionCode: newts | projectId: 244, 'has_feature_of_interest': , 'identifier': ark:/21547/DSz21792, 'label': ed5754fe295e377d6da2add6748fb7c0 newts, 'responsibility': [{'name': Vance Vredenburg, 'role': collector }, {'name': Vance Vredenburg, 'role': principalInvestigator}], 'result_time': 1896-01-01, 'sampling_site': {'description': NULL, 'label': California, 'place_name': [California, USA], 'sample_location': {'elevation': NULL, 'latitude': 37.87103, 'longitude': -122.27711}}} │ NULL │ NULL │ NULL │ NULL │ -122.27711 │ 37.87103 │ POINT (-122.27711 37.87103) │\n│ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │\n│ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │\n│ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │ · │\n│ ark:/21547/BNt2CmMQ0005 │ CmMQ0005 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2CmMQ0005}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2ANMQ0165 │ ANMQ0165 │ previousIdentifications: Acanthurus nigricans │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2ANMQ0165, 'label': a8b1f9fa321073f72f9a7881747ab592 IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': Marquesas, 'place_name': [French Polynesia, Marquesas], 'sample_location': {'elevation': NULL, 'latitude': -9.0, 'longitude': -139.3}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2ANMQ0165}] │ NULL │ -139.3 │ -9.0 │ POINT (-139.3 -9) │\n│ ark:/21547/BNt2ANMQ0165 │ ANMQ0165 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2ANMQ0165}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2CmMQ0004 │ CmMQ0004 │ previousIdentifications: Ctenochaetus marginatus │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2CmMQ0004, 'label': c8e4608b0409567824c8badfbaef685f IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': ua-huka, 'place_name': [French Polynesia, Marquesas, Ua Huka, ua-huka], 'sample_location': {'elevation': NULL, 'latitude': -8.90864, 'longitude': -139.55984}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2CmMQ0004}] │ NULL │ -139.55984 │ -8.90864 │ POINT (-139.55984 -8.90864) │\n│ ark:/21547/BNt2CmMQ0004 │ CmMQ0004 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2CmMQ0004}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2CmMQ0007 │ CmMQ0007 │ previousIdentifications: Ctenochaetus marginatus │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2CmMQ0007, 'label': c8e4608b0409567824c8badfbaef685f IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': ua-huka, 'place_name': [French Polynesia, Marquesas, Ua Huka, ua-huka], 'sample_location': {'elevation': NULL, 'latitude': -8.90864, 'longitude': -139.55984}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2CmMQ0007}] │ NULL │ -139.55984 │ -8.90864 │ POINT (-139.55984 -8.90864) │\n│ ark:/21547/BNt2CmMQ0007 │ CmMQ0007 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Ctenochaetus, marginatus] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}, {'keyword': Ua Huka}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2CmMQ0007}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2ANMQ0136 │ ANMQ0136 │ previousIdentifications: Acanthurus nigricans │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2ANMQ0136, 'label': a8b1f9fa321073f72f9a7881747ab592 IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': Marquesas, 'place_name': [French Polynesia, Marquesas], 'sample_location': {'elevation': NULL, 'latitude': -9.0, 'longitude': -139.3}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2ANMQ0136}] │ NULL │ -139.3 │ -9.0 │ POINT (-139.3 -9) │\n│ ark:/21547/BNt2ANMQ0136 │ ANMQ0136 │ NULL │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/organismpart}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ NULL │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/ot2ANMQ0136}] │ [genomic analysis] │ NULL │ NULL │ POINT EMPTY │\n│ ark:/21547/ot2ANMQ0137 │ ANMQ0137 │ previousIdentifications: Acanthurus nigricans │ GEOME │ [{'identifier': https://w3id.org/isample/vocabulary/materialsampleobjecttype/1.0/wholeorganism}] │ [{'identifier': https://w3id.org/isample/vocabulary/material/1.0/organicmaterial}] │ [{'identifier': https://w3id.org/isample/biology/biosampledfeature/1.0/Animalia}] │ [Acanthurus, nigricans] │ [{'keyword': Acanthuridae}, {'keyword': Actinopterygii}, {'keyword': Chordata}, {'keyword': French Polynesia}, {'keyword': Marquesas}, {'keyword': Perciformes}] │ {'description': expeditionCode: IPfish_A68_HL | projectId: 1, 'has_feature_of_interest': , 'identifier': ark:/21547/ot2ANMQ0137, 'label': a8b1f9fa321073f72f9a7881747ab592 IPfish_A68_HL, 'responsibility': [{'name': D. R. Robertson, 'role': collector }, {'name': H. A. Lessios, 'role': principalInvestigator}], 'result_time': 1995-05-01, 'sampling_site': {'description': NULL, 'label': Marquesas, 'place_name': [French Polynesia, Marquesas], 'sample_location': {'elevation': NULL, 'latitude': -9.0, 'longitude': -139.3}}} │ {'access_constraints': [], 'curation_location': , 'description': preservative: DMSO Buffer, 'label': , 'responsibility': [{'name': c, 'role': curator}, {'name': u, 'role': curator}, {'name': r, 'role': curator}, {'name': a, 'role': curator}, {'name': t, 'role': curator}, {'name': o, 'role': curator}, {'name': r, 'role': curator}, {'name': , 'role': }, {'name': S, 'role': curator}, {'name': T, 'role': curator}, {'name': R, 'role': curator}, {'name': I, 'role': curator}]} │ NULL │ [{'target': ark:/21547/BNt2ANMQ0137}] │ NULL │ -139.3 │ -9.0 │ POINT (-139.3 -9) │\n├─────────────────────────┴──────────┴──────────────────────────────────────────────────┴───────────────────┴──────────────────────────────────────────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────────┴───────────────────────────────────────────────────────────────────────────────────┴────────────────────────────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴────────────────────────┴───────────────────────────────────────┴────────────────────┴───────────────────────────┴──────────────────────────┴───────────────────────────────┤\n│ ? rows (>9999 rows, 20 shown) 17 columns │\n└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘\n" + ] + } + ], + "source": [ + "# Geoparquet\n", + "import duckdb\n", + "import time\n", + "import ibis\n", + "\n", + "\n", + "\n", + "def print_timing(start_time, operation):\n", + " elapsed = time.time() - start_time\n", + " print(f\"Time for {operation}: {elapsed:.2f} seconds\")\n", + "\n", + "# Connect to an in-memory DuckDB instance\n", + "start_time = time.time()\n", + "con = duckdb.connect()\n", + "print_timing(start_time, \"database connection\")\n", + "\n", + "# Load the GeoParquet file and create view\n", + "start_time = time.time()\n", + "geo_parquet_file = '/Users/raymondyee/Data/iSample/2025_02_20_10_30_49/isamples_export_2025_02_20_10_30_49_geo.parquet'\n", + "con.sql(f\"CREATE VIEW geosamples AS SELECT * FROM read_parquet('{geo_parquet_file}')\")\n", + "print_timing(start_time, \"creating view\")\n", + "\n", + "# Get column names dynamically\n", + "start_time = time.time()\n", + "columns = con.sql(\"SELECT column_name FROM information_schema.columns WHERE table_name = 'geosamples'\").fetchall()\n", + "column_names = [col[0] for col in columns]\n", + "print_timing(start_time, \"getting column names\")\n", + "\n", + "# Print available columns\n", + "print(\"\\nAvailable columns:\")\n", + "for col in column_names:\n", + " print(f\"- {col}\")\n", + "\n", + "# Get total row count\n", + "start_time = time.time()\n", + "row_count = con.sql(\"SELECT COUNT(*) FROM geosamples\").fetchone()[0]\n", + "print(f\"\\nTotal number of rows: {row_count:,}\")\n", + "print_timing(start_time, \"counting rows\")\n", + "\n", + "# Query the first 5 rows with all columns\n", + "start_time = time.time()\n", + "result = con.sql(\"\"\"\n", + " SELECT *\n", + " FROM geosamples \n", + " LIMIT 5\n", + "\"\"\").df()\n", + "print_timing(start_time, \"querying sample rows\")\n", + "\n", + "print(\"\\nFirst 5 rows:\")\n", + "print(result)\n", + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "import time\n", + "\n", + "# Start timing\n", + "start_time = time.time()\n", + "\n", + "# Read only a sample of the data (e.g., 1% for better performance)\n", + "# geo_parquet_file = '/Users/raymondyee/Data/iSample/2025_02_20_10_30_49/isamples_export_2025_02_20_10_30_49_geo.parquet'\n", + "geo_parquet_file = '/Users/raymondyee/Data/iSample/2025_04_21_16_23_46/isamples_export_2025_04_21_16_23_46_geo.parquet'\n", + "gdf = gpd.read_parquet(geo_parquet_file, columns=['geometry']) # Only read geometry column\n", + "\n", + "# Create map visualization of geographical sample points\n", + "# Sampling only 1% of data for better performance with large datasets\n", + "sample_size = len(gdf) // 100 # 1% of data\n", + "gdf_sampled = gdf.sample(n=sample_size, random_state=42)\n", + "\n", + "print(f\"Data loading and sampling time: {time.time() - start_time:.2f} seconds\")\n", + "\n", + "# Create figure and axis with larger size and projection\n", + "fig, ax = plt.subplots(figsize=(15, 10), \n", + " subplot_kw={'projection': ccrs.Robinson()})\n", + "\n", + "# Add map features\n", + "ax.add_feature(cfeature.LAND, facecolor='lightgray')\n", + "ax.add_feature(cfeature.OCEAN, facecolor='lightblue')\n", + "ax.add_feature(cfeature.COASTLINE)\n", + "ax.gridlines()\n", + "\n", + "# Plot with improved styling\n", + "gdf_sampled.plot(\n", + " ax=ax,\n", + " transform=ccrs.PlateCarree(),\n", + " alpha=0.5,\n", + " markersize=1,\n", + " color='red',\n", + " legend=True\n", + ")\n", + "\n", + "# Add title\n", + "plt.title(f'Sample of {sample_size:,} points from {len(gdf):,} total records')\n", + "\n", + "print(f\"Total execution time: {time.time() - start_time:.2f} seconds\")\n", + "\n", + "plt.show()\n", + "import duckdb\n", + "import os\n", + "\n", + "# Change working directory to the location of the GeoParquet file\n", + "os.chdir('/Users/raymondyee/Data/iSample/2025_02_20_10_30_49')\n", + "\n", + "# Initialize DuckDB connection\n", + "conn = duckdb.connect(':memory:') # or specify a database file\n", + "\n", + "# Install and load spatial extension\n", + "conn.execute(\"INSTALL spatial;\")\n", + "conn.execute(\"LOAD spatial;\")\n", + "\n", + "# Create temp view from parquet file\n", + "conn.execute(\"\"\"\n", + " CREATE TEMP VIEW my_data AS \n", + " SELECT * FROM read_parquet('isamples_export_2025_02_20_10_30_49_geo.parquet')\n", + "\"\"\")\n", + "\n", + "# Get count of rows\n", + "result = conn.execute(\"SELECT COUNT(*) FROM my_data\").fetchall()\n", + "\n", + "# Print result\n", + "print(f\"Total rows: {result[0][0]}\")\n", + "\n", + "# Close connection\n", + "conn.close()\n", + "import duckdb\n", + "\n", + "# Change working directory to the location of the GeoParquet file\n", + "os.chdir('/Users/raymondyee/Data/iSample/2025_02_20_10_30_49')\n", + "\n", + "# Create connection\n", + "conn = duckdb.connect(':memory:')\n", + "conn.execute(\"INSTALL spatial; LOAD spatial;\")\n", + "\n", + "# DuckDB can query Parquet directly - no need to create views\n", + "query = conn.table('isamples_export_2025_02_20_10_30_49_geo.parquet')\n", + "\n", + "# Queries stay lazy until you need results\n", + "print(f\"Total rows: {query.count()}\")\n", + "\n", + "# You can chain operations naturally\n", + "filtered = query.filter(\"some_condition\").limit(5)\n", + "\n", + "# Only converts to DataFrame when you actually call .df()\n", + "# filtered_df = filtered.df() # This would materialize the data\n", + "\n", + "\n", + "import os\n", + "import duckdb\n", + "from lonboard import viz\n", + "\n", + "# Change working directory to the location of the GeoParquet file\n", + "os.chdir('/Users/raymondyee/Data/iSample/2025_02_20_10_30_49')\n", + "\n", + "# Initialize DuckDB connection\n", + "conn = duckdb.connect(':memory:')\n", + "\n", + "# Install and load spatial extension\n", + "conn.execute(\"INSTALL spatial;\")\n", + "conn.execute(\"LOAD spatial;\")\n", + "\n", + "# First, let's check the geometry type and a sample\n", + "result = conn.execute(\"\"\"\n", + " SELECT \n", + " ST_GeometryType(geometry) as geom_type,\n", + " ST_AsText(geometry) as wkt,\n", + " sample_location_longitude,\n", + " sample_location_latitude\n", + " FROM read_parquet('isamples_export_2025_02_20_10_30_49_geo.parquet') \n", + " WHERE geometry IS NOT NULL \n", + " LIMIT 1\n", + "\"\"\").fetchall()\n", + "print(result)\n", + "\n", + "# Create temp view using longitude/latitude to create geometry\n", + "conn.execute(\"\"\"\n", + " CREATE TEMP VIEW my_data AS \n", + " SELECT \n", + " ST_AsWKB(ST_Point(sample_location_longitude, sample_location_latitude)) as geometry,\n", + " sample_identifier,\n", + " label,\n", + " description,\n", + " source_collection,\n", + " has_sample_object_type,\n", + " has_material_category,\n", + " has_context_category,\n", + " informal_classification,\n", + " keywords,\n", + " produced_by,\n", + " curation,\n", + " registrant,\n", + " related_resource,\n", + " sampling_purpose,\n", + " sample_location_longitude,\n", + " sample_location_latitude\n", + " FROM read_parquet('isamples_export_2025_02_20_10_30_49_geo.parquet')\n", + " WHERE sample_location_longitude IS NOT NULL \n", + " AND sample_location_latitude IS NOT NULL\n", + "\"\"\")\n", + "\n", + "# Check coordinate bounds\n", + "bounds = conn.execute(\"\"\"\n", + " SELECT \n", + " MIN(sample_location_longitude) as min_lon,\n", + " MAX(sample_location_longitude) as max_lon,\n", + " MIN(sample_location_latitude) as min_lat,\n", + " MAX(sample_location_latitude) as max_lat,\n", + " COUNT(*) as point_count\n", + " FROM my_data\n", + "\"\"\").fetchall()\n", + "print(\"\\nCoordinate bounds and point count:\")\n", + "print(bounds)\n", + "\n", + "# Query and visualize with map configuration\n", + "result = conn.sql(\"SELECT * FROM my_data LIMIT 10000\")\n", + "viz(\n", + " result,\n", + " map_kwargs={\n", + " # Lonboard 0.12+: initialize view using `view_state`, not `zoom`/`center`\n", + " \"view_state\": {\"zoom\": 1, \"latitude\": 0, \"longitude\": 0}\n", + " }\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2efc61ce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[('POINT', 'POINT (-122.57861 38.578888)', -122.57861, 38.578888)]\n", + "\n", + "Coordinate bounds and point count:\n", + "[(-180.0, 180.0, -89.983, 89.981, 5795511)]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/raymondyee/.pyenv/versions/3.12.9/envs/isamples-python-3.12.9/lib/python3.12/site-packages/lonboard/_geoarrow/ops/reproject.py:33: UserWarning: No CRS exists on data. If no data is shown on the map, double check that your CRS is WGS84.\n", + " warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fceaf0968b0546a4b296ffc2a3eeb2e3", + "version_major": 2, + "version_minor": 1 + }, + "text/plain": [ + "Map(basemap_style=25k may get sluggish. Use clustering (enabled) or downsample.\n", + "- For very large datasets, consider: tiling (3D Tiles), server‑side aggregation, or heatmaps.\n", + "\n", + "Next steps you could try later:\n", + "- Replace simple points with color by category (material/context)\n", + "- Add popups with richer HTML\n", + "- Stream chunks instead of embedding all JSON inline\n", + "- Switch to `GeoJsonDataSource.clustering` tuning (pixelRange / minimumClusterSize)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "719d5ed1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prepared 10000 points for CesiumJS (SAMPLE_FRACTION=None, MAX_POINTS=10000)\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import duckdb, json, os, math, textwrap\n", + "from IPython.display import HTML, display\n", + "\n", + "# --- Config ---\n", + "PARQUET_PATH = '/Users/raymondyee/Data/iSample/2025_02_20_10_30_49/isamples_export_2025_02_20_10_30_49_geo.parquet'\n", + "MAX_POINTS = 10000 # Upper bound of points to embed (tune for performance)\n", + "SAMPLE_FRACTION = None # e.g., 0.01 for 1% random sample; overrides MAX_POINTS if set\n", + "RANDOM_SEED = 42\n", + "\n", + "# --- Extract (lon, lat, id, label) subset via DuckDB ---\n", + "con = duckdb.connect()\n", + "query_base = f\"\"\"\n", + " SELECT \n", + " sample_location_longitude AS lon,\n", + " sample_location_latitude AS lat,\n", + " sample_identifier AS sample_id,\n", + " COALESCE(label, sample_identifier) AS label\n", + " FROM read_parquet('{PARQUET_PATH}')\n", + " WHERE sample_location_longitude IS NOT NULL\n", + " AND sample_location_latitude IS NOT NULL\n", + "\"\"\"\n", + "\n", + "if SAMPLE_FRACTION is not None:\n", + " points_df = con.sql(query_base + f\" USING SAMPLE {SAMPLE_FRACTION * 100}% (bernoulli, {RANDOM_SEED})\").df()\n", + "else:\n", + " points_df = con.sql(query_base + f\" LIMIT {MAX_POINTS}\").df()\n", + "\n", + "point_count = len(points_df)\n", + "print(f\"Prepared {point_count} points for CesiumJS (SAMPLE_FRACTION={SAMPLE_FRACTION}, MAX_POINTS={MAX_POINTS})\")\n", + "\n", + "# --- Convert to GeoJSON FeatureCollection ---\n", + "features = []\n", + "for row in points_df.itertuples(index=False):\n", + " lon, lat, sample_id, label = row\n", + " if math.isnan(lon) or math.isnan(lat):\n", + " continue\n", + " features.append({\n", + " \"type\": \"Feature\",\n", + " \"geometry\": {\"type\": \"Point\", \"coordinates\": [float(lon), float(lat)]},\n", + " \"properties\": {\"sample_id\": sample_id, \"label\": label}\n", + " })\n", + "geojson_obj = {\"type\": \"FeatureCollection\", \"features\": features}\n", + "geojson_str = json.dumps(geojson_obj) # embed directly (small subset)\n", + "\n", + "# --- HTML/JS Template for Cesium ---\n", + "html = f\"\"\"\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n", + "\"\"\"\n", + "\n", + "# Display\n", + "display(HTML(html))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e658719", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "ecf57b6a", + "metadata": {}, + "source": [ + "### CesiumJS Troubleshooting & Alternate Embed\n", + "If the earlier Cesium cell (inline `