File size: 11,065 Bytes
66f9450 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 | #!/usr/bin/env python3
"""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']}")
|