tmapper-py 0.1.0__py3-none-any.whl

tmapper/__init__.py

@@ -0,0 +1,63 @@
+from .sample_data import sample_data_path
+from .tknndigraph import tknndigraph
+from .filtergraph import filtergraph
+from .labeling import find_node_label
+from .tcm_distance import tcm_distance
+from .plotting import plot_tmgraph, plot_tmgraph_tcm, plot_tmgraph_interactive
+from .knngraph import knngraph
+from .cknngraph import cknngraph
+from .cycle_count import cycle_count
+from .cycle_count2p import cycle_count2p, reorg_cycles
+from .cycle_overlap import cycle_path_overlap
+from .cycle_cluster import cycle_cluster
+from .cycle_cluster_conn import cycle_cluster_conn
+from .cycle_cutter import cycle_cutter
+from .cycles_to_paths import cycles_to_paths
+from .cycle_path_decomp import cycle_path_decomp
+from .path_traffic import path_traffic
+from .modularity import qasym, cal_mod
+from .graph_utils import (
+    node_size,
+    node_measure,
+    normalize_geodesic,
+    normalize_tcm,
+    members_to_tidx,
+    subgraph_from_members,
+    sym_dyn_to_digraph,
+    digraph_to_graph,
+    find_blocks,
+)
+
+__all__ = [
+    "sample_data_path",
+    "tknndigraph",
+    "filtergraph",
+    "find_node_label",
+    "tcm_distance",
+    "plot_tmgraph",
+    "plot_tmgraph_tcm",
+    "plot_tmgraph_interactive",
+    "knngraph",
+    "cknngraph",
+    "cycle_count",
+    "cycle_count2p",
+    "reorg_cycles",
+    "cycle_path_overlap",
+    "cycle_cluster",
+    "cycle_cluster_conn",
+    "cycle_cutter",
+    "cycles_to_paths",
+    "cycle_path_decomp",
+    "path_traffic",
+    "qasym",
+    "cal_mod",
+    "node_size",
+    "node_measure",
+    "normalize_geodesic",
+    "normalize_tcm",
+    "members_to_tidx",
+    "subgraph_from_members",
+    "sym_dyn_to_digraph",
+    "digraph_to_graph",
+    "find_blocks",
+]

tmapper/_shortest_path.py

@@ -0,0 +1,22 @@
+"""Shared all-pairs shortest-path helper.
+
+Uses scipy's compiled Dijkstra (via ``scipy.sparse.csgraph.shortest_path``)
+instead of networkx's ``floyd_warshall_numpy``. The latter is O(n^3) with
+substantial per-iteration numpy overhead and becomes the dominant cost at
+realistic graph sizes (a few thousand nodes); our graphs are sparse (a
+handful of edges per node from the k-NN construction), where Dijkstra from
+every source is asymptotically and practically much faster.
+"""
+
+import networkx as nx
+from scipy.sparse.csgraph import shortest_path
+
+
+def all_pairs_distance(g, nodelist, weight="weight"):
+    """All-pairs shortest-path distance matrix for ``g``, ordered by
+    ``nodelist``. ``weight=None`` treats every edge as weight 1 (hop
+    count); ``weight="weight"`` (default) uses ``g``'s edge weights.
+    Unreachable pairs are ``inf``, matching ``nx.floyd_warshall_numpy``.
+    """
+    adj = nx.to_scipy_sparse_array(g, nodelist=nodelist, weight=weight, dtype=float)
+    return shortest_path(adj, method="auto", directed=True)

tmapper/app/__init__.py

@@ -0,0 +1,10 @@
+"""The interactive Streamlit app, and its launcher.
+
+Lives inside the package so that ``pip install "tmapper[app]"`` ships it --
+otherwise the app would only be runnable from a clone of the repository,
+which is exactly the friction it exists to remove.
+"""
+
+from .launcher import main
+
+__all__ = ["main"]

tmapper/app/launcher.py

@@ -0,0 +1,35 @@
+"""Console-script entry point: ``tmapper-app``.
+
+A Streamlit app is a *script Streamlit runs*, not a program you import and
+call, so this hands the app file to Streamlit's own CLI rather than
+executing it directly -- running it as a plain script would just print
+Streamlit's "missing ScriptRunContext" warnings and do nothing useful.
+
+Any extra arguments are passed straight through, so the usual Streamlit
+options still work::
+
+    tmapper-app --server.port 8600 --server.address 0.0.0.0
+"""
+
+import sys
+from pathlib import Path
+
+APP_FILE = Path(__file__).resolve().parent / "streamlit_app.py"
+
+
+def main(argv=None):
+    try:
+        from streamlit.web import cli as stcli
+    except ImportError:  # pragma: no cover - depends on install extras
+        raise SystemExit(
+            "The interactive app needs Streamlit, which is not installed.\n"
+            "Install it with:  pip install 'tmapper[app]'"
+        )
+
+    args = sys.argv[1:] if argv is None else list(argv)
+    sys.argv = ["streamlit", "run", str(APP_FILE), *args]
+    return stcli.main()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())