pz-scripts-data 1.1.1__tar.gz → 1.1.2__tar.gz

{pz_scripts_data-1.1.1/src/pz_scripts_data.egg-info → pz_scripts_data-1.1.2}/PKG-INFO

@@ -1,14 +1,10 @@
 Metadata-Version: 2.4
 Name: pz-scripts-data
-Version: 1.1.1
+Version: 1.1.2
 Summary: Dataset for the Scripts of Project Zomboid.
 Author: SimKDT
-License: PZ Scripts Data License
-        This dataset is provided as fully open-source. You are free to use, modify, repost this dataset and any tools in this projects. Any contribution to it is welcomed.
-        
-        We are not responsible for what is made with this dataset, whenever it gets updated and breaks anything.
+License-Expression: MIT
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Database
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable

{pz_scripts_data-1.1.1 → pz_scripts_data-1.1.2}/pyproject.toml

@@ -3,8 +3,8 @@ name = "pz-scripts-data"
 description = "Dataset for the Scripts of Project Zomboid."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12.3"
-version = "1.1.1"
-license = {file = "LICENSE"}
+version = "1.1.2"
+license = "MIT"
 authors = [
     { name = "SimKDT" },
 ]
@@ -15,7 +15,6 @@ dependencies = [
 ]
 classifiers = [
     "Programming Language :: Python :: 3.12",
-    "License :: OSI Approved :: MIT License",
     "Topic :: Database",
     "Operating System :: OS Independent",
     "Development Status :: 5 - Production/Stable",

pz_scripts_data-1.1.2/src/pz_scripts_data/blocks.py

@@ -0,0 +1,6 @@
+from enum import StrEnum
+
+class PropertyData(StrEnum):
+    NAME = 'name'
+    DESCRIPTION = 'description'
+    PROPERTIES = 'properties'

pz_scripts_data-1.1.2/src/pz_scripts_data/formatBlocks.py

@@ -0,0 +1,287 @@
+import json
+from pathlib import Path
+from typing import Any, Literal, Optional, TypedDict
+
+import yaml
+from pydantic import BaseModel, Field, ValidationError, model_validator
+
+from pz_scripts_data.blocks import PropertyData
+from pz_scripts_data.schema import BlockDefinition, ParameterDefinition
+
+
+class ScriptsBlock(BlockDefinition):
+    """Block used by the pipeline: parameters are keyed by lowercase name and relations are filled in during preparation."""
+
+    parameters: dict[str, ParameterDefinition] = Field(default_factory=dict) # type: ignore
+    children: list[str] | None = None
+    variants: list[str] | None = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def _key_parameters_by_name(cls, data: Any) -> Any:
+        if not isinstance(data, dict):
+            return data
+        parameters = data.get("parameters", [])
+        if not isinstance(parameters, list):
+            return data
+
+        keyed: dict[str, Any] = {}
+        for param in parameters:
+            name = param.get("name") if isinstance(param, dict) else None
+            if not isinstance(name, str):
+                raise ValueError("every parameter must have a 'name' to be referenced")
+            keyed[name.lower()] = param
+        return {**data, "parameters": keyed}
+
+
+class Item(TypedDict):
+    input: Path
+    output: Path
+    data: Optional[dict[str, ScriptsBlock]]
+
+
+items: list[Item] = [
+    Item(
+        input=Path("data/blocks"),
+        output=Path("out/scriptsBlocks.json"),
+        data=None,
+    ),
+    Item(
+        input=Path("data/roots"),
+        output=Path("out/roots.json"),
+        data=None,
+    ),
+]
+
+
+
+
+
+## PROCESS ITEM
+
+def fetchBlocks(item: Item):
+    # combine all block yaml files into one, validating each against the schema
+    blocks: dict[str, ScriptsBlock] = {}
+    for file_path in item['input'].glob("*.yaml"):
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = yaml.safe_load(f)
+        try:
+            block = ScriptsBlock.model_validate(data)
+        except ValidationError as exc:
+            raise ValueError(f"Invalid block definition in '{file_path}':\n{exc}") from exc
+        if block.name.lower() in blocks:
+            raise ValueError(f"Duplicate block name '{block.name}' found in '{file_path}'.")
+        blocks[block.name.lower()] = block
+    return blocks
+
+def process_properties(block: ScriptsBlock) -> ScriptsBlock:
+    # transform each property group's list into a dictionary keyed by property name
+    if block.properties is None:
+        return block
+    for property_data in block.properties.values():
+        properties: list = property_data[PropertyData.PROPERTIES]
+        property_data[PropertyData.PROPERTIES] = {prop[PropertyData.NAME]: prop for prop in properties}
+    return block
+
+# main
+
+def process(item: Item):
+    blocks = fetchBlocks(item)
+    for block in blocks.values():
+        process_properties(block)
+
+    return blocks
+
+
+
+## PREPARE
+
+# relationship and hierarchy
+
+def add_source_ref_to_targets(
+        source_name: str, 
+        targets_names: list[str], 
+        items: list[Item],
+        array_type: Literal["children", "variants"]):
+    """
+    This is used to add source_name to the targets's array_type.
+
+    For example:
+    - source_name -> child_name
+    - targets_names -> child_parents
+    - array_type -> children (of parent)
+    will add source_name in the array stored at key array_type of the targets of targets_names.
+    (child_name --append--> array (key: children) of each parents)
+    """
+    _processed: list[str] = []
+    for item in items:
+        blocks = item['data']
+        assert blocks is not None, "Something went wrong."
+
+        # add children_name ref to every parents
+        for parent_name in targets_names:
+            parent_block = blocks.get(parent_name.lower(), None)
+            if parent_block is None:
+                continue
+
+            # init if needed
+            if getattr(parent_block, array_type) is None:
+                setattr(parent_block, array_type, [])
+
+            # add name
+            children: list[str] = getattr(parent_block, array_type)
+            if source_name not in children:
+                children.append(source_name)
+            _processed.append(parent_name)
+
+    # we make sure they were all properly processed
+    for parent_name in targets_names:
+        if parent_name not in _processed:
+            raise ValueError(f"Parent block '{parent_name}' not found for block '{source_name}'.")
+
+
+def prepare_relationship(block: ScriptsBlock, items: list[Item]):
+    """
+    This will retrieve the parents of this block and add a reference to itself inside the data,
+    of this parent block
+    """
+    # handle parents
+    parents = block.parents
+    if parents:
+        add_source_ref_to_targets(block.name, parents, items, "children")
+
+    # handle variants
+    variant = block.variant_of
+    if variant:
+        add_source_ref_to_targets(block.name, [variant], items, "variants")
+
+
+# description and reference
+
+def find_block_in_items(block_name: str, items: list[Item]) -> ScriptsBlock | None:
+    for item in items:
+        blocks = item['data']
+        assert blocks is not None, "Something is wrong."
+
+        if block_name.lower() in blocks:
+            return blocks[block_name.lower()]
+    return None
+
+
+def copy_missing_fields(target: BaseModel, source: BaseModel) -> None:
+    """Copies every field explicitly set on source that isn't already set on target."""
+    for field_name in source.model_fields_set:
+        if field_name not in target.model_fields_set:
+            setattr(target, field_name, getattr(source, field_name))
+
+def copy_block_ref(block: ScriptsBlock, items: list[Item]) -> ScriptsBlock:
+    """
+    #desc copies the description of the source block
+    #ref copies every field of that source block into the block (if not already present)
+    """
+    # copy #desc
+    if block.ref_desc is not None:
+        desc_source = find_block_in_items(block.ref_desc, items)
+
+        if desc_source is not None:
+            if desc_source.description is None:
+                raise ValueError(f"Block '{block.name}' has #desc but source has no description.")
+            block.description = desc_source.description
+
+            # copy the short description if available too
+            if desc_source.short_description is not None:
+                block.short_description = desc_source.short_description
+
+    # copy #ref
+    if block.ref is not None:
+        ref_source = find_block_in_items(block.ref, items)
+        if ref_source is not None:
+            copy_missing_fields(block, ref_source)
+
+    return block
+
+
+# parameters
+
+def get_source_parameter(ref_key: str, items: list[Item]) -> ParameterDefinition:
+    """
+    This will return the source parameter from the ref_key.
+    The ref_key is in the format "BlockName/ParameterName"
+    """
+    # find the source block and parameter
+    path = ref_key.split('/')
+    assert len(path) == 2, f"Invalid #ref format for '{ref_key}'. Needs to be in format 'BlockName/ParameterName'."
+    origin_block = path[0]
+    origin_param = path[1].lower()
+
+    origin_block_data = find_block_in_items(origin_block, items)
+
+    # make sure the source block and parameter exist
+    if origin_block_data is None:
+        raise ValueError(f"Source block '{origin_block}' not found for parameter '{origin_param}'.")
+    if origin_param not in origin_block_data.parameters:
+        raise ValueError(f"Source block '{origin_block}' has no parameter '{origin_param}'.")
+
+    return origin_block_data.parameters[origin_param]
+
+def copy_parameters_ref(parameters: dict[str, ParameterDefinition], items: list[Item]):
+    for param_key, param in parameters.items():
+        if param.ref is not None:
+            source_param = get_source_parameter(param.ref, items)
+
+            # copy every field from the source parameter
+            # that isn't already set on the parameter
+            copy_missing_fields(param, source_param)
+
+        if param.ref_desc is not None:
+            source_param = get_source_parameter(param.ref_desc, items)
+
+            # make sure the source parameter has a description
+            if source_param.description is None:
+                raise ValueError(f"Parameter '{param_key}' has #desc but source has no description.")
+
+            # only copy the description
+            param.description = source_param.description
+
+
+# main
+
+def prepare(item: Item, items: list[Item]):
+    blocks = item['data']
+    assert blocks is not None, "Something went wrong."
+
+    for block in blocks.values():
+        prepare_relationship(block, items)
+        copy_block_ref(block, items)
+        copy_parameters_ref(block.parameters, items)
+
+
+    return blocks
+
+
+# serialization
+
+def serialize(blocks: dict[str, ScriptsBlock]) -> dict[str, dict[str, Any]]:
+    # only write the fields that were set, using their schema (alias) names
+    # the version is only used for validation, so it is not written
+    return {
+        name: block.model_dump(by_alias=True, exclude_unset=True, exclude={"version"})
+        for name, block in blocks.items()
+    }
+
+
+def main():
+    for item in items:
+        item['data'] = process(item)
+    for item in items:
+        item['data'] = prepare(item, items)
+    for item in items:
+        output_file = item['output']
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_file, 'w', encoding='utf-8') as f:
+            assert item['data'] is not None
+            json.dump(serialize(item['data']), f, indent=2, 
+                      ensure_ascii=False, sort_keys=True)
+
+if __name__ == "__main__":
+    main()

