c4reqber 5.6.0__py3-none-any.whl

src/simulations/boolnet_bridge.py

@@ -0,0 +1,132 @@
+# SPDX-License-Identifier: AGPL-3.0
+"""BoolNet bridge — Boolean network analysis for gene regulatory networks.
+
+Install: BiocManager::install("BoolNet") in R, then reticulate in Python.
+Alternative: pip install booleanNetwork (if available).
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .base_adapter import BaseSimulationAdapter, SimulationResult
+
+
+logger = logging.getLogger(__name__)
+
+
+class BoolNetBridge(BaseSimulationAdapter):
+    """Bridge to BoolNet for Boolean gene regulatory network analysis."""
+
+    _engine_name = "boolnet"
+    _package_checks = ["rpy2"]
+    _install_hint = (
+        "Install R + BoolNet:  BiocManager::install('BoolNet')  "
+        "Then in Python:  pip install rpy2  "
+        "Alternative: use Python boolean-network libraries (e.g. pystablemotifs)"
+    )
+
+    def run(self, input_data: dict[str, Any] | None = None) -> SimulationResult:
+        def _run(data: dict[str, Any]) -> dict[str, Any]:
+            network_file = data.get("network_file")
+            if not network_file:
+                # Generate a simple toggle-switch network inline
+                network = data.get("network", {
+                    "A": "!B",
+                    "B": "!A",
+                })
+                attractors = self._compute_attractors(network)
+                return {
+                    "attractors": attractors,
+                    "network_nodes": list(network.keys()),
+                    "note": "Computed attractors for Boolean network",
+                }
+
+            from rpy2.robjects.packages import importr
+            boolnet = importr("BoolNet")
+            net = boolnet.loadNetwork(network_file)
+            attrs = boolnet.getAttractors(net)
+            return {
+                "attractors": str(attrs),
+                "network_file": network_file,
+                "note": "BoolNet attractor analysis completed",
+            }
+
+        return self._run_wrapped(_run, input_data)
+
+    @staticmethod
+    def _compute_attractors(network: dict[str, str]) -> list[dict[str, int]]:
+        """Simple brute-force attractor computation for small networks."""
+        nodes = list(network.keys())
+        attractors = []
+        for state_bits in range(2 ** len(nodes)):
+            state = {n: (state_bits >> i) & 1 for i, n in enumerate(nodes)}
+            seen = []
+            current = state.copy()
+            while current not in seen:
+                seen.append(current.copy())
+                next_state = {}
+                for node, rule in network.items():
+                    next_state[node] = BoolNetBridge._eval_rule(rule, current)
+                current = next_state
+                if len(seen) > 100:
+                    break
+            if current in seen:
+                cycle_start = seen.index(current)
+                cycle = seen[cycle_start:]
+                if cycle not in [a["states"] for a in attractors]:
+                    attractors.append({"states": cycle, "period": len(cycle)})
+        return attractors
+
+    @staticmethod
+    def _eval_rule(rule: str, state: dict[str, int]) -> int:
+        """Evaluate a simple Boolean rule safely (no eval, AST-based).
+
+        Supported syntax: variable names, integers 0/1, NOT (!), AND (&), OR (|),
+        parentheses. Anything else returns 0. State values come from the local
+        state dict only — no attribute access, no function calls, no dunder names.
+        """
+        import ast
+
+        rule = rule.strip()
+        if not rule:
+            return 0
+
+        # Normalize Boolean operators to Python syntax.
+        rule = rule.replace("!", "not ").replace("&", " and ").replace("|", " or ")
+
+        try:
+            tree = ast.parse(rule, mode="eval")
+        except SyntaxError:
+            return 0
+
+        def _eval(node: ast.AST) -> int:
+            if isinstance(node, ast.Expression):
+                return _eval(node.body)
+            if isinstance(node, ast.Constant):
+                if isinstance(node.value, (int, bool)):
+                    return 1 if node.value else 0
+                return 0
+            if isinstance(node, ast.Name):
+                if node.id.startswith("__"):
+                    return 0
+                val = state.get(node.id)
+                if isinstance(val, (int, bool)):
+                    return 1 if val else 0
+                return 0
+            if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.Not):
+                return 0 if _eval(node.operand) else 1
+            if isinstance(node, ast.BoolOp):
+                values = [_eval(v) for v in node.values]
+                if isinstance(node.op, ast.And):
+                    return 1 if all(values) else 0
+                if isinstance(node.op, ast.Or):
+                    return 1 if any(values) else 0
+                return 0
+            # Reject calls, attributes, comparisons, subscripts, etc.
+            return 0
+
+        try:
+            return _eval(tree)
+        except Exception:
+            return 0

src/simulations/brian2_bridge.py

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: AGPL-3.0
+"""Brian2 bridge — spiking neural network simulator.
+
+Install: pip install brian2
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .base_adapter import BaseSimulationAdapter, SimulationResult
+
+
+logger = logging.getLogger(__name__)
+
+
+class Brian2Bridge(BaseSimulationAdapter):
+    """Bridge to Brian2 for SNN simulations."""
+
+    _engine_name = "brian2"
+    _package_checks = ["brian2"]
+    _install_hint = "pip install brian2"
+
+    def configure(self, params: dict[str, Any]) -> None:
+        super().configure(params)
+        # Expected: duration_ms, dt_ms
+
+    def run(self, input_data: dict[str, Any] | None = None) -> SimulationResult:
+        def _run(data: dict[str, Any]) -> dict[str, Any]:
+            from brian2 import NeuronGroup, SpikeMonitor, StateMonitor, defaultclock, ms, run
+
+            duration = self._params.get("duration_ms", 100) * ms
+            defaultclock.dt = self._params.get("dt_ms", 0.1) * ms
+
+            eqs = """
+            dv/dt = (I-v)/tau : volt
+            I : volt
+            tau : second
+            """
+            group = NeuronGroup(100, eqs, threshold="v>0.8*mV", reset="v=0*mV", method="exact")
+            group.v = "rand()*0.5*mV"
+            group.I = "(rand()*0.5 + 0.5)*mV"
+            group.tau = "(10 + rand()*10)*ms"
+
+            spike_mon = SpikeMonitor(group)
+            StateMonitor(group, "v", record=True)
+            run(duration)
+
+            return {
+                "spike_times_ms": {i: list(spike_mon.t[spike_mon.i == i] / ms) for i in range(5)},
+                "n_spikes": int(spike_mon.num_spikes),
+                "n_neurons": 100,
+                "note": "Brian2 SNN simulation completed",
+            }
+
+        return self._run_wrapped(_run, input_data)

