groundsource 0.1.0__tar.gz

groundsource-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sharath Sivamalaisamy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

groundsource-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.md
+recursive-include groundsource/data *.shp *.shx *.dbf *.prj *.cpg

groundsource-0.1.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: groundsource
+Version: 0.1.0
+Summary: Python package for Google's Groundsource flash flood dataset — 2.6M events, 150+ countries, 2000–2026
+Author: Shara
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/sharanry/groundsource
+Project-URL: Repository, https://github.com/sharanry/groundsource
+Project-URL: Issues, https://github.com/sharanry/groundsource/issues
+Keywords: flood,flash-flood,climate,groundsource,google,geospatial,dataset,gemini,natural-disaster,news-mining
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Scientific/Engineering :: Atmospheric Science
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.5
+Requires-Dist: pyarrow>=10.0
+Requires-Dist: geopandas>=0.13
+Requires-Dist: shapely>=2.0
+Requires-Dist: matplotlib>=3.6
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# groundsource
+
+**Python package for Google's Groundsource flash flood dataset.**
+
+Google used Gemini to extract 2.6 million flash flood events from news articles across 150+ countries (2000-2026). The raw data is a 667MB Parquet file with undocumented WKB geometries and no location labels. This package decodes the geometries, tags every event with country and continent, and provides a clean search and analysis API.
+
+```python
+from groundsource import FloodDB
+
+db = FloodDB()  # auto-downloads + enriches on first run
+floods = db.search(country="India", year_range=(2020, 2025))
+```
+
+## Installation
+
+```bash
+pip install groundsource
+```
+
+**Requirements:** Python 3.9+, pandas, pyarrow, geopandas, shapely, matplotlib
+
+On first run, the package downloads the dataset from Zenodo (~667MB), decodes 2.6M WKB polygons, and performs a spatial join against Natural Earth boundaries. This takes 2-3 minutes and is cached locally for instant subsequent loads.
+
+## Usage
+
+### Search
+
+```python
+from groundsource import FloodDB
+db = FloodDB()
+
+# By country (supports common aliases: "USA", "UK", "UAE", etc.)
+db.search(country="India")
+db.search(country="USA", year_range=(2020, 2025))
+
+# By city (98 major cities built-in, default 100km radius)
+db.search(city="Houston", radius_km=50)
+
+# By continent or bounding box
+db.search(continent="Asia")
+db.search(bbox=[0, 95, 25, 120])  # [min_lat, min_lon, max_lat, max_lon]
+```
+
+### Trend Analysis
+
+```python
+db.trend(country="India")                        # yearly event counts
+db.growth(country="India")                       # growth rate between two periods
+db.compare(["USA", "UK", "India", "Indonesia"])  # side-by-side comparison
+db.top_countries(20)                             # ranked by total events
+db.country_growth_ranking(20)                    # ranked by growth acceleration
+db.bias_check()                                  # global yearly counts for bias analysis
+```
+
+### Built-in Charts
+
+```python
+db.plot_hockey_stick(save_path="hockey_stick.png")
+db.plot_bias(save_path="bias.png")
+db.plot_top_countries(save_path="top_countries.png")
+db.plot_country_growth(save_path="growth.png")
+```
+
+### Raw DataFrame Access
+
+```python
+df = db.to_dataframe()
+# Columns: uuid, area_km2, start_date, end_date, centroid_lon, centroid_lat,
+#           country, iso_a3, continent, year
+```
+
+## What This Package Does
+
+The raw Parquet from Zenodo has 5 columns with no documentation:
+
+| Raw Column | Type | Issue |
+|-----------|------|-------|
+| `uuid` | string | ID only |
+| `area_km2` | float | Usable as-is |
+| `geometry` | WKB binary | Requires `shapely` to decode |
+| `start_date` | string | Not parsed as datetime |
+| `end_date` | string | Not parsed as datetime |
+
+This package enriches each event with:
+
+| Added Column | Source |
+|-------------|--------|
+| `centroid_lon`, `centroid_lat` | Decoded from WKB polygons |
+| `country`, `iso_a3` | Spatial join against Natural Earth |
+| `continent` | Natural Earth |
+| `year` | Extracted from `start_date` |
+
+## Reporting Bias
+
+The dataset shows 498 events in 2000 and 402,012 in 2024. This does not mean floods increased 807x. The data is extracted from news articles, and digital news coverage grew dramatically over this period. Any trend analysis should account for this reporting bias. Use `db.bias_check()` and `db.plot_bias()` to visualize this.
+
+![Bias Analysis](charts/02_bias_normalized.png)
+
+## Top Countries by Events Detected
+
+![Top Countries](charts/04_top_countries.png)
+
+## Dataset
+
+- **Source:** [Google Groundsource](https://research.google/blog/introducing-groundsource-turning-news-reports-into-data-with-gemini/)
+- **Download:** [Zenodo](https://zenodo.org/records/18647054) (CC BY 4.0)
+- **Records:** 2,646,302 events across 175 countries, 2000-2026
+- **Method:** Gemini parsed ~5M news articles
+- **Accuracy:** 60% location+timing, 82% practically useful (per Google)
+
+## License
+
+MIT. The underlying dataset is licensed CC BY 4.0 by Google.
+
+## Citation
+
+> Google Research. *Groundsource: Turning News Reports into Data with Gemini.* Zenodo, 2026. DOI: [10.5281/zenodo.18647054](https://zenodo.org/records/18647054)

groundsource-0.1.0/README.md

@@ -0,0 +1,117 @@
+# groundsource
+
+**Python package for Google's Groundsource flash flood dataset.**
+
+Google used Gemini to extract 2.6 million flash flood events from news articles across 150+ countries (2000-2026). The raw data is a 667MB Parquet file with undocumented WKB geometries and no location labels. This package decodes the geometries, tags every event with country and continent, and provides a clean search and analysis API.
+
+```python
+from groundsource import FloodDB
+
+db = FloodDB()  # auto-downloads + enriches on first run
+floods = db.search(country="India", year_range=(2020, 2025))
+```
+
+## Installation
+
+```bash
+pip install groundsource
+```
+
+**Requirements:** Python 3.9+, pandas, pyarrow, geopandas, shapely, matplotlib
+
+On first run, the package downloads the dataset from Zenodo (~667MB), decodes 2.6M WKB polygons, and performs a spatial join against Natural Earth boundaries. This takes 2-3 minutes and is cached locally for instant subsequent loads.
+
+## Usage
+
+### Search
+
+```python
+from groundsource import FloodDB
+db = FloodDB()
+
+# By country (supports common aliases: "USA", "UK", "UAE", etc.)
+db.search(country="India")
+db.search(country="USA", year_range=(2020, 2025))
+
+# By city (98 major cities built-in, default 100km radius)
+db.search(city="Houston", radius_km=50)
+
+# By continent or bounding box
+db.search(continent="Asia")
+db.search(bbox=[0, 95, 25, 120])  # [min_lat, min_lon, max_lat, max_lon]
+```
+
+### Trend Analysis
+
+```python
+db.trend(country="India")                        # yearly event counts
+db.growth(country="India")                       # growth rate between two periods
+db.compare(["USA", "UK", "India", "Indonesia"])  # side-by-side comparison
+db.top_countries(20)                             # ranked by total events
+db.country_growth_ranking(20)                    # ranked by growth acceleration
+db.bias_check()                                  # global yearly counts for bias analysis
+```
+
+### Built-in Charts
+
+```python
+db.plot_hockey_stick(save_path="hockey_stick.png")
+db.plot_bias(save_path="bias.png")
+db.plot_top_countries(save_path="top_countries.png")
+db.plot_country_growth(save_path="growth.png")
+```
+
+### Raw DataFrame Access
+
+```python
+df = db.to_dataframe()
+# Columns: uuid, area_km2, start_date, end_date, centroid_lon, centroid_lat,
+#           country, iso_a3, continent, year
+```
+
+## What This Package Does
+
+The raw Parquet from Zenodo has 5 columns with no documentation:
+
+| Raw Column | Type | Issue |
+|-----------|------|-------|
+| `uuid` | string | ID only |
+| `area_km2` | float | Usable as-is |
+| `geometry` | WKB binary | Requires `shapely` to decode |
+| `start_date` | string | Not parsed as datetime |
+| `end_date` | string | Not parsed as datetime |
+
+This package enriches each event with:
+
+| Added Column | Source |
+|-------------|--------|
+| `centroid_lon`, `centroid_lat` | Decoded from WKB polygons |
+| `country`, `iso_a3` | Spatial join against Natural Earth |
+| `continent` | Natural Earth |
+| `year` | Extracted from `start_date` |
+
+## Reporting Bias
+
+The dataset shows 498 events in 2000 and 402,012 in 2024. This does not mean floods increased 807x. The data is extracted from news articles, and digital news coverage grew dramatically over this period. Any trend analysis should account for this reporting bias. Use `db.bias_check()` and `db.plot_bias()` to visualize this.
+
+![Bias Analysis](charts/02_bias_normalized.png)
+
+## Top Countries by Events Detected
+
+![Top Countries](charts/04_top_countries.png)
+
+## Dataset
+
+- **Source:** [Google Groundsource](https://research.google/blog/introducing-groundsource-turning-news-reports-into-data-with-gemini/)
+- **Download:** [Zenodo](https://zenodo.org/records/18647054) (CC BY 4.0)
+- **Records:** 2,646,302 events across 175 countries, 2000-2026
+- **Method:** Gemini parsed ~5M news articles
+- **Accuracy:** 60% location+timing, 82% practically useful (per Google)
+
+## License
+
+MIT. The underlying dataset is licensed CC BY 4.0 by Google.
+
+## Citation
+
+> Google Research. *Groundsource: Turning News Reports into Data with Gemini.* Zenodo, 2026. DOI: [10.5281/zenodo.18647054](https://zenodo.org/records/18647054)

groundsource-0.1.0/groundsource/__init__.py

@@ -0,0 +1,6 @@
+"""groundsource — Python package for Google's Groundsource flash flood dataset."""
+
+from groundsource.db import FloodDB
+
+__version__ = "0.1.0"
+__all__ = ["FloodDB"]

groundsource-0.1.0/groundsource/cache.py

@@ -0,0 +1,63 @@
+"""Download and cache management for the Groundsource dataset."""
+
+import os
+import sys
+import urllib.request
+from pathlib import Path
+
+ZENODO_URL = "https://zenodo.org/records/18647054/files/groundsource_2026.parquet?download=1"
+PARQUET_FILENAME = "groundsource_2026.parquet"
+ENRICHED_FILENAME = "groundsource_enriched.parquet"
+
+
+def get_cache_dir() -> Path:
+    """Return platform-appropriate cache directory."""
+    if sys.platform == "win32":
+        base = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+    elif sys.platform == "darwin":
+        base = Path.home() / "Library" / "Caches"
+    else:
+        base = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache"))
+    cache_dir = base / "groundsource"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    return cache_dir
+
+
+def get_raw_parquet_path() -> Path:
+    return get_cache_dir() / PARQUET_FILENAME
+
+
+def get_enriched_parquet_path() -> Path:
+    return get_cache_dir() / ENRICHED_FILENAME
+
+
+def download_parquet(force: bool = False) -> Path:
+    """Download the raw Parquet from Zenodo if not already cached."""
+    path = get_raw_parquet_path()
+    if path.exists() and not force:
+        return path
+
+    print(f"Downloading Groundsource dataset ({PARQUET_FILENAME})...")
+    print(f"Source: {ZENODO_URL}")
+    print(f"Destination: {path}")
+
+    def _progress(block_num, block_size, total_size):
+        downloaded = block_num * block_size
+        if total_size > 0:
+            pct = min(100, downloaded * 100 / total_size)
+            mb = downloaded / (1024 * 1024)
+            total_mb = total_size / (1024 * 1024)
+            sys.stdout.write(f"\r  {mb:.0f}/{total_mb:.0f} MB ({pct:.1f}%)")
+            sys.stdout.flush()
+
+    urllib.request.urlretrieve(ZENODO_URL, str(path), reporthook=_progress)
+    print("\n  Download complete.")
+    return path
+
+
+def load_from_local(path: str) -> Path:
+    """Use a local Parquet file instead of downloading."""
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(f"Local parquet not found: {path}")
+    return p

groundsource-0.1.0/groundsource/charts.py

@@ -0,0 +1,206 @@
+"""Chart generators for Groundsource analysis. LinkedIn-worthy matplotlib charts."""
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+
+
+# Consistent style for all charts
+STYLE = {
+    "figure.facecolor": "white",
+    "axes.facecolor": "#f8f9fa",
+    "axes.grid": True,
+    "grid.alpha": 0.3,
+    "font.family": "sans-serif",
+    "font.size": 11,
+}
+
+
+def _apply_style():
+    plt.rcParams.update(STYLE)
+
+
+def plot_hockey_stick(yearly_counts: pd.DataFrame, save_path: str = None) -> plt.Figure:
+    """Chart 1: Total events per year — the 807x hockey stick.
+
+    yearly_counts: DataFrame with columns [year, count]
+    """
+    _apply_style()
+    fig, ax = plt.subplots(figsize=(12, 6))
+
+    ax.bar(yearly_counts["year"], yearly_counts["count"],
+           color="#1a73e8", alpha=0.85, width=0.8)
+
+    # Annotate the growth
+    first_year = yearly_counts.iloc[0]
+    peak_year = yearly_counts.loc[yearly_counts["count"].idxmax()]
+    growth = peak_year["count"] / first_year["count"] if first_year["count"] > 0 else 0
+
+    ax.annotate(
+        f'{first_year["count"]:,.0f} events',
+        xy=(first_year["year"], first_year["count"]),
+        xytext=(first_year["year"] + 3, peak_year["count"] * 0.3),
+        fontsize=10, color="#666",
+        arrowprops=dict(arrowstyle="->", color="#999"),
+    )
+    ax.annotate(
+        f'{peak_year["count"]:,.0f} events\n({growth:,.0f}x growth)',
+        xy=(peak_year["year"], peak_year["count"]),
+        xytext=(peak_year["year"] - 6, peak_year["count"] * 1.05),
+        fontsize=10, fontweight="bold", color="#d93025",
+        arrowprops=dict(arrowstyle="->", color="#d93025"),
+    )
+
+    ax.set_title("Flash Flood Events Detected Per Year\n— or is it news coverage?",
+                 fontsize=16, fontweight="bold", pad=15)
+    ax.set_xlabel("Year", fontsize=12)
+    ax.set_ylabel("Events Detected", fontsize=12)
+    ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, _: f"{x:,.0f}"))
+
+    ax.text(0.02, 0.95,
+            "Source: Google Groundsource dataset (2.6M events from news articles, 2000–2026)",
+            transform=ax.transAxes, fontsize=8, color="#999", va="top")
+
+    plt.tight_layout()
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches="tight")
+        print(f"  Saved: {save_path}")
+    return fig
+
+
+def plot_bias_normalized(yearly_counts: pd.DataFrame, save_path: str = None) -> plt.Figure:
+    """Chart 2: Overlay event growth vs estimated digital news growth.
+
+    Uses a simple exponential proxy for global digital news volume.
+    Internet users: ~400M (2000) → ~5.5B (2025) ≈ 13.75x
+    Online news output grew even faster due to digital-native outlets.
+    We use a conservative 15-20x estimate for indexed news articles.
+    """
+    _apply_style()
+    fig, ax = plt.subplots(figsize=(12, 6))
+
+    years = yearly_counts["year"].values
+    counts = yearly_counts["count"].values
+
+    # Normalize both to year 2007 (when dataset has enough events to be meaningful)
+    ref_idx = np.where(years == 2007)[0]
+    if len(ref_idx) == 0:
+        ref_idx = [7]  # fallback
+    ref_idx = ref_idx[0]
+
+    norm_events = counts / counts[ref_idx]
+
+    # Conservative proxy: internet users grew ~14x from 2000 to 2025
+    # Online news articles grew faster. Use a simple logistic-like growth curve.
+    internet_users_billions = {
+        2000: 0.41, 2001: 0.50, 2002: 0.63, 2003: 0.72, 2004: 0.82,
+        2005: 1.02, 2006: 1.15, 2007: 1.37, 2008: 1.57, 2009: 1.77,
+        2010: 2.02, 2011: 2.23, 2012: 2.49, 2013: 2.73, 2014: 2.96,
+        2015: 3.19, 2016: 3.42, 2017: 3.65, 2018: 3.90, 2019: 4.13,
+        2020: 4.59, 2021: 4.90, 2022: 5.16, 2023: 5.35, 2024: 5.52,
+        2025: 5.56, 2026: 5.60,
+    }
+    news_proxy = np.array([internet_users_billions.get(y, 5.6) for y in years])
+    norm_news = news_proxy / news_proxy[ref_idx]
+
+    ax.plot(years, norm_events, "o-", color="#d93025", linewidth=2.5,
+            markersize=5, label="Detected flood events", zorder=3)
+    ax.plot(years, norm_news, "s--", color="#1a73e8", linewidth=2,
+            markersize=4, label="Internet users (proxy for digital news)", zorder=2)
+
+    ax.fill_between(years, norm_events, norm_news,
+                    where=(norm_events > norm_news),
+                    alpha=0.1, color="#d93025")
+
+    ax.set_title("Are Floods Increasing — or Is News Coverage?\nBoth curves normalized to 2007 = 1.0",
+                 fontsize=15, fontweight="bold", pad=15)
+    ax.set_xlabel("Year", fontsize=12)
+    ax.set_ylabel("Growth relative to 2007", fontsize=12)
+    ax.legend(fontsize=11, loc="upper left")
+    ax.set_yscale("log")
+    ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, _: f"{x:.0f}x"))
+
+    ax.text(0.02, 0.02,
+            "Event detection grows faster than internet adoption — likely because\n"
+            "news digitization (articles going online) grew faster than raw user count.",
+            transform=ax.transAxes, fontsize=9, color="#666", va="bottom",
+            style="italic")
+
+    plt.tight_layout()
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches="tight")
+        print(f"  Saved: {save_path}")
+    return fig
+
+
+def plot_country_growth(growth_df: pd.DataFrame, n: int = 20,
+                        save_path: str = None) -> plt.Figure:
+    """Chart 3: Countries with highest growth factor — what might be real.
+
+    growth_df: from trends.country_growth_ranking()
+    """
+    _apply_style()
+    top = growth_df.head(n).copy()
+    top = top.sort_values("growth_factor", ascending=True)  # horizontal bar, ascending
+
+    fig, ax = plt.subplots(figsize=(10, 8))
+
+    colors = ["#d93025" if g > 50 else "#ea8600" if g > 20 else "#1a73e8"
+              for g in top["growth_factor"]]
+
+    ax.barh(top["country"], top["growth_factor"], color=colors, alpha=0.85)
+
+    for i, (_, row) in enumerate(top.iterrows()):
+        ax.text(row["growth_factor"] + 0.5, i,
+                f'{row["growth_factor"]:.0f}x',
+                va="center", fontsize=9, fontweight="bold")
+
+    ax.set_title("Which Countries Show the Fastest Growth in Detected Flood Events?\n"
+                 "Growth factor: avg events/year (2018–2025) vs (2005–2012)",
+                 fontsize=14, fontweight="bold", pad=15)
+    ax.set_xlabel("Growth Factor (higher = faster acceleration)", fontsize=11)
+
+    ax.text(0.98, 0.02,
+            "⚠ High growth may reflect news digitization, not actual flood increase.\n"
+            "Countries with low baseline coverage will show inflated growth.",
+            transform=ax.transAxes, fontsize=8, color="#999",
+            ha="right", va="bottom", style="italic")
+
+    plt.tight_layout()
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches="tight")
+        print(f"  Saved: {save_path}")
+    return fig
+
+
+def plot_top_countries(country_counts: pd.DataFrame, n: int = 20,
+                       save_path: str = None) -> plt.Figure:
+    """Chart 4: Top N countries by total event count — the LinkedIn chart."""
+    _apply_style()
+    top = country_counts.head(n).copy()
+    top = top.sort_values("count", ascending=True)
+
+    fig, ax = plt.subplots(figsize=(10, 8))
+
+    ax.barh(top["country"], top["count"], color="#1a73e8", alpha=0.85)
+
+    for i, (_, row) in enumerate(top.iterrows()):
+        ax.text(row["count"] + 500, i,
+                f'{row["count"]:,.0f}',
+                va="center", fontsize=9)
+
+    ax.set_title("Top 20 Countries by Total Flash Flood Events Detected (2000–2026)",
+                 fontsize=14, fontweight="bold", pad=15)
+    ax.set_xlabel("Total Events Detected", fontsize=11)
+    ax.xaxis.set_major_formatter(ticker.FuncFormatter(lambda x, _: f"{x:,.0f}"))
+
+    ax.text(0.98, 0.02,
+            "Source: Google Groundsource — 2.6M events extracted by Gemini from news articles",
+            transform=ax.transAxes, fontsize=8, color="#999", ha="right", va="bottom")
+
+    plt.tight_layout()
+    if save_path:
+        fig.savefig(save_path, dpi=150, bbox_inches="tight")
+        print(f"  Saved: {save_path}")
+    return fig

groundsource-0.1.0/groundsource/data/__init__.py

@@ -0,0 +1 @@
+# Data directory — contains Natural Earth shapefiles bundled with the package.

groundsource-0.1.0/groundsource/data/ne_110m_admin_0_countries.cpg

@@ -0,0 +1 @@
+UTF-8

groundsource-0.1.0/groundsource/data/ne_110m_admin_0_countries.prj

@@ -0,0 +1 @@
+GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.017453292519943295]]