{pz_scripts_data-1.1.1 → pz_scripts_data-1.1.2}/src/pz_scripts_data/schema.py

@@ -7,9 +7,9 @@
 import json
 import sys
 from pathlib import Path
-from typing import Any, Literal, Self
+from typing import Annotated, Any, Literal, Self
 
-from pydantic import BaseModel, ConfigDict, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, WithJsonSchema, model_validator
 from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
 from pydantic_core import core_schema
 
@@ -17,6 +17,9 @@ DEFAULT_OUTPUT = Path(__file__).resolve().parents[2] / "schemas" / "blocks.json"
 
 ScalarType = Literal["string", "float", "boolean", "integer"]
 
+# Accepts whole numbers as int so they are not widened to float on output. The JSON Schema stays "number".
+Number = Annotated[int | float, WithJsonSchema({"type": "number"})]
+
 
 class SchemaModel(BaseModel):
     """Base model. Unknown keys are rejected and no value may be null."""
@@ -109,12 +112,12 @@ class BlockDeprecation(SchemaModel):
 
 class _ArrayBase(SchemaModel):
     separator: str = Field(description="Specifies the separator used to split the string into array items.")
-    min_items: float | None = Field(
+    min_items: Number | None = Field(
         None,
         alias="min",
         description="The minimum number of items required in the array.",
     )
-    max_items: float | None = Field(
+    max_items: Number | None = Field(
         None,
         alias="max",
         description="The maximum number of items allowed in the array.",
@@ -270,7 +273,7 @@ class ParameterNeed(SchemaModel):
     """A condition on another parameter that must be met for this parameter to be valid."""
 
     name: str | None = Field(None, description="The name of the parameter that this condition depends on.")
-    values: list[str | float | bool] | None = Field(
+    values: list[str | Number | bool] | None = Field(
         None,
         description="The values of the dependent parameter that must be met for this parameter to be valid.",
     )
@@ -280,11 +283,11 @@ class ParameterNeed(SchemaModel):
         description="A mapping of values of the dependent parameter to the expected type of this parameter. For example, if the dependent parameter is 'type' and it has a value 'integer', then this parameter should be of type 'float'. The key is the value of the dependent parameter, and the value is the expected type of this parameter when the dependent parameter has that value.",
         examples=[{"integer": "float", "double": "float", "boolean": "boolean", "string": "string"}],
     )
-    minimum: float | None = Field(
+    minimum: Number | None = Field(
         None,
         description="The minimum value for this parameter when the dependent parameter has a specific value. Requires the target parameter to be of type 'float' or 'integer'.",
     )
-    maximum: float | None = Field(
+    maximum: Number | None = Field(
         None,
         description="The maximum value for this parameter when the dependent parameter has a specific value. Requires the target parameter to be of type 'float' or 'integer'.",
     )
@@ -335,16 +338,16 @@ class ParameterDefinition(SchemaModel):
         description="DEPRECATED: A list of parent block types for which this parameter is applicable.",
     )
     required: bool | None = Field(None, description="Indicates whether the parameter is required.")
-    default_value: str | float | bool | list[Any] | dict[str, Any] | None = Field(
+    default_value: str | Number | bool | list[Any] | dict[str, Any] | None = Field(
         None,
         alias="default",
         description="The default value for the parameter if not specified.",
     )
-    minimum: float | None = Field(
+    minimum: Number | None = Field(
         None,
         description="The minimum value for the parameter if it is a number. Needs type.main to be 'float' or 'integer' to be applicable.",
     )
-    maximum: float | None = Field(
+    maximum: Number | None = Field(
         None,
         description="The maximum value for the parameter if it is a number. Needs type.main to be 'float' or 'integer' to be applicable.",
     )
@@ -353,7 +356,7 @@ class ParameterDefinition(SchemaModel):
         alias="type",
         description="The data type of the parameter.",
     )
-    values: list[str | float] | None = Field(None, description="A list of allowed values for the parameter.")
+    values: list[str | Number] | None = Field(None, description="A list of allowed values for the parameter.")
     deprecated: ParameterDeprecation | None = None
     needs: list[ParameterNeed] | None = Field(
         None,

{pz_scripts_data-1.1.1 → pz_scripts_data-1.1.2/src/pz_scripts_data.egg-info}/PKG-INFO

@@ -1,14 +1,10 @@
 Metadata-Version: 2.4
 Name: pz-scripts-data
-Version: 1.1.1
+Version: 1.1.2
 Summary: Dataset for the Scripts of Project Zomboid.
 Author: SimKDT
-License: PZ Scripts Data License
-        This dataset is provided as fully open-source. You are free to use, modify, repost this dataset and any tools in this projects. Any contribution to it is welcomed.
-        
-        We are not responsible for what is made with this dataset, whenever it gets updated and breaks anything.
+License-Expression: MIT
 Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Database
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 5 - Production/Stable

pz_scripts_data-1.1.1/src/pz_scripts_data/blocks.py

@@ -1,65 +0,0 @@
-from enum import StrEnum
-
-class BlockProperties(StrEnum):
-    VERSION = 'version'
-    REF_DESC = '#desc'
-    REF_FULL = '#ref'
-    DEPRECATED = 'deprecated'
-
-    NAME = 'name'
-    ID = 'ID'
-    SOFT_OVERRIDE = 'softOverride'
-    NO_COMMA = 'noComma'
-    PATTERN = 'pattern'
-
-    DESCRIPTION = 'description'
-    SHORT_DESCRIPTION = 'short_description'
-
-    VARIANT = 'variantOf'
-    VARIANTS = 'variants'
-
-    PARENTS = 'parents'
-    CHILDREN = 'children'
-    NEEDS_CHILDREN = 'needsChildren'
-    PARAMETERS = 'parameters'
-    PROPERTIES = 'properties'
-
-    IS_ROOT = 'isRoot'
-
-class IDProperties(StrEnum):
-    OPTIONAL = 'optional'
-    CAN_HAVE_SPACES = 'canHaveSpace'
-    FORBIDDEN = 'forbidden'
-
-    VALUES = 'values'
-    PARENTS_WITHOUT = 'parentsWithout'
-    AS_TYPE = 'asType'
-
-    TRANSLATION = 'translation'
-
-class ParameterProperties(StrEnum):
-    REF_DESC = '#desc'
-    REF_FULL = '#ref'
-
-    NAME = 'name'
-    DESCRIPTION = 'description'
-
-    TYPE = 'type'
-    DEFAULT = 'default'
-    REQUIRED = 'required'
-    CAN_BE_EMPTY = 'canBeEmpty'
-    MINIMUM = 'minimum'
-    MAXIMUM = 'maximum'
-    VALUES = 'values'
-
-    DEPRECATED = 'deprecated'
-    IS_USELESS = 'isUseless'
-    ALLOW_DUPLICATES = 'allowDuplicates'
-    INCOMPATIBLE_WITH = 'incompatibleWith'
-
-    SEE_ALSO = 'seeAlso'
-
-class PropertyData(StrEnum):
-    NAME = 'name'
-    DESCRIPTION = 'description'
-    PROPERTIES = 'properties'

pz_scripts_data-1.1.1/src/pz_scripts_data/formatBlocks.py

@@ -1,279 +0,0 @@
-import os, json, yaml
-from pathlib import Path
-from typing import TypedDict, Optional, Any
-
-from pz_scripts_data.blocks import BlockProperties, ParameterProperties, IDProperties, PropertyData
-
-
-type ScriptsBlock = dict[str, Any]
-class Item(TypedDict):
-    input: Path
-    output: Path
-    data: Optional[dict[str, ScriptsBlock]]
-
-
-items: list[Item] = [
-    Item(
-        input=Path("data/blocks"),
-        output=Path("out/scriptsBlocks.json"),
-        data=None,
-    ),
-    Item(
-        input=Path("data/roots"),
-        output=Path("out/roots.json"),
-        data=None,
-    ),
-]
-
-
-
-
-
-## PROCESS ITEM
-
-def fetchBlocks(item: Item):
-    # combine all block json files into one
-    blocks: dict[str, ScriptsBlock] = {}
-    for file_path in item['input'].glob("*.yaml"):
-        with open(file_path, 'r', encoding='utf-8') as f:
-            data = yaml.safe_load(f)
-            key = data[ParameterProperties.NAME]
-            if key in blocks:
-                raise ValueError(f"Duplicate block name '{key}' found in '{file_path}'.")
-            blocks[key] = data
-    return blocks
-
-def process_parameters(data: ScriptsBlock) -> ScriptsBlock:
-    # remove unnecessary fields
-    data.pop(BlockProperties.VERSION)
-
-    # replace parameters array into dictionary
-    # where keys are lowercased parameter names
-    parameters_data = data.get(BlockProperties.PARAMETERS, [])
-    parameters_new = {}
-    for param_data in parameters_data:
-        name = param_data[ParameterProperties.NAME]
-        parameters_new[name.lower()] = param_data
-    data[BlockProperties.PARAMETERS] = parameters_new
-
-    # handle properties
-    properties_data = data.get(BlockProperties.PROPERTIES, None)
-    if properties_data is not None:
-        for property_data in properties_data.values():
-            # transform into dictionary too
-            new_properties = {}
-            properties: list = property_data[PropertyData.PROPERTIES]
-            for prop_data in properties:
-                prop_name = prop_data[PropertyData.NAME]
-                new_properties[prop_name] = prop_data
-            property_data[PropertyData.PROPERTIES] = new_properties
-
-    return data
-
-# main
-
-def process(item: Item):
-    blocks = fetchBlocks(item)
-    for key, block in blocks.items():
-        blocks[key] = process_parameters(block)
-
-    return blocks
-
-
-
-## PREPARE
-
-# relationship and hierarchy
-
-def add_source_ref_to_targets(
-        source_name: str, 
-        targets_names: list[str], 
-        items: list[Item],
-        array_type: BlockProperties):
-    """
-    This is used to add source_name to the targets's array_type.
-
-    For example:
-    - source_name -> child_name
-    - targets_names -> child_parents
-    - array_type -> children (of parent)
-    will add source_name in the array stored at key array_type of the targets of targets_names.
-    (child_name --append--> array (key: children) of each parents)
-    """
-    _processed: list[str] = []
-    for item in items:
-        blocks = item['data']
-        assert blocks is not None, "Something went wrong."
-
-        # add children_name ref to every parents
-        for parent_name in targets_names:
-            parent_block = blocks.get(parent_name, None)
-            if parent_block is None:
-                continue
-
-            # init if needed
-            if array_type not in parent_block:
-                parent_block[array_type] = []
-
-            # add name
-            children: list[str] = parent_block[array_type]
-            if source_name not in children:
-                children.append(source_name)
-            _processed.append(parent_name)
-
-    # we make sure they were all properly processed
-    for parent_name in targets_names:
-        if parent_name not in _processed:
-            raise ValueError(f"Parent block '{parent_name}' not found for block '{source_name}'.")
-
-
-def prepare_relationship(block: ScriptsBlock, items: list[Item]):
-    """
-    This will retrieve the parents of this block and add a reference to itself inside the data,
-    of this parent block
-    """
-    # handle parents
-    parents = block.get(BlockProperties.PARENTS, [])
-    if parents:
-        add_source_ref_to_targets(
-            block[BlockProperties.NAME], parents, items,
-            BlockProperties.CHILDREN)
-
-    # handle variants
-    variant = block.get(BlockProperties.VARIANT, None)
-    if variant:
-        add_source_ref_to_targets(
-            block[BlockProperties.NAME], [variant], items,
-            BlockProperties.VARIANTS)
-
-
-# description and reference
-
-def find_block_in_items(block_name: str, items: list[Item]) -> ScriptsBlock | None:
-    for item in items:
-        blocks = item['data']
-        assert blocks is not None, "Something is wrong."
-
-        if block_name in blocks:
-            return blocks[block_name]
-    return None
-
-
-def copy_block_ref(block: ScriptsBlock, items: list[Item]) -> ScriptsBlock:
-    """
-    #desc copies the description of the source block
-    #ref copies every key values of that source block into the block (if not already present)
-    """
-    # copy #desc
-    if BlockProperties.REF_DESC in block:
-        desc_source_key: str = block[BlockProperties.REF_DESC]
-        desc_source = find_block_in_items(desc_source_key, items)
-
-        if desc_source is not None:
-            block[BlockProperties.DESCRIPTION] = desc_source[BlockProperties.DESCRIPTION]
-
-            # copy the short description if available too
-            if BlockProperties.SHORT_DESCRIPTION in desc_source:
-                block[BlockProperties.SHORT_DESCRIPTION] = desc_source[BlockProperties.SHORT_DESCRIPTION]
-
-    # copy #ref
-    if BlockProperties.REF_FULL in block:
-        ref_source_key: str = block[BlockProperties.REF_FULL]
-        ref_source = find_block_in_items(ref_source_key, items)
-        if ref_source is not None:
-            # we copy every key-value from the ref_block
-            # that doesn't already exist in the block
-            for key, value in ref_source.items():
-                if key not in block:
-                    block[key] = value
-
-    return block
-
-
-# parameters
-
-def get_source_parameter(ref_key: str, items: list[Item]) -> dict:
-    """
-    This will return the source parameter data from the ref_key.
-    The ref_key is in the format "BlockName/ParameterName"
-    """
-    # find the source block and parameter
-    path = ref_key.split('/')
-    assert len(path) == 2, f"Invalid #ref format for '{ref_key}'. Needs to be in format 'BlockName/ParameterName'."
-    origin_block = path[0]
-    origin_param = path[1].lower()
-
-    origin_block_data = find_block_in_items(origin_block, items)
-
-    # make sure the source block and parameter exist
-    if origin_block_data is None:
-        raise ValueError(f"Source block '{origin_block}' not found for parameter '{origin_param}'.")
-    if BlockProperties.PARAMETERS not in origin_block_data:
-        raise ValueError(f"Source block '{origin_block}' has no parameters for parameter '{origin_param}'.")
-    if origin_param not in origin_block_data[BlockProperties.PARAMETERS]:
-        raise ValueError(f"Source block '{origin_block}' has no parameter '{origin_param}'.")
-
-    return origin_block_data[BlockProperties.PARAMETERS][origin_param]
-
-def copy_parameters_ref(parameters: dict[str, dict], items: list[Item]):
-    for param_key, param_data in parameters.items():
-        if ParameterProperties.REF_FULL in param_data:
-            ref_key = param_data[ParameterProperties.REF_FULL]
-            
-            source_param_data = get_source_parameter(ref_key, items)
-            assert source_param_data is not None, f"Source parameter '{ref_key}' not found for parameter '{param_key}'."
-
-            # copy every key-value from the source parameter data
-            # that doesn't already exist in the parameter data
-            for key, value in source_param_data.items():
-                if key not in param_data:
-                    param_data[key] = value
-
-        if ParameterProperties.REF_DESC in param_data:
-            desc_key = param_data[ParameterProperties.REF_DESC]
-
-            source_param_data = get_source_parameter(desc_key, items)
-            assert source_param_data is not None, f"Source parameter '{desc_key}' not found for parameter '{param_key}'."
-
-            # make sure the source parameter has a description
-            if ParameterProperties.DESCRIPTION not in source_param_data:
-                raise ValueError(f"Parameter '{param_key}' has #desc but source has no description.")
-
-            # only copy the description
-            param_data[ParameterProperties.DESCRIPTION] = source_param_data[ParameterProperties.DESCRIPTION]
-
-
-# main
-
-def prepare(item: Item, items: list[Item]):
-    blocks = item['data']
-    assert blocks is not None, "Something went wrong."
-
-    for block in blocks.values():
-        prepare_relationship(block, items)
-        copy_block_ref(block, items)
-
-        parameters = block.get(BlockProperties.PARAMETERS, {})
-        copy_parameters_ref(parameters, items)
-
-
-    return blocks
-
-
-
-
-
-
-def main():
-    for item in items:
-        item['data'] = process(item)
-    for item in items:
-        item['data'] = prepare(item, items)
-    for item in items:
-        output_file = item['output']
-        output_file.parent.mkdir(parents=True, exist_ok=True)
-        with open(output_file, 'w', encoding='utf-8') as f:
-            json.dump(item['data'], f, indent=2, ensure_ascii=False, sort_keys=True)
-
-if __name__ == "__main__":
-    main()