src/simulations/cobra_bridge.py

@@ -0,0 +1,54 @@
+# SPDX-License-Identifier: AGPL-3.0
+"""COBRApy bridge — constraint-based metabolic modeling (FBA, FVA, pFBA).
+
+Install: pip install cobra
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .base_adapter import BaseSimulationAdapter, SimulationResult
+
+
+logger = logging.getLogger(__name__)
+
+
+class CobraBridge(BaseSimulationAdapter):
+    """Bridge to COBRApy for flux balance analysis and metabolic modeling."""
+
+    _engine_name = "cobra"
+    _package_checks = ["cobra"]
+    _install_hint = "pip install cobra  (requires libglpk-dev or similar LP solver)"
+
+    def run(self, input_data: dict[str, Any] | None = None) -> SimulationResult:
+        def _run(data: dict[str, Any]) -> dict[str, Any]:
+            import cobra
+            from cobra.io import load_model
+
+            model_source = data.get("model", "textbook")
+            if model_source == "textbook":
+                model = load_model("textbook")
+            else:
+                model = cobra.io.read_sbml_model(model_source)
+
+            objective = data.get("objective", model.objective)
+            model.objective = objective
+
+            solution = model.optimize()
+            fva_fraction = data.get("fva_fraction")
+            result = {
+                "objective_value": solution.objective_value,
+                "status": solution.status,
+                "model_id": model.id,
+                "reactions_count": len(model.reactions),
+                "metabolites_count": len(model.metabolites),
+            }
+            if fva_fraction is not None:
+                from cobra.flux_analysis import flux_variability_analysis
+                fva = flux_variability_analysis(model, fraction_of_optimum=fva_fraction)
+                result["fva"] = fva.to_dict()
+
+            return result
+
+        return self._run_wrapped(_run, input_data)

src/simulations/config.py

@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: AGPL-3.0
+# Copyright (c) 2026 c4reqber Contributors
+"""Simulation Configuration — hardware-aware simulation orchestrator.
+
+Reads ~/.c4reqber/simulations.json. Controls which sim engines run based on:
+- User's hardware (Metal/CUDA/CPU)
+- User's budget (vast.ai key + cost limit)
+- User's mode preference (auto|gpu|cpu_only|off)
+
+Integrated into pipeline Step 7 and Step 11 (output generation).
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import platform
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+logger = logging.getLogger(__name__)
+
+CONFIG_PATH = Path.home() / ".c4reqber" / "simulations.json"
+DEFAULT_CONFIG = {
+    "mode": "auto",
+    "cost_limit_per_run": 5.00,
+    "fallback_to_protocol": True,
+    "providers": {
+        "vastai": {"api_key": "", "gpu_type": "RTX_4090"},
+        "local": {"cuda": False, "metal": False},
+    },
+}
+
+
+@dataclass
+class SimulationConfig:
+    """SimulationConfig."""
+    mode: str = "auto"  # "auto" | "gpu" | "cpu_only" | "off"
+    cost_limit_per_run: float = 5.00
+    fallback_to_protocol: bool = True
+    vastai_key: str = ""
+    gpu_type: str = "RTX_4090"
+    local_cuda: bool = False
+    local_metal: bool = False
+
+    @classmethod
+    def load(cls) -> SimulationConfig:
+        """Load."""
+        os.makedirs(CONFIG_PATH.parent, exist_ok=True)
+        if not CONFIG_PATH.exists():
+            _save_default()
+            return cls._from_dict(DEFAULT_CONFIG)
+        try:
+            data = json.loads(CONFIG_PATH.read_text())
+            return cls._from_dict(data)
+        except Exception:
+            return cls._from_dict(DEFAULT_CONFIG)
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> SimulationConfig:
+        providers = data.get("providers", {})
+        local = providers.get("local", {})
+        vastai = providers.get("vastai", {})
+        return cls(
+            mode=data.get("mode", "auto"),
+            cost_limit_per_run=float(data.get("cost_limit_per_run", 5.00)),
+            fallback_to_protocol=data.get("fallback_to_protocol", True),
+            vastai_key=vastai.get("api_key", "") or os.environ.get("VASTAI_API_KEY", ""),
+            gpu_type=vastai.get("gpu_type", "RTX_4090"),
+            local_cuda=local.get("cuda", False),
+            local_metal=local.get("metal", False),
+        )
+
+    def save(self) -> None:
+        """Save."""
+        data = {
+            "mode": self.mode,
+            "cost_limit_per_run": self.cost_limit_per_run,
+            "fallback_to_protocol": self.fallback_to_protocol,
+            "providers": {
+                "vastai": {"api_key": self.vastai_key, "gpu_type": self.gpu_type},
+                "local": {"cuda": self.local_cuda, "metal": self.local_metal},
+            },
+        }
+        os.makedirs(CONFIG_PATH.parent, exist_ok=True)
+        CONFIG_PATH.write_text(json.dumps(data, indent=2))
+
+    @property
+    def can_run_gpu(self) -> bool:
+        return bool(self.vastai_key) or self.local_cuda or self.local_metal
+
+    @property
+    def should_run_simulations(self) -> bool:
+        """Determine if should run simulations."""
+        if self.mode == "off":
+            return False
+        if self.mode == "cpu_only":
+            return True
+        if self.mode == "gpu":
+            return self.can_run_gpu
+        return True
+
+    @property
+    def should_generate_protocol(self) -> bool:
+        """Determine if should generate protocol."""
+        if self.mode == "off":
+            return self.fallback_to_protocol
+        if self.mode == "cpu_only" and not self.can_run_gpu:
+            return self.fallback_to_protocol
+        return True
+
+
+def _save_default() -> None:
+    os.makedirs(CONFIG_PATH.parent, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(DEFAULT_CONFIG, indent=2))
+
+
+def detect_hardware() -> dict[str, bool]:
+    """Auto-detect available compute hardware."""
+    hw = {"metal": False, "cuda": False, "nvidia_gpu": False, "apple_gpu": False}
+
+    # Apple Silicon (Metal via MPS)
+    if platform.system() == "Darwin" and platform.processor() == "arm":
+        hw["apple_gpu"] = True
+        try:
+            import torch
+            hw["metal"] = torch.backends.mps.is_available()
+        except Exception:
+            logger.debug("Provider check failed", exc_info=True)
+
+            pass
+
+    # NVIDIA GPU (CUDA)
+    try:
+        result = subprocess.run(["nvidia-smi"], capture_output=True, timeout=5)
+        hw["nvidia_gpu"] = result.returncode == 0
+        try:
+            import torch
+            hw["cuda"] = torch.cuda.is_available()
+        except Exception:
+            logger.debug("Provider check failed", exc_info=True)
+
+            pass
+    except Exception:
+        logger.debug("Hardware detection failed", exc_info=True)
+        pass
+
+    return hw
+
+
+def auto_configure() -> SimulationConfig:
+    """Auto configure."""
+    cfg = SimulationConfig.load()
+    hw = detect_hardware()
+
+    if hw["cuda"] or hw["metal"]:
+        cfg.local_cuda = hw["cuda"]
+        cfg.local_metal = hw["metal"]
+        if cfg.mode == "auto":
+            cfg.mode = "gpu"
+        logger.info("GPU detected: CUDA=%s Metal=%s → mode=%s", hw["cuda"], hw["metal"], cfg.mode)
+    else:
+        if cfg.mode == "auto":
+            cfg.mode = "cpu_only"
+        logger.info("No GPU detected → mode=cpu_only")
+
+    cfg.save()
+    return cfg

