booleannet 2.0__tar.gz

booleannet-2.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: booleannet
+Version: 2.0
+Summary: Boolean network modeling
+Author-email: Istvan Albert <istvan.albert@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: click<9,>=8.5

booleannet-2.0/README.md

@@ -0,0 +1,113 @@
+# BooleanNet
+
+BooleanNet is a training tool that makes use of existing Boolean network models, methods and algorithms.
+
+## Environment setup
+
+`booleannet` does not automatically install all of its dependencies as there might be conflicts across dependencies. We recommend using [pixi][pixi] as a virtual environment manager. 
+
+An example using `pixi` to set up the enviroment is:
+
+```bash
+pixi init
+pixi shell
+pixi add python=3.12 pip
+pip install git+https://github.com/hklarner/pyboolnet@3.0.16
+```
+
+Your enviroment is now set up with the necessary dependencies to use `booleannet`.
+
+[pixi]: https://pixi.prefix.dev/latest/
+
+## Install booleannet
+
+The libraires 
+```bash
+pip install booleannet
+```
+
+It installs the `bnet` command line tool that implements a number of subcommands.
+
+
+# bnet models: manage known models
+
+
+```bash
+# List all models
+bnet models | head
+```
+
+prints models by increasing number of variables:
+
+```
+id   name                                                   var    in    reg
+165  EGGSHELL-PATTERNING-PHENOMOENOLOGICAL                    4     4     16
+170  DROSOPHILA-GAP-B                                         4     3     15
+007  CORTICAL-AREA-DEVELOPMENT                                5     0     14
+109  ASYMMETRIC-CELL-DIVISION-A                               5     0     15
+169  DROSOPHILA-GAP-A                                         5     2     17
+171  DROSOPHILA-GAP-C                                         5     2     20
+172  DROSOPHILA-GAP-D                                         5     2     12
+184  P53-MDM2-NETWORK                                         5     1     15
+189  TRP-BIOSYNTHESIS                                         5     1     13
+...
+```
+
+To get the rules for a specific model:
+
+```bash
+# Get rules for model 7
+bnet models 7
+```
+
+prints:
+
+```
+Coup_fti* = not (Fgf8 or Sp8) or not (Sp8 or Fgf8)
+Emx2* = Coup_fti and not (Fgf8 or Sp8 or Pax6)
+Fgf8* = Fgf8 and Sp8 and not Emx2
+Pax6* = Sp8 and not (Emx2 or Coup_fti)
+Sp8* = Fgf8 and not Emx2
+```
+
+You can also get the rules for a model by name:
+
+```bash
+# Get rules for model by name
+bnet models CORTICAL-AREA-DEVELOPMENT
+```
+
+Get the rules in other formats:
+
+```bash
+# Get model 7 in BNet format
+bnet models 7 -f bnet
+```
+
+## bnet graphviz: visualize a model
+
+```bash
+# If you have a model in a file
+bnet graphviz -i model.txt
+```
+
+```bash
+# You can pipe the rule to graphviz
+bnet models CORTICAL-AREA-DEVELOPMENT | bnet graphviz
+```
+
+## Convert BBMB to JSON
+
+This is used internally to transform the BBMB model repository to a single JSON file.
+
+Skips a few large models that make the file too large.
+
+```bash
+python booleannet/bbm2json.py \
+       --summary ~/src/biodivine-boolean-models/models/summary.csv 
+       --models ~/src/biodivine-boolean-models/models 
+       --skip 253,248,79,261,256
+       --output models.json.gz
+```
+
+## Convert rules to images

booleannet-2.0/booleannet/__init__.py

@@ -0,0 +1 @@
+"""Boolean network modeling."""

booleannet-2.0/booleannet/__main__.py

@@ -0,0 +1,3 @@
+from booleannet.cli import main
+
+main()

