dsp-tools 0.9.13__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

dsp_tools/commands/create/create_on_server/properties.py

@@ -0,0 +1,119 @@
+from http import HTTPStatus
+from typing import Any
+
+import rustworkx as rx
+from loguru import logger
+from rdflib import Literal
+from rdflib import URIRef
+from tqdm import tqdm
+
+from dsp_tools.clients.ontology_clients import OntologyCreateClient
+from dsp_tools.commands.create.create_on_server.onto_utils import get_modification_date_onto_lookup
+from dsp_tools.commands.create.create_on_server.onto_utils import should_retry_request
+from dsp_tools.commands.create.create_on_server.onto_utils import sort_for_upload
+from dsp_tools.commands.create.models.create_problems import CollectedProblems
+from dsp_tools.commands.create.models.create_problems import CreateProblem
+from dsp_tools.commands.create.models.create_problems import UploadProblem
+from dsp_tools.commands.create.models.create_problems import UploadProblemType
+from dsp_tools.commands.create.models.parsed_ontology import ParsedProperty
+from dsp_tools.commands.create.models.server_project_info import CreatedIriCollection
+from dsp_tools.commands.create.models.server_project_info import ListNameToIriLookup
+from dsp_tools.commands.create.models.server_project_info import OntoLastModDateLookup
+from dsp_tools.commands.create.models.server_project_info import ProjectIriLookup
+from dsp_tools.commands.create.serialisation.ontology import serialise_property_graph_for_request
+
+
+def create_all_properties(
+    properties: list[ParsedProperty],
+    project_iri_lookup: ProjectIriLookup,
+    created_iris: CreatedIriCollection,
+    list_lookup: ListNameToIriLookup,
+    client: OntologyCreateClient,
+) -> tuple[CreatedIriCollection, CollectedProblems | None]:
+    upload_order = _get_property_create_order(properties)
+    logger.debug(f"Property creation order: {upload_order}")
+    prop_lookup = {p.name: p for p in properties}
+    all_problems: list[CreateProblem] = []
+    onto_lookup = get_modification_date_onto_lookup(project_iri_lookup, client)
+    progress_bar = tqdm(upload_order, desc="    Creating properties", dynamic_ncols=True)
+    logger.debug("Starting property creation")
+    for p in progress_bar:
+        prop = prop_lookup[p]
+        if previous_blocker := _is_property_blocked(prop, created_iris):
+            all_problems.append(previous_blocker)
+            created_iris.failed_properties.add(prop.name)
+        else:
+            list_iri = None
+            if prop.node_name is not None:
+                if not (found := list_lookup.get_iri(prop.node_name)):
+                    all_problems.append(UploadProblem(prop.name, UploadProblemType.PROPERTY_LIST_NOT_FOUND))
+                    continue
+                else:
+                    list_iri = Literal(f"hlist=<{found}>")
+            create_result = _create_one_property(prop, list_iri, onto_lookup, client)
+            if isinstance(create_result, Literal):
+                onto_lookup.update_last_mod_date(prop.onto_iri, create_result)
+                created_iris.created_properties.add(prop.name)
+            else:
+                all_problems.append(create_result)
+                created_iris.failed_properties.add(prop.name)
+    upload_problems = None
+    if all_problems:
+        upload_problems = CollectedProblems(
+            "    While creating properties the following problems occurred:", all_problems
+        )
+    return created_iris, upload_problems
+
+
+def _is_property_blocked(prop: ParsedProperty, created_iris: CreatedIriCollection) -> CreateProblem | None:
+    if created_iris.any_properties_failed(set(prop.supers)):
+        return UploadProblem(prop.name, UploadProblemType.PROPERTY_SUPER_FAILED)
+    if prop.object:
+        if created_iris.any_classes_failed({str(prop.object)}):
+            return UploadProblem(prop.name, UploadProblemType.PROPERTY_REFERENCES_FAILED_CLASS)
+    if prop.subject:
+        if created_iris.any_classes_failed({prop.subject}):
+            return UploadProblem(prop.name, UploadProblemType.PROPERTY_REFERENCES_FAILED_CLASS)
+    return None
+
+
+def _get_property_create_order(properties: list[ParsedProperty]) -> list[str]:
+    logger.debug("Creating property upload order.")
+    graph, node_to_iri = _make_graph_to_sort(properties)
+    return sort_for_upload(graph, node_to_iri)
+
+
+def _make_graph_to_sort(properties: list[ParsedProperty]) -> tuple[rx.PyDiGraph, dict[int, str]]:
+    graph: rx.PyDiGraph[Any, Any] = rx.PyDiGraph()
+    prop_iris = [x.name for x in properties]
+    node_indices = list(graph.add_nodes_from(prop_iris))
+    iri_to_node = dict(zip(prop_iris, node_indices))
+    node_to_iri = dict(zip(node_indices, prop_iris))
+    for i, p in enumerate(properties):
+        for super_prop in p.supers:
+            if super_prop in prop_iris:
+                graph.add_edge(iri_to_node[p.name], iri_to_node[super_prop], i)
+    return graph, node_to_iri
+
+
+def _create_one_property(
+    prop: ParsedProperty,
+    list_iri: Literal | None,
+    onto_lookup: OntoLastModDateLookup,
+    client: OntologyCreateClient,
+) -> Literal | CreateProblem:
+    prop_serialised = serialise_property_graph_for_request(
+        prop, list_iri, URIRef(prop.onto_iri), onto_lookup.get_last_mod_date(prop.onto_iri)
+    )
+    request_result = client.post_new_property(prop_serialised)
+    if isinstance(request_result, Literal):
+        return request_result
+    if should_retry_request(request_result):
+        new_mod_date = client.get_last_modification_date(onto_lookup.project_iri, prop.onto_iri)
+        prop_serialised = serialise_property_graph_for_request(prop, list_iri, URIRef(prop.onto_iri), new_mod_date)
+        request_result = client.post_new_property(prop_serialised)
+        if isinstance(request_result, Literal):
+            return request_result
+    if request_result.status_code == HTTPStatus.BAD_REQUEST:
+        return UploadProblem(prop.name, request_result.text)
+    return UploadProblem(prop.name, UploadProblemType.PROPERTY_COULD_NOT_BE_CREATED)

