feat: Update scripts with new metadata injection setup

Author: schnaitter

.github/workflows/update-metadata.yml

@@ -109,3 +109,116 @@ jobs:
           else
             echo "No metadata changes detected"
           fi
+name: Update Metadata
+
+on:
+  push:
+  workflow_dispatch:
+
+# Prevent infinite loops when workflow commits changes
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  update-metadata:
+    runs-on: ubuntu-latest
+    # Need write permission to push changes
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+
+      - name: Extract version from tag (if triggered by tag)
+        id: extract_version
+        run: |
+          if [[ "$GITHUB_REF" == refs/tags/v* ]]; then
+            TAG_NAME=${GITHUB_REF#refs/tags/}
+            # Remove 'v' prefix if present (v1.0.0 -> 1.0.0)
+            VERSION=${TAG_NAME#v}
+            echo "version=$VERSION" >> $GITHUB_OUTPUT
+            echo "tag_name=$TAG_NAME" >> $GITHUB_OUTPUT
+            echo "is_tag=true" >> $GITHUB_OUTPUT
+            echo "Triggered by version tag: $TAG_NAME (version: $VERSION)"
+          else
+            echo "is_tag=false" >> $GITHUB_OUTPUT
+            echo "Triggered by regular push to: $GITHUB_REF"
+          fi
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: '.python-version'
+          cache: pip
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pyyaml rdflib
+
+      - name: Update version metadata (if triggered by tag)
+        if: steps.extract_version.outputs.is_tag == 'true'
+        env:
+          TAG_VERSION: ${{ steps.extract_version.outputs.version }}
+        run: |
+          python -m quadriga.metadata.update_version_from_tag
+
+      - name: Update metadata files
+        env:
+          PYTHONHASHSEED: 0
+        run: python -m quadriga.metadata.run_all
+
+      - name: Check if files changed
+        id: check_changes
+        run: |
+          if git diff --quiet metadata.yml && git diff --quiet CITATION.bib && git diff --quiet CITATION.cff && git diff --quiet .zenodo.json && git diff --quiet metadata.jsonld && git diff --quiet metadata.rdf; then
+            echo "changes_detected=false" >> $GITHUB_OUTPUT
+          else
+            echo "changes_detected=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Commit changes (regular push)
+        if: steps.check_changes.outputs.changes_detected == 'true' && steps.extract_version.outputs.is_tag == 'false'
+        run: |
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git add metadata.yml CITATION.bib CITATION.cff .zenodo.json metadata.jsonld metadata.rdf
+          git commit -m "[Automated] Update metadata files"
+          git push
+
+      - name: Commit changes and move tag (tag-triggered)
+        if: steps.check_changes.outputs.changes_detected == 'true' && steps.extract_version.outputs.is_tag == 'true'
+        run: |
+          # Configure git
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+
+          # Commit the metadata changes
+          git add metadata.yml CITATION.bib CITATION.cff .zenodo.json metadata.jsonld metadata.rdf
+          git commit -m "[Automated] Update metadata for version ${{ steps.extract_version.outputs.version }}"
+
+          # Delete the old tag (locally and remotely)
+          git tag -d ${{ steps.extract_version.outputs.tag_name }}
+          git push origin :refs/tags/${{ steps.extract_version.outputs.tag_name }}
+
+          # Create new tag at the current commit (with updated metadata)
+          git tag ${{ steps.extract_version.outputs.tag_name }}
+
+          # Push the changes and the new tag
+          git push origin HEAD:main
+          git push origin ${{ steps.extract_version.outputs.tag_name }}
+
+          echo "Tag ${{ steps.extract_version.outputs.tag_name }} moved to commit with updated metadata"
+
+      - name: No changes needed
+        if: steps.check_changes.outputs.changes_detected == 'false'
+        run: |
+          if [[ "${{ steps.extract_version.outputs.is_tag }}" == "true" ]]; then
+            echo "Metadata already matches the tag version - no changes needed"
+          else
+            echo "No metadata changes detected"
+          fi

dev-requirements.txt

@@ -1 +1,5 @@
-pyyaml
+pyyaml
+mypy
+ruff
+types-PyYAML
+rdflib

quadriga/metadata/__init__.py

@@ -7,15 +7,17 @@
 
 __all__ = [
     "create_bibtex",
-    "update_citation_cff",
     "extract_from_book_config",
+    "update_citation_cff",
     "update_version_from_tag",
     "utils",
 ]
 
 # Import the modules to make their functions available
-from . import create_bibtex
-from . import update_citation_cff
-from . import extract_from_book_config
-from . import update_version_from_tag
-from . import utils
+from . import (
+    create_bibtex,
+    extract_from_book_config,
+    update_citation_cff,
+    update_version_from_tag,
+    utils,
+)

quadriga/metadata/create_bibtex.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
+
 import logging
 import sys
-from pathlib import Path
 
 from .utils import (
     extract_keywords,
@@ -11,6 +12,7 @@
 )
 
 logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+logger = logging.getLogger(__name__)
 
 # Map CFF types to BibTeX entry types
 CFF_TO_BIBTEX_TYPES = {
@@ -70,14 +72,15 @@
 }
 
 
-def create_bibtex_from_cff():
+def create_bibtex_from_cff() -> bool | None:
     """
-    Creates a CITATION.bib file from CITATION.cff.
+    Create a CITATION.bib file from CITATION.cff.
 
-    It reads citation data, prioritizing the 'preferred-citation' block if available,
+    Reads citation data, prioritizing the 'preferred-citation' block if available,
     formats authors, generates a citation key, and constructs a BibTeX entry.
 
-    Returns:
+    Returns
+    -------
         bool: True if successful, False otherwise.
     """
     try:
@@ -86,28 +89,31 @@ def create_bibtex_from_cff():
             repo_root = get_file_path("")  # Get repo root
             citation_cff_path = get_file_path("CITATION.cff", repo_root)
             citation_bib_path = get_file_path("CITATION.bib", repo_root)
-        except Exception as e:
-            logging.error(f"Failed to resolve file paths: {str(e)}")
+        except Exception:
+            logger.exception("Failed to resolve file paths")
             return False
 
         # Check if citation_cff_path exists
-        if not Path(citation_cff_path).exists():
-            logging.error(f"CITATION.cff file not found at {citation_cff_path}")
+        if not citation_cff_path.exists():
+            logger.error("CITATION.cff file not found at %s", citation_cff_path)
             return False
 
         # Read CITATION.cff using utility function
         citation_data = load_yaml_file(citation_cff_path)
 
-        if not citation_data:
-            logging.error(f"Could not load {citation_cff_path}. Exiting.")
+        if not citation_data or not isinstance(citation_data, dict):
+            logger.error("Could not load CITATION.cff or invalid format. Exiting.")
             return False
 
         # Extract data from preferred-citation or root
         if "preferred-citation" in citation_data:
-            logging.info("Using 'preferred-citation' section from CITATION.cff")
+            logger.info("Using 'preferred-citation' section from CITATION.cff")
             pref = citation_data.get("preferred-citation")
+            if not isinstance(pref, dict):
+                logger.error("preferred-citation is not a dictionary")
+                return False
         else:
-            logging.info("No 'preferred-citation' section found, using root data")
+            logger.info("No 'preferred-citation' section found, using root data")
             pref = citation_data
 
         # Validate required fields
@@ -116,19 +122,19 @@ def create_bibtex_from_cff():
         year = str(pref.get("year", ""))  # Ensure year is a string for generate_citation_key
 
         if not authors:
-            logging.warning("No authors found in CITATION.cff")
+            logger.warning("No authors found in CITATION.cff")
 
         if title == "Untitled":
-            logging.warning("No title found in CITATION.cff, using 'Untitled'")
+            logger.warning("No title found in CITATION.cff, using 'Untitled'")
 
         if not year:
-            logging.warning("No year found in CITATION.cff")
+            logger.warning("No year found in CITATION.cff")
 
         # Use utility function to format authors
         try:
             author_str = format_authors_for_bibtex(authors)
-        except Exception as e:
-            logging.error(f"Error formatting authors: {str(e)}")
+        except Exception:
+            logger.exception("Error formatting authors")
             author_str = ""
 
         # Choose entry type based on type field
@@ -141,19 +147,19 @@ def create_bibtex_from_cff():
         if entry_type == "thesis":
             # Check for thesis type information
             thesis_type = pref.get("thesis-type", "").lower()
-            if thesis_type == "master" or thesis_type == "masters" or thesis_type == "master's":
+            if thesis_type in {"master", "masters", "master's"}:
                 entry_type = "mastersthesis"
             else:
                 # Default to phdthesis if type is not specified or is something else
                 entry_type = "phdthesis"
 
-        logging.info(f"Converting CFF type '{cff_type}' to BibTeX entry type: {entry_type}")
+        logger.info("Converting CFF type '%s' to BibTeX entry type: %s", cff_type, entry_type)
 
         # Use utility function to generate citation key
         try:
             citation_key = generate_citation_key(authors, title, year)
-        except Exception as e:
-            logging.error(f"Error generating citation key: {str(e)}")
+        except Exception:
+            logger.exception("Error generating citation key")
             citation_key = "Unknown_Citation_Key"
 
         # Compile BibTeX entry
@@ -254,8 +260,8 @@ def create_bibtex_from_cff():
                 try:
                     editor_str = format_authors_for_bibtex(pref["collection-editors"])
                     bibtex_lines.append(f"  editor    = {{{editor_str}}},")
-                except Exception as e:
-                    logging.warning(f"Error formatting collection editors: {str(e)}")
+                except (KeyError, TypeError, AttributeError) as e:
+                    logger.warning("Error formatting collection editors: %s", e)
 
         # Special handling for software, code, data entries
         if cff_type.lower().startswith("software") or cff_type.lower() in [
@@ -299,39 +305,40 @@ def create_bibtex_from_cff():
                 bibtex_lines.append(f"  {field:<9} = {{{field_value}}},")
 
         # Handle list fields like languages
-        if "languages" in pref and pref["languages"]:
+        if pref.get("languages"):
             try:
                 languages_str = ", ".join(pref["languages"])
                 bibtex_lines.append(f"  language  = {{{languages_str}}},")
-            except Exception as e:
-                logging.warning(f"Error processing languages field: {str(e)}")
+            except (TypeError, AttributeError) as e:
+                logger.warning("Error processing languages field: %s", e)
 
         # Handle keywords field
-        if "keywords" in pref and pref["keywords"]:
+        if pref.get("keywords"):
             try:
                 keywords_list = extract_keywords(pref["keywords"])
                 if keywords_list:
                     keywords_str = ", ".join(keywords_list)
                     bibtex_lines.append(f"  keywords  = {{{keywords_str}}},")
-            except Exception as e:
-                logging.warning(f"Error processing keywords field: {str(e)}")
+            except (TypeError, AttributeError) as e:
+                logger.warning("Error processing keywords field: %s", e)
 
         # Close the entry
         bibtex_lines.append("}")
         bibtex = "\n".join(bibtex_lines)
 
         # Write to CITATION.bib
         try:
-            with open(citation_bib_path, "w", encoding="utf-8") as f:
+            with citation_bib_path.open("w", encoding="utf-8") as f:
                 f.write(bibtex)
-            logging.info(f"BibTeX citation successfully created at {citation_bib_path}")
-            return True
-        except IOError as e:
-            logging.error(f"Error writing to {citation_bib_path}: {e}")
+        except OSError:
+            logger.exception("Error writing to {citation_bib_path}")
             return False
+        else:
+            logger.info("BibTeX citation successfully created at %s", citation_bib_path)
+            return True
 
-    except Exception as e:
-        logging.exception(f"Unexpected error in create_bibtex_from_cff: {str(e)}")
+    except Exception:
+        logger.exception("Unexpected error in create_bibtex_from_cff")
         return False