Initial commit

tools/00_fetch_ud_clarin-dspace_metadata.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env -S uv run --script
+#
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+# ]
+# ///
+"""
+Download UD metadata for the different releases from the lindat clarin-dspace
+repository into `./templates/`:
+- BibTeX "Howto Cite"
+  (use the item's own data from the webpage)
+- dc.description
+  (use the clarin-dspace API to retrieve the item's metadata)
+
+We assume a clarin-dspace infrastructure with:
+- ".../repository/server/api/core/refbox/citations?type=bibtex&handle="
+  returning a bibtex entry for the given hdl
+- ".../repository/server/api/core/items/" as the API endpoint (core/items)
+"""
+
+import json
+import re
+import argparse
+import logging
+from pathlib import Path
+from urllib.error import URLError
+from urllib.request import urlopen
+from urllib.parse import urlparse
+
+# URL prefix
+citation_url_prefix = "https://lindat.mff.cuni.cz/repository/server/api/core/refbox/citations?type=bibtex&handle="
+description_url_prefix = "https://lindat.mff.cuni.cz/repository/server/api/core/items/"
+handle_url_prefix = "http://hdl.handle.net/"
+handle_redirect_url_prefix = "https://lindat.mff.cuni.cz/repository/items/"
+
+# OUTPUTFILE(s) directories
+outfile_pathprefix = "./etc/"
+citation_outfile_name = "citation-{rev}"
+description_outfile_name = "description-{rev}"
+
+# List of URL postfixes
+url_postfixes = {
+    # https://github.com/UniversalDependencies/docs/blob/bce7995aaa339c995c4e74a5568888fffec3d5a7/download.md?plain=1#L9
+    #
+    # "2.17": "",  #
+    "2.16": "11234/1-5901",  # 319 treebanks, 179 languages, released May 15, 2025.
+    "2.15": "11234/1-5787",  # 296 treebanks, 168 languages, released November 15, 2024.
+    "2.14": "11234/1-5502",  # 283 treebanks, 161 languages, released May 15, 2024.
+    "2.13": "11234/1-5287",  # 259 treebanks, 148 languages, released November 15, 2023.
+    "2.12": "11234/1-5150",  # 245 treebanks, 141 languages, released May 15, 2023.
+    "2.11": "11234/1-4923",  # 243 treebanks, 138 languages, released November 15, 2022.
+    "2.10": "11234/1-4758",  # 228 treebanks, 130 languages, released May 15, 2022.
+    "2.9":  "11234/1-4611",  # 217 treebanks, 122 languages, released November 15, 2021.
+    "2.8":  "11234/1-3687",  # 202 treebanks, 114 languages, released May 15, 2021.
+    "2.7":  "11234/1-3424",  # 183 treebanks, 104 languages, released November 15, 2020.
+}
+
+# Parse command line arguments
+parser = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+parser.add_argument('-o', '--override', action='store_true',
+                    help='override output file if it already exists')
+parser.add_argument('-v', '--verbose', action='count', default=0,
+                    help='increase verbosity level')
+args = parser.parse_args()
+
+# Set up logging
+logging.basicConfig(
+    level = max(logging.DEBUG, logging.INFO - args.verbose * 10),
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+
+# Iterate over the URL postfixes
+for rev,handle in url_postfixes.items():
+
+    try:
+        # Construct the full URL
+        citation_url = citation_url_prefix + handle
+        logging.debug(f"Using Citation URL: {citation_url}")
+
+        # Send a GET request to the URL
+        with urlopen(citation_url) as response:
+
+            # Read the JSON content
+            data = json.loads(response.read().decode())
+
+            # Extract the metadata field
+            metadata = data.get("metadata")
+
+            # Write the metadata to the output file
+            if metadata:
+                # Replace uneven space(s) at the beginning of lines with fixed
+                # number of spaces
+                metadata = "\n".join([re.sub('^( )+', '   ', line) for line in
+                            metadata.split("\n")])
+
+                # Open the output file in write mode
+                output_fn = f"{outfile_pathprefix}"+citation_outfile_name.format(rev=rev)
+                if args.override or not Path(output_fn).exists():
+                    with open(output_fn, "w") as fh:
+                        fh.write(metadata + "\n")
+                        logging.info(f"Successfully downloaded citation from {citation_url} and written to {output_fn}.")
+                else:
+                    logging.info(f"Output {output_fn} already exists: Not overriding.")
+
+
+        # Construct the full URL
+        handle_url = handle_url_prefix + handle
+        logging.debug(f"Using handle URL: {handle_url}")
+        # Send a GET request to the URL
+        with urlopen(handle_url) as response:
+            if response.url.startswith(handle_redirect_url_prefix):
+                itemid = (urlparse(response.url)).path.rsplit("/", 1)[-1]
+
+                description_url = description_url_prefix + itemid
+                with urlopen(description_url) as response:
+                    data = json.loads(response.read().decode())
+                    description = data["metadata"]["dc.description"][0]["value"]
+                    if description:
+
+                        # Open the output file in write mode
+                        output_fn = f"{outfile_pathprefix}"+description_outfile_name.format(rev=rev)
+                        if args.override or not Path(output_fn).exists():
+                            with open(output_fn, "w") as fh:
+                                fh.write(description+ "\n")
+                                logging.info(f"Successfully downloaded description from {description_url} and written to {output_fn}.")
+                        else:
+                            logging.info(f"Output {output_fn} already exists: Not overriding.")
+
+    except URLError as e:
+        logging.error(f"Error downloading: {e}")
+    except json.JSONDecodeError as e:
+        logging.error(f"Error decoding JSON: {e}")

tools/00_fetch_ud_codes_and_flags.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+#
+
+# This is a manual mapping of versions of codes_and_flags.yaml from:
+# * https://github.com/UniversalDependencies/docs-automation/commits/master/codes_and_flags.yaml
+# (identified by commit hash) matched to the closest date of UD versions from:
+# * https://github.com/UniversalDependencies/docs
+declare -A VER_MAPPING
+VER_MAPPING["2.7"]="a5124b817c04ee6c8b01b80b2adad518b06aa9b4"
+VER_MAPPING["2.8"]="26d595cd549e904a4d49b62fccb33602c9d18eb8"
+VER_MAPPING["2.9"]="6167b04d6dc5d953f4007dcd75b5fbbf8c7645d6"
+VER_MAPPING["2.10"]="953b1c6e70836b7a64b764e24f578ca787cfd89c"
+VER_MAPPING["2.11"]="25ee28cd173c2fee5e3a7ad493a4c6e137e13f6b"
+VER_MAPPING["2.12"]="32a51d28787795eea1c2e11b3572087a3dc228ac"
+VER_MAPPING["2.13"]="6712e116f6fda486223e183f56ffb8921695d4a6"
+VER_MAPPING["2.14"]="dabe6c89701b6127b867e27c0256eb4f9dfa9d46"
+VER_MAPPING["2.15"]="b3b3d95333d603db6aede3601a3cf9929b3470ae"
+VER_MAPPING["2.16"]="bc0cc9b94112253e3ea1e00b2dbe3a46c5f53fe3"
+VER_MAPPING["latest"]="a47b209d5d42c31351cc393a86512fd913ac2bba"
+
+###################
+#############
+#
+# USAGE
+#
+usage() { OUTPUT=${1:-"verbose"}
+echo "Usage: $0 [-o]" >&2
+[ $OUTPUT = "short" ] && exit 0
+>&2 cat << EOF
+
+Download versions of
+* codes_and_flags.yaml
+a yaml file mapping UD (long) language names to metadata.
+
+For example:
+German:
+  flag: DE
+  lcode: de
+  iso3: deu
+  family: IE
+  genus: Germanic
+
+Options:
+    -h              Print this help message
+    -o|--online     Enable online mode: (re-fetch files from GitHub)
+EOF
+}
+#
+######
+############
+##################
+
+ONLINE_MODE=false
+
+VALID_ARGS=$(getopt -o ho --long help,online -- "$@")
+if [[ $? -ne 0 ]]; then
+  usage "short"
+  exit 1;
+fi
+eval set -- "$VALID_ARGS"
+while [ : ]
+do
+  case "$1" in
+    -o | --online) ONLINE_MODE=true; shift   ;;
+    -h | --help)   usage;            shift   ; exit 0;;
+    --)                              shift   ; break ;;
+    *) >&2 echo Unsupported option: $1; usage; exit 1;;
+  esac
+done
+
+set -uo pipefail
+for key in ${!VER_MAPPING[@]}
+do
+    VER="${key}"
+    GIT_HASH="${VER_MAPPING[${key}]}"
+
+    CODES_AND_FLAGS_FN="etc/codes_and_flags-${VER}.yaml"
+    CODES_AND_FLAGS_URL="https://github.com/UniversalDependencies/docs-automation/blob/${GIT_HASH}/codes_and_flags.yaml"
+    CODES_AND_FLAGS_RAW_URL="https://raw.githubusercontent.com/UniversalDependencies/docs-automation/${GIT_HASH}/codes_and_flags.yaml"
+
+    # Fuction to get github API content
+    get_codes_and_flags() {
+        wget "${CODES_AND_FLAGS_RAW_URL}" -O "${CODES_AND_FLAGS_FN}"
+    }
+
+    # Check if the online argument is present
+    if [[ $ONLINE_MODE == true ]] || [[ ! -e ${CODES_AND_FLAGS_FN} ]]; then
+      # Download content
+      get_codes_and_flags
+    fi
+done