dsp_tools/commands/create/exceptions.py

@@ -0,0 +1,29 @@
+from dsp_tools.error.exceptions import InternalError
+from dsp_tools.error.exceptions import UserError
+
+#######
+# Input Validation Errors
+
+
+class ProjectJsonSchemaValidationError(UserError):
+    def __init__(self, detail_msg: str) -> None:
+        super().__init__(detail_msg)
+
+
+class CircularOntologyDependency(UserError):
+    """Class if a circular dependency was found in the ontology."""
+
+    def __init__(self, dependency_location: str) -> None:
+        msg = (
+            f"A circular dependency of {dependency_location} was found in your project. "
+            f"It is not possible for an ontology to have circular dependencies."
+        )
+        super().__init__(msg)
+
+
+#######
+# Internal Errors
+
+
+class UnableToCreateProjectError(InternalError):
+    """Class if a project cannot be created."""

dsp_tools/commands/create/lists_only.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+
+from loguru import logger
+
+from dsp_tools.cli.args import ServerCredentials
+from dsp_tools.clients.authentication_client_live import AuthenticationClientLive
+from dsp_tools.clients.project_client_live import ProjectClientLive
+from dsp_tools.commands.create.communicate_problems import print_all_problem_collections
+from dsp_tools.commands.create.communicate_problems import print_problem_collection
+from dsp_tools.commands.create.create_on_server.lists import create_lists
+from dsp_tools.commands.create.models.parsed_project import ParsedList
+from dsp_tools.commands.create.models.parsed_project import ParsedProject
+from dsp_tools.commands.create.models.parsed_project import ParsedProjectMetadata
+from dsp_tools.commands.create.project_validate import parse_and_validate_project
+from dsp_tools.error.exceptions import InternalError
+from dsp_tools.error.exceptions import ProjectNotFoundError
+from dsp_tools.utils.ansi_colors import BACKGROUND_BOLD_YELLOW
+from dsp_tools.utils.ansi_colors import RESET_TO_DEFAULT
+
+
+def create_lists_only(project_file: Path, creds: ServerCredentials) -> bool:
+    parsing_result = parse_and_validate_project(project_file, creds.server)
+    match parsing_result:
+        case ParsedProject():
+            return _handle_parsed_project_result(parsing_result, creds)
+        case list():
+            print_all_problem_collections(parsing_result)
+            return False
+        case _:
+            raise InternalError("Unreachable result of project parsing.")
+
+
+def _handle_parsed_project_result(parsed_project: ParsedProject, creds: ServerCredentials) -> bool:
+    list_result = parsed_project.lists
+    match list_result:
+        case list():
+            return _execute_list_creation(parsed_project.project_metadata, list_result, creds)
+        case None:
+            msg = "Your file did not contain any lists, therefore no lists were created on the server."
+            logger.info(msg)
+            print(BACKGROUND_BOLD_YELLOW + msg + RESET_TO_DEFAULT)
+            return False
+        case _:
+            raise InternalError("Unreachable result of project parsing.")
+
+
+def _execute_list_creation(
+    project_metadata: ParsedProjectMetadata, parsed_lists: list[ParsedList], creds: ServerCredentials
+) -> bool:
+    auth = AuthenticationClientLive(creds.server, creds.user, creds.password)
+    project_info = ProjectClientLive(creds.server, auth)
+    try:
+        project_iri = project_info.get_project_iri(project_metadata.shortcode)
+    except ProjectNotFoundError:
+        # we want a more precise error message
+        raise ProjectNotFoundError(
+            f"This commands adds lists to an existing project. "
+            f"The project with the shortcode {project_metadata.shortcode} does not exist on this server. "
+            f"If you wish to create an entire project, please use the `create` command without the flag."
+        ) from None
+
+    _, problems = create_lists(parsed_lists, project_metadata.shortcode, auth, project_iri)
+    if problems:
+        print_problem_collection(problems)
+        return False
+    return True

