Refactor: Rename and simplify README generation script

- Renamed 03_fill_universal_dependencies_tamplate.py to 03_generate_README.py
- Script now only generates README-{UD_VER}, not universal_dependencies-{UD_VER}
- Removed templates/universal_dependencies.tmpl (no longer needed)
- Updated docstring to reflect new focused purpose

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

tools/{03_fill_universal_dependencies_tamplate.py → 03_generate_README.py}

@@ -8,7 +8,7 @@
 # ]
 # ///
 """
-FIXME
+Generate README-{UD_VER} from templates/README.tmpl using metadata-{UD_VER}.json.
 """
 
 import json
@@ -54,22 +54,19 @@ if __name__ == '__main__':
     with Path(basepath, "etc", f"citation-{UD_VER}").open(mode='r') as fh:
         citation = (fh.read()).strip()
 
-    templates = {
-        Path(basepath, "templates", "universal_dependencies.tmpl"):
-        Path(basepath, f"universal_dependencies-{UD_VER}"),
-        Path(basepath, "templates", "README.tmpl"):
-        Path(basepath, f"README-{UD_VER}"),
-    }
-    for template_fn, output_fn in templates.items():
-        if args.override or not Path(output_fn).exists():
-            with template_fn.open(mode='r') as fh:
-                template = jinja2.Template(fh.read())
+    # Generate README from template
+    template_fn = Path(basepath, "templates", "README.tmpl")
+    output_fn = Path(basepath, f"README-{UD_VER}")
 