src/simulations/copasi_bridge.py

@@ -0,0 +1,46 @@
+# SPDX-License-Identifier: AGPL-3.0
+"""COPASI bridge — biochemical network analysis via Basico.
+
+Install: pip install copasi-basico  (or basico)
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .base_adapter import BaseSimulationAdapter, SimulationResult
+
+
+logger = logging.getLogger(__name__)
+
+
+class CopasiBridge(BaseSimulationAdapter):
+    """Bridge to COPASI via basico Python bindings."""
+
+    _engine_name = "copasi"
+    _package_checks = ["basico"]
+    _install_hint = "pip install copasi-basico"
+
+    def configure(self, params: dict[str, Any]) -> None:
+        super().configure(params)
+
+    def run(self, input_data: dict[str, Any] | None = None) -> SimulationResult:
+        def _run(data: dict[str, Any]) -> dict[str, Any]:
+            import basico
+
+            # Load SBML or create a simple model
+            sbml = data.get("sbml")
+            if sbml:
+                basico.load_model(sbml)
+            else:
+                basico.new_model(name="c4reqber")
+                basico.add_reaction("R1", "A -> B", {"A": 10, "B": 0})
+
+            tc = basico.run_time_course(duration=50, intervals=100)
+            return {
+                "timecourse_columns": list(tc.columns),
+                "timecourse_rows": len(tc),
+                "note": "COPASI time-course simulation completed",
+            }
+
+        return self._run_wrapped(_run, input_data)

src/simulations/diffeqpy_bridge.py

@@ -0,0 +1,49 @@
+# SPDX-License-Identifier: AGPL-3.0
+"""diffeqpy bridge — Julia DifferentialEquations.jl via Python.
+
+Install: pip install diffeqpy  (requires Julia installed)
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .base_adapter import BaseSimulationAdapter, SimulationResult
+
+
+logger = logging.getLogger(__name__)
+
+
+class DiffEqPyBridge(BaseSimulationAdapter):
+    """Bridge to DifferentialEquations.jl via diffeqpy."""
+
+    _engine_name = "diffeqpy"
+    _package_checks = ["diffeqpy"]
+    _install_hint = "pip install diffeqpy  (requires Julia >= 1.6 installed)"
+
+    def configure(self, params: dict[str, Any]) -> None:
+        super().configure(params)
+        # Expected: tspan, u0, algorithm
+
+    def run(self, input_data: dict[str, Any] | None = None) -> SimulationResult:
+        def _run(data: dict[str, Any]) -> dict[str, Any]:
+            from diffeqpy import de
+
+            def f(u, p, t):
+                return [-0.5 * u[0], 0.5 * u[0] - 0.3 * u[1]]
+
+            u0 = self._params.get("u0", [1.0, 0.0])
+            tspan = self._params.get("tspan", (0.0, 10.0))
+            prob = de.ODEProblem(f, u0, tspan)
+            sol = de.solve(prob, de.Tsit5(), saveat=0.1)
+
+            t = list(sol.t)
+            u = [list(row) for row in sol.u]
+            return {
+                "t": t,
+                "u": u,
+                "n_steps": len(t),
+                "note": "diffeqpy ODE solve completed",
+            }
+
+        return self._run_wrapped(_run, input_data)