booleannet-2.0/booleannet/bbm2json.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""
+Convert BBM models files to a JSON data file.
+
+Join models/summary.csv to each model directory and write one JSON object.
+
+Directory names follow the summary columns (regulations is not in the name):
+
+\b
+    [id-009]__[var-60]__[in-13]__[YEAST-APOPTOSIS]
+
+The output is a JSON object keyed by the zero-padded id from the CSV:
+
+\b
+    {
+      "009": {
+        "summary": {
+          "name": "YEAST-APOPTOSIS",
+          "variables": 60,
+          "inputs": 13,
+          "regulations": 114
+        },
+        "metadata": { ... },          # metadata.json, parsed
+        "readme": "...",              # README.md
+        "bnet": "...",                # model.bnet
+        "aeon": "...",                # model.aeon
+        "sbml": "...",                # model.sbml
+        "bma": { ... },               # model.bma.json, parsed
+        "booleannet": "...",          # model.booleannet.txt
+        "inferred_graph": "..."       # model.inferred-graph.aeon
+      }
+    }
+
+JSON files are stored as objects. The other formats stay as text.
+"""
+
+import csv
+import gzip
+import json
+import re
+from pathlib import Path
+
+import click
+
+ROOT = Path(__file__).resolve().parent
+
+DIR_RE = re.compile(
+    r"^\[id-(?P<id>\d+)\]__\[var-(?P<variables>\d+)\]__\[in-(?P<inputs>\d+)\]__\[(?P<name>.+)\]$"
+)
+
+# filename -> (output field, "json" or "text")
+FILES = {
+    "metadata.json": ("metadata", "json"),
+    "README.md": ("readme", "text"),
+    "model.bnet": ("bnet", "text"),
+    "model.aeon": ("aeon", "text"),
+    "model.sbml": ("sbml", "text"),
+    "model.bma.json": ("bma", "json"),
+    "model.booleannet.txt": ("booleannet", "text"),
+    "model.inferred-graph.aeon": ("inferred_graph", "text"),
+}
+
+
+def read_summary(path):
+    with path.open(newline="") as f:
+        rows = list(csv.DictReader(f, skipinitialspace=True))
+    by_id = {}
+    for row in rows:
+        model_id = row["ID"].zfill(3)
+        if model_id in by_id:
+            raise SystemExit(f"duplicate id {model_id} in {path}")
+        by_id[model_id] = {
+            "name": row["name"],
+            "variables": int(row["variables"]),
+            "inputs": int(row["inputs"]),
+            "regulations": int(row["regulations"]),
+        }
+    return by_id
+
+
+def index_dirs(models_dir):
+    by_id = {}
+    for path in sorted(models_dir.iterdir()):
+        if not path.is_dir():
+            continue
+        match = DIR_RE.match(path.name)
+        if not match:
+            raise SystemExit(f"directory name does not match summary pattern: {path.name}")
+        model_id = match.group("id").zfill(3)
+        if model_id in by_id:
+            raise SystemExit(f"duplicate id {model_id}: {path.name}")
+        by_id[model_id] = (path, match.groupdict())
+    return by_id
+
+
+def load_files(directory):
+    data = {}
+    for filename, (field, kind) in FILES.items():
+        path = directory / filename
+        if not path.is_file():
+            raise SystemExit(f"missing {path}")
+        text = path.read_text()
+        data[field] = json.loads(text) if kind == "json" else text
+    return data
+
+
+def parse_skip(ctx, param, value):
+    ids = set()
+    for part in value.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if not part.isdigit():
+            raise click.BadParameter(f"not a model id: {part}")
+        ids.add(part.zfill(3))
+    return ids
+
+
+def drop_skipped(summary, dirs, skip):
+    unknown = sorted(skip - set(summary) - set(dirs))
+    if unknown:
+        raise SystemExit(f"unknown skip id: {', '.join(unknown)}")
+    for model_id in skip:
+        summary.pop(model_id, None)
+        dirs.pop(model_id, None)
+
+
+def build(summary, dirs):
+    missing = sorted(set(summary) - set(dirs))
+    extra = sorted(set(dirs) - set(summary))
+    if missing or extra:
+        click.echo(
+            f"warning: summary/directory mismatch missing={missing} extra={extra}",
+            err=True,
+        )
+        for model_id in missing:
+            del summary[model_id]
+        for model_id in extra:
+            del dirs[model_id]
+
+    models = {}
+    for model_id in sorted(summary):
+        row = summary[model_id]
+        print(f"Processing: {row}")
+        path, parsed = dirs[model_id]
+        parsed_vars = int(parsed["variables"])
+        parsed_inputs = int(parsed["inputs"])
+        if (
+            parsed["name"] != row["name"]
+            or parsed_vars != row["variables"]
+            or parsed_inputs != row["inputs"]
+        ):
+            raise SystemExit(
+                f"id {model_id} summary {row} does not match directory {path.name}"
+            )
+        models[model_id] = {
+            "summary": row,
+            **load_files(path),
+        }
+    return models
+
+
+@click.command(help=__doc__)
+@click.option(
+    "--summary",
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    default= Path("models") / "summary.csv",
+    show_default=True,
+    help="Summary CSV joined onto each model.",
+)
+@click.option(
+    "--models",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    default=Path("models"),
+    show_default=True,
+    help="Directory of model folders.",
+)
+@click.option(
+    "--skip",
+    default="",
+    show_default=True,
+    callback=parse_skip,
+    help="Comma-separated model ids to leave out of the JSON. Ids are zero-padded to 3 digits.",
+)
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(dir_okay=False, path_type=Path),
+    default="models.json.gz",
+    show_default=True,
+    help="JSON file to write.",
+)
+def main(summary: Path, models: Path, output: Path, skip: set[str]) -> None:
+    rows = read_summary(summary)
+    dirs = index_dirs(models)
+    drop_skipped(rows, dirs, skip)
+    data = build(rows, dirs)
+    stream = gzip.open(output, "wt") if output.suffix == ".gz" else output.open("wt")
+    with stream as f:
+        json.dump(data, f, ensure_ascii=False, separators=(",", ":"), indent=2)
+        f.write("\n")
+    note = f", skipped {len(skip)}" if skip else ""
+    click.echo(f"wrote {len(data)} models to {output}{note}", err=True)
+
+
+if __name__ == "__main__":
+    main()

booleannet-2.0/booleannet/cli.py

@@ -0,0 +1,27 @@
+"""bnet command line."""
+
+import click
+
+from booleannet.commands.gviz import cli as gviz
+from booleannet.commands.models import main as models
+
+try:
+    import pyboolnet
+except ImportError:
+    print("# Error: pyboolnet is not installed. See the docs`.")
+    exit(1)
+
+# Subcommand name -> click command. Add a new tool here.
+COMMANDS = {
+    "models": models,
+    "graphviz": gviz,
+}
+
+
+@click.group("bnet", no_args_is_help=True)
+def main() -> None:
+    """BooleanNet command line tools."""
+
+
+for name, cmd in COMMANDS.items():
+    main.add_command(cmd, name=name)

booleannet-2.0/booleannet/commands/__init__.py

@@ -0,0 +1 @@
+"""Subcommands for ``bnet``. Register each one in ``booleannet.cli.COMMANDS``."""

booleannet-2.0/booleannet/commands/gviz.py

@@ -0,0 +1,107 @@
+"""Build a Graphviz interaction graph from BooleanNet rules."""
+
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from pyboolnet import log
+
+import click
+from pyboolnet.boolean_normal_forms import functions2primes
+from pyboolnet.interaction_graphs import (
+    add_style_interactionsigns,
+    igraph2dot,
+    primes2igraph,
+)
+
+KEYWORDS = {"and", "or", "not", "True", "False"}
+ENGINES = ("dot", "neato", "fdp", "sfdp", "circo", "twopi")
+IDENT = re.compile(r"\b[A-Za-z_][A-Za-z0-9_]*\b")
+
+
+def booleannet2functions(text: str) -> dict:
+    """Turn BooleanNet update rules into callables for pyboolnet.
+
+    Parameter names are sorted because functions2primes calls each
+    function with arguments in alphabetical order.
+    """
+    funcs = {}
+    for raw in text.splitlines():
+        line = raw.split("#", 1)[0].strip()
+        if not line:
+            continue
+        lhs, rhs = line.split("=", 1)
+        name = lhs.strip().removesuffix("*").strip()
+        expr = rhs.strip()
+        args = sorted(set(IDENT.findall(expr)) - KEYWORDS)
+        params = ", ".join(args)
+        src = f"lambda {params}: {expr}" if args else f"lambda: {expr}"
+        funcs[name] = eval(src, {"True": True, "False": False})
+    return funcs
+
+
+def read_rules(path: Path | None) -> tuple[str, Path | None]:
+    """Return rules text and the file output names inherit from.
+
+    A pipe is the rules source when stdin is not a terminal. Otherwise the
+    source is ``path`` or ``input.txt``. The returned path is that file, or
+    ``None`` when the rules came from stdin and no input file was given.
+    """
+    if not sys.stdin.isatty():
+        return sys.stdin.read(), path
+    path = path or Path("input.txt")
+    if not path.is_file():
+        raise click.ClickException(f"rules file not found: {path}")
+    return path.read_text(), path
+
+
+def rules2dot(text: str, dot_path: Path) -> None:
+    primes = functions2primes(booleannet2functions(text))
+    graph = primes2igraph(primes)
+    # Default width is ~0.2in for one-letter names, which clips the labels.
+    graph.graph["node"]["width"] = "0.55"
+    graph.graph["node"]["fontsize"] = "14"
+    graph.graph["node"]["color"] = "gray20"
+    graph.graph["node"]["penwidth"] = "1.4"
+    # width is a minimum; let longer labels expand the circle
+    graph.graph["node"]["fixedsize"] = "false"
+    for name in graph.nodes:
+        if name.startswith("v_"):
+            graph.nodes[name]["label"] = name.removeprefix("v_")
+    add_style_interactionsigns(graph)
+    igraph2dot(graph, str(dot_path))
+
+
+def write_image(dot: Path, image: Path, engine: str = "neato") -> None:
+    """Render a dot file. The image format is the output suffix, such as png or pdf.
+
+    pyboolnet's layout lookup is hardcoded to /usr/bin, so this calls the engine on PATH.
+    """
+    exe = shutil.which(engine)
+    if exe is None:
+        raise click.ClickException(f"{engine} not found on PATH")
+    fmt = image.suffix.lstrip(".").lower()
+    if not fmt:
+        raise click.ClickException(f"image path needs an extension such as .png or .pdf: {image}")
+    subprocess.run([exe, f"-T{fmt}", str(dot), "-o", str(image)], check=True)
+    log.info(f"image written to {image}")
+
+
+@click.command()
+@click.option("-i", "--input", "rules", type=click.Path(dir_okay=False, path_type=Path), help="BooleanNet rules file. Used when stdin is a terminal. Default: input.txt.")
+@click.option("-d", "--dot", "dot", type=click.Path(dir_okay=False, path_type=Path), help="Dot output. Default: input path with a .dot suffix, or output.dot when reading stdin with no input file.")
+@click.option("-o", "--output", "image", type=click.Path(dir_okay=False, path_type=Path), help="Image output. Default: input path with a .pdf suffix, or output.pdf when reading stdin with no input file. Format follows the extension (png, pdf, svg).")
+@click.option("-e", "--engine", default="circo", show_default=True, type=click.Choice(ENGINES), help="Graphviz layout engine.")
+def cli(rules: Path | None, dot: Path | None, image: Path | None, engine: str) -> None:
+    """Generates a Graphviz graph from a model."""
+    text, source = read_rules(rules)
+    if source is None:
+        dot = dot or Path("output.dot")
+        image = image or Path("output.pdf")
+    else:
+        dot = dot or source.with_suffix(".dot")
+        image = image or source.with_suffix(".pdf")
+    rules2dot(text, dot)
+    write_image(dot, image, engine)

booleannet-2.0/booleannet/commands/models.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""List models or print one model in a chosen format.
+
+    bnet models                 one summary row per model
+    bnet models 1               bnet for model 001
+    bnet models CORTICAL        model whose name contains CORTICAL
+    bnet models 1 -f aeon       aeon for model 001
+    bnet models -d models.json  read a chosen JSON database
+"""
+
+import gzip
+import json
+import sys
+from importlib.resources import files
+from pathlib import Path
+
+import click
+
+DATA = files("booleannet").joinpath("data", "models.json.gz")
+FORMATS = (
+    "bnet",
+    "booleannet",
+    "sbml",
+    "aeon",
+    "bma",
+    "inferred_graph",
+    "metadata",
+    "readme",
+)
+JSON_FORMATS = {"bma", "metadata"}
+
+
+def load_models(path: Path | None):
+    if path is None:
+        with DATA.open("rb") as raw, gzip.open(raw, "rt") as f:
+            return json.load(f)
+    opener = gzip.open if path.suffix == ".gz" else open
+    with opener(path, "rt") as f:
+        return json.load(f)
+
+
+def list_summaries(models):
+    rows = []
+    for model_id, model in models.items():
+        summary = model["summary"]
+        rows.append((
+            model_id,
+            summary["name"],
+            summary["variables"],
+            summary["inputs"],
+            summary["regulations"],
+        ))
+    rows.sort(key=lambda row: (row[2], row[0]))
+    name_w = max(len(name) for _, name, _, _, _ in rows)
+    click.echo(f"{'id':3}  {'name':<{name_w}}  {'var':>5}  {'in':>4}  {'reg':>5}")
+    for model_id, name, variables, inputs, regulations in rows:
+        click.echo(f"{model_id}  {name:<{name_w}}  {variables:5}  {inputs:4}  {regulations:5}")
+
+
+def find_models(models, key: str) -> list[str]:
+    """Match a number to an id, or text to an id or name."""
+    if key.isdigit():
+        model_id = key.zfill(3)
+        return [model_id] if model_id in models else []
+    needle = key.casefold()
+    return [
+        model_id
+        for model_id, model in models.items()
+        if needle in model_id.casefold() or needle in model["summary"]["name"].casefold()
+    ]
+
+
+def emit(model, fmt):
+    value = model[fmt]
+    if fmt in JSON_FORMATS:
+        click.echo(json.dumps(value, ensure_ascii=False))
+        return
+    click.echo(value, nl=not value.endswith("\n"))
+
+
+@click.command()
+@click.argument("key", required=False)
+@click.option(
+    "-d",
+    "--database",
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    help="JSON or JSON.gz database. Default: packaged data/models.json.gz.",
+)
+@click.option(
+    "-f",
+    "--format",
+    "fmt",
+    default="booleannet",
+    show_default=True,
+    type=click.Choice(FORMATS),
+    help="Model file to print when KEY is given.",
+)
+def main(key, database, fmt):
+    """List model summaries, or print one model in the chosen format.
+
+    KEY is a number (1 or 001) or text matched against the id or name.
+    """
+    models = load_models(database)
+    if key is None:
+        list_summaries(models)
+        return
+
+    hits = find_models(models, key)
+    if not hits:
+        raise click.ClickException(f"no model {key}")
+    if len(hits) > 1:
+        lines = [f"{i}  {models[i]['summary']['name']}" for i in sorted(hits)]
+        raise click.ClickException("several models match:\n" + "\n".join(lines))
+    emit(models[hits[0]], fmt)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except BrokenPipeError:
+        sys.stdout.close()
+        sys.exit(0)