-            with output_fn.open(mode='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.")
+    if args.override or not output_fn.exists():
+        with template_fn.open(mode='r') as fh:
+            template = jinja2.Template(fh.read())
+
+        with output_fn.open(mode='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/templates/universal_dependencies.tmpl

@@ -1,683 +0,0 @@
-### THIS IS A GENERATED FILE.
-
-from dataclasses import dataclass
-from typing import Dict, Optional
-
-import conllu
-
-import datasets
-
-
-# Helper functions for parsing CoNLL-U format fields
-
-def parse_feats(feats_str: Optional[str]) -> Dict[str, str]:
-    """
-    Parse CoNLL-U FEATS field string to dictionary.
-
-    Args:
-        feats_str: CoNLL-U format string like "Case=Nom|Number=Sing" or None
-
-    Returns:
-        Dictionary mapping feature names to values, empty dict if None
-
-    Example:
-        >>> parse_feats("Case=Nom|Number=Sing")
-        {'Case': 'Nom', 'Number': 'Sing'}
-        >>> parse_feats(None)
-        {}
-    """
-    if feats_str is None:
-        return {}
-    return dict(kv.split('=', 1) for kv in feats_str.split('|'))
-
-
-def parse_deps(deps_str: Optional[str]) -> Dict[str, str]:
-    """
-    Parse CoNLL-U DEPS field string to dictionary.
-
-    Args:
-        deps_str: CoNLL-U enhanced dependencies format like "4:nsubj|6:nsubj" or None
-
-    Returns:
-        Dictionary mapping head indices to dependency relations, empty dict if None
-
-    Example:
-        >>> parse_deps("4:nsubj|6:nsubj")
-        {'4': 'nsubj', '6': 'nsubj'}
-        >>> parse_deps(None)
-        {}
-    """
-    if deps_str is None:
-        return {}
-    return dict(kv.split(':', 1) for kv in deps_str.split('|'))
-
-
-def parse_misc(misc_str: Optional[str]) -> Dict[str, str]:
-    """
-    Parse CoNLL-U MISC field string to dictionary.
-
-    Args:
-        misc_str: CoNLL-U format string like "SpaceAfter=No|Translit=yes" or None
-
-    Returns:
-        Dictionary mapping misc attribute names to values, empty dict if None
-
-    Example:
-        >>> parse_misc("SpaceAfter=No")
-        {'SpaceAfter': 'No'}
-        >>> parse_misc(None)
-        {}
-    """
-    if misc_str is None:
-        return {}
-    return dict(kv.split('=', 1) for kv in misc_str.split('|'))
-
-
-def example_to_conllu(example: Dict, upos_names: Optional[list] = None) -> str:
-    """
-    Convert a single dataset example back to CoNLL-U format.
-
-    Args:
-        example: Dataset example (sentence) with all fields
-        upos_names: Optional list of UPOS label names for ClassLabel conversion
-
-    Returns:
-        CoNLL-U formatted string for this sentence
-
-    Example:
-        >>> from datasets import load_dataset
-        >>> ds = load_dataset("commul/universal_dependencies", "en_ewt", split="train")
-        >>> conllu_str = example_to_conllu(ds[0])
-        >>> print(conllu_str)
-        # newdoc id = ...
-        # sent_id = ...
-        # text = ...
-        1	The	...
-        <BLANKLINE>
-    """
-    lines = []
-
-    # Add metadata in original order (comments list contains markers for sent_id and text positions)
-    for comment in example.get('comments', []):
-        if comment == "__SENT_ID__":
-            lines.append(f"# sent_id = {example['sent_id']}")
-        elif comment == "__TEXT__":
-            lines.append(f"# text = {example['text']}")
-        else:
-            lines.append(f"# {comment}")
-
-    # Parse MWT ranges to know when to insert them
-    mwt_ranges = {}
-    for mwt in example.get('mwt', []):
-        mwt_id = mwt['id']  # e.g., "1-2"
-        if '-' in mwt_id:
-            start, _ = mwt_id.split('-')
-            mwt_ranges[int(start)] = mwt
-
-    # Parse empty node positions
-    empty_nodes_dict = {}
-    for empty_node in example.get('empty_nodes', []):
-        try:
-            node_id = float(empty_node['id'])
-            if node_id not in empty_nodes_dict:
-                empty_nodes_dict[node_id] = []
-            empty_nodes_dict[node_id].append(empty_node)
-        except (ValueError, KeyError):
-            pass
-
-    def _get_en_fields(empty_node):
-        en_fields = [
-            empty_node.get('id', '_'),
-            empty_node.get('form', '_'),
-            empty_node.get('lemma', '_'),
-            empty_node.get('upos', '_'),
-            empty_node.get('xpos') or '_',
-            empty_node.get('feats') or '_',
-            empty_node.get('head', '_'),
-            empty_node.get('deprel', '_'),
-            empty_node.get('deps') or '_',
-            empty_node.get('misc') or '_',
-        ]
-        return en_fields
-
-    # Insert empty nodes that come before token 1 (e.g., 0.1, 0.2)
-    for node_id in sorted(empty_nodes_dict.keys()):
-        if node_id < 1:
-            for empty_node in empty_nodes_dict[node_id]:
-                en_fields = _get_en_fields(empty_node)
-                lines.append('\t'.join(en_fields))
-
-    # Build token lines
-    token_idx = 1
-    for i in range(len(example['tokens'])):
-        # Insert MWT line before this token if needed
-        if token_idx in mwt_ranges:
-            mwt = mwt_ranges[token_idx]
-            feats = mwt.get('feats') or '_'
-            misc = mwt.get('misc') or '_'
-            lines.append(f"{mwt['id']}\t{mwt['form']}\t_\t_\t_\t{feats}\t_\t_\t_\t{misc}")
-
-        # Convert UPOS from ClassLabel index to string if needed
-        upos_value = example['upos'][i]
-        if isinstance(upos_value, int) and upos_names:
-            upos_value = upos_names[upos_value]
-
-        # Build token line
-        fields = [
-            str(token_idx),
-            str(example['tokens'][i]),
-            str(example['lemmas'][i]),
-            str(upos_value),
-            str(example['xpos'][i] or '_'),
-            str(example['feats'][i] or '_'),
-            str(example['head'][i]),
-            str(example['deprel'][i]),
-            str(example['deps'][i] or '_'),
-            str(example['misc'][i] or '_'),
-        ]
-        lines.append('\t'.join(fields))
-
-        # Insert empty nodes after this token if needed (e.g., 22.1 after token 22)
-        for node_id in sorted(empty_nodes_dict.keys()):
-            if int(node_id) == token_idx:
-                for empty_node in empty_nodes_dict[node_id]:
-                    en_fields = _get_en_fields(empty_node)
-                    lines.append('\t'.join(en_fields))
-
-        token_idx += 1
-
-    # Add blank line after sentence per UD spec
-    return '\n'.join(lines) + '\n\n'
-
-
-def write_conllu(dataset, output=None, split=None):
-    """
-    Write dataset back to CoNLL-U format.
-
-    Args:
-        dataset: Dataset or DatasetDict to write
-        output: Output destination (default: stdout):
-            - None: write to stdout
-            - str/Path: write to file path
-            - file-like object: write to buffer/stream
-        split: For DatasetDict, which split to write (default: all splits)
-
-    Returns:
-        None
-
-    Example:
-        >>> from datasets import load_dataset
-        >>> ds = load_dataset("commul/universal_dependencies", "en_ewt", split="train")
-        >>>
-        >>> # Write to stdout
-        >>> write_conllu(ds)
-        >>>
-        >>> # Write to file
-        >>> write_conllu(ds, "output.conllu")
-        >>>
-        >>> # Write to buffer
-        >>> import io
-        >>> buffer = io.StringIO()
-        >>> write_conllu(ds, buffer)
-        >>> conllu_text = buffer.getvalue()
-    """
-    import sys
-    from pathlib import Path
-
-    # Handle DatasetDict
-    if hasattr(dataset, 'keys'):  # DatasetDict
-        if split:
-            # Write specific split
-            if split not in dataset:
-                raise ValueError(f"Split '{split}' not found. Available: {list(dataset.keys())}")
-            dataset = dataset[split]
-        else:
-            # Write all splits
-            for split_name, split_dataset in dataset.items():
-                if output is None:
-                    print(f"# Split: {split_name}", file=sys.stderr)
-                write_conllu(split_dataset, output, split=None)
-            return
-
-    # Get UPOS names if available
-    upos_names = None
-    if hasattr(dataset, 'features') and 'upos' in dataset.features:
-        upos_feature = dataset.features['upos']
-        if hasattr(upos_feature, 'feature') and hasattr(upos_feature.feature, 'names'):
-            upos_names = upos_feature.feature.names
-
-    # Determine output stream
-    if output is None:
-        # Write to stdout
-        stream = sys.stdout
-        close_after = False
-    elif isinstance(output, (str, Path)):
-        # Write to file
-        stream = open(output, 'w', encoding='utf-8')
-        close_after = True
-    else:
-        # Assume file-like object
-        stream = output
-        close_after = False
-
-    try:
-        # Write each example
-        for example in dataset:
-            conllu_str = example_to_conllu(example, upos_names=upos_names)
-            stream.write(conllu_str)
-            stream.write('\n')  # Extra newline between sentences
-    finally:
-        if close_after:
-            stream.close()
-
-
-_CITATION = r"""\
-{{ citation }}
-"""  # noqa: W605
-
-_DESCRIPTION = """\
-{{ description }}
-"""
-
-_NAMES = [
-{%- for name,metadata in data.items()|sort(attribute='1.dirname') %}
-    "{{ name }}",
-{%- endfor %}
-]
-
-_DESCRIPTIONS = {
-{%- for name,metadata in data.items()|sort(attribute='1.dirname') %}
-    "{{ name }}": """{{ metadata.summary }}""",
-{%- endfor %}
-}
-
-_LICENSES = {
-{%- for name,metadata in data.items()|sort(attribute='1.dirname') %}
-    "{{ name }}": "{{ metadata.license }}",
-{%- endfor %}
-}
-
-_PREFIX = "https://raw.githubusercontent.com/UniversalDependencies/"
-_UD_DATASETS = {
-    {%- for name,metadata in data.items()|sort(attribute='1.dirname') %}
-        "{{ name }}": {
-            {%- for fileset_split_name,fileset_split_data in metadata.splits.items() %}
-                "{{ fileset_split_name }}": {{ fileset_split_data.files }},
-            {%- endfor %}
-        },
-    {%- endfor %}
-}
-
-
-@dataclass
-class UniversalDependenciesConfig(datasets.BuilderConfig):
-    """BuilderConfig for Universal Dependencies"""
-
-    def __init__(self, name: str, **kwargs):
-        super().__init__(name, version=datasets.Version("{{ ud_ver }}.0"), **kwargs)
-
-
-class UniversalDependencies(datasets.GeneratorBasedBuilder):
-    """Universal Dependencies Datasets"""
-
-    BUILDER_CONFIGS = [
-        UniversalDependenciesConfig(
-            name=name,
-        )
-        for name in _NAMES
-    ]
-    BUILDER_CONFIG_CLASS = UniversalDependenciesConfig
-
-    def _info(self):
-        return datasets.DatasetInfo(
-            homepage=f"https://github.com/UniversalDependencies/" + _UD_DATASETS[self.config.name]["test"][0].split("/")[0],
-            description=_DESCRIPTIONS[self.config.name],
-            citation=None,  # would need to be the dataset specific citation
-            license=_LICENSES[self.config.name],
-            features=datasets.Features(
-                {
-                    "sent_id": datasets.Value("string"),
-                    "text": datasets.Value("string"),
-                    "comments": datasets.Sequence(datasets.Value("string")),
-                    "tokens": datasets.Sequence(datasets.Value("string")),
-                    "lemmas": datasets.Sequence(datasets.Value("string")),
-                    "upos": datasets.Sequence(
-                        datasets.features.ClassLabel(
-                            names=[
-                                "NOUN",
-                                "PUNCT",
-                                "ADP",
-                                "NUM",
-                                "SYM",
-                                "SCONJ",
-                                "ADJ",
-                                "PART",
-                                "DET",
-                                "CCONJ",
-                                "PROPN",
-                                "PRON",
-                                "X",
-                                "_",
-                                "ADV",
-                                "INTJ",
-                                "VERB",
-                                "AUX",
-                            ]
-                        )
-                    ),
-                    "xpos": datasets.Sequence(datasets.Value("string")),
-                    "feats": datasets.Sequence(datasets.Value("string")),
-                    "head": datasets.Sequence(datasets.Value("string")),
-                    "deprel": datasets.Sequence(datasets.Value("string")),
-                    "deps": datasets.Sequence(datasets.Value("string")),
-                    "misc": datasets.Sequence(datasets.Value("string")),
-                    "mwt": datasets.Sequence(
-                        {
-                            "id": datasets.Value("string"),
-                            "form": datasets.Value("string"),
-                            "feats": datasets.Value("string"),
-                            "misc": datasets.Value("string"),
-                        }
-                    ),
-                    "empty_nodes": datasets.Sequence(
-                        {
-                            "id": datasets.Value("string"),
-                            "form": datasets.Value("string"),
-                            "lemma": datasets.Value("string"),
-                            "upos": datasets.Value("string"),
-                            "xpos": datasets.Value("string"),
-                            "feats": datasets.Value("string"),
-                            "head": datasets.Value("string"),
-                            "deprel": datasets.Value("string"),
-                            "deps": datasets.Value("string"),
-                            "misc": datasets.Value("string"),
-                        }
-                    ),
-                }
-            ),
-            supervised_keys=None,
-        )
-
-    def _split_generators(self, dl_manager):
-        """Returns SplitGenerators."""
-        urls_to_download = {}
-        for split, address in _UD_DATASETS[self.config.name].items():
-            urls_to_download[split] = []
-            if isinstance(address, list):
-                for add in address:
-                    urls_to_download[split].append(_PREFIX + add)
-            else:
-                urls_to_download[split].append(_PREFIX + address)
-
-        downloaded_files = dl_manager.download_and_extract(urls_to_download)
-        splits = []
-
-        if "train" in downloaded_files:
-            splits.append(
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN, gen_kwargs={"filepath": downloaded_files["train"]})
-            )
-
-        if "dev" in downloaded_files:
-            splits.append(
-                datasets.SplitGenerator(
-                    name=datasets.Split("dev"), gen_kwargs={"filepath": downloaded_files["dev"]}
-                )
-            )
-
-        if "test" in downloaded_files:
-            splits.append(
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST, gen_kwargs={"filepath": downloaded_files["test"]})
-            )
-
-        return splits
-
-    def _conllu_dict_to_string(self, value):
-        """
-        Convert CoNLL-U field value to standard CoNLL-U string format.
-        Used for reconstruction/output.
-        """
-        if value is None:
-            return "_"
-        if isinstance(value, dict):
-            if not value:
-                return "_"
-            # Convert dict to CoNLL-U format: Key=Value|Key2=Value2
-            items = [f"{k}={v}" for k, v in sorted(value.items())]
-            return "|".join(items)
-        s = str(value)
-        if s == "None":
-            return "_"
-        return s
-
-    def _conllu_optional_field(self, value):
-        """
-        Convert CoNLL-U optional field value to Python representation.
-        Returns None for unspecified values (_), proper format otherwise.
-
-        Use for: XPOS, FEATS, DEPS, MISC (optional fields per UD spec)
-        """
-        if value is None:
-            return None
-        if isinstance(value, dict):
-            if not value:
-                return None  # Empty dict = no features
-            # Convert dict to CoNLL-U format: Key=Value|Key2=Value2
-            items = [f"{k}={v}" for k, v in sorted(value.items())]
-            return "|".join(items)
-        # String value
-        s = str(value)
-        if s == "None" or s == "_" or s == "":
-            return None
-        return s
-
-    def _extract_raw_fields(self, sentence_text):
-        """Extract raw FEATS, XPOS, DEPS, and MISC fields to bypass conllu parsing bugs."""
-        raw_fields = {}
-
-        for line in sentence_text.split('\n'):
-            line = line.strip()
-            if not line or line.startswith('#'):
-                continue
-
-            fields = line.split('\t')
-            if len(fields) < 10:
-                continue
-
-            token_id = fields[0]
-            xpos = fields[4] if fields[4] != '_' else None
-            feats = fields[5] if fields[5] != '_' else None
-            deps = fields[8] if fields[8] != '_' else None
-            misc = fields[9] if fields[9] != '_' else None
-
-            raw_fields[token_id] = {
-                'xpos': xpos,
-                'feats': feats,
-                'deps': deps,
-                'misc': misc
-            }
-
-        return raw_fields
-
-    def _extract_raw_comments(self, sentence_text):
-        """Extract raw comment lines to preserve duplicates and empty values."""
-        comments = []
-        sent_id = None
-        text = None
-
-        for line in sentence_text.split('\n'):
-            line = line.strip()
-            if not line.startswith('#'):
-                continue
-
-            comment_content = line[1:].strip()
-            if not comment_content:
-                continue
-
-            if ' = ' in comment_content:
-                key, value = comment_content.split(' = ', 1)
-                key = key.strip()
-                value = value.strip()
-
-                if key == 'sent_id':
-                    sent_id = value
-                    comments.append("__SENT_ID__")
-                elif key == 'text':
-                    text = value
-                    comments.append("__TEXT__")
-                else:
-                    # Preserve raw format including empty values
-                    if value:
-                        comments.append(f"{key} = {value}")
-                    else:
-                        comments.append(f"{key} =")
-            else:
-                # Comment without = (like "newpar" or "# newpar")
-                comments.append(comment_content)
-
-        return comments, sent_id, text
-
-    def _generate_examples(self, filepath):
-        id = 0
-        for path in filepath:
-            # Read raw file for comment extraction
-            with open(path, "r", encoding="utf-8") as f:
-                file_content = f.read()
-            sentence_blocks = file_content.split('\n\n')
-
-            with open(path, "r", encoding="utf-8") as data_file:
-                tokenlist = list(conllu.parse_incr(data_file))
-                for idx, sent in enumerate(tokenlist):
-                    # Extract raw comments and fields from original text
-                    if idx < len(sentence_blocks):
-                        comments, sent_id, text = self._extract_raw_comments(sentence_blocks[idx])
-                        raw_fields = self._extract_raw_fields(sentence_blocks[idx])
-                    else:
-                        comments = []
-                        sent_id = None
-                        text = None
-                        raw_fields = {}
-
-                    # Fallback to conllu metadata if needed
-                    if sent_id is None:
-                        if "sent_id" in sent.metadata:
-                            sent_id = sent.metadata["sent_id"]
-                        else:
-                            sent_id = str(id)
-
-                    if text is None and "text" in sent.metadata:
-                        text = sent.metadata["text"]
-
-                    # Note: comments and raw fields extracted from raw file, bypassing conllu bugs
-
-                    # Extract Multi-Word Tokens (MWTs) - tokens with tuple IDs like (1, '-', 2)
-                    # Note: Exclude empty nodes which have '.' as middle element: (22, '.', 1)
-                    # Per UD spec: MWTs can have ID, FORM, MISC, and optionally FEATS (for "Typo=Yes")
-                    mwts = []
-                    for token in sent:
-                        if isinstance(token["id"], tuple) and len(token["id"]) == 3 and token["id"][1] == '-':
-                            # MWT line (e.g., (1, '-', 2) for "1-2")
-                            mwt_id = f"{token['id'][0]}-{token['id'][2]}"
-
-                            # Use raw fields if available (bypasses conllu parsing bugs)
-                            if mwt_id in raw_fields:
-                                feats = raw_fields[mwt_id]['feats']
-                                misc = raw_fields[mwt_id]['misc']
-                            else:
-                                # Fallback to conllu parsed values
-                                feats = self._conllu_optional_field(token["feats"])
-                                misc = self._conllu_optional_field(token["misc"])
-
-                            mwts.append({
-                                "id": mwt_id,
-                                "form": token["form"],
-                                "feats": feats,
-                                "misc": misc
-                            })
-
-                    # Extract Empty Nodes - tokens with decimal IDs like 22.1
-                    # These are represented as tuples: (22, '.', 1)
-                    empty_nodes = []
-                    for token in sent:
-                        if isinstance(token["id"], tuple) and len(token["id"]) == 3 and token["id"][1] == '.':
-                            # Empty node (e.g., (22, '.', 1) for ID "22.1")
-                            empty_node_id = f"{token['id'][0]}.{token['id'][2]}"
-
-                            # Use raw fields if available (bypasses conllu parsing bugs)
-                            if empty_node_id in raw_fields:
-                                xpos = raw_fields[empty_node_id]['xpos']
-                                feats = raw_fields[empty_node_id]['feats']
-                                deps = raw_fields[empty_node_id]['deps']
-                                misc = raw_fields[empty_node_id]['misc']
-                            else:
-                                # Fallback to conllu parsed values
-                                xpos = token["xpos"] or None
-                                feats = self._conllu_dict_to_string(token["feats"])
-                                deps = self._conllu_dict_to_string(token["deps"])
-                                misc = self._conllu_dict_to_string(token["misc"])
-
-                            empty_nodes.append({
-                                "id": empty_node_id,
-                                "form": token["form"],
-                                "lemma": token["lemma"] or "_",
-                                "upos": token["upos"] or "_",
-                                "xpos": xpos or "_",
-                                "feats": feats,
-                                "head": str(token["head"]) if token["head"] is not None else "_",
-                                "deprel": str(token["deprel"]) if token["deprel"] else "_",
-                                "deps": deps,
-                                "misc": misc
-                            })
-
-                    # Filter to syntactic words only (exclude MWTs and empty nodes)
-                    sent_filtered = sent.filter(id=lambda x: type(x) is int)
-
-                    tokens = [token["form"] for token in sent_filtered]
-
-                    # If text wasn't in metadata, reconstruct from tokens
-                    if text is None:
-                        text = " ".join(tokens)
-
-                    # Extract fields for regular tokens, using raw fields when available
-                    xpos_list = []
-                    feats_list = []
-                    deps_list = []
-                    misc_list = []
-
-                    for token in sent_filtered:
-                        token_id = str(token["id"])
-
-                        # Use raw fields if available (bypasses conllu parsing bugs)
-                        if token_id in raw_fields:
-                            xpos_list.append(raw_fields[token_id]['xpos'])
-                            feats_list.append(raw_fields[token_id]['feats'])
-                            deps_list.append(raw_fields[token_id]['deps'])
-                            misc_list.append(raw_fields[token_id]['misc'])
-                        else:
-                            # Fallback to conllu parsed values
-                            xpos_list.append(self._conllu_optional_field(token["xpos"]))
-                            feats_list.append(self._conllu_optional_field(token["feats"]))
-                            deps_list.append(self._conllu_optional_field(token["deps"]))
-                            misc_list.append(self._conllu_optional_field(token["misc"]))
-
-                    # Yield example with proper types per UD specification:
-                    # - Required fields (FORM, LEMMA, UPOS, HEAD, DEPREL): always string
-                    # - Optional fields (XPOS, FEATS, DEPS, MISC): None when unspecified
-                    yield id, {
-                        "sent_id": sent_id,
-                        "text": text,
-                        "comments": comments,
-                        "tokens": tokens,
-                        "lemmas": [token["lemma"] for token in sent_filtered],
-                        "upos": [token["upos"] for token in sent_filtered],
-                        "xpos": xpos_list,
-                        "feats": feats_list,
-                        "head": [str(token["head"]) if token["head"] is not None else "_" for token in sent_filtered],
-                        "deprel": [str(token["deprel"]) if token["deprel"] else "_" for token in sent_filtered],
-                        "deps": deps_list,
-                        "misc": misc_list,
-                        "mwt": mwts,
-                        "empty_nodes": empty_nodes,
-                    }
-                    id += 1