src/simulations/domain_selector.py

@@ -0,0 +1,13 @@
+DOMAIN_SIMULATION_MAP = {
+    'materials': ['cfd','phase_field','thermal','atomistic_deposition','composite_mechanics','crystal_growth','dft','elasticity_3d'],
+    'biology': ['agent_based','epidemic_sir','hodgkin_huxley','enzyme_kinetics','population_genetics','predator_prey','gene_regulatory','protein_folding'],
+    'climate': ['climate_gcm','advection_diffusion','air_quality','thermal','boundary_layer','reaction_diffusion','forest_gap','cellular_automata'],
+    'physics': ['n_body','double_pendulum','wave_equation','quantum_harmonic_oscillator','spring_mass','acoustic_wave','maxwell_fdtd','black_hole_accretion'],
+    'medicine': ['epidemic_seir','pharmacokinetics','enzyme_kinetics','signal_transduction','age_structured','hodgkin_huxley','neural_mass','agent_based'],
+    'neuroscience': ['neural_mass','hodgkin_huxley','connectome','synaptic_plasticity','agent_based','ising_model','cellular_automata','wave_equation'],
+    'computer_science': ['neural_network','cellular_automata','game_theory','markov_chain','monte_carlo_pi','bootstrap','optimization_lp','social_network'],
+}
+
+
+def get_domain_simulations(domain: str, count: int = 8) -> list[str]:
+    return DOMAIN_SIMULATION_MAP.get(domain, DOMAIN_SIMULATION_MAP['physics'])[:count]

