fix: unbound variable due to link missing (#210)

* fix: handle validation errors gracefully and filter empty links

- Fix UnboundLocalError in sort_yaml.py by validating conferences
  individually instead of via list comprehension
- Skip invalid conferences instead of failing the entire process
- Filter out ICS calendar entries without valid links at import time

* feat: fill missing links from historical conference data

When an ICS calendar entry has no link, look up the conference name
in existing YAML data and use the historical link with the year
replaced. This allows conferences without descriptions to still
have valid links if we've seen them before.

* style: fix ruff SIM102 and PERF203 warnings

- Combine nested if statements in fill_links_from_history (SIM102)
- Extract validate_conference helper to avoid try-except in loop (PERF203)

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

utils/import_python_official.py

@@ -37,6 +37,66 @@
 logger = get_tqdm_logger(__name__)
 
 
+def fill_links_from_history(df_ics: pd.DataFrame, df_yml: pd.DataFrame) -> pd.DataFrame:
+    """Fill missing links in ICS data from historical conference data.
+
+    For conferences without links, look up the conference name in historical data
+    and use that link, replacing any year references with the current year.
+
+    Parameters
+    ----------
+    df_ics : pd.DataFrame
+        DataFrame with ICS conference data (may have empty links)
+    df_yml : pd.DataFrame
+        DataFrame with existing conference data from YAML files
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with missing links filled where historical data exists
+    """
+    if df_yml.empty:
+        return df_ics
+
+    # Create a lookup of conference names to their most recent links
+    # Group by normalized conference name and get the most recent entry
+    historical_links = {}
+    for _, row in df_yml.iterrows():
+        conf_name = row.get("conference", "")
+        link = row.get("link", "")
+        year = row.get("year", 0)
+
+        # Keep the most recent link for each conference
+        if conf_name and link and (conf_name not in historical_links or year > historical_links[conf_name][1]):
+            historical_links[conf_name] = (link, year)
+
+    filled_count = 0
+    for idx, row in df_ics.iterrows():
+        link = row.get("link", "")
+        if not link or len(str(link).strip()) == 0:
+            conf_name = row.get("conference", "")
+            target_year = row.get("year", datetime.now(tz=timezone.utc).year)
+
+            if conf_name in historical_links:
+                hist_link, hist_year = historical_links[conf_name]
+                # Replace the historical year with the target year in the link
+                new_link = re.sub(
+                    rf"\b{hist_year}\b",
+                    str(target_year),
+                    str(hist_link),
+                )
+                df_ics.at[idx, "link"] = new_link
+                filled_count += 1
+                logger.debug(
+                    f"Filled link for '{conf_name}' from historical data: {new_link}",
+                )
+
+    if filled_count > 0:
+        logger.info(f"Filled {filled_count} missing links from historical conference data")
+
+    return df_ics
+
+
 def ics_to_dataframe() -> pd.DataFrame:
     """Parse an .ics file and return a DataFrame with the event data.
 
@@ -241,6 +301,21 @@ def main(year=None, base="") -> bool:
             logger.warning("No conference data retrieved from calendar")
             return False
 
+        # Try to fill missing links from historical conference data
+        logger.info("Filling missing links from historical data")
+        df_ics = fill_links_from_history(df_ics, df_yml)
+
+        # Filter out entries with empty or missing links
+        initial_count = len(df_ics)
+        df_ics = df_ics[df_ics["link"].str.len() > 0]
+        filtered_count = initial_count - len(df_ics)
+        if filtered_count > 0:
+            logger.info(f"Filtered out {filtered_count} entries without valid links")
+
+        if df_ics.empty:
+            logger.warning("No conferences with valid links after filtering")
+            return False
+
     except Exception as e:
         logger.error(f"Failed to initialize import process: {e}")
         return False

utils/sort_yaml.py

@@ -301,15 +301,19 @@ def sort_data(base="", prefix="", skip_links=False):
     for i, q in enumerate(data.copy()):
         data[i] = order_keywords(q)
 
+    def validate_conference(q: dict) -> Conference | None:
+        """Validate a single conference entry, returning None if invalid."""
+        try:
+            return Conference(**q)
+        except pydantic.ValidationError as e:
+            logger.error(f"❌ Validation error in conference: {e}")
+            logger.debug(f"Invalid data: \n{yaml.dump(q, default_flow_style=False)}")
+            return None
+
     logger.info("✅ Validating conference data with Pydantic schema")
-    validation_errors = 0
-
-    try:
-        new_data = [Conference(**q) for q in data]
-    except pydantic.ValidationError as e:
-        validation_errors += 1
-        logger.error(f"❌ Validation error in conference: {e}")
-        logger.debug(f"Invalid data: \n{yaml.dump(q, default_flow_style=False)}")
+    validated = [validate_conference(q) for q in data]
+    new_data = [c for c in validated if c is not None]
+    validation_errors = len(validated) - len(new_data)
 
     if validation_errors > 0:
         logger.warning(f"⚠️  {validation_errors} conferences failed validation and were skipped")