dsp_tools/commands/create/models/create_problems.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+@dataclass
+class CollectedProblems:
+    header: str
+    problems: list[CreateProblem]
+
+
+@dataclass
+class UserInformation:
+    focus_object: str
+    msg: UserInformationMessage
+
+
+class UserInformationMessage(StrEnum):
+    LIST_EXISTS_ON_SERVER = "The list already exists on the server, therefore it is skipped entirely."
+
+
+@dataclass
+class CreateProblem:
+    problematic_object: str
+    problem: ProblemType | str
+
+
+@dataclass
+class InputProblem(CreateProblem):
+    problem: InputProblemType | str
+
+
+@dataclass
+class UploadProblem(CreateProblem):
+    problem: UploadProblemType | str
+
+
+class ProblemType(StrEnum): ...
+
+
+class InputProblemType(ProblemType):
+    USER_PASSWORD_NOT_SET = (
+        "This user cannot be created as no password is specified and no default password is saved in a .env file."
+    )
+    DUPLICATE_LIST_NAME = "You have lists in your project with the same name, this is not permitted."
+    PREFIX_COULD_NOT_BE_RESOLVED = (
+        "The prefix used is not defined in the 'prefix' section of the file, "
+        "nor does it belong to one of the project ontologies."
+    )
+    INVALID_PERMISSIONS_OVERRULE = (
+        "This class cannot be used in limited_view permissions "
+        "because it is not a subclass of StillImageRepresentation."
+    )
+    UNDEFINED_REFERENCE = "Reference not defined in the project."
+    UNDEFINED_SUPER_PROPERTY = "This property is derived from an invalid super-property."
+    UNDEFINED_SUPER_CLASS = "This resource is derived from an invalid super-class."
+    UNDEFINED_PROPERTY_IN_CARDINALITY = "This cardinality references a property that does not exist."
+    DUPLICATE_CLASS_NAME = "This class name appears multiple times in the same ontology."
+    DUPLICATE_PROPERTY_NAME = "This property name appears multiple times in the same ontology."
+    MIN_CARDINALITY_ONE_WITH_CIRCLE = (
+        "This property is part of a circular reference and must have cardinality 0-1 or 0-n."
+    )
+
+
+class UploadProblemType(ProblemType):
+    # Groups
+    GROUP_COULD_NOT_BE_CREATED = "The group could not be created."
+    # Users
+    USER_COULD_NOT_BE_CREATED = "The user could not be created."
+    USER_COULD_NOT_BE_ADDED_TO_GROUP = "The user could not be added to some or all of the custom groups."
+    USER_GROUPS_NOT_FOUND = "The user could not be added to the groups because they do not exist on the server."
+    PROJECT_MEMBERSHIP_COULD_NOT_BE_ADDED = "The user could not be added as project member."
+    PROJECT_ADMIN_COULD_NOT_BE_ADDED = "The user could not be added as project admin."
+    # Lists
+    LIST_COULD_NOT_BE_CREATED = "The list could not be created on the server."
+    LIST_NODE_COULD_NOT_BE_CREATED = "The list node could not be created on the server."
+    # Ontology
+    CARDINALITY_COULD_NOT_BE_ADDED = "The cardinality could not be added."
+    CARDINALITY_PROPERTY_NOT_FOUND = "The referenced property does not exist on the server."
+    PROPERTY_COULD_NOT_BE_CREATED = "The property could not be created."
+    PROPERTY_LIST_NOT_FOUND = "The property cannot be created, because the list it references does not exist."
+    PROPERTY_SUPER_FAILED = "The property cannot be created, because its super-property was not created."
+    PROPERTY_REFERENCES_FAILED_CLASS = "The property cannot be created, because a class it references was not created."
+    CLASS_COULD_NOT_BE_CREATED = "The class could not be created."
+    CLASS_SUPER_FAILED = "The class cannot be created, because its super-class was not created."
+    ONTOLOGY_COULD_NOT_BE_CREATED = "The ontology cannot be created."

