causalphylo 0.1.0__py3-none-any.whl

causalphylo/__init__.py

@@ -0,0 +1,80 @@
+"""
+CausalPhylo — identification over mixed-evidence knowledge graphs.
+
+Two questions, kept separate on purpose.
+
+:mod:`causalphylo.graph_semantics` asks which edges may carry a causal
+claim at all. A graph assembled from public sources mixes mechanistic,
+directed assertions with mere co-occurrence; running do-calculus over
+the second kind assumes the very thing the method is meant to establish.
+
+:mod:`causalphylo.backdoor` asks, on the admissible subgraph, whether a
+causal effect is identifiable — Pearl's backdoor criterion, reporting
+*why* identification failed rather than merely that it did.
+
+Both operate on plain :class:`networkx.DiGraph` objects whose edges
+carry ``edge_type`` and ``evidence_class`` attributes. The package has
+no domain model of its own and no dependency beyond NetworkX.
+
+``find_adjustment_set`` takes the full graph and restricts to the
+admissible acyclic core itself, so no caller can forget that step.
+
+>>> import networkx as nx
+>>> from causalphylo import find_adjustment_set
+>>> G = nx.DiGraph()
+>>> G.add_edge("U", "X", edge_type="activates", evidence_class="regulatory")
+>>> G.add_edge("U", "D", edge_type="associated_with",
+...            evidence_class="genetic_association")
+>>> G.add_edge("X", "D", edge_type="associated_with",
+...            evidence_class="genetic_association")
+>>> verdict = find_adjustment_set(G, "X", "D")
+>>> verdict.identifiable
+True
+>>> verdict.adjustment_set
+('U',)
+>>> verdict.reason.value
+'identifiable_by_adjustment'
+"""
+
+from __future__ import annotations
+
+from causalphylo.backdoor import (
+    MAX_ADJUSTMENT_SET_SIZE,
+    MAX_CANDIDATE_POOL,
+    Identification,
+    IdentificationReason,
+    confounding_sensitivity,
+    find_adjustment_set,
+    mutilated_graph,
+    satisfies_backdoor,
+)
+from causalphylo.graph_semantics import (
+    CAUSAL_EDGE_TYPES,
+    GENETIC_EVIDENCE_CLASSES,
+    AcyclicCore,
+    acyclic_core,
+    causal_subgraph,
+    cyclic_components,
+    is_causal_admissible,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "CAUSAL_EDGE_TYPES",
+    "GENETIC_EVIDENCE_CLASSES",
+    "MAX_ADJUSTMENT_SET_SIZE",
+    "MAX_CANDIDATE_POOL",
+    "AcyclicCore",
+    "Identification",
+    "IdentificationReason",
+    "__version__",
+    "acyclic_core",
+    "causal_subgraph",
+    "confounding_sensitivity",
+    "cyclic_components",
+    "find_adjustment_set",
+    "is_causal_admissible",
+    "mutilated_graph",
+    "satisfies_backdoor",
+]

causalphylo/backdoor.py

