splittrace 0.1.0__py3-none-any.whl

splittrace/__init__.py

@@ -0,0 +1,4 @@
+"""Audit declared sample provenance, not a guarantee of leakage absence."""
+from .core import audit, map_interval
+
+__all__ = ["audit", "map_interval"]

splittrace/cli.py

@@ -0,0 +1,70 @@
+import argparse
+import csv
+import hashlib
+import html
+import json
+from pathlib import Path
+
+from .core import audit
+
+
+def read_rows(path, samples=False):
+    path = Path(path)
+    if path.suffix.lower() == ".json":
+        rows = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(rows, list) or any(not isinstance(r, dict) for r in rows):
+            raise ValueError("JSON input must be a list of objects")
+        return rows
+    if path.suffix.lower() != ".csv":
+        raise ValueError("inputs must be .csv or .json")
+    with path.open(encoding="utf-8-sig", newline="") as handle:
+        rows = [{k: v for k, v in row.items() if v != ""} for row in csv.DictReader(handle)]
+    if samples:
+        for row in rows:
+            row["parent_ids"] = json.loads(row.get("parent_ids", "[]"))
+            for key in ("start", "end"):
+                if key in row:
+                    row[key] = float(row[key])
+    return rows
+
+
+def html_report(report):
+    """Standalone, script-free report; all user-controlled content is escaped."""
+    body = html.escape(json.dumps(report, ensure_ascii=False, indent=2))
+    return ('<!doctype html><html lang="en"><meta charset="utf-8">'
+            '<meta name="viewport" content="width=device-width,initial-scale=1">'
+            '<title>SplitTrace audit</title><style>body{font:16px system-ui;max-width:1000px;'
+            'margin:40px auto;padding:0 20px}pre{white-space:pre-wrap;overflow-wrap:anywhere;'
+            'font-size:13px}h1{font-size:24px}</style><h1>SplitTrace: ' + report["status"] +
+            '</h1><p>Metadata-only audit. PASS does not certify absence of all leakage. '
+            'This report may contain sample identifiers; review before sharing.</p><pre>' + body + '</pre></html>')
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description="Audit existing signal-ML splits and declared sample lineage.")
+    parser.add_argument("samples", help="CSV or JSON list of provenance nodes")
+    parser.add_argument("assignments", help="CSV or JSON list: sample_id, split, fold")
+    parser.add_argument("--policy", required=True, choices=["cross_subject", "within_recording_future"])
+    parser.add_argument("--lineage-complete", action="store_true", help="Assert all parent relationships are supplied")
+    parser.add_argument("--output", type=Path)
+    parser.add_argument("--html", type=Path)
+    args = parser.parse_args(argv)
+    try:
+        report = audit(read_rows(args.samples, True), read_rows(args.assignments),
+                       policy=args.policy, lineage_complete=args.lineage_complete)
+        report["input_sha256"] = {name: hashlib.sha256(Path(path).read_bytes()).hexdigest()
+                                  for name,path in [("samples",args.samples),("assignments",args.assignments)]}
+        encoded = json.dumps(report, ensure_ascii=False, indent=2)
+        if args.output:
+            args.output.write_text(encoded + "\n", encoding="utf-8")
+        if args.html:
+            args.html.write_text(html_report(report), encoding="utf-8")
+        print(encoded)
+        return {"PASS": 0, "FAIL": 1, "UNKNOWN": 2}[report["status"]]
+    except (ValueError, TypeError, KeyError, OSError) as error:
+        print(json.dumps({"status": "INVALID_INPUT", "error": str(error)}))
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

splittrace/core.py