dsp_tools/commands/create/models/parsed_ontology.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from enum import StrEnum
+from enum import auto
+
+from dsp_tools.utils.rdf_constants import KNORA_API_PREFIX
+from dsp_tools.utils.rdf_constants import SALSAH_GUI_PREFIX
+
+
+@dataclass
+class ParsedOntology:
+    name: str
+    label: str
+    comment: str | None
+    classes: list[ParsedClass]
+    properties: list[ParsedProperty]
+    cardinalities: list[ParsedClassCardinalities]
+
+
+@dataclass
+class ParsedClass:
+    name: str
+    labels: dict[str, str]
+    comments: dict[str, str] | None
+    supers: list[str]
+    onto_iri: str
+
+
+@dataclass
+class ParsedProperty:
+    name: str
+    labels: dict[str, str]
+    comments: dict[str, str] | None
+    supers: list[str]
+    object: KnoraObjectType | str
+    subject: str | None
+    gui_element: GuiElement
+    node_name: str | None
+    onto_iri: str
+
+
+class KnoraObjectType(StrEnum):
+    BOOLEAN = f"{KNORA_API_PREFIX}BooleanValue"
+    COLOR = f"{KNORA_API_PREFIX}ColorValue"
+    DATE = f"{KNORA_API_PREFIX}DateValue"
+    DECIMAL = f"{KNORA_API_PREFIX}DecimalValue"
+    GEONAME = f"{KNORA_API_PREFIX}GeonameValue"
+    INT = f"{KNORA_API_PREFIX}IntValue"
+    LIST = f"{KNORA_API_PREFIX}ListValue"
+    TEXT = f"{KNORA_API_PREFIX}TextValue"
+    TIME = f"{KNORA_API_PREFIX}TimeValue"
+    URI = f"{KNORA_API_PREFIX}UriValue"
+
+
+class GuiElement(StrEnum):
+    CHECKBOX = f"{SALSAH_GUI_PREFIX}Checkbox"
+    COLORPICKER = f"{SALSAH_GUI_PREFIX}Colorpicker"
+    DATE = f"{SALSAH_GUI_PREFIX}Date"
+    SPINBOX = f"{SALSAH_GUI_PREFIX}Spinbox"
+    GEONAMES = f"{SALSAH_GUI_PREFIX}Geonames"
+    LIST = f"{SALSAH_GUI_PREFIX}List"
+    SIMPLETEXT = f"{SALSAH_GUI_PREFIX}SimpleText"
+    TEXTAREA = f"{SALSAH_GUI_PREFIX}Textarea"
+    RICHTEXT = f"{SALSAH_GUI_PREFIX}Richtext"
+    SEARCHBOX = f"{SALSAH_GUI_PREFIX}Searchbox"
+    TIME_STAMP = f"{SALSAH_GUI_PREFIX}TimeStamp"
+
+
+@dataclass
+class ParsedClassCardinalities:
+    class_iri: str
+    cards: list[ParsedPropertyCardinality]
+
+
+@dataclass
+class ParsedPropertyCardinality:
+    propname: str
+    cardinality: Cardinality
+    gui_order: int | None
+
+
+class Cardinality(Enum):
+    C_0_1 = auto()
+    C_1 = auto()
+    C_0_N = auto()
+    C_1_N = auto()

