Upload 3 files

Russia_regions_data.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6c87635401d364d438db96c1bcf0fbf513ab22a299b7b23c6082e6fac165b69d
-size 60001
+oid sha256:7c6fbeffe32651121b34b38db76f19f6ffeac91894b97d6bc1e17181a906e33c
+size 89033

app.py

@@ -13,8 +13,8 @@ except Exception as e:
     print(f"Error loading files: {e}")
     # Fallback dummy data
     df = pd.DataFrame(columns=['section', 'subsection', 'indicator_name', 'comment', 'year', 
-                               'indicator_value', 'indicator_unit', 'indicator_code', 
-                               'Region', 'object_oktmo', 'ISO'])
+                               'indicator_value', 'rel_indicator_value', 'indicator_unit', 'positive',
+                               'indicator_code', 'Region', 'object_oktmo', 'ISO'])
     gdf = gpd.GeoDataFrame(columns=['ISO', 'geometry'])
 
 # Ensure geometries are in standard lat/lon
@@ -25,10 +25,10 @@ gdf = gdf.to_crs(epsg=4326)
 # Filter for unique indicator_code
 df_unique = df.drop_duplicates(subset=['indicator_code']).copy()
 
-# Define columns (removed indicator_value from display)
+# Define columns (added indicator_value and rel_indicator_value, hidden positive)
 display_columns = [
     'section', 'subsection', 'indicator_name', 'comment', 
-    'year', 'indicator_unit'
+    'year', 'indicator_value', 'rel_indicator_value', 'indicator_unit'
 ]
 hidden_link_key = 'indicator_code'
 
@@ -80,8 +80,8 @@ def remove_outliers(series):
     Q1 = series.quantile(0.01)
     Q3 = series.quantile(0.99)
     IQR = Q3 - Q1
-    lower_bound = Q1 - 1.5 * IQR
-    upper_bound = Q3 + 1.5 * IQR
+    lower_bound = Q1 - 2 * IQR
+    upper_bound = Q3 + 2 * IQR
     return series.where((series >= lower_bound) & (series <= upper_bound), np.nan)
 
 def should_use_log_scale(values):
@@ -128,13 +128,67 @@ def format_value(value):
 
 # 4. Define App Logic
 # ---------------------------------------------------------
+def create_ranking_map():
+    """Create the default map showing overall rankings"""
+    # Filter for the overall ranking indicator
+    df_ranking = df[df['indicator_code'] == 'OVERALL_RANKING'].copy()
+    
+    if df_ranking.empty:
+        return px.choropleth(title="Overall Ranking not found")
+    
+    # Ensure one row per region
+    df_ranking = df_ranking.drop_duplicates(subset=['ISO'], keep='first')
+    
+    # Use rel_indicator_value (which is the same as indicator_value for ranking)
+    df_ranking['color_value'] = df_ranking['rel_indicator_value']
+    
+    # Merge with Geometry
+    merged = gdf.merge(df_ranking, on='ISO', how='inner')
+    
+    if merged.empty:
+        return px.choropleth(title="No ranking data available")
+
+    # Color scale: blue (lower/better) to red (higher/worse)
+    fig = px.choropleth_map(
+        merged,
+        geojson=merged.geometry,
+        locations=merged.index, 
+        color='color_value',
+        color_continuous_scale="RdYlBu_r",  # Blue (low/good) to Red (high/bad)
+        map_style="satellite-streets",
+        zoom=2,
+        center={"lat": 60, "lon": 90},
+        opacity=0.6,
+        labels={'color_value': 'Overall Ranking'}
+    )
+
+    # Format values for tooltip
+    merged['formatted_value'] = merged['rel_indicator_value'].apply(format_value)
+
+    # Tooltip Configuration
+    fig.update_traces(
+        customdata=merged[['Region', 'formatted_value']],
+        hovertemplate=(
+            "<b>Region:</b> %{customdata[0]}<br>"
+            "<b>Overall Ranking:</b> %{customdata[1]}"
+            "<extra></extra>"
+        )
+    )
+    
+    fig.update_layout(
+        margin={"r":0,"t":0,"l":0,"b":0},
+        height=800
+    )
+    
+    return fig
+
 def update_map(select_data: gr.SelectData, current_table_data):
     """
     Triggered when a cell in the table is clicked.
     select_data.index is a tuple (row, col) or int depending on version.
     """
     if select_data is None:
-        return None
+        return create_ranking_map()
 
     # Handle index format (it often comes as [row, col] or just row index)
     # We safely extract the row index
@@ -148,7 +202,7 @@ def update_map(select_data: gr.SelectData, current_table_data):
     if isinstance(current_table_data, pd.DataFrame):
         selected_row = current_table_data.iloc[row_index]
     else:
