Upload dotcausal.py with huggingface_hub

dotcausal.py

@@ -0,0 +1,202 @@
+"""HuggingFace Datasets loader for .causal knowledge graph files."""
+
+import datasets
+from datasets import DatasetInfo, Features, Value, Sequence
+
+
+class CausalConfig(datasets.BuilderConfig):
+    """BuilderConfig for .causal files."""
+
+    def __init__(
+        self,
+        include_inferred: bool = True,
+        min_confidence: float = 0.0,
+        **kwargs,
+    ):
+        """
+        Args:
+            include_inferred: Include inferred triplets (default: True)
+            min_confidence: Minimum confidence threshold (default: 0.0)
+        """
+        super().__init__(**kwargs)
+        self.include_inferred = include_inferred
+        self.min_confidence = min_confidence
+
+
+class CausalDataset(datasets.GeneratorBasedBuilder):
+    """
+    HuggingFace Dataset loader for .causal knowledge graph files.
+
+    The .causal format is a binary knowledge graph with embedded deterministic
+    inference. It provides zero-hallucination fact retrieval with full provenance.
+
+    Usage:
+        from datasets import load_dataset
+
+        # Load from local file
+        ds = load_dataset("chkmie/dotcausal", data_files="knowledge.causal")
+
+        # Load with config
+        ds = load_dataset(
+            "chkmie/dotcausal",
+            data_files="knowledge.causal",
+            include_inferred=True,
+            min_confidence=0.5,
+        )
+
+    Features:
+        - trigger (str): The cause/trigger entity
+        - mechanism (str): The relationship type
+        - outcome (str): The effect/outcome entity
+        - confidence (float): Confidence score (0-1)
+        - is_inferred (bool): Whether derived or explicit
+        - source (str): Original source (e.g., paper)
+        - provenance (list): Source triplets for inferred facts
+
+    References:
+        - PyPI: https://pypi.org/project/dotcausal/
+        - GitHub: https://github.com/DT-Foss/dotcausal
+        - Paper: https://doi.org/10.5281/zenodo.18326222
+    """
+
+    BUILDER_CONFIG_CLASS = CausalConfig
+    BUILDER_CONFIGS = [
+        CausalConfig(
+            name="default",
+            version=datasets.Version("1.0.0"),
+            description="Load all triplets from .causal files",
+        ),
+        CausalConfig(
+            name="explicit_only",
+            version=datasets.Version("1.0.0"),
+            description="Load only explicit triplets (no inferred)",
+            include_inferred=False,
+        ),
+        CausalConfig(
+            name="high_confidence",
+            version=datasets.Version("1.0.0"),
+            description="Load triplets with confidence >= 0.8",
+            min_confidence=0.8,
+        ),
+    ]
+    DEFAULT_CONFIG_NAME = "default"
+
+    def _info(self):
+        return DatasetInfo(
+            description="""\
+.causal knowledge graph dataset with embedded deterministic inference.
+Each row represents a causal triplet (trigger → mechanism → outcome).
+""",
+            features=Features(
+                {
+                    "trigger": Value("string"),
+                    "mechanism": Value("string"),
+                    "outcome": Value("string"),
+                    "confidence": Value("float32"),
+                    "is_inferred": Value("bool"),
+                    "source": Value("string"),
+                    "provenance": Sequence(Value("string")),
+                }
+            ),
+            homepage="https://dotcausal.com",
+            license="MIT",
+            citation="""\
+@article{foss2026causal,
+  author = {Foss, David Tom},
+  title = {The .causal Format: Deterministic Inference for AI-Assisted Hypothesis Amplification},
+  journal = {Zenodo},
+  year = {2026},
+  doi = {10.5281/zenodo.18326222}
+}
+""",
+        )
+
+    def _split_generators(self, dl_manager):
+        """Generate splits from data files."""
+        data_files = self.config.data_files
+
+        if not data_files:
+            raise ValueError(
+                "No data_files specified. Use: load_dataset('chkmie/dotcausal', data_files='your_file.causal')"
+            )
+
+        # Handle different data_files formats
+        if isinstance(data_files, dict):
+            # {"train": ["file1.causal"], "test": ["file2.causal"]}
+            splits = []
+            for split_name, files in data_files.items():
+                if isinstance(files, str):
+                    files = [files]
+                downloaded = dl_manager.download_and_extract(files)
+                splits.append(
+                    datasets.SplitGenerator(
+                        name=split_name,
+                        gen_kwargs={"filepaths": downloaded},
+                    )
+                )
+            return splits
+        elif isinstance(data_files, (list, tuple)):
+            # ["file1.causal", "file2.causal"]
+            downloaded = dl_manager.download_and_extract(list(data_files))
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={"filepaths": downloaded},
+                )
+            ]
+        else:
+            # Single file string
+            downloaded = dl_manager.download_and_extract([data_files])
+            return [
+                datasets.SplitGenerator(
+                    name=datasets.Split.TRAIN,
+                    gen_kwargs={"filepaths": downloaded},
+                )
+            ]
+
+    def _generate_examples(self, filepaths):
+        """Generate examples from .causal files."""
+        try:
+            from dotcausal import CausalReader
+        except ImportError:
+            raise ImportError(
+                "dotcausal package required. Install with: pip install dotcausal"
+            )
+
+        if isinstance(filepaths, str):
+            filepaths = [filepaths]
+
+        idx = 0
+        for filepath in filepaths:
+            reader = CausalReader(filepath)
+
+            # Get all triplets via search
+            results = reader.search("", limit=100000)
+
+            for r in results:
+                # Apply filters from config
+                confidence = r.get("confidence", 1.0)
+                is_inferred = r.get("is_inferred", False)
+
+                if confidence < self.config.min_confidence:
+                    continue
+                if not self.config.include_inferred and is_inferred:
+                    continue
+
+                # Convert provenance to list of strings
+                provenance = r.get("provenance", [])
+                if not isinstance(provenance, list):
+                    provenance = [str(provenance)] if provenance else []
+                else:
+                    provenance = [str(p) for p in provenance]
+
+                yield idx, {
+                    "trigger": r.get("trigger", ""),
+                    "mechanism": r.get("mechanism", ""),
+                    "outcome": r.get("outcome", ""),
+                    "confidence": float(confidence),
+                    "is_inferred": bool(is_inferred),
+                    "source": r.get("source", ""),
+                    "provenance": provenance,
+                }
+                idx += 1