dsp_tools/commands/create/models/parsed_project.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from dsp_tools.commands.create.models.parsed_ontology import ParsedOntology
+
+
+@dataclass
+class ParsedProject:
+    prefixes: dict[str, str]
+    project_metadata: ParsedProjectMetadata
+    permissions: ParsedPermissions
+    groups: list[ParsedGroup]
+    users: list[ParsedUser]
+    user_memberships: list[ParsedUserMemberShipInfo]
+    lists: list[ParsedList]
+    ontologies: list[ParsedOntology]
+
+
+@dataclass
+class ParsedProjectMetadata:
+    shortcode: str
+    shortname: str
+    longname: str
+    descriptions: dict[str, str]
+    keywords: list[str]
+    enabled_licenses: list[str]
+
+
+@dataclass
+class ParsedPermissions:
+    default_permissions: str
+    default_permissions_overrule: dict[str, str | list[str]] | None
+
+
+@dataclass
+class ParsedGroup:
+    name: str
+    descriptions: list[ParsedGroupDescription]
+
+
+@dataclass
+class ParsedGroupDescription:
+    lang: str
+    text: str
+
+
+@dataclass
+class ParsedUser:
+    username: str
+    email: str
+    given_name: str
+    family_name: str
+    password: str
+    lang: str
+
+
+@dataclass
+class ParsedUserMemberShipInfo:
+    username: str
+    is_admin: bool
+    groups: list[str]
+
+
+@dataclass
+class ParsedList:
+    list_info: ParsedNodeInfo
+    children: list[ParsedListNode]
+
+
+@dataclass
+class ParsedNodeInfo:
+    name: str
+    labels: dict[str, str]
+    comments: dict[str, str] | None
+
+
+@dataclass
+class ParsedListNode:
+    node_info: ParsedNodeInfo
+    children: list[ParsedListNode]

dsp_tools/commands/create/models/rdf_ontology.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rdflib import Literal
+from rdflib import URIRef
+
+
+@dataclass
+class RdfCardinalityRestriction:
+    owl_property: URIRef
+    cardinality_value: Literal

dsp_tools/commands/create/models/server_project_info.py

