ceos-ard-cli 0.3.0__tar.gz → 0.5.0__tar.gz

{ceos_ard_cli-0.3.0 → ceos_ard_cli-0.5.0}/.editorconfig

@@ -9,6 +9,7 @@ end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true
 charset = utf-8
+max_line_length = 120
 
 # 4 space indentation
 [*.py]
@@ -23,4 +24,4 @@ indent_size = 2
 [*.{md,adoc}]
 trim_trailing_whitespace = false
 indent_style = space
-indent_size = 2
+indent_size = 2

{ceos_ard_cli-0.3.0 → ceos_ard_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ceos-ard-cli
-Version: 0.3.0
+Version: 0.5.0
 Summary: CLI tools for CEOS-ARD to generate and validate PFS documents
 Project-URL: Homepage, https://github.com/ceos-org/ceos-ard-cli
 Project-URL: Repository, https://github.com/ceos-org/ceos-ard-cli
@@ -13,10 +13,11 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
 Requires-Dist: bibtexparser==2.0.0b8
-Requires-Dist: click>=8.0.0
-Requires-Dist: jinja2>=3.1.0
-Requires-Dist: playwright>=1.50.0
-Requires-Dist: strictyaml>=1.7.0
+Requires-Dist: click<9,>=8.0.0
+Requires-Dist: jinja2<4,>=3.1.0
+Requires-Dist: mergedeep<2,>=1.3.4
+Requires-Dist: playwright<2,>=1.50.0
+Requires-Dist: strictyaml<2,>=1.7.0
 Provides-Extra: dev
 Requires-Dist: build; extra == 'dev'
 Requires-Dist: pre-commit; extra == 'dev'
@@ -42,12 +43,19 @@ CLI for working with the [CEOS-ARD building blocks and PFSes](https://github.com
 
 In order to make working with CEOS-ARD easier we have developed command-line interface (CLI) tools.
 
+> [!TIP]
+> Most people won't need to install this tool.
+> Instead, you can use the [CEOS-ARD Editor](https://editor.ceos-ard.moregeo.it)
+> to edit and/or generate the CEOS-ARD PFS documents.
+
 ### Installation
 
 [Pixi](https://pixi.sh/) is a modern package management tool that handles both conda and PyPI dependencies.
 
-1. Install Pixi by following the [installation instructions](https://pixi.sh/latest/#installation)
-2. Clone this repository: `git clone https://github.com/ceos-org/ceos-ard-cli`
+1. Install Pixi by following the [installation instructions](https://pixi.sh/latest/#installation) (don't follow the "Get Started" instructions, you only need to run the single command provided in the "Installation" section).
+2. Clone this repository and the ceos-ard repository:
+   - `git clone https://github.com/ceos-org/ceos-ard`
+   - `git clone https://github.com/ceos-org/ceos-ard-cli`
 3. Navigate to the directory: `cd ceos-ard-cli`
 4. Install dependencies: `pixi install`
 5. Install browser for PDF rendering: `pixi run install-browser`
@@ -55,7 +63,7 @@ In order to make working with CEOS-ARD easier we have developed command-line int
 ### Run the CLI
 
 1. Run `pixi shell`
-2. Switch into the folder that contains the contents of the `ceos-ard` repository
+2. Switch into the folder that contains the contents of the `ceos-ard` repository: `cd ../ceos-ard`
 3. Run `ceos-ard` with the command you want to execute, e.g. `ceos-ard generate-all -o build`
 
 See the [available commands](#commands) for further details.

{ceos_ard_cli-0.3.0 → ceos_ard_cli-0.5.0}/README.md

@@ -16,12 +16,19 @@ CLI for working with the [CEOS-ARD building blocks and PFSes](https://github.com
 
 In order to make working with CEOS-ARD easier we have developed command-line interface (CLI) tools.
 
+> [!TIP]
+> Most people won't need to install this tool.
+> Instead, you can use the [CEOS-ARD Editor](https://editor.ceos-ard.moregeo.it)
+> to edit and/or generate the CEOS-ARD PFS documents.
+
 ### Installation
 
 [Pixi](https://pixi.sh/) is a modern package management tool that handles both conda and PyPI dependencies.
 
-1. Install Pixi by following the [installation instructions](https://pixi.sh/latest/#installation)
-2. Clone this repository: `git clone https://github.com/ceos-org/ceos-ard-cli`
+1. Install Pixi by following the [installation instructions](https://pixi.sh/latest/#installation) (don't follow the "Get Started" instructions, you only need to run the single command provided in the "Installation" section).
+2. Clone this repository and the ceos-ard repository:
+   - `git clone https://github.com/ceos-org/ceos-ard`
+   - `git clone https://github.com/ceos-org/ceos-ard-cli`
 3. Navigate to the directory: `cd ceos-ard-cli`
 4. Install dependencies: `pixi install`
 5. Install browser for PDF rendering: `pixi run install-browser`
@@ -29,7 +36,7 @@ In order to make working with CEOS-ARD easier we have developed command-line int
 ### Run the CLI
 
 1. Run `pixi shell`
-2. Switch into the folder that contains the contents of the `ceos-ard` repository
+2. Switch into the folder that contains the contents of the `ceos-ard` repository: `cd ../ceos-ard`
 3. Run `ceos-ard` with the command you want to execute, e.g. `ceos-ard generate-all -o build`
 
 See the [available commands](#commands) for further details.

{ceos_ard_cli-0.3.0 → ceos_ard_cli-0.5.0}/ceos_ard_cli/__init__.py

@@ -40,12 +40,12 @@ def cli():
     help="Adds an 'Assessment' section to the requirements (for editable Word documents)",
 )
 @click.option(
-    "--json",
+    "--debug",
     is_flag=True,
     default=False,
-    help="Outputs a JSON file for debugging purposes",
+    help="Enables debugging mode, e.g. outputs a JSON file for debugging purposes and gives a stacktrace",
 )
-def compile(pfs, output, input_dir, editable, json):
+def compile(pfs, output, input_dir, editable, debug):
     """
     Compiles the Markdown file for the given PFS.
     """
@@ -56,10 +56,13 @@ def compile(pfs, output, input_dir, editable, json):
         output = "-".join(pfs)
 
     try:
-        compile_(pfs, output, input_dir, editable=editable, debug=json)
+        compile_(pfs, output, input_dir, editable=editable, debug=debug)
     except Exception as e:
-        print(e)
-        sys.exit(1)
+        if debug:
+            raise e
+        else:
+            print(e)
+            sys.exit(1)
 
 
 @click.command()
@@ -84,9 +87,7 @@ def compile(pfs, output, input_dir, editable, json):
     help="Generate self-contained HTML files",
 )
 @click.option("--pdf", is_flag=True, default=True, help="Enable/disable PDF generation")
-@click.option(
-    "--docx", is_flag=True, default=True, help="Enable/disable Word (docx) generation"
-)
+@click.option("--docx", is_flag=True, default=True, help="Enable/disable Word (docx) generation")
 @click.option(
     "--id",
     default=None,
@@ -107,9 +108,7 @@ def compile(pfs, output, input_dir, editable, json):
     default=None,
     help="Overrides the PFS type of the document",
 )
-def generate(
-    pfs, output, input_dir, self_contained, pdf, docx, id, title, version, pfs_type
-):
+def generate(pfs, output, input_dir, self_contained, pdf, docx, id, title, version, pfs_type):
     """
     Generates the Word and HTML files for the given PFS.
 
@@ -156,9 +155,7 @@ def generate(
     help="Generate self-contained HTML files",
 )
 @click.option("--pdf", is_flag=True, default=True, help="Enable/disable PDF generation")
-@click.option(
-    "--docx", is_flag=True, default=True, help="Enable/disable Word (docx) generation"
-)
+@click.option("--docx", is_flag=True, default=True, help="Enable/disable Word (docx) generation")
 @click.option(
     "--pfs",
     "-p",

{ceos_ard_cli-0.3.0 → ceos_ard_cli-0.5.0}/ceos_ard_cli/compile.py

@@ -1,18 +1,17 @@
 import shutil
+from collections import defaultdict
 from pathlib import Path
 from typing import Union
-from collections import defaultdict
 
-from .schema import REFERENCE_PATH
-from .utils.files import read_file, write_file
+from .schema import REFERENCE_PATH, get_empty_requirement_part
+from .utils.files import fix_path, read_file, write_file
 from .utils.pfs import read_pfs
 from .utils.requirement import slugify
 from .utils.template import read_template
 
 
 def topological_sort_requirements(
-    requirements_by_pfs: list[list[str]],
-    equivalence_groups: dict[str, str] = None
+    requirements_by_pfs: list[list[str]], equivalence_groups: dict[str, str] = None
 ) -> list[str]:
     """
     Topologically sort requirements while preserving relative order from each PFS document.
@@ -88,6 +87,7 @@ def topological_sort_requirements(
             in_degree[successor] -= 1
             if in_degree[successor] == 0:
                 import bisect
+
                 bisect.insort(queue, successor)
 
     # Check for cycles
@@ -158,7 +158,7 @@ def combine_pfs(multi_pfs):
         "glossary": {},
         "references": set(),
         "annexes": {},
-        "authors": {},
+        "authors": "",
         "requirements": [],
     }
     categories = {}
@@ -179,16 +179,6 @@ def combine_pfs(multi_pfs):
         data["references"].update(pfs["references"])
         data["annexes"] = to_id_dict(pfs["annexes"])
 
-        for organization in pfs["authors"]:
-            key = organization["name"] + organization.get("country", "")
-            if key not in data["authors"]:
-                data["authors"][key] = organization
-            else:
-                existing = data["authors"][key]["members"]
-                for member in organization["members"]:
-                    if member not in existing:
-                        existing.append(member)
-
         for block in pfs["requirements"]:
             cat_id = block["category"]["id"]
             if cat_id not in categories:
@@ -230,16 +220,12 @@ def combine_pfs(multi_pfs):
     data["glossary"] = list(data["glossary"].values())
     data["references"] = list(data["references"])
     data["annexes"] = list(data["annexes"].values())
-    data["authors"] = list(data["authors"].values())
 
     for value in categories.values():
         cat_id = value["id"]
         # Use topological sort to merge requirements from all PFS documents
         # Pass equivalence groups so requirements with same title stay together
-        sorted_req_ids = topological_sort_requirements(
-            requirement_orders[cat_id],
-            equivalence_groups.get(cat_id, {})
-        )
+        sorted_req_ids = topological_sort_requirements(requirement_orders[cat_id], equivalence_groups.get(cat_id, {}))
         sorted_requirements = [requirements[cat_id][req_id] for req_id in sorted_req_ids]
 
         data["requirements"].append(
@@ -252,6 +238,58 @@ def combine_pfs(multi_pfs):
     return data
 
 
+def deep_replace(base, overrides):
+    """Deep merge where override values replace base values."""
+    result = base.copy()
+    for key, value in overrides.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = deep_replace(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def deep_append(base, additions):
+    """Deep merge where addition values are appended to base values."""
+    result = base.copy()
+    for key, value in additions.items():
+        if key not in result:
+            result[key] = value
+        elif isinstance(result[key], str) and isinstance(value, str):
+            if len(result[key]) > 0:
+                result[key] += "\n\n" + value
+            else:
+                result[key] = value
+        elif isinstance(result[key], list) and isinstance(value, list):
+            result[key] = result[key] + value
+        elif isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = deep_append(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def resolve_ref(item):
+    """Resolve a single ref/replace/append pattern into a flat structure."""
+    if isinstance(item, dict) and "ref" in item:
+        result = item["ref"]
+        if item.get("replace"):
+            result = deep_replace(result, item["replace"])
+        if item.get("append"):
+            result = deep_append(result, item["append"])
+        return result
+    return item
+
+
+def resolve_refs(data):
+    """Resolve all ref/replace/append patterns in PFS data."""
+    for block in data["requirements"]:
+        block["category"] = resolve_ref(block["category"])
+        for idx, req in enumerate(block["requirements"]):
+            block["requirements"][idx] = resolve_ref(req)
+    return data
+
+
 def compile(
     pfs: Union[list[str], str],
     out: Union[Path, str],
@@ -275,15 +313,20 @@ def compile(
 
     multi_pfs = {}
     for p in pfs:
-        # read the PFS information and
+        # read the PFS information,
+        # resolve ref/replace/append patterns and
         # move the glossary and references to the top level
-        multi_pfs[p] = bubble_up(read_pfs(p, input_dir))
+        multi_pfs[p] = bubble_up(resolve_refs(read_pfs(p, input_dir)))
 
     if len(pfs) > 1:
         data = combine_pfs(multi_pfs)
     else:
         data = multi_pfs[pfs[0]]
 
+    if isinstance(data["authors"], list):
+        # Convert list of authors to Markdown
+        data["authors"] = "\n".join(map(lambda a: f"- {a}", data["authors"]))
+
     # Override metadata if provided
     data["id"] = metadata.get("id") or data["id"]
     data["title"] = metadata.get("title") or data["title"]
@@ -318,7 +361,34 @@ def compile_bibtex(data, out, input_dir: Path):
 
 # make uid unique so that it can be used in multiple categories
 def create_uid(block, req_id):
-    return slugify(block["category"]["id"] + "." + req_id)
+    return slugify(block["category"]["id"] + "-" + req_id)
+
+
+def path_to_id(filepath, input_dir):
+    req_dir = Path(input_dir) / "requirements"
+    rel_path = fix_path(Path(filepath).relative_to(req_dir))
+    if rel_path.endswith(".yaml"):
+        rel_path = rel_path[:-5]
+    return rel_path
+
+
+def _resolve_dep_path(path, cid, local_requirements, all_requirements, input_dir):
+    """Resolve a dependency path to a requirement UID."""
+    if path in local_requirements[cid]:
+        return local_requirements[cid][path]
+    elif path in all_requirements:
+        return all_requirements[path]
+    else:
+        raise ValueError(f"Unmet dependency '{path}' in category '{cid}'")
+
+
+def append_requirement(target, req):
+    if len(target["description"]) > 0:
+        target["description"] += "\n\n" + req["description"]
+    else:
+        target["description"] = req["description"]
+    target["notes"].extend(req["notes"])
+    target["metadata"].update(req["metadata"])
 
 
 def compile_markdown(data, out, editable, input_dir: Path):
@@ -329,14 +399,32 @@ def compile_markdown(data, out, editable, input_dir: Path):
     context["editable"] = editable
     # sort glossary
     context["glossary"] = sorted(context["glossary"], key=lambda x: x["term"].lower())
-    # todo: implement automatic creation of history based on git logs?
-    # todo: alternatively, add changelog to the individual files with a timestamp and compile it from there
-    context["history"] = "Not available yet"
+    # todo: Derive changelogs automatically
 
     # make a dict of all requirements for efficient dependency lookup
     all_requirements = {}
     # make a dict of the requirements in this category for efficient dependency lookup
     local_requirements = {}
+
+    # Merge individual requirements into goal and threshold requirements
+    for block in context["requirements"]:
+        for idx, req in enumerate(block["requirements"]):
+            threshold = None
+            goal = None
+            for reqname in req["requirements"]:
+                subreq = req["requirements"][reqname]
+                if subreq.get("optional", False):
+                    if goal is None:
+                        goal = get_empty_requirement_part()
+                    append_requirement(goal, subreq)
+                else:
+                    if threshold is None:
+                        threshold = get_empty_requirement_part()
+                    append_requirement(threshold, subreq)
+
+            req["threshold"] = threshold
+            req["goal"] = goal
+
     # generate uid for each requirement and fill dependency lookups
     for block in context["requirements"]:
         cid = block["category"]["id"]
@@ -344,28 +432,20 @@ def compile_markdown(data, out, editable, input_dir: Path):
         for req in block["requirements"]:
             # make uid unique if it can be used in multiple categories
             req["uid"] = create_uid(block, req["id"])
-            local_requirements[cid][req["id"]] = req["uid"]
-            all_requirements[req["id"]] = req["uid"]
+            rel_path = path_to_id(req["filepath"], input_dir)
+            local_requirements[cid][rel_path] = req["uid"]
+            all_requirements[rel_path] = req["uid"]
 
     # resolve dependencies
     for block in context["requirements"]:
         cid = block["category"]["id"]
         for req in block["requirements"]:
-            for i, id in enumerate(req["dependencies"]):
-                # 1. Check to the requirement in the same requirement category.
-                if id in local_requirements[cid]:
-                    ref_id = local_requirements[cid][id]
-                # 2. Refers to the requirement in any other category.
-                elif id in all_requirements:
-                    ref_id = all_requirements[id]
-                else:
-                    raise ValueError(
-                        f"Unmet dependency {id} for requirement {req['uid']}"
-                    )
-
-                req["dependencies"][i] = ref_id
-                # Update the requirements in the texts
-                update_requirement_references(req, id, ref_id)
+            resolved_deps = []
+            for alias, path in req["dependencies"].items():
+                ref_id = _resolve_dep_path(path, cid, local_requirements, all_requirements, input_dir)
+                resolved_deps.append(ref_id)
+                update_requirement_references(req, alias, ref_id)
+            req["dependencies"] = resolved_deps
 
     # read, fill and write the template
     template = read_template(input_dir)
@@ -375,23 +455,20 @@ def compile_markdown(data, out, editable, input_dir: Path):
 
 # replace all requirement references in the texts with the resolved references
 def update_requirement_references(req, old_id, new_id):
-    req["description"] = update_requirement_reference(
-        req["description"], old_id, new_id
-    )
-    if req["threshold"] is not None:
-        req["threshold"]["description"] = update_requirement_reference(
-            req["threshold"]["description"], old_id, new_id
-        )
-        req["threshold"]["notes"] = update_requirement_reference(
-            req["threshold"]["notes"], old_id, new_id
-        )
-    if req["goal"] is not None:
-        req["goal"]["description"] = update_requirement_reference(
-            req["goal"]["description"], old_id, new_id
-        )
-        req["goal"]["notes"] = update_requirement_reference(
-            req["goal"]["notes"], old_id, new_id
-        )
+    req["description"] = update_requirement_reference(req["description"], old_id, new_id)
+
+    for key in req["requirements"]:
+        update_requirement_part_references(req["requirements"][key], old_id, new_id)
+
+    if req.get("threshold"):
+        update_requirement_part_references(req["threshold"], old_id, new_id)
+    if req.get("goal"):
+        update_requirement_part_references(req["goal"], old_id, new_id)
+
+
+def update_requirement_part_references(part, old_id, new_id):
+    part["description"] = update_requirement_reference(part["description"], old_id, new_id)
+    part["notes"] = update_requirement_reference(part["notes"], old_id, new_id)
 
 
 # replace all requirement references in the given texts with the resolved references

ceos_ard_cli-0.5.0/ceos_ard_cli/schema.py

@@ -0,0 +1,172 @@
+from strictyaml import (
+    Bool,
+    EmptyDict,
+    EmptyList,
+    Enum,
+    Map,
+    MapPattern,
+    Optional,
+    Regex,
+    Seq,
+    Str,
+    UniqueSeq,
+)
+
+from .strictyaml.id_reference import IdReference
+from .strictyaml.markdown import Markdown
+from .utils.files import fix_path
+
+REFERENCE_PATH = "./references/{id}.bib"
+GLOSSARY_PATH = "./glossary/{id}.yaml"
+INTRODUCTION_PATH = "./sections/introduction/{id}.yaml"
+ANNEX_PATH = "./sections/annexes/{id}.yaml"
+REQUIREMENT_CATEGORY_PATH = "./sections/requirement-categories/{id}.yaml"
+REQUIREMENT_PATH = "./requirements/{id}.yaml"
+
+
+_REFS = lambda path, base_path, schema=None, resolve=False: (
+    EmptyList() | UniqueSeq(IdReference(path, base_path, schema, resolve))
+)
+_RESOLVED_REFS = lambda path, base_path, schema: _REFS(path, base_path, schema, resolve=True)
+_RESOLVED_SECTIONS = lambda path, base_path: _RESOLVED_REFS(path, base_path, SECTION)
+_REFERENCE_IDS = lambda base_path: _REFS(REFERENCE_PATH, base_path)
+_DEPS = lambda path, base_path, schema=None: (
+    EmptyDict() | MapPattern(Str(), IdReference(path, base_path, schema, resolve=False))
+)
+
+_REQUIREMENT_PART = Map(
+    {
+        "description": Markdown(),
+        Optional("notes", default=[]): EmptyList() | Seq(Markdown()),
+        Optional("metadata", default={}): EmptyDict(),  # todo: add metadata schema
+        Optional("optional", default=False): Bool(),
+    }
+)
+
+_REQUIREMENT_PART_OVERRIDE = Map(
+    {
+        Optional("description"): Markdown(),
+        Optional("notes"): EmptyList() | Seq(Markdown()),
+        Optional("metadata"): EmptyDict(),  # todo: add metadata schema
+        Optional("optional"): Bool(),
+    }
+)
+
+
+def get_empty_requirement_part():
+    return {
+        "description": "",
+        "notes": [],
+        "metadata": {},
+    }
+
+
+_CHANGES = EmptyList() | Seq(
+    Map(
+        {
+            "date": Regex(r"\d{4}-\d{2}-\d{2}"),  # ISO date format
+            "author": Str(),
+            "change": Markdown(),
+            "reason": Str(),
+            "level": Enum(["major", "minor", "patch"]),
+        }
+    )
+)
+
+GLOSSARY = lambda file, base_path: Map(
+    {
+        Optional("filepath", default=fix_path(file)): Str(),
+        "term": Str(),
+        "description": Markdown(),
+    }
+)
+_RESOLVED_GLOSSARY = lambda base_path: _RESOLVED_REFS(GLOSSARY_PATH, base_path, GLOSSARY)
+
+SECTION = lambda file, base_path: Map(
+    {
+        Optional("filepath", default=fix_path(file)): Str(),
+        Optional("id", default=""): Str(),
+        "title": Str(),
+        "description": Markdown(),
+        Optional("glossary", default=[]): _RESOLVED_GLOSSARY(base_path),
+        Optional("references", default=[]): _REFERENCE_IDS(base_path),
+        Optional("changes", default=[]): _CHANGES,
+    }
+)
+
+PARTIAL_SECTION = lambda file, base_path: Map(
+    {
+        Optional("title"): Str(),
+        Optional("description"): Markdown(),
+        Optional("glossary"): _RESOLVED_GLOSSARY(base_path),
+        Optional("references"): _REFERENCE_IDS(base_path),
+        Optional("changes"): _CHANGES,
+    }
+)
+
+REQUIREMENT = lambda file, base_path: Map(
+    {
+        Optional("filepath", default=fix_path(file)): Str(),
+        "id": Str(),
+        "title": Str(),
+        Optional("description", default=""): Markdown(),
+        "requirements": MapPattern(Str(), _REQUIREMENT_PART),
+        Optional("dependencies", default={}): _DEPS(REQUIREMENT_PATH, base_path, REQUIREMENT),
+        Optional("glossary", default=[]): _RESOLVED_GLOSSARY(base_path),
+        Optional("references", default=[]): _REFERENCE_IDS(base_path),
+        Optional("changes", default=[]): _CHANGES,
+        Optional("history", default=[]): EmptyList() | Seq(Str()),
+    }
+)
+
+PARTIAL_REQUIREMENT = lambda file, base_path: Map(
+    {
+        Optional("title"): Str(),
+        Optional("description"): Markdown(),
+        Optional("requirements"): MapPattern(Str(), _REQUIREMENT_PART_OVERRIDE),
+        Optional("dependencies"): _DEPS(REQUIREMENT_PATH, base_path, REQUIREMENT),
+        Optional("glossary"): _RESOLVED_GLOSSARY(base_path),
+        Optional("references"): _REFERENCE_IDS(base_path),
+        Optional("changes"): _CHANGES,
+        Optional("history"): Seq(Str()),
+    }
+)
+
+PFS_DOCUMENT = lambda file, base_path: Map(
+    {
+        "title": Str(),
+        "version": Str(),
+        "type": Str(),
+        "applies_to": Markdown(),
+        "authors": Markdown() | Seq(Str()),
+        Optional("introduction", default=[]): _RESOLVED_SECTIONS(INTRODUCTION_PATH, base_path),
+        "requirements": Seq(
+            Map(
+                {
+                    "category": Map(
+                        {
+                            "ref": IdReference(REQUIREMENT_CATEGORY_PATH, base_path, SECTION),
+                            Optional("replace", default={}): EmptyDict() | PARTIAL_SECTION(file, base_path),
+                            Optional("append", default={}): EmptyDict() | PARTIAL_SECTION(file, base_path),
+                        }
+                    )
+                    | IdReference(REQUIREMENT_CATEGORY_PATH, base_path, SECTION),
+                    "requirements": Seq(
+                        Map(
+                            {
+                                "ref": IdReference(REQUIREMENT_PATH, base_path, REQUIREMENT),
+                                Optional("replace", default={}): EmptyDict() | PARTIAL_REQUIREMENT(file, base_path),
+                                Optional("append", default={}): EmptyDict() | PARTIAL_REQUIREMENT(file, base_path),
+                            }
+                        )
+                        | IdReference(REQUIREMENT_PATH, base_path, REQUIREMENT)
+                    ),
+                }
+            )
+        ),
+        Optional("glossary", default=[]): _RESOLVED_GLOSSARY(base_path),
+        Optional("references", default=[]): _REFERENCE_IDS(base_path),
+        Optional("annexes", default=[]): _RESOLVED_SECTIONS(ANNEX_PATH, base_path),
+        Optional("changes", default=[]): _CHANGES,
+    }
+)

{ceos_ard_cli-0.3.0 → ceos_ard_cli-0.5.0}/ceos_ard_cli/strictyaml/id_reference.py

@@ -15,14 +15,10 @@ class IdReference(strictyaml.ScalarValidator):
         self._resolve = resolve
 
     def validate_scalar(self, chunk):
-        file = Path(self._base_path) / Path(
-            self._path_template.format(id=chunk.contents)
-        )
+        file = Path(self._base_path) / Path(self._path_template.format(id=chunk.contents))
         content = None
         if not file.exists():
-            chunk.expecting_but_found(
-                f"expecting an existing file at {file} for id '{chunk.contents}'"
-            )
+            chunk.expecting_but_found(f"expecting an existing file at {file} for id '{chunk.contents}'")
         elif file.suffix == ".yaml":
             content = read_yaml(file, self._schema, self._base_path)
             if "id" not in content or len(content["id"]) == 0:
@@ -34,13 +30,9 @@ class IdReference(strictyaml.ScalarValidator):
             if len(library.failed_blocks) > 0:
                 chunk.expecting_but_found(f"expecting a valid bibtex entry at {file}")
             elif len(library.entries) != 1:
-                chunk.expecting_but_found(
-                    f"expecting a single bibtex entry per file in {file}, found {count}"
-                )
+                chunk.expecting_but_found(f"expecting a single bibtex entry per file in {file}, found {count}")
             elif library.entries[0].key != file.stem:
-                chunk.expecting_but_found(
-                    f"expecting bibtex identifier to match file name in {file}"
-                )
+                chunk.expecting_but_found(f"expecting bibtex identifier to match file name in {file}")
         else:
             content = read_file(file)