| import json |
| import os |
| from pathlib import Path |
|
|
| import pandas as pd |
| from PIL import Image |
|
|
| try: |
| import rasterio |
| import streamlit as st |
| except ImportError as exc: |
| raise SystemExit( |
| "viewer_standardization.py requires streamlit and rasterio.\n" |
| "Install missing packages, then run: streamlit run viewer_standardization.py" |
| ) from exc |
|
|
|
|
| BASE_DIR = Path(__file__).resolve().parent |
| HOST_NAME = "esdac" |
| DATASETS_DIR = BASE_DIR / "datasets" / HOST_NAME |
| STATUS_PATH = BASE_DIR / "src" / HOST_NAME / "status.json" |
| ICON_PATH = BASE_DIR / "resources" / "erp.jpeg" |
| DEFAULT_DATASET = "soil-bulk-density-europe" |
| DEFAULT_FILE = "Public/packing_density.png" |
|
|
| VIEWABLE_EXTENSIONS = { |
| ".csv", |
| ".json", |
| ".png", |
| ".jpg", |
| ".jpeg", |
| ".txt", |
| ".tif", |
| ".tiff", |
| } |
| STATUS_OPTIONS = ["UNEXAMINED", "SKIPPED", "REQUESTED", "DOWNLOADED", "PROCESSED"] |
|
|
|
|
| def format_bytes(size): |
| size = float(size) |
| for unit in ["B", "KB", "MB", "GB"]: |
| if size < 1024 or unit == "GB": |
| return f"{size:.1f} {unit}" if unit != "B" else f"{int(size)} B" |
| size /= 1024 |
| return f"{size:.1f} GB" |
|
|
|
|
| @st.cache_data(show_spinner=False) |
| def get_datasets(): |
| datasets = {} |
|
|
| try: |
| with open(STATUS_PATH, encoding="utf-8") as f: |
| items = json.load(f) |
| except Exception as exc: |
| return datasets, f"Error reading {STATUS_PATH}: {exc}" |
|
|
| for item in items: |
| name = item["name"] |
| dataset_path = DATASETS_DIR / name |
| processed_path = dataset_path / "processed" |
|
|
| if not processed_path.exists(): |
| continue |
|
|
| file_list = [] |
| for root, _, files in os.walk(processed_path): |
| root_path = Path(root) |
| for file_name in files: |
| path = root_path / file_name |
| if path.suffix.lower() in VIEWABLE_EXTENSIONS: |
| rel_path = path.relative_to(processed_path) |
| file_list.append(str(rel_path)) |
|
|
| datasets[name] = { |
| "name": name, |
| "title": item.get("title", ""), |
| "url": item.get("url"), |
| "abstract": item.get("abstract") or "", |
| "request_needed": item.get("request_needed", False), |
| "status": item.get("status"), |
| "notes": item.get("notes"), |
| "screened_by": item.get("screened_by"), |
| "requested_downloaded_by": item.get("requested_downloaded_by"), |
| "processed_by": item.get("processed_by"), |
| "files": sorted(file_list), |
| "path": str(dataset_path), |
| "processed_path": str(processed_path), |
| } |
|
|
| return datasets, None |
|
|
|
|
| def file_stats(path): |
| stat = path.stat() |
| return { |
| "Path": str(path), |
| "Size": format_bytes(stat.st_size), |
| "Modified": pd.Timestamp(stat.st_mtime, unit="s").strftime("%Y-%m-%d %H:%M:%S"), |
| } |
|
|
|
|
| def format_value(value): |
| if isinstance(value, float): |
| return f"{value:.6g}" |
| return str(value) |
|
|
|
|
| def render_dataset_info(data): |
| st.subheader(data["name"]) |
| if data.get("title"): |
| st.write(data["title"]) |
|
|
| cols = st.columns(4) |
| cols[0].metric("Status", data.get("status") or "NA") |
| cols[1].metric("Files", f"{len(data.get('files', [])):,}") |
| cols[2].metric("Request needed", str(data.get("request_needed"))) |
| cols[3].metric("Processed by", data.get("processed_by") or "NA") |
|
|
| details = { |
| "URL": data.get("url"), |
| "Screened by": data.get("screened_by"), |
| "Requested/downloaded by": data.get("requested_downloaded_by"), |
| "Notes": data.get("notes"), |
| "Dataset path": data.get("path"), |
| } |
| visible_details = {k: v for k, v in details.items() if v not in (None, "")} |
| if visible_details: |
| st.table(pd.DataFrame(visible_details.items(), columns=["Field", "Value"])) |
|
|
| if data.get("abstract"): |
| with st.expander("Abstract", expanded=True): |
| st.write(data["abstract"]) |
|
|
|
|
| def show_csv(path): |
| max_rows = st.sidebar.slider("CSV preview rows", 20, 500, 100, step=20) |
| df = pd.read_csv(path, low_memory=False, nrows=max_rows) |
| st.dataframe( |
| df, |
| use_container_width=True, |
| height=620, |
| ) |
| st.caption(f"Previewing first {len(df):,} rows and {len(df.columns):,} columns.") |
|
|
|
|
| def show_image(path): |
| image = Image.open(path) |
| st.image(image, use_container_width=True) |
| st.caption(f"Shape: {image.height} x {image.width}") |
|
|
|
|
| def show_json(path): |
| with open(path, encoding="utf-8") as f: |
| content = json.load(f) |
| st.json(content, expanded=False) |
|
|
|
|
| def show_raster(path): |
| with rasterio.open(path) as src: |
| summary = { |
| "Shape": f"{src.height} x {src.width}", |
| "Bands": src.count, |
| "Datatype": ", ".join(src.dtypes), |
| "NoData value": src.nodata, |
| "CRS": str(src.crs), |
| "Bounds": str(src.bounds), |
| "Transform": str(src.transform), |
| } |
| st.table(pd.DataFrame(summary.items(), columns=["Field", "Value"])) |
|
|
|
|
| def show_text(path): |
| max_chars = st.sidebar.slider("Text preview characters", 1_000, 100_000, 20_000, step=1_000) |
| with open(path, encoding="utf-8", errors="replace") as f: |
| content = f.read(max_chars + 1) |
| truncated = len(content) > max_chars |
| if truncated: |
| content = content[:max_chars] |
| st.code(content) |
| if truncated: |
| st.caption(f"Preview truncated at {max_chars:,} characters.") |
|
|
|
|
| def render_file(path): |
| suffix = path.suffix.lower() |
|
|
| st.subheader(path.name) |
| st.table(pd.DataFrame(file_stats(path).items(), columns=["Field", "Value"])) |
|
|
| try: |
| if suffix == ".csv": |
| show_csv(path) |
| elif suffix in {".png", ".jpg", ".jpeg"}: |
| show_image(path) |
| elif suffix == ".json": |
| show_json(path) |
| elif suffix in {".tif", ".tiff"}: |
| show_raster(path) |
| else: |
| show_text(path) |
| except Exception as exc: |
| st.error(f"Error previewing {path.name}: {exc}") |
|
|
|
|
| def select_dataset(datasets): |
| selected_statuses = st.sidebar.multiselect( |
| "Status", |
| STATUS_OPTIONS, |
| default=["PROCESSED"], |
| ) |
|
|
| search = st.sidebar.text_input("Search dataset", "") |
| needle = search.strip().lower() |
|
|
| filtered = [ |
| item |
| for item in datasets.values() |
| if item.get("status") in selected_statuses |
| and ( |
| not needle |
| or needle in item["name"].lower() |
| or needle in (item.get("title") or "").lower() |
| ) |
| ] |
| filtered.sort(key=lambda item: item["name"].lower()) |
|
|
| if not filtered: |
| return None |
|
|
| default_index = 0 |
| for idx, item in enumerate(filtered): |
| if item["name"] == DEFAULT_DATASET: |
| default_index = idx |
| break |
|
|
| return st.sidebar.selectbox( |
| "Dataset", |
| filtered, |
| index=default_index, |
| format_func=lambda item: item["name"], |
| ) |
|
|
|
|
| def select_file(dataset): |
| files = dataset.get("files", []) |
| if not files: |
| return None |
|
|
| search = st.sidebar.text_input("Search file", "") |
| needle = search.strip().lower() |
| filtered = [path for path in files if not needle or needle in path.lower()] |
|
|
| if not filtered: |
| st.sidebar.warning("No matching files.") |
| return None |
|
|
| options = ["Dataset overview"] + filtered |
| default_index = options.index(DEFAULT_FILE) if DEFAULT_FILE in options else 0 |
|
|
| return st.sidebar.selectbox( |
| "Processed file", |
| options, |
| index=default_index, |
| ) |
|
|
|
|
| def main(): |
| st.set_page_config( |
| page_title="Standardization Viewer", |
| page_icon=str(ICON_PATH) if ICON_PATH.exists() else None, |
| layout="wide", |
| initial_sidebar_state="expanded", |
| ) |
|
|
| st.sidebar.title("Standardization Viewer") |
| datasets, error = get_datasets() |
| if error: |
| st.error(error) |
| return |
|
|
| dataset = select_dataset(datasets) |
| if dataset is None: |
| st.warning("No datasets match the selected filters.") |
| return |
|
|
| selected_file = select_file(dataset) |
|
|
| st.title("Standardization Viewer") |
| render_dataset_info(dataset) |
|
|
| if selected_file and selected_file != "Dataset overview": |
| path = Path(dataset["processed_path"]) / selected_file |
| st.divider() |
| render_file(path) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
