| |
| """Genera RDF/OWL y datasets desde data/iom_spec.json, única fuente tabular.""" |
| from __future__ import annotations |
|
|
| import csv |
| import json |
| from pathlib import Path |
| from rdflib import BNode, Graph, Literal, Namespace |
| from rdflib.namespace import OWL, RDF, RDFS, XSD |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| SPEC = json.loads((ROOT / "data" / "iom_spec.json").read_text(encoding="utf-8")) |
| IO = Namespace("http://example.org/iom#") |
| g = Graph() |
| for prefix, namespace in (("io", IO), ("rdfs", RDFS), ("xsd", XSD), ("owl", OWL)): |
| g.bind(prefix, namespace) |
|
|
| ontology = IO.Ontology |
| g.add((ontology, RDF.type, OWL.Ontology)) |
| g.add((ontology, OWL.versionInfo, Literal(SPEC["spec_version"]))) |
| g.add((ontology, RDFS.label, Literal("Ontología IOM", lang="es"))) |
| g.add((ontology, RDFS.comment, Literal(SPEC["source_note"], lang="es"))) |
| classes = ("OntoNode", "VectorStep", "Perspective", "ExpandedCategory", "Position", "Direction", "SourceModel") |
| for name in classes: |
| g.add((IO[name], RDF.type, OWL.Class)) |
| for names in (("OntoNode", "VectorStep", "ExpandedCategory", "Perspective"),): |
| axiom = BNode("iomDisjointCoreClasses") |
| head = BNode("iomDisjointClassList0") |
| g.add((axiom, RDF.type, OWL.AllDisjointClasses)) |
| g.add((axiom, OWL.members, head)) |
| cells = [BNode(f"iomDisjointClassList{i}") for i in range(len(names))] |
| for index, name in enumerate(names): |
| g.add((cells[index], RDF.first, IO[name])) |
| g.add((cells[index], RDF.rest, cells[index + 1] if index + 1 < len(cells) else RDF.nil)) |
|
|
| object_properties = { |
| "hasPerspective": ("OntoNode", "Perspective"), |
| "hasPosition": ("OntoNode", "Position"), |
| "hasDirection": ("OntoNode", "Direction"), |
| "hasVector": ("VectorStep", "Perspective"), |
| "mirrorOf": ("OntoNode", "OntoNode"), |
| "creates": ("OntoNode", "OntoNode"), |
| } |
| datatype_properties = { |
| "hasTriadIndex": ("OntoNode", XSD.integer), |
| "hasPhase": ("OntoNode", XSD.string), |
| "hasLocalPos": ("OntoNode", XSD.integer), |
| "displayLabel": ("OntoNode", XSD.string), |
| "hasCyclePhase": ("VectorStep", XSD.string), |
| "hasAxisPosition": ("VectorStep", XSD.integer), |
| "hasStepIndex": ("VectorStep", XSD.integer), |
| "displayArrow": ("VectorStep", XSD.string), |
| "hasLevel": ("ExpandedCategory", XSD.integer), |
| "declaredTriadCount": ("SourceModel", XSD.integer), |
| "declaredPerspectiveCount": ("SourceModel", XSD.integer), |
| "declaredOperatorCount": ("SourceModel", XSD.integer), |
| "declaredExpandedCategoryCount": ("SourceModel", XSD.integer), |
| } |
| for name, (domain, range_) in object_properties.items(): |
| prop = IO[name] |
| g.add((prop, RDF.type, OWL.ObjectProperty)) |
| g.add((prop, RDFS.domain, IO[domain])) |
| g.add((prop, RDFS.range, IO[range_])) |
| for name, (domain, range_) in datatype_properties.items(): |
| prop = IO[name] |
| g.add((prop, RDF.type, OWL.DatatypeProperty)) |
| g.add((prop, RDFS.domain, IO[domain])) |
| g.add((prop, RDFS.range, range_)) |
| for name in ("hasPerspective", "hasPosition", "hasDirection", "hasVector", "hasTriadIndex", "hasPhase", "hasLocalPos", "displayLabel", "hasCyclePhase", "hasAxisPosition", "hasStepIndex", "displayArrow", "hasLevel"): |
| g.add((IO[name], RDF.type, OWL.FunctionalProperty)) |
| g.add((IO.mirrorOf, RDF.type, OWL.SymmetricProperty)) |
|
|
| for pos, label in [("→", "→"), ("0", "0"), ("←", "←")]: |
| g.add((IO[pos], RDF.type, OWL.NamedIndividual)) |
| g.add((IO[pos], RDF.type, IO.Position)) |
| g.add((IO[pos], RDFS.label, Literal(label, lang="es"))) |
| for direction in ("evol", "invol"): |
| g.add((IO[direction], RDF.type, OWL.NamedIndividual)) |
| g.add((IO[direction], RDF.type, IO.Direction)) |
| _perspective_labels = SPEC.get("perspective_labels") or { |
| "Ind": "Individualidad", "D": "Dualidad", "Tot": "Totalidad", |
| "Evol": "Evolución", "Invol": "Involución", |
| } |
| for name, label in _perspective_labels.items(): |
| g.add((IO[name], RDF.type, IO.Perspective)) |
| g.add((IO[name], RDFS.label, Literal(label, lang="es"))) |
|
|
| position_meta = SPEC["positions"] |
| position_indices = position_meta["indices"] |
| position_names_adv = ["→", "0", "→"] |
| position_names_ret = ["←", "0", "←"] |
| perspective_names = position_meta["perspectives"] |
| perspectives = [IO[name] for name in perspective_names] |
| triad_meta = SPEC["triads"] |
| triad_rows = {phase: triad_meta[phase] for phase in ("adv", "ret")} |
| index_base = triad_meta.get("index_base", 0) |
| n_triads = len(triad_rows["adv"]) |
| triad_ids = range(index_base, index_base + n_triads) |
| nodes_csv = [] |
| for phase, rows in triad_rows.items(): |
| direction = IO[SPEC["phases"][phase]["direction"]] |
| for row_index, labels in enumerate(rows): |
| triad_idx = index_base + row_index |
| for pos_idx, label in enumerate(labels): |
| node = IO[f"T{triad_idx:02d}_{phase}_P{pos_idx}"] |
| g.add((node, RDF.type, IO.OntoNode)) |
| g.add((node, IO.hasTriadIndex, Literal(triad_idx, datatype=XSD.integer))) |
| g.add((node, IO.hasPhase, Literal(phase, datatype=XSD.string))) |
| g.add((node, IO.hasLocalPos, Literal(pos_idx, datatype=XSD.integer))) |
| display_labels = position_meta["adv_labels" if phase == "adv" else "ret_labels"] |
| display_label = display_labels[pos_idx] |
| g.add((node, IO.displayLabel, Literal(display_label, datatype=XSD.string))) |
| pos_names = position_names_adv if phase == "adv" else position_names_ret |
| g.add((node, IO.hasPosition, IO[pos_names[pos_idx]])) |
| g.add((node, IO.hasPerspective, perspectives[pos_idx])) |
| g.add((node, IO.hasDirection, direction)) |
| g.add((node, RDFS.label, Literal(label, lang="es"))) |
| nodes_csv.append({"node_id": str(node).split("#", 1)[1], "triad_index": triad_idx, "phase": phase, |
| "direction": str(direction).split("#", 1)[1], "position_index": pos_idx, |
| "position": pos_names[pos_idx], "display_label": display_label, |
| "perspective": perspective_names[pos_idx], "label": label}) |
|
|
| for triad_idx in triad_ids: |
| for pos_idx in range(3): |
| adv = IO[f"T{triad_idx:02d}_adv_P{pos_idx}"] |
| ret = IO[f"T{triad_idx:02d}_ret_P{2-pos_idx}"] |
| g.add((adv, IO.mirrorOf, ret)) |
| g.add((ret, IO.mirrorOf, adv)) |
|
|
| for triad_idx in triad_ids: |
| for rule in SPEC["creation_rules"]: |
| for source_pos in rule["source_positions"]: |
| for target_pos in rule["target_positions"]: |
| source = IO[f"T{triad_idx:02d}_{rule['source_phase']}_P{source_pos}"] |
| target = IO[f"T{triad_idx:02d}_{rule['target_phase']}_P{target_pos}"] |
| g.add((source, IO.creates, target)) |
|
|
| vector_csv = [] |
| for vector_row in SPEC["vectors"]: |
| vector, phase = vector_row["name"], vector_row["phase"] |
| for step_index, (label, axis_pos) in enumerate(zip(vector_row["labels"], vector_row["axis_positions"])): |
| step = IO[f"vector_{vector.lower()}_{phase}_{step_index}"] |
| g.add((step, RDF.type, IO.VectorStep)) |
| g.add((step, IO.hasVector, IO[vector])) |
| g.add((step, IO.hasCyclePhase, Literal(phase, datatype=XSD.string))) |
| g.add((step, IO.hasAxisPosition, Literal(axis_pos, datatype=XSD.integer))) |
| g.add((step, IO.hasStepIndex, Literal(step_index, datatype=XSD.integer))) |
| g.add((step, IO.displayArrow, Literal(vector_row["arrow"], datatype=XSD.string))) |
| g.add((step, RDFS.label, Literal(label, lang="es"))) |
| vector_csv.append({"step_id": str(step).split("#", 1)[1], "vector": vector, "phase": phase, |
| "step_index": step_index, "axis_position": axis_pos, "label": label, |
| "arrow": vector_row["arrow"]}) |
|
|
| for level, labels in SPEC["expanded_categories"].items(): |
| for index, label in enumerate(labels, 1): |
| category = IO[f"expanded_L{level}_{index:02d}"] |
| g.add((category, RDF.type, IO.ExpandedCategory)) |
| g.add((category, IO.hasLevel, Literal(int(level), datatype=XSD.integer))) |
| g.add((category, RDFS.label, Literal(label, lang="es"))) |
|
|
| model = IO.SourceModel |
| g.add((model, RDF.type, IO.SourceModel)) |
| for prop, value in ((IO.declaredTriadCount, 13), (IO.declaredPerspectiveCount, 5), |
| (IO.declaredOperatorCount, 4), (IO.declaredExpandedCategoryCount, 21)): |
| g.add((model, prop, Literal(value, datatype=XSD.integer))) |
|
|
| relation_csv = [] |
| relation_lookup = {} |
| for subject, _, obj in g.triples((None, IO.mirrorOf, None)): |
| relation_lookup[(str(subject), str(obj))] = "mirrorOf" |
| for subject, _, obj in g.triples((None, IO.creates, None)): |
| relation_lookup[(str(subject), str(obj))] = "creates" |
| for triad_idx in triad_ids: |
| ids = [IO[f"T{triad_idx:02d}_{phase}_P{pos}"] for phase in ("adv", "ret") for pos in range(3)] |
| for source in ids: |
| for target in ids: |
| if source == target: |
| continue |
| relation_csv.append({"triad_index": triad_idx, "source": str(source).split("#", 1)[1], |
| "target": str(target).split("#", 1)[1], |
| "relation": relation_lookup.get((str(source), str(target)), "none")}) |
|
|
| assert len(triad_rows["adv"]) == len(triad_rows["ret"]) == 13 |
| assert position_indices == [0, 1, 2] |
| assert len(nodes_csv) == 78 |
| assert len(vector_csv) == 20 |
| assert sum(1 for _ in g.triples((None, IO.creates, None))) == 104 |
| assert len(relation_csv) == 13 * 6 * 5 |
|
|
| out = ROOT / "ontology" / "io_ontology.ttl" |
| out.parent.mkdir(parents=True, exist_ok=True) |
| out.write_text(g.serialize(format="turtle").rstrip() + "\n", encoding="utf-8") |
|
|
| def write_csv(path: Path, rows: list[dict]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("w", newline="", encoding="utf-8") as handle: |
| writer = csv.DictWriter(handle, fieldnames=list(rows[0]), lineterminator="\n") |
| writer.writeheader() |
| writer.writerows(rows) |
|
|
| write_csv(ROOT / "datasets" / "triad_nodes.csv", nodes_csv) |
| write_csv(ROOT / "datasets" / "vector_steps.csv", vector_csv) |
| write_csv(ROOT / "datasets" / "relation_candidates.csv", relation_csv) |
|
|
| _stamp = { |
| "spec_version": SPEC["spec_version"], |
| "schema_version": SPEC.get("schema_version"), |
| "source_date": SPEC.get("source_date"), |
| "purpose_id": (SPEC.get("purpose") or {}).get("id"), |
| "purpose_label": (SPEC.get("purpose") or {}).get("label"), |
| "artifacts": [ |
| "datasets/triad_nodes.csv", |
| "datasets/vector_steps.csv", |
| "datasets/relation_candidates.csv", |
| "ontology/io_ontology.ttl", |
| ], |
| } |
| (ROOT / "datasets" / "GENERATED_FROM.json").write_text( |
| json.dumps(_stamp, ensure_ascii=False, indent=2) + "\n", encoding="utf-8" |
| ) |
| print(f"Tríadas: {n_triads} por fase (índice {index_base}–{index_base + n_triads - 1}); nodos: {len(nodes_csv)}; creates: 104; espejos: 78") |
| print(f"Pasos vectoriales: {len(vector_csv)}; candidatos PI-HGAT-T: {len(relation_csv)}") |
| print(f"OWL/Turtle: {out}") |
| print(f"Sello: datasets/GENERATED_FROM.json spec_version={SPEC['spec_version']}") |
|
|