@@ -0,0 +1,247 @@
+"""
+Pearl's backdoor criterion, and an honest verdict when it cannot be met.
+
+Z satisfies the backdoor criterion relative to (X, Y) when no node in Z
+is a descendant of X, and Z blocks every path between X and Y that
+starts with an arrow into X (Pearl, *Causality*, 2nd ed., Def. 3.3.1).
+Both halves matter: the descendant condition rules out conditioning on
+a mediator or a collider downstream of the treatment, and blocking only
+the *backdoor* paths -- never the causal path itself -- is what a
+plain d-separation test does not do for free. To test the second half
+with a generic d-separation routine, the edges leaving the treatment
+are removed first: that deletes the causal path (and anything X causes)
+while leaving every backdoor path, the ones entering X through an
+arrow, exactly as they were.
+
+This module reports *why* identification failed, not merely that it did.
+The reasons are a closed enum so that a run's failures aggregate into a
+distribution rather than a pile of prose.
+
+A note on trivial identification. When no confounder appears in the
+graph, the empty set satisfies the criterion and the effect is
+identifiable -- but a knowledge graph is open-world, and a missing edge
+is missing knowledge rather than evidence of no confounding. So a
+trivial verdict is reported under its own reason and carries
+``n_near_miss_confounders``: how many nodes regulate the treatment and
+have *some* association with the outcome that fell short of admissibility.
+A target with many near misses is fragile. This is the same move as an
+E-value in observational epidemiology -- not "there is no confounding"
+but "here is how much it would take to break this".
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+from itertools import combinations
+
+import networkx as nx
+
+from causalphylo.graph_semantics import acyclic_core, causal_subgraph
+
+# A larger bound buys little and costs combinatorially: the number of
+# candidate subsets grows as C(pool, size). Reaching the bound is
+# reported via Identification.search_truncated, never hidden.
+MAX_ADJUSTMENT_SET_SIZE = 3
+MAX_CANDIDATE_POOL = 20
+
+__all__ = [
+    "MAX_ADJUSTMENT_SET_SIZE",
+    "MAX_CANDIDATE_POOL",
+    "Identification",
+    "IdentificationReason",
+    "confounding_sensitivity",
+    "find_adjustment_set",
+    "mutilated_graph",
+    "satisfies_backdoor",
+]
+
+
+class IdentificationReason(StrEnum):
+    """Why identification succeeded or failed. A closed set."""
+
+    IDENTIFIABLE_BY_ADJUSTMENT = "identifiable_by_adjustment"
+    IDENTIFIABLE_TRIVIALLY = "identifiable_trivially"
+    NO_CAUSAL_PATH = "no_causal_path"
+    CYCLIC_COMPONENT = "cyclic_component"
+    NO_VALID_ADJUSTMENT_SET = "no_valid_adjustment_set"
+    TREATMENT_ABSENT = "treatment_absent"
+    OUTCOME_ABSENT = "outcome_absent"
+
+
+@dataclass(frozen=True)
+class Identification:
+    """The verdict on one (treatment, outcome) pair."""
+
+    identifiable: bool
+    adjustment_set: tuple[str, ...]
+    reason: IdentificationReason
+    search_truncated: bool = False
+    n_near_miss_confounders: int = 0
+
+
+def mutilated_graph(G: nx.DiGraph, treatment: str) -> nx.DiGraph:
+    """G with every edge into ``treatment`` removed. G is not modified."""
+    mutilated = G.copy()
+    mutilated.remove_edges_from(list(G.in_edges(treatment)))
+    return mutilated
+
+
+def satisfies_backdoor(
+    G: nx.DiGraph,
+    treatment: str,
+    outcome: str,
+    adjustment: frozenset[str],
+) -> bool:
+    """Whether ``adjustment`` satisfies the backdoor criterion.
+
+    ``G`` must be a DAG containing both nodes; callers reach this through
+    ``find_adjustment_set``, which guarantees that.
+    """
+    if treatment in adjustment or outcome in adjustment:
+        return False
+
+    if adjustment & nx.descendants(G, treatment):
+        return False
+
+    # The backdoor criterion asks whether Z blocks every path between
+    # X and Y that starts with an arrow *into* X -- it says nothing
+    # about the causal path itself. Testing that with a generic
+    # d-separation routine means removing X's *out*-edges first, so the
+    # direct causal edge (and any directed path through it) cannot
+    # register as "still connected" and mask an open backdoor path.
+    # This is a different mutilation from ``mutilated_graph``, which
+    # removes edges *into* the treatment for the interventional graph
+    # G_X-bar used elsewhere (e.g. the do-operator's truncated
+    # factorization); the two must not be confused.
+    backdoor_graph = G.copy()
+    backdoor_graph.remove_edges_from(list(G.out_edges(treatment)))
+
+    return bool(
+        nx.is_d_separator(
+            backdoor_graph,
+            {treatment},
+            {outcome},
+            set(adjustment),
+        )
+    )
+
+
+def confounding_sensitivity(
+    dag: nx.DiGraph,
+    full_graph: nx.DiGraph,
+    treatment: str,
+    outcome: str,
+) -> int:
+    """Count near-miss confounders of ``treatment`` and ``outcome``.
+
+    A near miss is a node that reaches the treatment in the causal DAG
+    and carries some edge to the outcome in the full graph that was not
+    admissible -- a literature association, a shared pathway. Each one is
+    a confounder the graph hints at but does not license adjusting for.
+    """
+    if treatment not in dag:
+        return 0
+
+    ancestors = nx.ancestors(dag, treatment)
+    admissible_parents = set(dag.predecessors(outcome)) if outcome in dag else set()
+
+    return sum(
+        1
+        for node in ancestors
+        if node not in admissible_parents
+        and full_graph.has_edge(node, outcome)
+    )
+
+
+def find_adjustment_set(
+    G: nx.DiGraph,
+    treatment: str,
+    outcome: str,
+) -> Identification:
+    """Search for a minimal valid backdoor adjustment set.
+
+    ``G`` is the *full* disease graph. Restriction to the causal subgraph
+    and to its acyclic core happens here, so no caller can forget it.
+    """
+    causal = causal_subgraph(G)
+    core = acyclic_core(causal)
+    dag = core.dag
+
+    if treatment in core.excluded or outcome in core.excluded:
+        return Identification(
+            identifiable=False,
+            adjustment_set=(),
+            reason=IdentificationReason.CYCLIC_COMPONENT,
+        )
+
+    # TREATMENT_ABSENT / OUTCOME_ABSENT mean the node does not exist in
+    # the graph at all -- a typo, a stale ID. That is a different fact
+    # from a node that exists but has no causal-admissible edge: such a
+    # node is dropped from ``dag`` by causal_subgraph, and reporting it
+    # as "absent" would blame the query when the honest complaint is
+    # that there is no causal path in what evidence exists. So presence
+    # is checked against the full input graph, not against ``dag``.
+    if treatment not in G:
+        return Identification(
+            identifiable=False,
+            adjustment_set=(),
+            reason=IdentificationReason.TREATMENT_ABSENT,
+        )
+
+    if outcome not in G:
+        return Identification(
+            identifiable=False,
+            adjustment_set=(),
+            reason=IdentificationReason.OUTCOME_ABSENT,
+        )
+
+    if (
+        treatment not in dag
+        or outcome not in dag
+        or not nx.has_path(dag, treatment, outcome)
+    ):
+        return Identification(
+            identifiable=False,
+            adjustment_set=(),
+            reason=IdentificationReason.NO_CAUSAL_PATH,
+        )
+
+    if satisfies_backdoor(dag, treatment, outcome, frozenset()):
+        return Identification(
+            identifiable=True,
+            adjustment_set=(),
+            reason=IdentificationReason.IDENTIFIABLE_TRIVIALLY,
+            n_near_miss_confounders=confounding_sensitivity(
+                dag, G, treatment, outcome,
+            ),
+        )
+
+    descendants = nx.descendants(dag, treatment)
+    pool = sorted(
+        (
+            node for node in dag.nodes()
+            if node not in descendants
+            and node not in (treatment, outcome)
+        ),
+        key=lambda n: (-dag.nodes[n].get("score", 0.0), n),
+    )
+    truncated = len(pool) > MAX_CANDIDATE_POOL
+    pool = pool[:MAX_CANDIDATE_POOL]
+
+    for size in range(1, MAX_ADJUSTMENT_SET_SIZE + 1):
+        for candidate in combinations(pool, size):
+            if satisfies_backdoor(dag, treatment, outcome, frozenset(candidate)):
+                return Identification(
+                    identifiable=True,
+                    adjustment_set=tuple(sorted(candidate)),
+                    reason=IdentificationReason.IDENTIFIABLE_BY_ADJUSTMENT,
+                    search_truncated=truncated,
+                )
+
+    return Identification(
+        identifiable=False,
+        adjustment_set=(),
+        reason=IdentificationReason.NO_VALID_ADJUSTMENT_SET,
+        search_truncated=truncated or len(pool) > MAX_ADJUSTMENT_SET_SIZE,
+    )

causalphylo/graph_semantics.py

@@ -0,0 +1,133 @@
+"""
+Which edges may carry a causal claim.
+
+A disease graph assembled from public sources mixes two kinds of edge.
+Some assert a mechanism with a direction: OmniPath's signed regulatory
+interactions, where a curator has said that A acts on B. Others assert
+only that two things occur together: a literature co-mention, membership
+of a shared pathway, an undirected protein interaction whose arrow exists
+because one protein landed in the first column of an API response.
+
+Do-calculus over the second kind assumes the very thing a causal method
+is supposed to establish. So this module partitions the edge types and
+identification runs only on the causal-admissible subgraph. Associational
+edges keep contributing to evidence scoring; they stop being arrows.
+
+Gene -> disease is admitted only on genetic evidence. A germline variant
+is randomised at conception, so a genetic association carries a
+natural-experiment warrant that a co-mention does not -- the Mendelian
+randomisation argument (Davey Smith & Ebrahim, 2003, Int J Epidemiol
+32:1-22). That warrant is what earns the arrow.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import networkx as nx
+
+# Directed, mechanistic, with an asserted direction.
+CAUSAL_EDGE_TYPES: frozenset[str] = frozenset({
+    "activates",
+    "inhibits",
+    "phosphorylates",
+    "regulates",
+    "upregulates",
+    "downregulates",
+    "causes",
+})
+
+# Gene -> disease edge types, admissible only under genetic evidence.
+_ASSOCIATION_EDGE_TYPES: frozenset[str] = frozenset({"associated_with"})
+
+GENETIC_EVIDENCE_CLASSES: frozenset[str] = frozenset({
+    "genetic_association",
+    "somatic_mutation",
+})
+
+__all__ = [
+    "CAUSAL_EDGE_TYPES",
+    "GENETIC_EVIDENCE_CLASSES",
+    "AcyclicCore",
+    "acyclic_core",
+    "causal_subgraph",
+    "cyclic_components",
+    "is_causal_admissible",
+]
+
+
+def is_causal_admissible(attrs: dict) -> bool:
+    """Whether an edge with these attributes may carry a causal claim.
+
+    Parameters
+    ----------
+    attrs
+        Edge attribute mapping, as stored on the NetworkX graph. Reads
+        ``edge_type`` and ``evidence_class``.
+    """
+    edge_type = attrs.get("edge_type", "")
+    if edge_type in CAUSAL_EDGE_TYPES:
+        return True
+    if edge_type in _ASSOCIATION_EDGE_TYPES:
+        return attrs.get("evidence_class", "") in GENETIC_EVIDENCE_CLASSES
+    return False
+
+
+def causal_subgraph(G: nx.DiGraph) -> nx.DiGraph:
+    """The subgraph of causal-admissible edges, attributes preserved.
+
+    Nodes left with no admissible edge are dropped: a node that
+    participates in no causal relation cannot be a treatment, an
+    outcome, or a confounder.
+    """
+    admissible = [
+        (u, v) for u, v, attrs in G.edges(data=True)
+        if is_causal_admissible(attrs)
+    ]
+    return G.edge_subgraph(admissible).copy()
+
+
+def cyclic_components(G: nx.DiGraph) -> list[frozenset[str]]:
+    """Strongly connected components with cycles, including self-loops."""
+    cyclic = []
+    for component in nx.strongly_connected_components(G):
+        # Non-trivial SCC (more than one node)
+        if len(component) > 1:
+            cyclic.append(frozenset(component))
+        # Single node with self-loop
+        elif len(component) == 1:
+            node = next(iter(component))
+            if G.has_edge(node, node):
+                cyclic.append(frozenset(component))
+    return cyclic
+
+
+@dataclass(frozen=True)
+class AcyclicCore:
+    """A DAG carved out of a possibly-cyclic graph, and what was removed.
+
+    ``excluded`` names every node that sat in a feedback loop. Those
+    nodes are not silently repaired: d-separation is undefined on them,
+    and identification reports ``cyclic_component`` rather than guessing
+    an acyclic orientation.
+    """
+
+    dag: nx.DiGraph
+    excluded: frozenset[str]
+
+
+def acyclic_core(G: nx.DiGraph) -> AcyclicCore:
+    """Remove every node in a strongly connected component with cycles.
+
+    Biological regulatory networks are full of feedback, and
+    ``nx.is_d_separator`` requires a DAG of the whole graph -- not merely
+    of the neighbourhood under test. So cyclic nodes come out entirely,
+    and the caller is told which.
+    """
+    cyclic_nodes: set[str] = set()
+    for component in cyclic_components(G):
+        cyclic_nodes |= set(component)
+
+    dag = G.copy()
+    dag.remove_nodes_from(cyclic_nodes)
+    return AcyclicCore(dag=dag, excluded=frozenset(cyclic_nodes))