tools/01_fetch_ud_repos.sh

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+#
+# This script is based on:
+# https://github.com/UniversalDependencies/docs-automation
+#
+# ./fetch_ud_repos.sh -h
+#
+
+# Set default vars and names directories and output files
+[ -e .env ] && . .env
+ONLINE_MODE=false
+UD_VER=${UD_VER:-"2.15"}
+UD_REV="r${UD_VER}"
+UDS_SUBDIR="UD_repos"; mkdir -p ${UDS_SUBDIR}
+GIT_API_OUTPUT=".UniversalDependencies.repos"
+GIT_SUBMODULES_ADD=".UD_submodules_add.commands"
+
+# Additional arguments for the `git submodule add` command(s)
+
+###################
+#############
+#
+# USAGE
+#
+usage() { OUTPUT=${1:-"verbose"}
+echo "Usage: $0 [-o] [-r REV]" >&2
+[ $OUTPUT = "short" ] && exit 0
+>&2 cat << EOF
+
+Identify all relevant UD repositories from GitHub:
+* https://github.com/UniversalDependencies/
+and generate a list of submodules to add to a (newly created) repository in the
+subdirectory ${UDS_SUBDIR}/.
+
+    "${GIT_API_OUTPUT}" contains the (saved) list of GitHub repositories; the
+        file can be updated by running this script with the '-o|--online' option.
+    "${GIT_SUBMODULES_ADD}" contains the list of submodules to add to the main
+        repository.
+
+Options:
+    -h              Print this help message
+    -o|--online     Enable online mode: (re-fetch UD repos from GitHub instead
+                    of using ${GIT_API_OUTPUT})
+    -r|--rev VER    The UD GitHub tagged version to checkout (default: ${UD_VER})
+EOF
+}
+#
+######
+############
+##################
+
+VALID_ARGS=$(getopt -o hor: --long help,online,rev: -- "$@")
+if [[ $? -ne 0 ]]; then
+  usage "short"
+  exit 1;
+fi
+
+eval set -- "$VALID_ARGS"
+while [ : ]
+do
+  case "$1" in
+    -o | --online) ONLINE_MODE=true; shift   ;;
+    -r | --rev)    UD_VER="$2";      shift 2 ;;
+    -h | --help)   usage;            shift   ; exit 0;;
+    --)                              shift   ; break ;;
+    *) >&2 echo Unsupported option: $1; usage; exit 1;;
+  esac
+done
+
+set -uo pipefail
+
+# Function to get github API content
+get_github_api_content() {
+
+    # We are interested in these keys:
+    #
+    #    "git_url": "git://github.com/UniversalDependencies/docs.git",
+    #    "ssh_url": "git@github.com:UniversalDependencies/docs.git",
+    #    "clone_url": "https://github.com/UniversalDependencies/docs.git",
+    #    "svn_url": "https://github.com/UniversalDependencies/docs",
+    #    "homepage": "http://universaldependencies.org/",
+    #
+    # -> "clone_url"
+
+    #This will last us to 300 repositories
+    (for pg in 1 2 3; do wget "https://api.github.com/orgs/UniversalDependencies/repos?page=$pg&per_page=100" -O - ; done ) \
+            | grep clone_url \
+            | grep -Po 'https://.*?(?=")' \
+        > ${UDS_SUBDIR}/${GIT_API_OUTPUT}
+}
+
+# Check if the online argument is present
+if [[ $ONLINE_MODE == true ]] || [[ ! -e ${UDS_SUBDIR}/${GIT_API_OUTPUT} ]]; then
+  # Download github API content
+  get_github_api_content
+fi
+
+
+MSG=""
+echo "" > ${UDS_SUBDIR}/${GIT_SUBMODULES_ADD}
+for r in $(cat ${UDS_SUBDIR}/${GIT_API_OUTPUT} | sort)
+do
+    l=$(echo $r | perl -pe 's/.*\///' | cut -f 1 -d.)
+
+    # Process all potential UD_ repos
+    if [[ $l == UD_* ]] && [[ $l != UD_v2 ]]
+    then
+        # Create a file for the full set
+        echo "git submodule add --depth 1 -- $r $l" \
+            >> ${UDS_SUBDIR}/${GIT_SUBMODULES_ADD}
+
+        # Missing subdir
+        if [[ ! -e ${UDS_SUBDIR}/$l ]]
+        then
+            # git submodule add
+            # [-b <branch>] [-f|--force] [--name <name>] [--reference <repository>]
+            # [--ref-format <format>] [--depth <depth>] [--] <repository> [<path>]
+
+            MSG="$MSG\n${UDS_SUBDIR}/$l"
+        fi
+    fi
+done
+
+# git show-ref refs/tags/${UD_REV}
+# echo "git submodule --quiet foreach 'export name; bash -c \"(git fetch --depth 1 origin refs/tags/${UD_REV}:refs/tags/${UD_REV} ) || (echo \$name; pushd ../..; git submodule deinit -f \$name; popd)\" '" >> ${GIT_SUBMODULES_ADD}
+echo "git submodule --quiet foreach 'export name; bash -c \"( REF=\$(git ls-remote --exit-code origin refs/tags/${UD_REV} | cut -f1) && [ ! -z \\\$REF ] && git fetch --depth=1 origin \\\$REF && echo \\\$REF > .tag-${UD_REV}) || ( echo No rev:${UD_REV} \\\$name )\" ' " >> ${UDS_SUBDIR}/${GIT_SUBMODULES_ADD}
+
+
+echo "Missing repos:"
+echo -e "$MSG"
+
+if [[ ! -e ${UDS_SUBDIR}/.git ]]
+then
+    echo "${UDS_SUBDIR}: "'missing .git: run `git init` in subdirectory!'
+fi