@@ -0,0 +1,194 @@
+"""Small, deterministic metadata auditor with explicit coverage limits.
+
+Intervals must already refer to ORIGINAL recording coordinates. No signal data
+is inspected and no implicit conversion between clocks or sample rates occurs.
+"""
+from collections import deque
+from itertools import combinations
+from math import isfinite
+
+ROLES = ("train", "validation", "test")
+RULES = ("sample_identity", "subject", "lineage", "interval", "chronology")
+
+
+def map_interval(start, end, *, origin_offset, original_units_per_local_unit):
+    """Explicit affine mapping to original coordinates (e.g. resampled indices).
+
+    Only positive linear transforms are supported. Caller supplies provenance;
+    this does not infer clocks, filtering support, padding or nonlinear warps.
+    """
+    values = (start, end, origin_offset, original_units_per_local_unit)
+    if any(isinstance(v, bool) or not isinstance(v, (float, int)) or not isfinite(v) for v in values):
+        raise ValueError("mapping values must be finite numbers")
+    if start >= end or original_units_per_local_unit <= 0:
+        raise ValueError("mapping needs start < end and a positive scale")
+    mapped = (origin_offset + start * original_units_per_local_unit,
+              origin_offset + end * original_units_per_local_unit)
+    if not all(isfinite(v) for v in mapped) or mapped[0] >= mapped[1]:
+        raise ValueError("mapping overflow or collapsed interval")
+    return mapped
+
+
+def _id(value, name):
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{name} must be a nonempty string")
+    return value
+
+
+def _nodes(samples):
+    nodes = {}
+    for item in samples:
+        item = dict(item)
+        sid = _id(item.get("sample_id"), "sample_id")
+        if sid in nodes:
+            raise ValueError(f"duplicate sample_id: {sid}")
+        kind = item.setdefault("kind", "sample")
+        if kind not in ("sample", "recording"):
+            raise ValueError("kind must be sample or recording")
+        parents = item.setdefault("parent_ids", [])
+        if not isinstance(parents, list) or len(set(map(str, parents))) != len(parents):
+            raise ValueError("parent_ids must be a list without duplicates")
+        for parent in parents:
+            _id(parent, "parent_id")
+        for key in ("subject_id", "recording_id", "coordinate_system"):
+            if item.get(key) is not None:
+                _id(item[key], key)
+        start, end = item.get("start"), item.get("end")
+        if (start is None) != (end is None):
+            raise ValueError("start and end must be supplied together")
+        if start is not None:
+            if any(isinstance(v, bool) or not isinstance(v, (float, int)) or not isfinite(v)
+                   for v in (start, end)) or start >= end:
+                raise ValueError("interval must have finite numeric start < end")
+            if not item.get("recording_id") or not item.get("coordinate_system"):
+                raise ValueError("interval needs recording_id and coordinate_system")
+        nodes[sid] = item
+    if not nodes:
+        raise ValueError("samples must not be empty")
+    # Iterative topological ordering: no recursion-limit failure on long chains.
+    children = {sid: [] for sid in nodes}
+    indegree = {}
+    for sid, node in nodes.items():
+        indegree[sid] = len(node["parent_ids"])
+        for parent in node["parent_ids"]:
+            if parent not in nodes:
+                raise ValueError(f"missing parent {parent} referenced by {sid}")
+            children[parent].append(sid)
+    ready = deque(sorted(sid for sid, count in indegree.items() if count == 0))
+    order = []
+    while ready:
+        sid = ready.popleft()
+        order.append(sid)
+        for child in sorted(children[sid]):
+            indegree[child] -= 1
+            if indegree[child] == 0:
+                ready.append(child)
+    if len(order) != len(nodes):
+        raise ValueError("cycle in parent_ids")
+    # One deterministic witness path per ancestor, including the node itself.
+    paths = {}
+    for sid in order:
+        paths[sid] = {sid: [sid]}
+        for parent in sorted(nodes[sid]["parent_ids"]):
+            for ancestor, path in paths[parent].items():
+                paths[sid].setdefault(ancestor, [sid] + path)
+    return nodes, paths
+
+
+def audit(samples, assignments, *, policy, lineage_complete=False, max_findings=1000):
+    """Return JSON-serializable findings for each independent fold.
+
+    policy: cross_subject OR within_recording_future.
+    lineage_complete: user's declaration that all parent relationships are given.
+    Max findings limits returned examples, NEVER the underlying failure counts.
+    Unknown metadata fails closed (UNKNOWN) unless a proven violation makes FAIL.
+    All comparisons are within each fold; ordinary cross-fold reuse is allowed.
+    """
+    if policy not in ("cross_subject", "within_recording_future"):
+        raise ValueError("explicit policy must be cross_subject or within_recording_future")
+    if not isinstance(lineage_complete, bool):
+        raise ValueError("lineage_complete must be boolean")
+    if isinstance(max_findings, bool) or not isinstance(max_findings, int) or max_findings < 0:
+        raise ValueError("max_findings must be a nonnegative integer")
+    nodes, paths = _nodes(samples)
+    folds, seen = {}, set()
+    for row in assignments:
+        sid = _id(row.get("sample_id"), "assignment sample_id")
+        fold = _id(row.get("fold", "0"), "fold")
+        role = row.get("split")
+        if sid not in nodes or nodes[sid]["kind"] != "sample":
+            raise ValueError(f"assignment must reference a sample: {sid}")
+        if role not in ROLES:
+            raise ValueError("split must be train, validation or test")
+        key = (fold, role, sid)
+        if key in seen:
+            raise ValueError(f"duplicate assignment: {key}")
+        seen.add(key)
+        folds.setdefault(fold, {}).setdefault(role, []).append(sid)
+    if not folds:
+        raise ValueError("assignments must not be empty")
+    findings, counts, fold_results = [], {r: 0 for r in RULES}, []
+    for fold, groups in sorted(folds.items()):
+        if "train" not in groups or not any(r in groups for r in ("validation", "test")):
+            raise ValueError(f"fold {fold} needs train and an evaluation partition")
+        state = {r: {"violations": 0, "unknown_pairs": 0} for r in RULES}
+
+        def emit(rule, left, right, left_role, right_role, evidence):
+            counts[rule] += 1
+            state[rule]["violations"] += 1
+            if len(findings) < max_findings:
+                findings.append(dict(rule=rule, fold=fold, left=left, right=right,
+                                     left_split=left_role, right_split=right_role, evidence=evidence))
+
+        for left_role, right_role in combinations([r for r in ROLES if r in groups], 2):
+            for left in sorted(groups[left_role]):
+                for right in sorted(groups[right_role]):
+                    a, b = nodes[left], nodes[right]
+                    args = (left, right, left_role, right_role)
+                    if left == right:
+                        emit("sample_identity", *args, {"sample_id": left})
+                    if policy == "cross_subject":
+                        if a.get("subject_id") is None or b.get("subject_id") is None:
+                            state["subject"]["unknown_pairs"] += 1
+                        elif a["subject_id"] == b["subject_id"]:
+                            emit("subject", *args, {"subject_id": a["subject_id"]})
+                    common = sorted(set(paths[left]) & set(paths[right]))
+                    # A whole recording may legitimately feed both partitions.
+                    # Shared example ancestors (e.g. one augmented epoch) may not.
+                    example_ancestors = [s for s in common if nodes[s]["kind"] == "sample"]
+                    if example_ancestors:
+                        ancestor = min(example_ancestors, key=lambda s: (len(paths[left][s]) + len(paths[right][s]), s))
+                        emit("lineage", *args, {"ancestor": ancestor,
+                            "left_path": paths[left][ancestor], "right_path": paths[right][ancestor]})
+                    if not lineage_complete:
+                        state["lineage"]["unknown_pairs"] += 1
+                    complete = all(n.get(k) is not None for n in (a, b)
+                                   for k in ("recording_id", "coordinate_system", "start", "end"))
+                    comparable = complete and a["recording_id"] == b["recording_id"] and a["coordinate_system"] == b["coordinate_system"]
+                    if not complete or (a.get("recording_id") == b.get("recording_id") and not comparable):
+                        state["interval"]["unknown_pairs"] += 1
+                    elif comparable:
+                        start, end = max(a["start"], b["start"]), min(a["end"], b["end"])
+                        if start < end:
+                            emit("interval", *args, {"recording_id": a["recording_id"],
+                                "coordinate_system": a["coordinate_system"],
+                                "overlap_start": start, "overlap_end": end, "overlap_length": end-start})
+                    if policy == "within_recording_future":
+                        if not comparable:
+                            state["chronology"]["unknown_pairs"] += 1
+                        elif a["end"] > b["start"]:
+                            emit("chronology", *args, {"earlier_split_end": a["end"],
+                                "later_split_start": b["start"], "recording_id": a["recording_id"]})
+        for rule, details in state.items():
+            skip = (rule == "subject" and policy != "cross_subject") or (rule == "chronology" and policy != "within_recording_future")
+            details["status"] = "SKIP" if skip else "FAIL" if details["violations"] else "UNKNOWN" if details["unknown_pairs"] else "PASS"
+        fold_results.append({"fold": fold, "partition_sizes": {r:len(ids) for r,ids in groups.items()}, "checks": state})
+    statuses = [check["status"] for f in fold_results for check in f["checks"].values()]
+    verdict = "FAIL" if "FAIL" in statuses else "UNKNOWN" if "UNKNOWN" in statuses else "PASS"
+    return {"schema_version": 1, "policy": policy, "lineage_complete": lineage_complete,
+            "status": verdict, "folds": fold_results, "violation_counts": counts,
+            "findings": findings, "findings_truncated": sum(counts.values()) > len(findings),
+            "limitations": ["Checks declared metadata only; PASS is not proof of absence of all leakage.",
+                            "Coordinates must already be mapped to the original recording; no implicit conversion.",
+                            "No nested-CV, signal similarity, fitted-preprocessing or target-availability audit.",
+                            "Quadratic pair scan: prototype for small manifests, not large-scale production."]}