causalphylo-0.1.0.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.5
+Name: causalphylo
+Version: 0.1.0
+Summary: Pearl's backdoor criterion over knowledge graphs — separates edges that may carry a causal claim from those that only assert co-occurrence
+Project-URL: Homepage, https://github.com/Neoforge-Labs/causalphylo
+Project-URL: Documentation, https://causalphylo.neoforgelabs.tech/
+Project-URL: Repository, https://github.com/Neoforge-Labs/causalphylo
+Project-URL: Issues, https://github.com/Neoforge-Labs/causalphylo/issues
+Author: Kelyn Paul Njeri
+License-Expression: LicenseRef-CausalPhylo-NonCommercial
+License-File: LICENSE
+Keywords: backdoor-criterion,causal-inference,do-calculus,identification,knowledge-graph,networkx,pearl
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: networkx>=3.3
+Description-Content-Type: text/markdown
+
+# CausalPhylo
+
+> Identification over knowledge graphs, where not every edge has earned its arrow.
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12%2B-blue.svg)](https://python.org)
+[![License](https://img.shields.io/badge/license-Non--Commercial-orange.svg)](LICENSE)
+[![Docs](https://img.shields.io/badge/docs-causalphylo.neoforgelabs.tech-teal.svg)](https://causalphylo.neoforgelabs.tech/)
+
+**CausalPhylo** implements Pearl's backdoor criterion over
+[NetworkX](https://networkx.org) directed graphs, together with the
+admissibility rules that decide which edges may carry a causal claim in the
+first place. It was extracted from [NeoRx](https://github.com/Neoforge-Labs/neorx),
+where it is the engine behind causal drug-target identification.
+
+It has one runtime dependency: NetworkX.
+
+**Full documentation: [causalphylo.neoforgelabs.tech](https://causalphylo.neoforgelabs.tech/)**
+
+## The problem it solves
+
+A graph assembled from public sources mixes two kinds of edge.
+
+Some assert a **mechanism with a direction** — a curated regulatory
+interaction where someone has established that A acts on B. Others assert only
+that two things **occur together**: a literature co-mention, membership of a
+shared pathway, an undirected protein interaction whose arrow exists only
+because one protein landed in the first column of an API response.
+
+Running do-calculus over the second kind assumes the very thing a causal
+method is supposed to establish. So CausalPhylo partitions the edges first,
+and identification runs only on the causal-admissible subgraph. Associational
+edges are not discarded — they stop being arrows.
+
+Gene → disease edges are admitted only on genetic evidence. A germline variant
+is randomised at conception, so a genetic association carries a
+natural-experiment warrant that a co-mention does not — the Mendelian
+randomisation argument ([Davey Smith & Ebrahim, 2003](https://doi.org/10.1093/ije/dyg070),
+*Int J Epidemiol* 32:1–22). That warrant is what earns the arrow.
+
+## Install
+
+```bash
+uv pip install causalphylo
+```
+
+## Use
+
+```python
+import networkx as nx
+from causalphylo import find_adjustment_set
+
+# The textbook confounding shape: U is a common cause of X and D.
+G = nx.DiGraph()
+G.add_edge("U", "X", edge_type="activates", evidence_class="regulatory")
+G.add_edge("U", "D", edge_type="associated_with", evidence_class="genetic_association")
+G.add_edge("X", "D", edge_type="associated_with", evidence_class="genetic_association")
+
+verdict = find_adjustment_set(G, "X", "D")
+
+verdict.identifiable      # True
+verdict.adjustment_set    # ('U',)
+verdict.reason.value      # 'identifiable_by_adjustment'
+```
+
+`find_adjustment_set` takes the **full** graph. Restriction to the admissible
+subgraph and to its acyclic core happens inside, so no caller can forget it.
+
+Edges carry two attributes that the admissibility rules read: `edge_type` and
+`evidence_class`. Nothing else about your graph is assumed — CausalPhylo has no
+domain model of its own.
+
+## It tells you *why* it failed
+
+A method that reports only pass/fail gives you a pile of prose to read. These
+reasons are a closed enum, so a run's failures aggregate into a distribution:
+
+| `reason` | Meaning |
+|---|---|
+| `identifiable_by_adjustment` | A valid backdoor adjustment set was found |
+| `identifiable_trivially` | No confounder appears in the graph (see the caveat below) |
+| `no_causal_path` | No admissible directed path from treatment to outcome |
+| `cyclic_component` | Treatment or outcome sits in a feedback loop; d-separation is undefined there |
+| `no_valid_adjustment_set` | Confounders exist, but no admissible subset blocks every backdoor path |
+| `treatment_absent` / `outcome_absent` | Node is not in the admissible subgraph |
+
+**The trivial case is not a clean bill of health.** A knowledge graph is
+open-world: a missing edge is missing knowledge, not evidence of no
+confounding. So a trivial verdict carries `n_near_miss_confounders` — how many
+nodes regulate the treatment and have *some* association with the outcome that
+fell short of admissibility. A target with many near misses is fragile. This is
+the same move as an E-value in observational epidemiology: not "there is no
+confounding", but "here is how much it would take to break this".
+
+`search_truncated` reports when the subset search hit its bound
+(`MAX_ADJUSTMENT_SET_SIZE`, `MAX_CANDIDATE_POOL`) rather than exhausting the
+space. It is never hidden.
+
+## API
+
+**`causalphylo.graph_semantics`** — which edges may carry a causal claim
+
+| | |
+|---|---|
+| `is_causal_admissible(attrs)` | Whether an edge with these attributes may carry a causal claim |
+| `causal_subgraph(G)` | The subgraph of admissible edges, attributes preserved |
+| `cyclic_components(G)` | Strongly connected components with cycles, self-loops included |
+| `acyclic_core(G)` | A DAG carved out of a cyclic graph, plus the nodes removed |
+| `CAUSAL_EDGE_TYPES`, `GENETIC_EVIDENCE_CLASSES` | The admissibility vocabularies |
+
+**`causalphylo.backdoor`** — identification on the admissible subgraph
+
+| | |
+|---|---|
+| `find_adjustment_set(G, treatment, outcome)` | Search for a minimal valid adjustment set |
+| `satisfies_backdoor(G, treatment, outcome, adjustment)` | Whether `adjustment` (a frozenset) satisfies the criterion |
+| `mutilated_graph(G, treatment)` | G with edges *into* the treatment removed — the interventional graph G<sub>X&#772;</sub> |
+| `confounding_sensitivity(dag, full_graph, treatment, outcome)` | Near-miss confounder count behind a trivial verdict |
+
+Cyclic nodes are not silently repaired. `acyclic_core` removes every node in a
+feedback loop and names them in `excluded`, because `nx.is_d_separator` requires
+a DAG of the whole graph — not merely of the neighbourhood under test.
+
+## Development
+
+```bash
+uv venv && uv pip install -e . --group dev
+.venv/bin/python -m pytest
+```
+
+## Licence
+
+CausalPhylo Source Available License — non-commercial use permitted, commercial
+use requires a separate licence. See [LICENSE](LICENSE).
+
+Copyright (c) 2026 Kelyn Paul Njeri, NeoForge Labs.

causalphylo-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+causalphylo/__init__.py,sha256=VD6W3ih7dPHRcGFDNeIinGcJcidrjn5yp85rUtHwxBc,2415
+causalphylo/backdoor.py,sha256=-hosnpyr3oxcHidyesQi4ES_eM7Y64n8TLesSdDjCIA,8755
+causalphylo/graph_semantics.py,sha256=c1MRJEr0sgo1e2ZjO88ZW9pJz72Dq1ELwNyA2lSmbSg,4426
+causalphylo/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+causalphylo-0.1.0.dist-info/METADATA,sha256=tvoCwZycWAt2WhAT4ktlIF3YYK1uoIk9QBUcpOfLAw4,7316
+causalphylo-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+causalphylo-0.1.0.dist-info/licenses/LICENSE,sha256=6PJ5o2-hp6p63jiQibT78GkNThqHz5n7I34PObslgmM,1654
+causalphylo-0.1.0.dist-info/RECORD,,

causalphylo-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

causalphylo-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,31 @@
+CausalPhylo Source Available License
+
+Copyright (c) 2026 Kelyn Paul Njeri, NeoForge Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, and distribute the Software for NON-COMMERCIAL PURPOSES ONLY,
+subject to the following conditions:
+
+1. NON-COMMERCIAL USE PERMITTED. You may use, copy, modify, merge, and
+   distribute the Software and derivative works thereof for personal,
+   academic, educational, and research purposes at no charge.
+
+2. COMMERCIAL USE PROHIBITED WITHOUT LICENCE. You may NOT use the Software,
+   or any derivative works thereof, for commercial purposes — including but
+   not limited to: selling the Software or services built on it, incorporating
+   it into commercial products, or using it to generate revenue — without
+   obtaining a separate commercial licence from the copyright holder.
+
+   To obtain a commercial licence, contact: kelyn@neoforgelabs.tech
+
+3. ATTRIBUTION. The above copyright notice and this permission notice shall
+   be included in all copies or substantial portions of the Software.
+
+4. NO WARRANTY. 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.