tools/02_traverse_ud_repos.py

@@ -0,0 +1,261 @@
+#!/usr/bin/env -S uv run --script
+#
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#   "pyyaml",
+#   "load-dotenv",
+# ]
+# ///
+"""
+Collect relevant metadata from local UD directories:
+- extracting the '# Summary' from the beginning and machine readable
+  metadata from the end of the README.{md,txt} file
+- using the UD directory name for collecting metadata from the
+  codes_and_flags.yaml file
+- collecting {dev,train,test}.conllu files.
+"""
+
+import json
+import os
+import xml.etree.ElementTree as ET
+import argparse
+import logging
+from collections import defaultdict
+from pathlib import Path
+
+import yaml
+from dotenv import load_dotenv
+
+
+load_dotenv()
+UD_VER = os.getenv('UD_VER', "2.15")
+
+# Parse command line arguments
+parser = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+parser.add_argument('-o', '--override', action='store_true',
+                    help='override output file if it already exists')
+parser.add_argument('-v', '--verbose', action='count', default=0,
+                    help='increase verbosity level')
+args = parser.parse_args()
+
+# Set up logging
+logging.basicConfig(
+    level = max(logging.DEBUG, logging.INFO - args.verbose * 10),
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+
+def extract_metadata(file_path) -> {}:
+    """
+    Collect relevant metadata from UD directories.
+
+    Args:
+        file_path (str): The path to the README.{md,txt} file.
+
+    Returns:
+        dict: The extracted metadata.
+    """
+    metadata = {
+        "summary": None,
+        "license": None,
+        "genre": None,
+        "lemmas": None,
+        "upos": None,
+        "xpos": None,
+        "language": None,   # German:
+        "flag": None,       #   flag: DE
+        "lcode": None,      #   lcode: de
+        "iso3": None,       #   iso3: deu
+        "family": None,     #   family: IE
+        "genus": None,      #   genus: Germanic
+        # "splits": None,      # {"dev":    {"files": []},
+                               #  "train":  {"files": []},
+                               #  "test":   {"files": []},
+                               #  "unknown":{"files": []}}
+    }
+
+    with open(file_path, 'r') as file:
+        lines = [line.strip() for line in file.readlines()]
+        summary_start = None
+        summary_end = None
+        for i, line in enumerate(lines):
+            if not summary_start and line.strip().startswith('# '):
+                summary_start = i + 1
+            elif summary_start and line.strip().startswith('# '):
+                summary_end = i - 1
+                break
+
+        if summary_start and summary_end:
+            # we have a summary
+            metadata["summary"] = (' '.join(lines[summary_start:summary_end])).strip()
+
+        # This is a (quite hackish) approach inspired by:
+        # https://github.com/UniversalDependencies/LICENSE/blob/master/generate_license_for_lindat.pl
+        for line in lines[summary_end:]:
+            if ":" in line:
+                key, val = line.split(":", 1)
+                if key.lower() in metadata.keys():
+                    if key.lower() == "genre":
+                        val = val.strip().split(" ")
+                    else:
+                        val = val.strip()
+                    metadata[key.lower()] = val
+    return metadata
+
+
+def traverse_directory(directory):
+    """
+    Traverses the directory and its first-level subdirectories, finds the
+    specified files, and extracts the summary from the README.{md,txt} file.
+
+    Args:
+        directory (str): The path to the directory.
+
+    Returns:
+        dict: A dictionary containing the extracted summaries for each file.
+    """
+    results = defaultdict(lambda: defaultdict(dict))
+
+    with open(os.path.join('etc', f"codes_and_flags-latest.yaml"), 'r') as file:
+        codes_and_flags = yaml.safe_load(file)
+        logging.debug(codes_and_flags)
+
+    for item in os.listdir(directory):
+        if item.startswith("."):
+            continue
+
+        if os.path.isdir(os.path.join(directory, item)):
+            dir_path = os.path.join(directory, item)
+            logging.debug(dir_path)
+
+            tag_fn = os.path.join(dir_path, f".tag-r{UD_VER}")
+            if not Path(tag_fn).exists():
+                logging.info(f"No tag file:{tag_fn}: Ignoring content.")
+                continue
+
+            results[item]["splits"] = {
+                "dev": {"files": [], "num_bytes": 0},
+                "test": {"files": [], "num_bytes": 0},
+                "train": {"files": [], "num_bytes": 0},
+                "unknown": {"files": [], "num_bytes": 0}
+            }
+            for file in os.listdir(dir_path):
+                if file.endswith(".conllu"):
+                    file_path = os.path.join(dir_path, file)
+                    github_path = os.path.join(item, f"r{UD_VER}", file)
+                    logging.debug(file_path)
+                    match file:
+                        case x if "dev" in file:
+                            subset = "dev"
+                        case x if "test" in file:
+                            subset = "test"
+                            pass
+                        case x if "train" in file:
+                            subset = "train"
+                        case _:
+                            subset = "unknown"
+                    results[item]["splits"][subset]["files"].append(github_path)
+
+                    sum_bytes = os.stat(file_path).st_size
+                    results[item]["splits"][subset]["num_bytes"] += sum_bytes
+
+                elif file.startswith("README") and (file.endswith(
+                        tuple(["md", "txt"]))):
+                    results[item].update(
+                        extract_metadata(os.path.join(dir_path, file)))
+                    # print(results[item])
+
+                elif file == "stats.xml":
+                    # Extract size values:
+                    # <treebank>
+                    #  <size>
+                    #    <total><sentences>15589</sentences><tokens>287708</tokens><words>292756</words><fused>5048</fused></total>
+                    #    <train><sentences>13813</sentences><tokens>259167</tokens><words>263777</words><fused>4610</fused></train>
+                    #    <dev><sentences>799</sentences><tokens>12316</tokens><words>12480</words><fused>164</fused></dev>
+                    #    <test><sentences>977</sentences><tokens>16225</tokens><words>16499</words><fused>274</fused></test>
+                    #  </size>
+                    tree = ET.parse(os.path.join(dir_path, file))
+                    root = tree.getroot()
+                    size_node = root.find('.//size')
+                    if size_node is None:
+                        continue
+
+                    for child_node_name in ["train", "dev", "test"]:
+
+                        child_node = size_node.find(child_node_name)
+                        if child_node is None:
+                            continue
+
+                        for child_child_node_name in ["sentences", "tokens", "words"]:
+                            value = child_node.find(child_child_node_name).text
+                            # print(f"Item:{item} {child_node_name}-{child_child_node_name}: {value}")
+
+                            if value and int(value) > 0:
+                                results[item]["splits"][child_node_name][f"num_{child_child_node_name}"] = value
+                                # print(f"key: {child_node_name}")
+                                # print(f"value: {value}")
+
+            # 'Read' language name from the dirname (UD_Abaza-ATB/), extract
+            # the relevant metadata from 'codes_and_flags.yaml' and add it to
+            # the metadata.
+            # ```
+            # Abaza:
+            #   flag: RU-ABAZA
+            #   lcode: abq
+            #   iso3: abq
+            #   family: Northwest Caucasian
+            # ```
+            language = item[3:].rsplit("-", 1)[0].replace("_", " ")
+            results[item]["language"] = language
+            #print(f"item: {item}, language: {language}")
+            results[item].update(codes_and_flags[language])
+
+            # 'Read' the corpus name from the dirname (UD_Abaza-ATB/) and
+            # construct a short name for the data set:
+            # abq_atb
+            corpus_name = item[3:].rsplit("-", 1)[1].lower()
+            name = f"{results[item]["lcode"]}_{corpus_name}"
+            results[item]["name"] = name
+
+            # Delete empty
+            #   1. file subsets
+            for fileset_k,fileset_v in list(results[item]["splits"].items()):
+                if not fileset_v["files"]:
+                    del results[item]["splits"][fileset_k]
+
+            #   2. sets without a summary, files or license
+            if not results[item]["summary"]:
+                del results[item]
+                print(f"ITEM DELETED - no summary: {item}")
+
+            if not any([value["files"] for value in
+                        results[item]["splits"].values()]):
+                print(results[item]["splits"])
+                del results[item]
+                print(f"ITEM DELETED - no files  : {item}")
+
+            if not results[item]["license"]:
+                del results[item]
+                print(f"ITEM DELETED - no license: {item}")
+
+    return results
+
+
+if __name__ == '__main__':
+    directory = 'UD_repos'
+    results = traverse_directory(directory)
+    for file, metadata in results.items():
+        print(f"Directory: {file}")
+        # print(metadata)
+        # print('---')
+
+    # Write the metadata to json
+    output_fn = 'metadata.json'
+    if args.override or not open(output_fn, 'r').read():
+        with open(output_fn, 'w') as fh:
+            json.dump(results, fh, ensure_ascii=False)
+            print(f"{output_fn} written")
+    else:
+        logging.info(f"Output {output_fn} already exists: Not overriding.")

tools/03_fill_universal_dependencies_tamplate.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env -S uv run --script
+#
+# /// script
+# requires-python = ">=3.12"
+# dependencies = [
+#   "Jinja2",
+#   "load-dotenv",
+# ]
+# ///
+"""
+FIXME
+"""
+
+import json
+import os
+import argparse
+import logging
+from pathlib import Path
+
+import jinja2
+from dotenv import load_dotenv
+
+
+load_dotenv()
+UD_VER = os.getenv('UD_VER', "2.15")
+
+# Parse command line arguments
+parser = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+parser.add_argument('-o', '--override', action='store_true',
+                    help='override output file if it already exists')
+parser.add_argument('-v', '--verbose', action='count', default=0,
+                    help='increase verbosity level')
+args = parser.parse_args()
+
+# Set up logging
+logging.basicConfig(
+    level = max(logging.DEBUG, logging.INFO - args.verbose * 10),
+    format='%(asctime)s [%(levelname)s] %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+
+
+if __name__ == '__main__':
+    # Read the metadata from json
+    with open('metadata.json', 'r') as fh:
+        metadata = json.load(fh)
+
+    with open(f'etc/description-{UD_VER}', 'r') as fh:
+        description = (fh.read()).strip()
+
+    with open(f'etc/citation-{UD_VER}', 'r') as fh:
+        citation = (fh.read()).strip()
+
+    templates = {
+        "templates/universal_dependencies.tmpl":
+        f"universal_dependencies-{UD_VER}",
+        "templates/README.tmpl":
+        f"README-{UD_VER}",
+    }
+    for template_fn, output_fn in templates.items():
+        if args.override or not Path(output_fn).exists():
+            with open(template_fn, 'r') as fh:
+                template = jinja2.Template(fh.read())
+
+            with open(output_fn, 'w') as fh:
+                output = template.render(citation=citation,
+                                         description=description,
+                                         data=metadata, ud_ver=UD_VER,)
+                fh.write(output)
+                print(f"{output_fn} written")
+        else:
+            logging.info(f"Output {output_fn} already exists: Not overriding.")

tools/README.md

@@ -0,0 +1,32 @@
+# README
+
+## 00 (./etc/)
+### `00_fetch_ud_clarin-dspace_metadata.py`
+Download `./etc/citation-VER` and `./etc/description-VER` UD metadata files for
+the different releases from the lindat clarin-dspace repository.
+
+### `00_fetch_ud_codes_and_flags.sh`
+Download `./etc/codes_and_flags.yaml`, a yaml file mapping UD (long) language
+names to metadata from UD `docs-automation` at GitHub.
+
+
+## 01
+Identify all relevant UD repositories from GitHub:
+* https://github.com/UniversalDependencies/
+and generate a list of submodules to add to a (newly created) repository in the
+subdirectory `./UD_Repos/`.
+
+
+## 02
+Collect relevant metadata from local UD directories:
+- extracting the '# Summary' from the beginning and machine readable
+  metadata from the end of the README.{md,txt} file
+- using the UD directory name for collecting metadata from the
+  codes_and_flags.yaml file
+- collecting {dev,train,test}.conllu files.
+
+
+## 03
+Use `./templates/` and generate:
+- `universal_dependencies.py`
+- `README.md`