booleannet-2.0/booleannet.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: booleannet
+Version: 2.0
+Summary: Boolean network modeling
+Author-email: Istvan Albert <istvan.albert@gmail.com>
+Requires-Python: >=3.12
+Requires-Dist: click<9,>=8.5

booleannet-2.0/booleannet.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+booleannet/__init__.py
+booleannet/__main__.py
+booleannet/bbm2json.py
+booleannet/cli.py
+booleannet.egg-info/PKG-INFO
+booleannet.egg-info/SOURCES.txt
+booleannet.egg-info/dependency_links.txt
+booleannet.egg-info/entry_points.txt
+booleannet.egg-info/requires.txt
+booleannet.egg-info/top_level.txt
+booleannet/commands/__init__.py
+booleannet/commands/gviz.py
+booleannet/commands/models.py
+booleannet/data/models.json.gz

booleannet-2.0/booleannet.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

booleannet-2.0/booleannet.egg-info/entry_points.txt

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

booleannet-2.0/booleannet.egg-info/requires.txt

@@ -0,0 +1 @@
+click<9,>=8.5

booleannet-2.0/booleannet.egg-info/top_level.txt

@@ -0,0 +1 @@
+booleannet

booleannet-2.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=69"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "booleannet"
+version = "2.0"
+description = "Boolean network modeling"
+authors = [{ name = "Istvan Albert", email = "istvan.albert@gmail.com" }]
+requires-python = ">=3.12"
+dependencies = ["click>=8.5,<9"]
+
+[project.scripts]
+bnet = "booleannet.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["booleannet*"]
+
+[tool.setuptools.package-data]
+booleannet = ["data/*.json.gz"]

booleannet-2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+