splittrace-0.1.0.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: splittrace
+Version: 0.1.0
+Summary: Metadata-first audit of derived samples across existing ML splits
+Author: Ryu Koda
+License-Expression: MIT
+Project-URL: Repository, https://github.com/R-Koda/splittrace
+Project-URL: Issues, https://github.com/R-Koda/splittrace/issues
+Keywords: data-leakage,cross-validation,eeg,provenance,machine-learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# SplitTrace — trace data leakage back to its source
+
+[![Tests](https://github.com/R-Koda/splittrace/actions/workflows/tests.yml/badge.svg)](https://github.com/R-Koda/splittrace/actions/workflows/tests.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+**Experimental Python library for auditing existing EEG and sensor-data splits.**
+
+Audit existing train/validation/test assignments for EEG and sensor experiments.
+Trace derived examples back through declared parent IDs, inspect intervals in
+original-recording coordinates, and return evidence for each violation.
+
+Different filenames and different pixel values can still come from the same
+source epoch. SplitTrace accepts declared parent relationships and reports the
+path that connects a training example to an evaluation example:
+
+```text
+train: a → image-01 → epoch-01 ← b :test
+                     ^ shared source example
+```
+
+It also checks subject mixing, overlapping source intervals and, under an explicit
+policy, chronological ordering. Missing metadata is **UNKNOWN**, not a clean bill
+of health. All bundled examples are synthetic; no patient data is included.
+
+**Early prototype:** small manifests only, with no real-user validation yet.
+The distribution name and import name are both `splittrace`.
+
+日本語の試用手順は [PILOT.md](https://github.com/R-Koda/splittrace/blob/main/PILOT.md)。実行済みの比較結果は
+[results/comparison.html](https://github.com/R-Koda/splittrace/blob/main/results/comparison.html)、派生元追跡の出力例は
+[results/derived-audit.html](https://github.com/R-Koda/splittrace/blob/main/results/derived-audit.html) を開いてください。
+
+## Install from PyPI / pipでインストール
+
+Python 3.10 or later. Create and activate a virtual environment first:
+
+```sh
+python3 -m venv .venv
+```
+
+macOS / Linux: `source .venv/bin/activate`
+
+Windows PowerShell: `.venv\Scripts\Activate.ps1`
+
+```sh
+python -m pip install splittrace
+splittrace --help
+```
+
+The help screen confirms that the command is available. Install only the tools you need.
+[PyPI package](https://pypi.org/project/splittrace/) · [Source and examples](https://github.com/R-Koda/splittrace)
+
+サンプルCSV・Notebookなどはpipでは配置されません。公開デモはブラウザで開けます。自分でサンプルを実行する場合はGitHubの「Code → Download ZIP」で取得・展開し、READMEの相対パスをそのフォルダー内から指定してください。
+
+## Article & live demo / 紹介記事と公開デモ
+
+- [個別ガイド / SplitTrace：データ分割の混入を派生元から点検する](https://ryu-koda.com/blog/splittrace-data-leakage-check/)
+- [紹介記事：データを分ける・評価する・公開する。Pythonの小さな確認ツールを3つ作りました](https://ryu-koda.com/blog/python-tools-splittrace-eventscore-notebook/) — Japanese overview of SplitTrace, EventScore Explorer, and Notebook Publish Check.
+- [公開デモをブラウザで開く / Open the live demo](https://ryu-koda.com/articles/python-tools/splittrace-demo.html) — Synthetic data only; no installation required.
+
+公開デモは合成データの出力例です。自分のファイルをアップロードする画面ではありません。
+The hosted demo is a sample report, not a file-upload service.
+
+## Run without installing anything
+
+Python 3.10+; the core and CLI use only the standard library.
+
+```sh
+git clone https://github.com/R-Koda/splittrace.git
+cd splittrace
+```
+
+From the repository directory:
+
+```sh
+PYTHONPATH=src python3 -m splittrace.cli \
+  examples/derived-samples.json examples/derived-assignments.json \
+  --policy cross_subject --lineage-complete \
+  --output results/local-audit.json --html results/local-audit.html
+```
+
+This intentionally leaking example exits **1**; that is the expected result,
+not an installation error. The report contains the paths
+`a → image-01 → epoch-01` and `b → epoch-01`. No signal values are read.
+CLI exit codes: `0` = all applicable checks PASS; `1` = a declared policy violation;
+`2` = UNKNOWN coverage or invalid input (inspect `status` to distinguish them).
+
+For an editable install in your own virtual environment:
+
+```sh
+python3 -m venv .venv
+.venv/bin/python -m pip install -e .
+.venv/bin/splittrace --help
+```
+
+## Python API
+
+```python
+from splittrace import audit, map_interval
+
+samples = [
+    {"sample_id": "epoch-01"},
+    {"sample_id": "image-01", "parent_ids": ["epoch-01"]},
+    {"sample_id": "a", "parent_ids": ["image-01"]},
+    {"sample_id": "b", "parent_ids": ["epoch-01"]},
+]
+assignments = [
+    {"sample_id": "a", "split": "train", "fold": "0"},
+    {"sample_id": "b", "split": "test", "fold": "0"},
+]
+report = audit(samples, assignments, policy="cross_subject", lineage_complete=True)
+assert report["status"] == "FAIL"
+# Other checks remain UNKNOWN when their required metadata is absent.
+
+# Convert a local, resampled interval to original sample coordinates explicitly:
+start, end = map_interval(0, 128, origin_offset=256, original_units_per_local_unit=2)
+assert (start, end) == (256, 512)
+```
+
+## Data contract
+
+Samples are dictionaries / JSON objects. CSV is also accepted; its `parent_ids`
+cell must be a JSON array, quoted following normal CSV rules. Blank optional CSV
+cells are missing metadata. Numeric interval cells are parsed as floats.
+
+- `sample_id`: nonempty, globally unique string. Reference nodes may exist without
+  assignment to a split. Parent references must resolve; cycles are rejected.
+- `parent_ids`: list of directly contributing source-example IDs. Declare all
+  parents for mixtures. Examples sharing a sample ancestor are flagged across
+  partitions. This is a conservative **source-example separation policy**, not a
+  statistical proof that all shared ancestry invalidates every evaluation.
+- `kind`: `sample` (default) or `recording`. A whole raw recording used as a graph
+  parent should be `recording`; merely sharing that parent does not fail lineage.
+  Interval or subject checks still apply. Do not label an actual shared training
+  example as a recording to bypass the check.
+- `subject_id`: canonical ID; namespace IDs that are only unique within a site.
+- `recording_id`: canonical original-recording ID, not a derived filename.
+- `coordinate_system`: explicit common coordinate label, e.g.
+  `original-samples-256hz` or `original-seconds`.
+- `start`, `end`: finite values in that original coordinate system, `[start,end)`.
+  Touching intervals are not overlapping. Values are not rounded implicitly.
+
+The library does not automatically inherit time intervals or subject metadata
+through arbitrary transformations. Attach canonical metadata to assigned leaves.
+`map_interval` only implements a supplied positive affine mapping. Nonlinear
+warps, filter support, padding and unknown clock shifts require user-provided
+provenance or must remain unverified.
+
+Assignments contain `sample_id`, `split` (`train`, `validation`, `test`) and `fold`
+(string, default `"0"`). Each fold needs train and an evaluation partition. All
+partition pairs within a fold are checked. Ordinary reuse across independent
+folds is allowed; nested-CV semantics are not implemented.
+
+## Policies and coverage
+
+- `cross_subject`: subject IDs must not cross partitions. No global time ordering
+  is required. Shared source examples and raw interval overlap are also checked.
+- `within_recording_future`: subject sharing is allowed; within each common
+  recording/coordinate system, train must end no later than validation/test
+  starts, and validation must precede test. Cross-recording chronological claims
+  are UNKNOWN because clocks are not assumed comparable. This narrowly scoped
+  policy does not audit future-target availability or preprocessing fit history.
+
+`lineage_complete=True` is a declaration by the caller, not something the library
+can prove. Omitting it makes lineage coverage UNKNOWN even if no shared ancestor
+was found. Missing subject or interval metadata makes affected checks UNKNOWN.
+A proven violation makes the overall result FAIL even if other checks are UNKNOWN.
+PASS means only that the supplied metadata satisfies the applicable rules.
+
+Results include per-fold checks, unknown-pair counts, violation counts and evidence
+paths. `max_findings` limits returned examples, not failure counts. HTML/JSON
+reports include identifiers and paths; keep them local or redact before sharing.
+The tool performs no network requests, uploads, model training or automatic edits.
+
+## Validation performed
+
+On 2026-11-09, Python 3.14.7:
+
+- 23 standard-library tests passed, including malformed manifests, parent cycles,
+  multiple parents, interval boundaries, coordinate mapping, missing metadata,
+  ordinary K-fold reuse, validation/test contamination and HTML escaping.
+- 7 synthetic scenarios matched their expected PASS/FAIL/UNKNOWN outcomes.
+- Compared against **leakfence 0.5.0**, NumPy 2.5.4 in an isolated environment.
+  Subject mixing and interval overlap were detected by both tools. Clean splits
+  were not flagged. The full machine-readable output is `results/comparison.json`.
+
+In the derived-source case, leakfence's native input has no parent-graph field.
+Calling it with only the available native metadata produced no flag; that is not
+a safety verdict. **Manually grouping leaves by source also made leakfence detect
+the problem.** Our demonstrated distinction is accepting the parent graph and
+returning the chain of evidence, not a uniquely powerful detection algorithm.
+
+The comparison uses the same available supported metadata, with the manual
+source-group adapter shown separately. It is a small functional comparison, not
+an independent benchmark, speed test, accuracy improvement, or proof of demand.
+Deepchecks and other competitors were not executed in this prototype comparison.
+
+Reproduce tests and the nearest-competitor comparison:
+
+```sh
+PYTHONPATH=src python3 -m unittest discover -s tests -v
+python3 -m venv /tmp/splittrace-comparison
+/tmp/splittrace-comparison/bin/python -m pip install -r requirements-comparison.txt
+/tmp/splittrace-comparison/bin/python scripts/compare.py
+```
+
+## Deliberate limits
+
+Pairwise scanning is quadratic in partition sizes; ancestor-path storage also
+grows with graph size/depth. Use small manifests. There is no performance claim.
+No approximate content matching, nested-CV audit, persistent exception management,
+automatic clock recovery, preprocessing tracing, causal/label leakage analysis or
+proof of independence is implemented. Synthetic tests are not real-user validation.
+
+Feedback is welcome from EEG, wearable-sensor and other windowed-signal projects:
+can you supply source IDs/coordinates, and does a provenance path help you fix a
+split? See [CONTRIBUTING.md](https://github.com/R-Koda/splittrace/blob/main/CONTRIBUTING.md) and the Japanese [trial guide](https://github.com/R-Koda/splittrace/blob/main/PILOT.md).
+
+## References
+
+- [leakfence](https://github.com/ptapal/leakfence)
+- [Deepchecks train-test validation](https://docs.deepchecks.com/stable/api/generated/deepchecks.tabular.suites.train_test_validation.html)
+- [bioLeak](https://github.com/selcukorkmaz/bioLeak)
+
+This prototype contains no copied competitor implementation. Optional comparison
+dependencies retain their own licenses and are installed separately.
+
+## License
+
+[MIT](https://github.com/R-Koda/splittrace/blob/main/LICENSE). Copyright (c) 2026 Ryu Koda.

splittrace-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+splittrace/__init__.py,sha256=Jwghan426MN0ra9fJY2R6Ewc_97WhFYXHIPbdWvjngA,151
+splittrace/cli.py,sha256=pdNF3l11prR6sMQIcUeHjkv7VKMY5b0L0ujKIOTQlGI,3367
+splittrace/core.py,sha256=gzSslCR1nKYgFSttouzVjDv8TzPyXNzapALRns5-Fh4,11000
+splittrace-0.1.0.dist-info/licenses/LICENSE,sha256=g92amfOtr0v2qgLJkCaw1xM9vtUm6PuYqjNM5rUYReE,1065
+splittrace-0.1.0.dist-info/METADATA,sha256=JAkcL4_kqt-TYd1h0xxbiGWq7nbrxzg32w5waRrieeU,12161
+splittrace-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+splittrace-0.1.0.dist-info/entry_points.txt,sha256=o_z4-hEqty3zFUgigWDt9WNDjciBV1SgjtZhutiz42c,51
+splittrace-0.1.0.dist-info/top_level.txt,sha256=yG-_ixhhEk_j318DZ-V3Vx-dly47HBH3FaQpePllsjk,11
+splittrace-0.1.0.dist-info/RECORD,,

splittrace-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

splittrace-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+splittrace = splittrace.cli:main

splittrace-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryu Koda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

splittrace-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+splittrace