Upload 2 files

app.py

@@ -0,0 +1,689 @@
+import gradio as gr
+import plotly.graph_objects as go
+import numpy as np
+import pandas as pd
+
+# Import mendeleev for comprehensive periodic table data
+try:
+    from mendeleev.fetch import fetch_table
+    MENDELEEV_AVAILABLE = True
+except ImportError:
+    print("mendeleev library not found. Please install it using: pip install mendeleev")
+    MENDELEEV_AVAILABLE = False
+
+def load_periodic_data():
+    """Load comprehensive periodic table data using mendeleev library"""
+    if not MENDELEEV_AVAILABLE:
+        return pd.DataFrame(), []
+    
+    try:
+        # Get the full periodic table with all properties
+        df = fetch_table('elements')
+        
+        # Get available columns and filter out non-numeric ones
+        numeric_columns = df.select_dtypes(include=[np.number]).columns.tolist()
+        
+        # Remove non-property columns
+        exclude_cols = ['atomic_number', 'period', 'group_id', 'mass_number', 'mass', 'id']
+        numeric_columns = [col for col in numeric_columns if col not in exclude_cols]
+        
+        return df, numeric_columns
+    except Exception as e:
+        print(f"Error loading mendeleev data: {e}")
+        return pd.DataFrame(), []
+
+# Load data
+elements_data, available_properties = load_periodic_data()
+
+def is_continuous_correlative_property(prop_name, df):
+    """Determine if a property is continuous AND correlative with atomic number (should be excluded from dropdown)"""
+    # Properties that are both continuous and strongly correlative with atomic number
+    continuous_correlative_properties = {
+        'atomic_weight', 'atomic_mass', 'mass', 'weight'
+    }
+    
+    # Check if property name contains continuous correlative indicators
+    for cont_prop in continuous_correlative_properties:
+        if cont_prop in prop_name.lower():
+            return True
+    
+    # Check if property is highly correlated with atomic number
+    if prop_name in df.columns and 'atomic_number' in df.columns:
+        data = df[[prop_name, 'atomic_number']].dropna()
+        if len(data) > 20:
+            correlation = data[prop_name].corr(data['atomic_number'])
+            # High correlation (>0.9) indicates strong relationship with atomic number
+            # Combined with high uniqueness indicates continuous correlative property
+            unique_ratio = len(data[prop_name].unique()) / len(data[prop_name])
+            if abs(correlation) > 0.9 and unique_ratio > 0.8:
+                return True
+    
+    return False
+
+def is_integer_property(prop_name, df):
+    """Determine if a property should be treated as integer"""
+    integer_properties = {
+        'period', 'group_id', 'group', 'block_number', 'neutrons',
+        'electrons', 'protons', 'valence', 'oxidation_states'
+    }
+    
+    # Check explicit integer properties
+    for int_prop in integer_properties:
+        if int_prop in prop_name.lower():
+            return True
+    
+    # Check if all non-null values are integers
+    if prop_name in df.columns:
+        data = df[prop_name].dropna()
+        if len(data) > 5:
+            # Check if all values are close to integers
+            are_integers = np.allclose(data, np.round(data), rtol=0, atol=1e-10)
+            return are_integers
+    
+    return False
+
+def calculate_color_variance(data, use_log=False):
+    """Calculate the effective color variance for a given scaling approach"""
+    if len(data) < 3:
+        return 0
+    
+    if use_log:
+        # For log scale, need positive values
+        positive_data = data[data > 0]
+        if len(positive_data) < 3:
+            return 0
+        scaled_data = np.log10(positive_data)
+    else:
+        scaled_data = data
+    
+    # Normalize to 0-1 range (simulating color mapping)
+    min_val, max_val = scaled_data.min(), scaled_data.max()
+    if max_val == min_val:
+        return 0
+    
+    normalized = (scaled_data - min_val) / (max_val - min_val)
+    
+    # Calculate effective variance - higher means better color distribution
+    return np.var(normalized)
+
+def requires_log_scale(prop_name, df):
+    """Improved heuristic to determine if logarithmic scale maximizes color palette utilization"""
+    if prop_name not in df.columns:
+        return False
+    
+    data = df[prop_name].dropna()
+    if len(data) < 10:
+        return False
+    
+    # Must have all positive values for log scale
+    if data.min() <= 0:
+        return False
+    
+    # Properties that typically benefit from log scale (abundance-related)
+    log_scale_indicators = [
+        'abundance', 'concentration', 'ppm', 'ppb', 'radioactive',
+        'half_life', 'decay', 'isotope_abundance'
+    ]
+    
+    for indicator in log_scale_indicators:
+        if indicator in prop_name.lower():
+            return True
+    
+    # Calculate color variance for both approaches
+    linear_variance = calculate_color_variance(data, use_log=False)
+    log_variance = calculate_color_variance(data, use_log=True)
+    
+    # Use log scale if it provides significantly better color distribution
+    # Require at least 50% improvement to switch to log scale
+    improvement_threshold = 1.5
+    
+    # Additional criteria for when log scale is beneficial:
+    # 1. Log scale provides better variance AND
+    # 2. Data has wide range (>2 orders of magnitude) OR high skewness
+    
+    range_ratio = data.max() / data.min()
+    data_skewness = abs(data.skew()) if hasattr(data, 'skew') else 0
+    
+    use_log_conditions = [
+        log_variance > linear_variance * improvement_threshold,  # Log provides better color distribution
+        range_ratio > 100 or data_skewness > 2,  # Data is suitable for log scaling
+        len(data) > 20  # Sufficient data points
+    ]
+    
+    return all(use_log_conditions)
+
+def get_element_series_description(df):
+    """Get element series description based on available data"""
+    # Try to find series-related columns
+    series_columns = []
+    for col in df.columns:
+        if any(term in col.lower() for term in ['series', 'group_name', 'category', 'family', 'type']):
+            series_columns.append(col)
+    
+    # Prefer columns with descriptive names
+    if 'series' in df.columns:
+        return 'series'
+    elif 'group_name' in df.columns:
+        return 'group_name'
+    elif series_columns:
+        return series_columns[0]
+    
+    # If no series column, try to create one from period and group
+    if 'period' in df.columns and 'group_id' in df.columns:
+        return 'period'  # Fallback to period
+    
+    return None
+
+def create_element_series_mapping(df):
+    """Create a mapping of element series if not available"""
+    if 'series' in df.columns:
+        return 'Element Series', 'series'
+    
+    # Try other descriptive columns
+    descriptive_columns = {
+        'group_name': 'Element Group',
+        'category': 'Element Category', 
+        'family': 'Element Family',
+        'type': 'Element Type'
+    }
+    
+    for col, label in descriptive_columns.items():
+        if col in df.columns and df[col].notna().sum() > 50:
+            return label, col
+    
+    # If no good series data, use period as fallback
+    if 'period' in df.columns:
+        return 'Period', 'period'
+    
+    return None, None
+
+def filter_relevant_properties(df, available_props):
+    """Filter properties to keep only relevant ones with sufficient data, excluding continuous correlative properties"""
+    
+    # Define curated properties with quality thresholds (these stay for internal use)
+    curated_properties = {
+        'atomic_weight': {'label': 'Atomic Mass (u)', 'min_data': 100, 'log_scale': False},
+        'density': {'label': 'Density (g/cm³)', 'min_data': 50, 'log_scale': False},
+        'en_pauling': {'label': 'Electronegativity (Pauling)', 'min_data': 70, 'log_scale': False},
+        'atomic_radius': {'label': 'Atomic Radius (pm)', 'min_data': 50, 'log_scale': False},
+        'vdw_radius': {'label': 'Van der Waals Radius (pm)', 'min_data': 40, 'log_scale': False},
+        'covalent_radius': {'label': 'Covalent Radius (pm)', 'min_data': 40, 'log_scale': False},
+        'ionenergy': {'label': 'First Ionization Energy (eV)', 'min_data': 80, 'log_scale': False},
+        'electron_affinity': {'label': 'Electron Affinity (eV)', 'min_data': 40, 'log_scale': False},
+        'melting_point': {'label': 'Melting Point (K)', 'min_data': 70, 'log_scale': False},
+        'boiling_point': {'label': 'Boiling Point (K)', 'min_data': 60, 'log_scale': False},
+        'atomic_volume': {'label': 'Atomic Volume (cm³/mol)', 'min_data': 40, 'log_scale': False},
+        'thermal_conductivity': {'label': 'Thermal Conductivity (W/mK)', 'min_data': 30, 'log_scale': False},
+        'c6': {'label': 'C6 Dispersion Coefficient', 'min_data': 30, 'log_scale': False},
+        'dipole_polarizability': {'label': 'Dipole Polarizability', 'min_data': 30, 'log_scale': False},
+        'period': {'label': 'Period', 'min_data': 100, 'log_scale': False},
+        'group_id': {'label': 'Group', 'min_data': 100, 'log_scale': False},
+    }
+    
+    # Check which properties are available and have sufficient data
+    valid_properties = {}
+    dropdown_properties = {}  # Separate dict for dropdown (excluding continuous correlative)
+    property_info = {}
+    
+    # First, try to add element series as the default
+    default_label, default_property = create_element_series_mapping(df)
+    if default_property and default_property in df.columns:
+        non_null_count = df[default_property].notna().sum()
+        if non_null_count >= 50:  # Lower threshold for series data
+            valid_properties[default_label] = default_property
+            dropdown_properties[default_label] = default_property
+            property_info[default_property] = {
+                'label': default_label, 
+                'min_data': 50, 
+                'log_scale': False,
+                'is_default': True
+            }
+    
+    for prop_name, prop_config in curated_properties.items():
+        if prop_name in available_props:
+            # Count non-null values
+            non_null_count = df[prop_name].notna().sum()
+            if non_null_count >= prop_config['min_data']:
+                valid_properties[prop_config['label']] = prop_name
+                property_info[prop_name] = prop_config
+                
+                # Only add to dropdown if not continuous and correlative
+                if not is_continuous_correlative_property(prop_name, df):
+                    dropdown_properties[prop_config['label']] = prop_name
+    
+    # Add any other properties with very good data coverage (>80 elements)
+    for prop in available_props:
+        if prop not in curated_properties:
+            non_null_count = df[prop].notna().sum()
+            if non_null_count > 80:  # High threshold for uncurated properties
+                display_name = prop.replace('_', ' ').title()
+                log_scale = requires_log_scale(prop, df)
+                valid_properties[display_name] = prop
+                property_info[prop] = {'label': display_name, 'min_data': 80, 'log_scale': log_scale}
+                
+                # Only add to dropdown if not continuous and correlative
+                if not is_continuous_correlative_property(prop, df):
+                    dropdown_properties[display_name] = prop
+    
+    return valid_properties, dropdown_properties, property_info
+
+# Get valid properties
+valid_properties, dropdown_properties, property_info = filter_relevant_properties(elements_data, available_properties)
+
+def get_portland_like_colorscale(use_log=False):
+    """Get Portland or Portland-like colorscale"""
+    # Portland is great - let's use variations of it
+    if use_log:
+        # For log scale, use a slightly adjusted Portland to handle the wider dynamic range
+        return 'Portland'
+    else:
+        return 'Portland'
+
+def should_use_log_scale(property_name, df):
+    """Determine if logarithmic scale should be used based on data distribution"""
+    if property_name not in df.columns:
+        return False
+    
+    # Check if explicitly configured
+    if property_name in property_info:
+        configured_log = property_info[property_name].get('log_scale', False)
+        if configured_log:
+            return True
+    
+    # Use improved heuristic
+    return requires_log_scale(property_name, df)
+
+# Standard periodic table positions
+ELEMENT_POSITIONS = {
+    # Period 1
+    1: (1, 1), 2: (18, 1),
+    # Period 2
+    3: (1, 2), 4: (2, 2), 5: (13, 2), 6: (14, 2), 7: (15, 2), 8: (16, 2), 9: (17, 2), 10: (18, 2),
+    # Period 3
+    11: (1, 3), 12: (2, 3), 13: (13, 3), 14: (14, 3), 15: (15, 3), 16: (16, 3), 17: (17, 3), 18: (18, 3),
+    # Period 4
+    19: (1, 4), 20: (2, 4), 21: (3, 4), 22: (4, 4), 23: (5, 4), 24: (6, 4), 25: (7, 4), 26: (8, 4),
+    27: (9, 4), 28: (10, 4), 29: (11, 4), 30: (12, 4), 31: (13, 4), 32: (14, 4), 33: (15, 4), 34: (16, 4), 35: (17, 4), 36: (18, 4),
+    # Period 5
+    37: (1, 5), 38: (2, 5), 39: (3, 5), 40: (4, 5), 41: (5, 5), 42: (6, 5), 43: (7, 5), 44: (8, 5),
+    45: (9, 5), 46: (10, 5), 47: (11, 5), 48: (12, 5), 49: (13, 5), 50: (14, 5), 51: (15, 5), 52: (16, 5), 53: (17, 5), 54: (18, 5),
+    # Period 6
+    55: (1, 6), 56: (2, 6), 
+    # Lanthanides (period 6 continued)
+    57: (4, 9), 58: (5, 9), 59: (6, 9), 60: (7, 9), 61: (8, 9), 62: (9, 9), 63: (10, 9), 64: (11, 9),
+    65: (12, 9), 66: (13, 9), 67: (14, 9), 68: (15, 9), 69: (16, 9), 70: (17, 9), 71: (18, 9),
+    # Period 6 continued
+    72: (4, 6), 73: (5, 6), 74: (6, 6), 75: (7, 6), 76: (8, 6), 77: (9, 6), 78: (10, 6), 79: (11, 6),
+    80: (12, 6), 81: (13, 6), 82: (14, 6), 83: (15, 6), 84: (16, 6), 85: (17, 6), 86: (18, 6),
+    # Period 7
+    87: (1, 7), 88: (2, 7),
+    # Actinides (period 7 continued)
+    89: (4, 10), 90: (5, 10), 91: (6, 10), 92: (7, 10), 93: (8, 10), 94: (9, 10), 95: (10, 10), 96: (11, 10),
+    97: (12, 10), 98: (13, 10), 99: (14, 10), 100: (15, 10), 101: (16, 10), 102: (17, 10), 103: (18, 10),
+    # Period 7 continued
+    104: (4, 7), 105: (5, 7), 106: (6, 7), 107: (7, 7), 108: (8, 7), 109: (9, 7), 110: (10, 7), 111: (11, 7),
+    112: (12, 7), 113: (13, 7), 114: (14, 7), 115: (15, 7), 116: (16, 7), 117: (17, 7), 118: (18, 7)
+}
+
+def get_electronic_configuration(element):
+    """Extract electronic configuration from element data"""
+    # Try different possible column names for electronic configuration
+    config_columns = ['electronic_configuration', 'electron_configuration', 'econf', 'ec']
+    
+    for col in config_columns:
+        if col in element.index and pd.notna(element.get(col)):
+            return str(element[col])
+    
+    # If no explicit electronic configuration column, try to construct it from other data
+    # This is a fallback - the mendeleev library should have this data
+    return None
+
+def create_hover_text(element, selected_property, original_value, display_value):
+    """Create detailed hover text for an element"""
+    
+    def format_value(value, unit="", is_integer=False):
+        if pd.isna(value):
+            return "N/A"
+        if isinstance(value, (int, float)):
+            if is_integer:
+                return f"{int(round(value))} {unit}".strip()
+            elif abs(value) >= 1000:
+                return f"{value:.2e} {unit}".strip()
+            elif abs(value) >= 10:
+                return f"{value:.2f} {unit}".strip()
+            else:
+                return f"{value:.3f} {unit}".strip()
+        return str(value)
+    
+    # Get property info
+    prop_config = property_info.get(selected_property, {})
+    prop_label = prop_config.get('label', selected_property.replace('_', ' ').title())
+    
+    # Determine if this is an integer property
+    is_int_prop = is_integer_property(selected_property, elements_data)
+    
+    # Determine units based on property name
+    if 'density' in selected_property.lower():
+        unit = "g/cm³"
+    elif 'electronegativity' in selected_property.lower():
+        unit = ""
+    elif 'radius' in selected_property.lower():
+        unit = "pm"
+    elif 'energy' in selected_property.lower() or 'ionization' in selected_property.lower():
+        unit = "eV"
+    elif 'affinity' in selected_property.lower():
+        unit = "eV"
+    elif 'point' in selected_property.lower() or 'temperature' in selected_property.lower():
+        unit = "K"
+    elif 'weight' in selected_property.lower() or 'mass' in selected_property.lower():
+        unit = "u"
+    elif 'volume' in selected_property.lower():
+        unit = "cm³/mol"
+    elif 'conductivity' in selected_property.lower():
+        unit = "W/mK"
+    else:
+        unit = ""
+    
+    current_str = format_value(original_value, unit, is_int_prop)
+    
+    # Build hover text with key properties
+    hover_lines = [
+        f"<b>{element.get('name', 'N/A')} ({element.get('symbol', 'N/A')})</b>",
+        f"<b>{prop_label}: {current_str}</b>",
+        "",  # Empty line for separation
+        f"Atomic Number: {element.get('atomic_number', 'N/A')}",
+    ]
+    
+    # Add electronic configuration if available
+    electronic_config = get_electronic_configuration(element)
+    if electronic_config:
+        hover_lines.append(f"Electronic Configuration: {electronic_config}")
+    
+    # Add key properties if available
+    key_properties = [
+        ('atomic_weight', 'Atomic Weight', 'u', False),
+        ('period', 'Period', '', True),
+        ('group_id', 'Group', '', True),
+        ('block', 'Block', '', False),
+        ('en_pauling', 'Electronegativity', '', False),
+        ('atomic_radius', 'Atomic Radius', 'pm', False),
+        ('ionenergy', 'Ionization Energy', 'eV', False),
+        ('melting_point', 'Melting Point', 'K', False),
+        ('boiling_point', 'Boiling Point', 'K', False),
+        ('density', 'Density', 'g/cm³', False),
+    ]
+    
+    for prop_name, display_name, prop_unit, is_int in key_properties:
+        if prop_name in element.index and pd.notna(element.get(prop_name)):
+            value_str = format_value(element[prop_name], prop_unit, is_int)
+            hover_lines.append(f"{display_name}: {value_str}")
+    
+    return "<br>".join(hover_lines)
+
+def create_periodic_table_figure(selected_property_label):
+    """Create the periodic table figure for the given property"""
+    
+    if not MENDELEEV_AVAILABLE or elements_data.empty:
+        fig = go.Figure()
+        fig.add_annotation(
+            text="Mendeleev library not available. Please install: pip install mendeleev",
+            showarrow=False,
+            font=dict(size=16)
+        )
+        return fig
+    
+    # Get the actual property name from the label
+    selected_property = valid_properties.get(selected_property_label)
+    if not selected_property:
+        fig = go.Figure()
+        fig.add_annotation(
+            text=f"Property '{selected_property_label}' not available",
+            showarrow=False,
+            font=dict(size=16)
+        )
+        return fig
+    
+    # Filter out elements without the selected property
+    property_data = elements_data[selected_property].dropna()
+    
+    if property_data.empty:
+        fig = go.Figure()
+        fig.add_annotation(
+            text=f"No data available for {selected_property_label}",
+            showarrow=False,
+            font=dict(size=16)
+        )
+        return fig
+    
+    # Determine if we should use log scale
+    use_log = should_use_log_scale(selected_property, elements_data)
+    
+    # Prepare data for visualization
+    if use_log:
+        # For log scale, we need positive values
+        positive_data = property_data[property_data > 0]
+        if positive_data.empty:
+            use_log = False
+            viz_data = property_data
+            min_value = property_data.min()
+            max_value = property_data.max()
+        else:
+            viz_data = np.log10(positive_data)
+            min_value = viz_data.min()
+            max_value = viz_data.max()
+    else:
+        viz_data = property_data
+        min_value = property_data.min()
+        max_value = property_data.max()
+    
+    # Initialize data lists
+    hover_texts = []
+    element_symbols = []
+    atomic_numbers = []
+    x_positions = []
+    y_positions = []
+    element_values = []
+    
+    # Process each element
+    for _, element in elements_data.iterrows():
+        atomic_num = element['atomic_number']
+        
+        # Skip elements without position data
+        if atomic_num not in ELEMENT_POSITIONS:
+            continue
+        
+        x_pos, y_pos = ELEMENT_POSITIONS[atomic_num]
+        x_positions.append(x_pos)
+        y_positions.append(11 - y_pos)  # Invert y-axis for correct table layout
+        element_symbols.append(element['symbol'])
+        atomic_numbers.append(atomic_num)
+        
+        # Get property value
+        original_value = element[selected_property]
+        
+        if pd.notna(original_value):
+            if use_log and original_value > 0:
+                display_value = np.log10(original_value)
+            else:
+                display_value = original_value
+        else:
+            display_value = np.nan
+        
+        element_values.append(display_value)
+        
+        # Create comprehensive hover text
+        hover_text = create_hover_text(element, selected_property, original_value, display_value)
+        hover_texts.append(hover_text)
+    
+    # Create the figure
+    fig = go.Figure()
+    
+    # Add scatter plot
+    fig.add_trace(go.Scatter(
+        x=x_positions,
+        y=y_positions,
+        mode='markers+text',
+        text=element_symbols,
+        hoverinfo='text',
+        hovertext=hover_texts,
+        textfont=dict(
+            family="Arial, sans-serif",
+            size=14,
+            color="white",
+            weight="bold",
+        ),
+        hoverlabel=dict(
+            bgcolor="rgba(255,255,255,0.95)",
+            font_size=12,
+            font_family="Arial, sans-serif",
+            bordercolor="black"
+        ),
+        marker=dict(
+            symbol='square',
+            color=element_values,
+            size=45,
+            colorscale=get_portland_like_colorscale(use_log),
+            cmin=min_value,
+            cmax=max_value,
+            colorbar=dict(
+                title=f"{selected_property_label}{'<br>(log scale)' if use_log else ''}",
+                thickness=20,
+                x=1.02
+            ),
+            showscale=True,
+            line=dict(color='black', width=1)
+        )
+    ))
+    
+    # Add atomic number annotations
+    for i in range(len(x_positions)):
+        fig.add_annotation(
+            x=x_positions[i],
+            y=y_positions[i] + 0.3,
+            text=str(atomic_numbers[i]),
+            showarrow=False,
+            font=dict(
+                family="Arial, sans-serif",
+                size=8,
+                color="white",
+                weight="bold",
+            )
+        )
+    
+    # Add lanthanide and actinide labels
+    fig.add_annotation(x=3, y=2, text="Lanthanides", showarrow=False, 
+                      font=dict(size=10, weight="bold"))
+    fig.add_annotation(x=3, y=1, text="Actinides", showarrow=False, 
+                      font=dict(size=10, weight="bold"))
+    
+    # Update layout
+    title_text = f'<b>Periodic Table by {selected_property_label}</b>'
+    if use_log:
+        title_text += '<br><span style="font-size:14px;">(Logarithmic Color Scale)</span>'
+    
+    fig.update_layout(
+        title=dict(
+            text=title_text,
+            x=0.5,
+            font=dict(size=24)
+        ),
+        xaxis=dict(
+            range=[0, 19],
+            showgrid=False,
+            zeroline=False,
+            showticklabels=False,
+            visible=False
+        ),
+        yaxis=dict(
+            range=[0, 12],
+            showgrid=False,
+            zeroline=False,
+            showticklabels=False,
+            visible=False
+        ),
+        plot_bgcolor='white',
+        paper_bgcolor='#f8f9fa',
+        width=1200,
+        height=800,
+        margin=dict(l=20, r=100, t=100, b=20)
+    )
+    
+    return fig
+
+# Create Gradio interface
+def create_gradio_app():
+    """Create the Gradio interface"""
+    
+    if not MENDELEEV_AVAILABLE or not dropdown_properties:
+        def error_interface():
+            return "❌ Mendeleev library not available or no valid properties found. Please install: pip install mendeleev"
+        
+        return gr.Interface(
+            fn=error_interface,
+            inputs=[],
+            outputs=gr.Textbox(label="Error"),
+            title="Periodic Table Dashboard - Error"
+        )
+    
+    # Get property options for dropdown (excluding continuous correlative properties)
+    property_options = list(dropdown_properties.keys())
+    
+    # Set default to element series if available, otherwise first property
+    default_property = None
+    for label, prop_name in dropdown_properties.items():
+        if property_info.get(prop_name, {}).get('is_default', False):
+            default_property = label
+            break
+    
+    if not default_property and property_options:
+        default_property = property_options[0]
+    
+    with gr.Blocks(title="Interactive Periodic Table", theme=gr.themes.Soft()) as app:
+        gr.Markdown("# 🧪 Interactive Periodic Table")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                property_dropdown = gr.Dropdown(
+                    choices=property_options,
+                    value=default_property,
+                    label="Select Property to Colourize",
+                )
+        with gr.Row():
+            plot_output = gr.Plot(show_label=False)
+        with gr.Row():
+            gr.Markdown(f""" 
+                **🔬 Data Source:** [Mendeleev Library](https://mendeleev.readthedocs.io/)
+                """)
+        
+        # Update plot when dropdown changes
+        property_dropdown.change(
+            fn=create_periodic_table_figure,
+            inputs=[property_dropdown],
+            outputs=[plot_output]
+        )
+        
+        # Initialize with first property
+        app.load(
+            fn=create_periodic_table_figure,
+            inputs=[property_dropdown],
+            outputs=[plot_output]
+        )
+    
+    return app
+
+# Create and run the app
+if __name__ == "__main__":
+    print(f"🚀 Starting Gradio app with {len(dropdown_properties)} properties (excluding continuous correlative)")
+    if dropdown_properties:
+        print("📋 Available dropdown properties:")
+        for label, prop_name in dropdown_properties.items():
+            log_note = " (log scale)" if should_use_log_scale(prop_name, elements_data) else ""
+            int_note = " (integer)" if is_integer_property(prop_name, elements_data) else ""
+            default_note = " (DEFAULT)" if property_info.get(prop_name, {}).get('is_default', False) else ""
+            data_count = elements_data[prop_name].notna().sum()
+            print(f"  • {label}: {data_count} elements{log_note}{int_note}{default_note}")
+    
+    print(f"\n📋 Total valid properties (including continuous correlative): {len(valid_properties)}")
+    
+    app = create_gradio_app()
+    app.launch()

requirements.txt

@@ -0,0 +1,5 @@
+plotly
+gradio
+pandas
+numpy
+lxml