-        return None
+        return create_ranking_map()
     
     # Find the corresponding unique indicator code
     match = df_unique[
@@ -161,6 +215,7 @@ def update_map(select_data: gr.SelectData, current_table_data):
         
     selected_code = match.iloc[0][hidden_link_key]
     selected_unit = match.iloc[0]['indicator_unit']
+    selected_positive = match.iloc[0]['positive']
     
     # Filter main data for this indicator
     df_filtered = df[df['indicator_code'] == selected_code].copy()
@@ -168,12 +223,15 @@ def update_map(select_data: gr.SelectData, current_table_data):
     # Ensure one row per region (remove duplicates, keep first occurrence)
     df_filtered = df_filtered.drop_duplicates(subset=['ISO'], keep='first')
     
-    # Remove outliers (replace with NaN)
-    df_filtered['indicator_value_clean'] = remove_outliers(df_filtered['indicator_value'])
+    # Remove outliers (replace with NaN) - use rel_indicator_value
+    df_filtered['value_clean'] = remove_outliers(df_filtered['rel_indicator_value'])
+    
+    # Calculate Rankings based on positive column
+    df_filtered_for_ranking = df_filtered.dropna(subset=['value_clean']).copy()
     
-    # Calculate Rankings (Desc: Higher Value = Rank 1) - excluding NaN values
-    df_filtered_for_ranking = df_filtered.dropna(subset=['indicator_value_clean']).copy()
-    df_filtered_for_ranking = df_filtered_for_ranking.sort_values('indicator_value_clean', ascending=False).reset_index(drop=True)
+    # If P: higher is better (ascending=False), if N or other: lower is better (ascending=True)
+    ascending = (selected_positive != 'P')
+    df_filtered_for_ranking = df_filtered_for_ranking.sort_values('value_clean', ascending=ascending).reset_index(drop=True)
     df_filtered_for_ranking['Ranking'] = range(1, len(df_filtered_for_ranking) + 1)
     
     # Merge rankings back
@@ -184,14 +242,14 @@ def update_map(select_data: gr.SelectData, current_table_data):
     )
     
     # Decide if we should use log scale
-    use_log = should_use_log_scale(df_filtered['indicator_value_clean'])
+    use_log = should_use_log_scale(df_filtered['value_clean'])
     
     # Create color scale values (log if needed)
     if use_log:
-        df_filtered['color_value'] = np.log10(df_filtered['indicator_value_clean'])
+        df_filtered['color_value'] = np.log10(df_filtered['value_clean'])
         color_label = f"{selected_unit} (log scale)"
     else:
-        df_filtered['color_value'] = df_filtered['indicator_value_clean']
+        df_filtered['color_value'] = df_filtered['value_clean']
         color_label = selected_unit
 
     # Merge with Geometry
@@ -200,22 +258,30 @@ def update_map(select_data: gr.SelectData, current_table_data):
     if merged.empty:
         return px.choropleth(title="No data for this indicator")
 
-    # Construct Map with divergent color scale
+    # Determine color scale based on positive column
+    # If P: red (low/bad) to blue (high/good)
+    # If N or other: blue (low/good) to red (high/bad)
+    if selected_positive == 'P':
+        color_scale = "RdYlBu"  # Blue (low/bad) to Red (high/good)
+    else:
+        color_scale = "RdYlBu_r"  # Red (low/good) to Blue (high/bad) reversed
+
+    # Construct Map with appropriate color scale
     fig = px.choropleth_map(
         merged,
         geojson=merged.geometry,
         locations=merged.index, 
         color='color_value',
-        color_continuous_scale="RdYlBu_r",  # Divergent color scale (red-yellow-blue reversed)
+        color_continuous_scale=color_scale,  # Red (low/good) to Blue (high/bad)
         map_style="satellite-streets",
         zoom=2,
         center={"lat": 60, "lon": 90},
         opacity=0.6,
-        labels={'color_value': color_label}
+        labels={'color_value': 'Overall Ranking'}
     )
 
     # Format values for tooltip
-    merged['formatted_value'] = merged['indicator_value'].apply(format_value)
+    merged['formatted_value'] = merged['rel_indicator_value'].apply(format_value)
     merged['formatted_ranking'] = merged['Ranking'].apply(lambda x: str(int(x)) if pd.notna(x) else "N/A")
 
     # Tooltip Configuration
@@ -225,14 +291,14 @@ def update_map(select_data: gr.SelectData, current_table_data):
             "<b>Rank:</b> %{customdata[0]}<br>"
             "<b>Region:</b> %{customdata[1]}<br>"
             "<b>Indicator Name:</b> %{customdata[2]}<br>"
-            "<b>Indicator Value:</b> %{customdata[3]}"
+            "<b>Relative Value:</b> %{customdata[3]}"
             "<extra></extra>"
         )
     )
     
     fig.update_layout(
         margin={"r":0,"t":0,"l":0,"b":0},
-        height=800  # Increased map height
+        height=800
     )
     
     return fig
@@ -243,7 +309,8 @@ with gr.Blocks(title="Russian Regions Analytics") as demo:
     gr.Markdown("## Russian Regional Indicators")
     
     with gr.Row():
-        map_plot = gr.Plot(label="Regional Distribution")
+        # Initialize with ranking map
+        map_plot = gr.Plot(label="Regional Distribution", value=create_ranking_map())
     
     with gr.Row():
         # Prepare table value with styling metadata
@@ -258,10 +325,10 @@ with gr.Blocks(title="Russian Regions Analytics") as demo:
         table = gr.DataFrame(
             value=table_value, 
             label="Select an Indicator",
-            datatype=["str", "str", "str", "str", "number", "str"],
+            datatype=["str", "str", "str", "str", "number", "number", "number", "str"],
             interactive=True,
-            max_height=700,  # Increased table height
-            column_widths=column_widths  # Smart column widths based on content
+            max_height=700,
+            column_widths=column_widths
         )
 
     # Wire the selection event