@nahisaho/satori 0.22.0 → 0.24.0

package/src/.github/skills/scientific-geospatial-analysis/SKILL.md

@@ -0,0 +1,274 @@
+---
+name: scientific-geospatial-analysis
+description: |
+  地理空間データ解析スキル。GeoPandas ベクターデータ処理・
+  Rasterio ラスター解析・Folium/Kepler.gl インタラクティブ地図・
+  空間自己相関 (Moran's I)・クリギング補間・CRS 変換。
+---
+
+# Scientific Geospatial Analysis
+
+地理空間データの前処理・空間統計・インタラクティブ地図可視化
+パイプラインを提供する。
+
+## When to Use
+
+- GeoPandas でベクターデータ (Shapefile/GeoJSON) を処理するとき
+- ラスターデータ (GeoTIFF) を読み込み解析するとき
+- 空間自己相関 (Moran's I / LISA) を検定するとき
+- クリギング (Kriging) で空間補間するとき
+- Folium/Kepler.gl でインタラクティブ地図を作成するとき
+- CRS (座標参照系) 変換・空間結合をするとき
+
+> **Note**: 環境特化 GIS (SoilGrids/WorldClim) は `scientific-environmental-geodata` を参照。
+
+---
+
+## Quick Start
+
+## 1. GeoPandas ベクターデータ処理
+
+```python
+import numpy as np
+import pandas as pd
+
+
+def load_and_process_geodata(filepath, target_crs="EPSG:4326"):
+    """
+    GeoPandas ベクター/ポイントデータ読み込み・CRS 変換。
+
+    Parameters:
+        filepath: str — Shapefile / GeoJSON / GPKG パス
+        target_crs: str — 変換先座標系
+    """
+    import geopandas as gpd
+
+    gdf = gpd.read_file(filepath)
+    original_crs = gdf.crs
+
+    if gdf.crs != target_crs:
+        gdf = gdf.to_crs(target_crs)
+
+    # 基本統計
+    bounds = gdf.total_bounds  # [minx, miny, maxx, maxy]
+    geom_types = gdf.geometry.geom_type.value_counts().to_dict()
+
+    print(f"GeoData: {len(gdf)} features, CRS: {original_crs} → {target_crs}")
+    print(f"  Bounds: [{bounds[0]:.4f}, {bounds[1]:.4f}] "
+          f"to [{bounds[2]:.4f}, {bounds[3]:.4f}]")
+    print(f"  Geometry types: {geom_types}")
+    return gdf
+
+
+def spatial_join(gdf_left, gdf_right, how="inner", predicate="intersects"):
+    """
+    空間結合 (Spatial Join)。
+
+    Parameters:
+        gdf_left: GeoDataFrame — 左テーブル
+        gdf_right: GeoDataFrame — 右テーブル
+        how: str — "inner" / "left" / "right"
+        predicate: str — "intersects" / "within" / "contains"
+    """
+    import geopandas as gpd
+
+    if gdf_left.crs != gdf_right.crs:
+        gdf_right = gdf_right.to_crs(gdf_left.crs)
+
+    joined = gpd.sjoin(gdf_left, gdf_right, how=how, predicate=predicate)
+
+    print(f"Spatial Join ({predicate}, {how}): "
+          f"{len(gdf_left)} × {len(gdf_right)} → {len(joined)}")
+    return joined
+```
+
+## 2. 空間自己相関 (Moran's I / LISA)
+
+```python
+def spatial_autocorrelation(gdf, value_col, weight_type="queen"):
+    """
+    空間自己相関検定 — Global Moran's I + LISA。
+
+    Parameters:
+        gdf: GeoDataFrame — ジオメトリ + 属性データ
+        value_col: str — 解析対象カラム
+        weight_type: str — "queen" / "rook" / "knn"
+    """
+    from libpysal.weights import Queen, Rook, KNN
+    from esda.moran import Moran, Moran_Local
+    import matplotlib.pyplot as plt
+
+    # 空間重み行列
+    if weight_type == "queen":
+        w = Queen.from_dataframe(gdf)
+    elif weight_type == "rook":
+        w = Rook.from_dataframe(gdf)
+    elif weight_type == "knn":
+        w = KNN.from_dataframe(gdf, k=5)
+
+    w.transform = "r"
+    y = gdf[value_col].values
+
+    # Global Moran's I
+    moran_global = Moran(y, w)
+
+    # LISA (Local Indicators of Spatial Association)
+    moran_local = Moran_Local(y, w)
+
+    gdf = gdf.copy()
+    gdf["lisa_cluster"] = moran_local.q  # 1=HH, 2=LH, 3=LL, 4=HL
+    gdf["lisa_significant"] = moran_local.p_sim < 0.05
+    gdf["local_moran_i"] = moran_local.Is
+
+    # 可視化
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 7))
+
+    gdf.plot(column=value_col, ax=ax1, legend=True,
+             cmap="RdYlBu_r", edgecolor="gray", linewidth=0.3)
+    ax1.set_title(f"{value_col} (Moran's I={moran_global.I:.4f}, "
+                  f"p={moran_global.p_sim:.4f})")
+
+    cluster_labels = {1: "High-High", 2: "Low-High",
+                      3: "Low-Low", 4: "High-Low", 0: "Not Significant"}
+    sig_gdf = gdf[gdf["lisa_significant"]]
+    if len(sig_gdf) > 0:
+        sig_gdf.plot(column="lisa_cluster", ax=ax2,
+                     categorical=True, legend=True,
+                     edgecolor="gray", linewidth=0.3)
+    ax2.set_title("LISA Clusters (p < 0.05)")
+
+    plt.tight_layout()
+    path = "spatial_autocorrelation.png"
+    plt.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close()
+
+    print(f"Moran's I = {moran_global.I:.4f}, p = {moran_global.p_sim:.4f}")
+    print(f"LISA: {gdf['lisa_significant'].sum()} significant clusters")
+    return {"moran_i": moran_global.I, "p_value": moran_global.p_sim,
+            "gdf": gdf, "fig": path}
+```
+
+## 3. クリギング空間補間
+
+```python
+def kriging_interpolation(points_df, x_col, y_col, value_col,
+                          grid_resolution=100,
+                          variogram_model="spherical"):
+    """
+    Ordinary Kriging 空間補間。
+
+    Parameters:
+        points_df: pd.DataFrame — 観測点データ
+        x_col, y_col: str — 座標カラム
+        value_col: str — 補間対象カラム
+        grid_resolution: int — グリッド解像度
+        variogram_model: str — "spherical" / "exponential" / "gaussian"
+    """
+    from pykrige.ok import OrdinaryKriging
+    import matplotlib.pyplot as plt
+
+    x = points_df[x_col].values
+    y = points_df[y_col].values
+    z = points_df[value_col].values
+
+    ok = OrdinaryKriging(
+        x, y, z,
+        variogram_model=variogram_model,
+        verbose=False, enable_plotting=False)
+
+    grid_x = np.linspace(x.min(), x.max(), grid_resolution)
+    grid_y = np.linspace(y.min(), y.max(), grid_resolution)
+    z_pred, ss_pred = ok.execute("grid", grid_x, grid_y)
+
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
+
+    im1 = ax1.imshow(z_pred, origin="lower",
+                     extent=[x.min(), x.max(), y.min(), y.max()],
+                     cmap="viridis")
+    ax1.scatter(x, y, c="red", s=10, edgecolors="black", linewidths=0.5)
+    ax1.set_title(f"Kriging Prediction ({variogram_model})")
+    plt.colorbar(im1, ax=ax1)
+
+    im2 = ax2.imshow(ss_pred, origin="lower",
+                     extent=[x.min(), x.max(), y.min(), y.max()],
+                     cmap="Reds")
+    ax2.set_title("Kriging Variance (Uncertainty)")
+    plt.colorbar(im2, ax=ax2)
+
+    plt.tight_layout()
+    path = "kriging_result.png"
+    plt.savefig(path, dpi=150, bbox_inches="tight")
+    plt.close()
+
+    print(f"Kriging ({variogram_model}): {grid_resolution}×{grid_resolution} grid, "
+          f"{len(x)} observation points")
+    return {"z_pred": z_pred, "variance": ss_pred,
+            "grid_x": grid_x, "grid_y": grid_y, "fig": path}
+```
+
+## 4. Folium インタラクティブ地図
+
+```python
+def interactive_map(gdf, value_col=None, popup_cols=None,
+                    tiles="CartoDB positron",
+                    output="interactive_map.html"):
+    """
+    Folium インタラクティブ地図。
+
+    Parameters:
+        gdf: GeoDataFrame — 地理空間データ
+        value_col: str | None — Choropleth カラム
+        popup_cols: list[str] | None — ポップアップ表示カラム
+        tiles: str — タイル名
+        output: str — 出力 HTML
+    """
+    import folium
+
+    center = [gdf.geometry.centroid.y.mean(),
+              gdf.geometry.centroid.x.mean()]
+    m = folium.Map(location=center, zoom_start=8, tiles=tiles)
+
+    if value_col and gdf.geometry.geom_type.iloc[0] in ["Polygon", "MultiPolygon"]:
+        folium.Choropleth(
+            geo_data=gdf.__geo_interface__,
+            data=gdf, columns=[gdf.index.name or "index", value_col],
+            key_on="feature.id",
+            fill_color="YlOrRd",
+            legend_name=value_col
+        ).add_to(m)
+    else:
+        for _, row in gdf.iterrows():
+            popup_text = ""
+            if popup_cols:
+                popup_text = "<br>".join(
+                    [f"<b>{c}</b>: {row[c]}" for c in popup_cols])
+            folium.CircleMarker(
+                location=[row.geometry.centroid.y, row.geometry.centroid.x],
+                radius=5, popup=popup_text,
+                color="blue", fill=True
+            ).add_to(m)
+
+    m.save(output)
+    print(f"Interactive map → {output} ({len(gdf)} features)")
+    return output
+```
+
+---
+
+## パイプライン統合
+
+```
+environmental-geodata → geospatial-analysis → advanced-visualization
+  (環境データ取得)        (空間解析)             (高度可視化)
+         │                     │                      ↓
+  epidemiology ───────────────┘          interactive-dashboard
+    (空間疫学)                              (ダッシュボード)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `spatial_autocorrelation.png` | Moran's I + LISA | → reporting |
+| `kriging_result.png` | クリギング補間 | → visualization |
+| `interactive_map.html` | Folium 地図 | → dashboard |

package/src/.github/skills/scientific-interactive-dashboard/SKILL.md

@@ -0,0 +1,346 @@
+---
+name: scientific-interactive-dashboard
+description: |
+  インタラクティブダッシュボードスキル。
+  Streamlit / Dash / Panel / Voilà による
+  科学データダッシュボード構築・リアルタイムパラメータ探索 UI ・
+  ウィジェット連動・データアップロード・解析パイプライン UI 化。
+---
+
+# Scientific Interactive Dashboard
+
+科学データのインタラクティブダッシュボードを構築し、
+パラメータ探索・結果共有・リアルタイム解析を実現する。
+
+## When to Use
+
+- Streamlit で迅速にデータ探索ダッシュボードを構築するとき
+- Dash でカスタマイズ性の高い解析 UI を作成するとき
+- Panel / Voilà で Jupyter ノートブックをダッシュボード化するとき
+- パラメータスライダー + リアルタイム更新の UI を実装するとき
+- 複数人で解析結果を共有するとき
+- 非プログラマーに解析ツールを提供するとき
+
+---
+
+## Quick Start
+
+## 1. Streamlit 科学データダッシュボード
+
+```python
+def generate_streamlit_dashboard(output_path="dashboard_app.py"):
+    """
+    Streamlit ダッシュボードテンプレート生成。
+
+    Parameters:
+        output_path: str — 出力 Python ファイル
+    """
+    code = '''
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+
+
+st.set_page_config(page_title="Scientific Data Dashboard",
+                   layout="wide", page_icon="🔬")
+
+st.title("🔬 Scientific Data Dashboard")
+
+# --- サイドバー: データアップロード & パラメータ ---
+st.sidebar.header("Settings")
+
+uploaded_file = st.sidebar.file_uploader(
+    "Upload CSV / Excel", type=["csv", "xlsx"])
+
+if uploaded_file is not None:
+    if uploaded_file.name.endswith(".csv"):
+        df = pd.read_csv(uploaded_file)
+    else:
+        df = pd.read_excel(uploaded_file)
+else:
+    # デモデータ
+    np.random.seed(42)
+    n = 500
+    df = pd.DataFrame({
+        "x": np.random.randn(n),
+        "y": np.random.randn(n),
+        "z": np.random.randn(n),
+        "category": np.random.choice(["A", "B", "C"], n),
+        "value": np.random.exponential(2, n)
+    })
+    st.sidebar.info("Demo data loaded (upload your own CSV)")
+
+# --- データ概要 ---
+col1, col2, col3 = st.columns(3)
+col1.metric("Rows", len(df))
+col2.metric("Columns", len(df.columns))
+col3.metric("Missing", int(df.isnull().sum().sum()))
+
+# --- タブ ---
+tab1, tab2, tab3, tab4 = st.tabs(
+    ["📊 Explorer", "📈 Distribution", "🔗 Correlation", "📋 Data"])
+
+numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+cat_cols = df.select_dtypes(exclude=[np.number]).columns.tolist()
+
+with tab1:
+    st.subheader("Interactive Explorer")
+    c1, c2 = st.columns(2)
+    x_col = c1.selectbox("X axis", numeric_cols, index=0)
+    y_col = c2.selectbox("Y axis", numeric_cols,
+                          index=min(1, len(numeric_cols)-1))
+    color_col = st.selectbox("Color", [None] + cat_cols + numeric_cols)
+
+    fig = px.scatter(df, x=x_col, y=y_col, color=color_col,
+                     opacity=0.7, title=f"{x_col} vs {y_col}")
+    st.plotly_chart(fig, use_container_width=True)
+
+with tab2:
+    st.subheader("Distribution Analysis")
+    dist_col = st.selectbox("Column", numeric_cols, key="dist")
+    n_bins = st.slider("Bins", 10, 100, 30)
+    fig2 = px.histogram(df, x=dist_col, nbins=n_bins,
+                        marginal="box", title=f"Distribution: {dist_col}")
+    st.plotly_chart(fig2, use_container_width=True)
+
+with tab3:
+    st.subheader("Correlation Matrix")
+    corr = df[numeric_cols].corr()
+    fig3 = px.imshow(corr, text_auto=".2f", color_continuous_scale="RdBu_r",
+                     title="Correlation Heatmap")
+    st.plotly_chart(fig3, use_container_width=True)
+
+with tab4:
+    st.subheader("Raw Data")
+    st.dataframe(df, use_container_width=True)
+    csv = df.to_csv(index=False)
+    st.download_button("Download CSV", csv, "data.csv", "text/csv")
+'''
+
+    with open(output_path, "w") as f:
+        f.write(code)
+
+    print(f"Streamlit dashboard → {output_path}")
+    print(f"  Run: streamlit run {output_path}")
+    return output_path
+```
+
+## 2. Dash コールバックダッシュボード
+
+```python
+def generate_dash_dashboard(output_path="dash_app.py"):
+    """
+    Dash ダッシュボードテンプレート生成。
+
+    Parameters:
+        output_path: str — 出力 Python ファイル
+    """
+    code = '''
+from dash import Dash, html, dcc, Input, Output, dash_table
+import pandas as pd
+import numpy as np
+import plotly.express as px
+
+app = Dash(__name__)
+
+# デモデータ
+np.random.seed(42)
+n = 500
+df = pd.DataFrame({
+    "x": np.random.randn(n),
+    "y": np.random.randn(n),
+    "z": np.random.randn(n),
+    "group": np.random.choice(["Control", "Treatment A", "Treatment B"], n),
+    "response": np.random.exponential(2, n)
+})
+
+numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+
+app.layout = html.Div([
+    html.H1("Scientific Data Dashboard", style={"textAlign": "center"}),
+
+    html.Div([
+        html.Div([
+            html.Label("X Axis"),
+            dcc.Dropdown(id="x-col", options=numeric_cols,
+                         value=numeric_cols[0])
+        ], style={"width": "30%", "display": "inline-block"}),
+        html.Div([
+            html.Label("Y Axis"),
+            dcc.Dropdown(id="y-col", options=numeric_cols,
+                         value=numeric_cols[1])
+        ], style={"width": "30%", "display": "inline-block"}),
+        html.Div([
+            html.Label("Color"),
+            dcc.Dropdown(id="color-col",
+                         options=df.columns.tolist(),
+                         value="group")
+        ], style={"width": "30%", "display": "inline-block"}),
+    ], style={"padding": "20px"}),
+
+    html.Div([
+        html.Div([dcc.Graph(id="scatter-plot")],
+                 style={"width": "50%", "display": "inline-block"}),
+        html.Div([dcc.Graph(id="histogram")],
+                 style={"width": "50%", "display": "inline-block"}),
+    ]),
+
+    html.Div([
+        html.H3("Summary Statistics"),
+        dash_table.DataTable(
+            id="summary-table",
+            columns=[{"name": c, "id": c}
+                     for c in ["stat"] + numeric_cols],
+            style_table={"overflowX": "auto"})
+    ], style={"padding": "20px"})
+])
+
+@app.callback(
+    [Output("scatter-plot", "figure"),
+     Output("histogram", "figure"),
+     Output("summary-table", "data")],
+    [Input("x-col", "value"),
+     Input("y-col", "value"),
+     Input("color-col", "value")]
+)
+def update_plots(x_col, y_col, color_col):
+    fig1 = px.scatter(df, x=x_col, y=y_col, color=color_col,
+                      opacity=0.7, title=f"{x_col} vs {y_col}")
+    fig2 = px.histogram(df, x=x_col, color=color_col,
+                        marginal="box", barmode="overlay", opacity=0.7)
+    stats = df[numeric_cols].describe().reset_index()
+    stats.columns = ["stat"] + numeric_cols
+    return fig1, fig2, stats.to_dict("records")
+
+if __name__ == "__main__":
+    app.run(debug=True, port=8050)
+'''
+
+    with open(output_path, "w") as f:
+        f.write(code)
+
+    print(f"Dash dashboard → {output_path}")
+    print(f"  Run: python {output_path}")
+    return output_path
+```
+
+## 3. Panel ダッシュボード
+
+```python
+def generate_panel_dashboard(output_path="panel_app.py"):
+    """
+    Panel ダッシュボードテンプレート生成。
+
+    Parameters:
+        output_path: str — 出力 Python ファイル
+    """
+    code = '''
+import panel as pn
+import pandas as pd
+import numpy as np
+import plotly.express as px
+
+pn.extension("plotly")
+
+# デモデータ
+np.random.seed(42)
+n = 500
+df = pd.DataFrame({
+    "x": np.random.randn(n),
+    "y": np.random.randn(n),
+    "z": np.random.randn(n),
+    "group": np.random.choice(["A", "B", "C"], n),
+    "value": np.random.exponential(2, n)
+})
+
+numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+
+# ウィジェット
+x_select = pn.widgets.Select(name="X Axis", options=numeric_cols, value="x")
+y_select = pn.widgets.Select(name="Y Axis", options=numeric_cols, value="y")
+n_bins = pn.widgets.IntSlider(name="Histogram Bins", start=10, end=100, value=30)
+
+
+@pn.depends(x_select, y_select)
+def scatter_plot(x_col, y_col):
+    fig = px.scatter(df, x=x_col, y=y_col, color="group",
+                     opacity=0.7, title=f"{x_col} vs {y_col}")
+    return fig
+
+
+@pn.depends(x_select, n_bins)
+def hist_plot(x_col, bins):
+    fig = px.histogram(df, x=x_col, nbins=bins, color="group",
+                       barmode="overlay", opacity=0.7)
+    return fig
+
+
+dashboard = pn.template.FastListTemplate(
+    title="Scientific Data Dashboard",
+    sidebar=[x_select, y_select, n_bins],
+    main=[
+        pn.Row(pn.pane.Plotly(scatter_plot, sizing_mode="stretch_width"),
+               pn.pane.Plotly(hist_plot, sizing_mode="stretch_width")),
+        pn.pane.DataFrame(df.describe().T, sizing_mode="stretch_width")
+    ]
+)
+
+dashboard.servable()
+'''
+
+    with open(output_path, "w") as f:
+        f.write(code)
+
+    print(f"Panel dashboard → {output_path}")
+    print(f"  Run: panel serve {output_path}")
+    return output_path
+```
+
+## 4. ダッシュボード比較ガイド
+
+```python
+def compare_dashboard_frameworks():
+    """
+    Streamlit / Dash / Panel / Voilà 比較表を出力。
+    """
+    comparison = pd.DataFrame({
+        "Framework": ["Streamlit", "Dash", "Panel", "Voilà"],
+        "Ease_of_Use": ["★★★★★", "★★★☆☆", "★★★★☆", "★★★★★"],
+        "Customization": ["★★★☆☆", "★★★★★", "★★★★☆", "★★☆☆☆"],
+        "Interactivity": ["★★★★☆", "★★★★★", "★★★★★", "★★★☆☆"],
+        "Performance": ["★★★☆☆", "★★★★★", "★★★★☆", "★★★☆☆"],
+        "Deployment": ["Streamlit Cloud", "Heroku/AWS", "Any ASGI", "Binder/Hub"],
+        "Best_For": [
+            "Rapid prototyping, data exploration",
+            "Production apps, complex callbacks",
+            "Jupyter integration, scientific viz",
+            "Notebook → dashboard conversion"
+        ]
+    })
+
+    print("=== Dashboard Framework Comparison ===")
+    print(comparison.to_string(index=False))
+    return comparison
+```
+
+---
+
+## パイプライン統合
+
+```
+advanced-visualization → interactive-dashboard → presentation-design
+    (高度可視化)           (ダッシュボード)          (プレゼン)
+         │                       │                      ↓
+  missing-data-analysis ────────┘            scientific-schematics
+    (欠損値解析)                                (図式デザイン)
+```
+
+## パイプライン出力
+
+| ファイル | 説明 | 次スキル |
+|---------|------|---------|
+| `dashboard_app.py` | Streamlit ダッシュボード | → deployment |
+| `dash_app.py` | Dash ダッシュボード | → deployment |
+| `panel_app.py` | Panel ダッシュボード | → deployment |
+| `framework_comparison.csv` | フレームワーク比較 | → 選択指針 |