@@ -0,0 +1,100 @@
+from dataclasses import dataclass
+from dataclasses import field
+
+from rdflib import Literal
+from rdflib import URIRef
+
+from dsp_tools.error.exceptions import InternalError
+from dsp_tools.utils.rdf_constants import KNORA_API_PREFIX
+
+
+@dataclass
+class ProjectIriLookup:
+    project_iri: str
+    onto_iris: dict[str, str] = field(default_factory=dict)
+
+    def add_onto(self, name: str, iri: str) -> None:
+        self.onto_iris[name] = iri
+
+    def does_onto_exist(self, name: str) -> bool:
+        return bool(self.onto_iris.get(name))
+
+
+@dataclass
+class OntoLastModDateLookup:
+    project_iri: str
+    onto_iris: dict[str, URIRef]
+    iri_to_last_modification_date: dict[str, Literal] = field(default_factory=dict)
+
+    def get_last_mod_date(self, iri: str) -> Literal:
+        return self.iri_to_last_modification_date[iri]
+
+    def update_last_mod_date(self, iri: str, last_modification_date: Literal) -> None:
+        self.iri_to_last_modification_date[iri] = last_modification_date
+
+
+@dataclass
+class GroupNameToIriLookup:
+    name2iri: dict[str, str]
+    shortname: str
+
+    def check_exists(self, name: str) -> bool:
+        return name in self.name2iri.keys()
+
+    def add_iri(self, name: str, iri: str) -> None:
+        if self.check_exists(name):
+            raise InternalError(f"Group with the name '{name}' already exists in the lookup.")
+        self.name2iri[name] = iri
+        self.name2iri[f"{self.shortname}:{name}"] = iri
+
+    def get_iri(self, name: str) -> str | None:
+        return self.name2iri.get(name)
+
+
+@dataclass
+class UserNameToIriLookup:
+    name2iri: dict[str, str] = field(default_factory=dict)
+
+    def check_exists(self, name: str) -> bool:
+        return name in self.name2iri.keys()
+
+    def add_iri(self, name: str, iri: str) -> None:
+        if self.check_exists(name):
+            raise InternalError(f"User with the name '{name}' already exists in the lookup.")
+        self.name2iri[name] = iri
+
+    def get_iri(self, name: str) -> str | None:
+        return self.name2iri.get(name)
+
+
+@dataclass
+class CreatedIriCollection:
+    created_classes: set[str] = field(default_factory=set)
+    created_properties: set[str] = field(default_factory=set)
+    failed_classes: set[str] = field(default_factory=set)
+    failed_properties: set[str] = field(default_factory=set)
+
+    def __post_init__(self) -> None:
+        self.created_properties.update({f"{KNORA_API_PREFIX}seqnum", f"{KNORA_API_PREFIX}isPartOf"})
+
+    def any_properties_failed(self, props: set[str]) -> bool:
+        return bool(props.intersection(self.failed_properties))
+
+    def any_classes_failed(self, classes: set[str]) -> bool:
+        return bool(classes.intersection(self.failed_classes))
+
+
+@dataclass
+class ListNameToIriLookup:
+    name2iri: dict[str, str]
+
+    def check_list_exists(self, name: str) -> bool:
+        return name in self.name2iri.keys()
+
+    def add_iri(self, name: str, iri: str) -> None:
+        if self.check_list_exists(name):
+            raise InternalError(f"List with the name '{name}' already exists in the lookup.")
+        self.name2iri[name] = iri
+
+    def get_iri(self, name: str) -> str | None:
+        return self.name2iri.get(name)

dsp_tools/commands/create/parsing/parse_lists.py

@@ -0,0 +1,45 @@
+from collections import Counter
+from typing import Any
+
+from dsp_tools.commands.create.models.create_problems import CollectedProblems
+from dsp_tools.commands.create.models.create_problems import CreateProblem
+from dsp_tools.commands.create.models.create_problems import InputProblem
+from dsp_tools.commands.create.models.create_problems import InputProblemType
+from dsp_tools.commands.create.models.parsed_project import ParsedList
+from dsp_tools.commands.create.models.parsed_project import ParsedListNode
+from dsp_tools.commands.create.models.parsed_project import ParsedNodeInfo
+
+
+def parse_list_section(lists: list[dict[str, Any]]) -> list[ParsedList] | CollectedProblems:
+    list_section = [_parse_one_list(one_list) for one_list in lists]
+    list_names = [parsed_list.list_info.name for parsed_list in list_section]
+    duplicates = {name for name, count in Counter(list_names).items() if count > 1}
+    if duplicates:
+        problems: list[CreateProblem] = [
+            InputProblem(problematic_object=name, problem=InputProblemType.DUPLICATE_LIST_NAME) for name in duplicates
+        ]
+        return CollectedProblems(header="The following problems were found in the list section:", problems=problems)
+    return list_section
+
+
+def _parse_one_list(one_list: dict[str, Any]) -> ParsedList:
+    list_info = _parse_node_info(one_list)
+    children = _parse_nodes_and_children(one_list["nodes"]) if "nodes" in one_list else []
+    return ParsedList(list_info=list_info, children=children)
+
+
+def _parse_node_info(one_node: dict[str, Any]) -> ParsedNodeInfo:
+    return ParsedNodeInfo(
+        name=one_node["name"],
+        labels=one_node["labels"],
+        comments=one_node.get("comments"),
+    )
+
+
+def _parse_nodes_and_children(list_nodes: list[dict[str, Any]]) -> list[ParsedListNode]:
+    parsed_nodes = []
+    for node in list_nodes:
+        node_info = _parse_node_info(node)
+        children = _parse_nodes_and_children(node["nodes"]) if "nodes" in node else []
+        parsed_nodes.append(ParsedListNode(node_info=node_info, children=children))
+    return parsed_nodes