src/simulations/fenicsx_bridge.py

@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: AGPL-3.0
+"""FEniCSx bridge — high-level FEM PDE solver (dolfinx).
+
+Install: conda install -c conda-forge fenics-dolfinx
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .base_adapter import BaseSimulationAdapter, SimulationResult
+
+
+logger = logging.getLogger(__name__)
+
+
+class FenicsxBridge(BaseSimulationAdapter):
+    """Bridge to FEniCSx / DOLFINx for finite-element PDE solving."""
+
+    _engine_name = "fenicsx"
+    _package_checks = ["dolfinx"]
+    _install_hint = "conda install -c conda-forge fenics-dolfinx"
+
+    def configure(self, params: dict[str, Any]) -> None:
+        super().configure(params)
+        # Expected keys: mesh_resolution, element_degree, equation_type
+
+    def run(self, input_data: dict[str, Any] | None = None) -> SimulationResult:
+        def _run(data: dict[str, Any]) -> dict[str, Any]:
+            import dolfinx
+            import numpy as np
+            import ufl
+            from dolfinx import fem, mesh
+            from mpi4py import MPI
+
+            # Default: solve Poisson on unit square
+            n = self._params.get("mesh_resolution", 32)
+            degree = self._params.get("element_degree", 1)
+            domain = mesh.create_unit_square(MPI.COMM_WORLD, n, n)
+            V = fem.functionspace(domain, ("Lagrange", degree))
+
+            u = ufl.TrialFunction(V)
+            v = ufl.TestFunction(V)
+            f = fem.Constant(domain, 1.0)
+            a = ufl.dot(ufl.grad(u), ufl.grad(v)) * ufl.dx
+            L = f * v * ufl.dx
+
+            # Dirichlet BC u=0 on boundary
+            tdim = domain.topology.dim
+            fdim = tdim - 1
+            domain.topology.create_entities(fdim)
+            boundary_facets = dolfinx.mesh.locate_entities_boundary(
+                domain, fdim, lambda x: np.full(x.shape[1], True)
+            )
+            bc = fem.dirichletbc(
+                0.0,
+                dolfinx.fem.locate_dofs_topological(V, fdim, boundary_facets),
+                V,
+            )
+
+            problem = fem.petsc.LinearProblem(a, L, bcs=[bc])
+            uh = problem.solve()
+
+            # Extract L2 norm as scalar metric
+            expr = fem.Expression(uh * uh, V.element.interpolation_points())
+            uh2 = fem.Function(V)
+            uh2.interpolate(expr)
+            l2_norm = float(domain.comm.allreduce(
+                fem.assemble_scalar(fem.form(uh2 * ufl.dx)), op=MPI.SUM
+            ) ** 0.5)
+
+            return {
+                "l2_norm": l2_norm,
+                "dofs": V.dofmap.index_map.size_global,
+                "mesh_cells": domain.topology.index_map(tdim).size_global,
+            }
+
+        return self._run_wrapped(_run, input_data)

src/simulations/gromacs_bridge.py

@@ -0,0 +1,39 @@
+# SPDX-License-Identifier: AGPL-3.0
+"""GROMACS bridge via gmxapi.
+
+Install: conda install -c conda-forge gromacs && pip install gmxapi
+"""
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from .base_adapter import BaseSimulationAdapter, SimulationResult
+
+
+logger = logging.getLogger(__name__)
+
+
+class GromacsBridge(BaseSimulationAdapter):
+    """Bridge to GROMACS molecular dynamics via gmxapi."""
+
+    _engine_name = "gromacs"
+    _package_checks = ["gmxapi"]
+    _install_hint = "conda install -c conda-forge gromacs && pip install gmxapi"
+
+    def configure(self, params: dict[str, Any]) -> None:
+        super().configure(params)
+
+    def run(self, input_data: dict[str, Any] | None = None) -> SimulationResult:
+        def _run(data: dict[str, Any]) -> dict[str, Any]:
+            import gmxapi as gmx
+
+            version = getattr(gmx, "__version__", "unknown")
+            # gmxapi requires actual TPR input for a real run.
+            # Return availability metadata.
+            return {
+                "gmxapi_version": version,
+                "note": "gmxapi available; provide .tpr file for production run",
+            }
+
+        return self._run_wrapped(_run, input_data)