Update streamlit_app.py

streamlit_app.py

@@ -15,6 +15,7 @@ import tempfile
 import shutil
 import time
 from datetime import datetime, timezone
+import yaml
 
 # Set page config
 st.set_page_config(
@@ -68,8 +69,63 @@ class AttentionResultsExplorer:
         self.available_languages = self._get_available_languages_from_github()
         self.relation_types = None
     
+    def _download_experiment_config(self):
+        """Download and parse the experiment_config.yaml file from GitHub"""
+        config_path = self.cache_dir / "experiment_config.yaml"
+        
+        # Check if we have a cached version and use_cache is enabled
+        if config_path.exists() and self.use_cache:
+            try:
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    return yaml.safe_load(f)
+            except Exception as e:
+                st.warning(f"Could not load cached config, downloading fresh: {str(e)}")
+        
+        # Download from GitHub
+        config_url = f"https://raw.githubusercontent.com/{self.github_repo}/refs/heads/master/experiment_config.yaml"
+        response = self._make_github_request(config_url, "experiment configuration file")
+        
+        if response is None:
+            # Try to load from cache as fallback
+            if config_path.exists():
+                try:
+                    with open(config_path, 'r', encoding='utf-8') as f:
+                        return yaml.safe_load(f)
+                except Exception:
+                    pass
+            return None
+        
+        try:
+            config_content = response.text
+            # Save to cache
+            with open(config_path, 'w', encoding='utf-8') as f:
+                f.write(config_content)
+            
+            # Parse and return
+            return yaml.safe_load(StringIO(config_content))
+            
+        except Exception as e:
+            st.error(f"Could not parse experiment configuration: {str(e)}")
+            return None
+
     def _get_available_languages_from_github(self):
-        """Get available languages from GitHub API without downloading"""
+        """Get available languages from experiment config file"""
+        config = self._download_experiment_config()
+        
+        if config is None:
+            # Fallback to directory-based discovery
+            return self._get_available_languages_from_directories()
+        
+        try:
+            languages = list(config.get('languages', {}).keys())
+            return sorted(languages)
+        except Exception as e:
+            st.warning(f"Could not parse languages from config: {str(e)}")
+            # Fallback to directory-based discovery
+            return self._get_available_languages_from_directories()
+    
+    def _get_available_languages_from_directories(self):
+        """Fallback method: Get available languages from GitHub API directory listing"""
         api_url = f"https://api.github.com/repos/{self.github_repo}/contents"
         
         response = self._make_github_request(api_url, "available languages")
@@ -89,6 +145,56 @@ class AttentionResultsExplorer:
             st.warning(f"Could not parse language list from GitHub: {str(e)}")
             # Fallback to local cache if available
             return self._get_available_languages_local()
+
+    def _get_models_for_language(self, language):
+        """Get all models for a specific language from the experiment config"""
+        config = self._download_experiment_config()
+        
+        if config is None:
+            return []
+        
+        try:
+            # Get language-specific models
+            language_models = config.get('languages', {}).get(language, {}).get('models', [])
+            
+            # Get multilingual models
+            multilingual_models = config.get('multilingual_models', [])
+            
+            # Combine both lists
+            all_models = language_models + multilingual_models
+            return sorted(list(set(all_models)))  # Remove duplicates and sort
+            
+        except Exception as e:
+            st.warning(f"Could not get models for {language}: {str(e)}")
+            return []
+
+    def _get_first_language_model_pair(self):
+        """Get the first language-model pair from the experiment config for configuration discovery"""
+        config = self._download_experiment_config()
+        
+        if config is None:
+            return None, None
+            
+        try:
+            languages = config.get('languages', {})
+            multilingual_models = config.get('multilingual_models', [])
+            
+            # Find first language with models
+            for language, lang_config in languages.items():
+                models = lang_config.get('models', [])
+                if models:
+                    return language, models[0]
+            
+            # If no language-specific models, use first language with first multilingual model
+            if multilingual_models and languages:
+                first_language = list(languages.keys())[0]
+                return first_language, multilingual_models[0]
+            
+            return None, None
+            
+        except Exception as e:
+            st.warning(f"Could not find language-model pair: {str(e)}")
+            return None, None
     
     def _get_available_languages_local(self):
         """Get available languages from local cache"""
@@ -176,15 +282,25 @@ class AttentionResultsExplorer:
     def _discover_config_parameters(self, language=None):
         """Dynamically discover configuration parameters from available configs
         
-        For performance optimization, we only inspect the first language since
-        configurations are consistent across all languages and models.
+        Now uses the first language-model pair from experiment config to discover
+        valid configuration parameters, since configurations are consistent across
+        all language-model combinations.
         """
         try:
-            # Use first available language if none specified (optimization)
+            # Get the first language-model pair from experiment config
             if language is None:
-                if not self.available_languages:
+                language, model = self._get_first_language_model_pair()
+                if language is None or model is None:
+                    st.warning("Could not find any language-model pairs in experiment config")
                     return {}
-                language = self.available_languages[0]
+                st.info(f"🔍 Discovering configurations using {language.upper()}/{model} (configurations are consistent across all languages and models)")
+            else:
+                # If language is specified, try to get first model for that language
+                models = self._get_models_for_language(language)
+                if not models:
+                    st.warning(f"No models found for language {language}")
+                    return {}
+                model = models[0]
             
             available_configs = self._get_experimental_configs(language)
             if not available_configs:
@@ -361,7 +477,14 @@ class AttentionResultsExplorer:
         return self._find_best_matching_config(language, target_params)
     
     def _get_models(self, language, config):
-        """Get all models for a language and configuration from GitHub API"""
+        """Get all models for a language and configuration from experiment config"""
+        # First try to get models from experiment config
+        models = self._get_models_for_language(language)
+        
+        if models:
+            return models
+        
+        # Fallback to GitHub API directory listing if config unavailable
         api_url = f"https://api.github.com/repos/{self.github_repo}/contents/results_{language}/{config}"
         response = self._make_github_request(api_url, f"models for {language}/{config}")
         
@@ -373,7 +496,7 @@ class AttentionResultsExplorer:
             except Exception as e:
                 st.warning(f"Could not parse models for {language}/{config}: {str(e)}")
         
-        # Fallback to local cache if available
+        # Final fallback to local cache if available
         config_dir = self.base_path / f"results_{language}" / config
         if config_dir.exists():
             models = [d.name for d in config_dir.iterdir() if d.is_dir()]