PyAntiGen 1.0.9__py3-none-any.whl

framework/template/data/make_flipflop_data.py

@@ -0,0 +1,174 @@
+"""
+Generate the synthetic Flipflop dataset (Flipflop.csv) used by Example4/Example5.
+
+The model is the two-step chain A -> B -> C (rates k_A_to_B, k_B_to_C) dosed by
+an event (A = dose at t = delay), observed through the scaled output
+predicted_B = SF * B_Comp1 / V_Comp1 on a log10 scale. Because
+
+    B(tau) = dose * k1 * (exp(-k1 tau) - exp(-k2 tau)) / (k2 - k1)
+
+swapping (k1, k2) -> (k2, k1) rescales B by k2/k1, and a fitted SF absorbs that
+rescaling exactly: (k1, k2, SF) and (k2, k1, SF*k1/k2) produce *identical*
+predicted_B trajectories. That is the classic pharmacokinetic "flip-flop"
+ambiguity, and it makes the likelihood exactly bimodal in these parameters.
+
+To turn the exact symmetry into a *known, finite* likelihood gap between the
+two modes, the Early treatment also carries a handful of very noisy direct
+observations of predicted_A = A_Comp1 / V_Comp1 (A depends only on k1, so it
+breaks the swap). sigma_logA is tuned so the swapped mode sits near the 95%
+chi-square threshold (dNLL = 1.9207): high enough to make the true confidence
+region interesting, low enough that a mis-scaled dNLL moves it across the
+threshold and visibly changes the reported CI.
+
+The seed is fixed so the committed Flipflop.csv is reproducible. After writing
+the CSV the script refits both modes with scipy against the closed-form model
+(no RoadRunner involved) and prints the *realized* swap-mode dNLL gap under the
+same frozen-sigma convention the framework's diagnostics use, so the expected
+gap is recorded next to the data it belongs to.
+"""
+import argparse
+
+import numpy as np
+import pandas as pd
+
+# Ground truth
+K1_TRUE, K2_TRUE, SF_TRUE = 0.35, 0.07, 1.6
+SIGMA_LOGB = 0.05   # dex, noise on log10(SF*B)
+SIGMA_LOGA = 0.75   # dex, noise on log10(A); tuned to put the swap mode near dNLL ~ 2
+N_B_REPS = 3
+
+TREATMENTS = {
+    "Early": {"dose": 10.0, "delay": 5.0,
+              "t_B": np.arange(6.0, 48.1, 3.0), "t_A": np.array([6.0, 9.0, 12.0, 15.0])},
+    "Late":  {"dose": 5.0, "delay": 10.0,
+              "t_B": np.arange(12.0, 48.1, 3.0), "t_A": np.array([])},
+}
+
+FLOOR = 1e-12  # same floor the loss-config expressions use
+
+
+def chain_A(t, dose, delay, k1):
+    tau = np.maximum(np.asarray(t, dtype=float) - delay, 0.0)
+    return np.where(tau > 0, dose * np.exp(-k1 * tau), 0.0)
+
+
+def chain_B(t, dose, delay, k1, k2):
+    tau = np.maximum(np.asarray(t, dtype=float) - delay, 0.0)
+    if abs(k1 - k2) < 1e-10:
+        core = dose * k1 * tau * np.exp(-k1 * tau)
+    else:
+        core = dose * k1 * (np.exp(-k1 * tau) - np.exp(-k2 * tau)) / (k2 - k1)
+    return np.where(tau > 0, core, 0.0)
+
+
+def log10f(x):
+    return np.log10(np.maximum(x, FLOOR))
+
+
+def generate(seed):
+    rng = np.random.default_rng(seed)
+    rows = []
+    for name, tr in TREATMENTS.items():
+        logB_true = log10f(SF_TRUE * chain_B(tr["t_B"], tr["dose"], tr["delay"], K1_TRUE, K2_TRUE))
+        logB_reps = logB_true[:, None] + rng.normal(0.0, SIGMA_LOGB, size=(len(logB_true), N_B_REPS))
+        logA = {}
+        if len(tr["t_A"]):
+            logA_true = log10f(chain_A(tr["t_A"], tr["dose"], tr["delay"], K1_TRUE))
+            for t, v in zip(tr["t_A"], logA_true + rng.normal(0.0, SIGMA_LOGA, size=len(tr["t_A"]))):
+                logA[t] = v
+        for i, t in enumerate(tr["t_B"]):
+            rows.append({
+                "Treatment": name, "time": t,
+                "logB1": logB_reps[i, 0], "logB2": logB_reps[i, 1], "logB3": logB_reps[i, 2],
+                "logA": logA.get(t, np.nan),
+            })
+    return pd.DataFrame(rows)
+
+
+# --- realized-gap check (framework NLL convention, closed-form model) --------
+
+def _stack_data(df):
+    """Return per-treatment stacked logB data and Early logA data."""
+    out = {}
+    for name, tr in TREATMENTS.items():
+        sub = df[df["Treatment"] == name]
+        t = np.concatenate([sub["time"].to_numpy()] * N_B_REPS)
+        y = np.concatenate([sub[f"logB{i+1}"].to_numpy() for i in range(N_B_REPS)])
+        out[name] = (t, y)
+    early = df[(df["Treatment"] == "Early") & df["logA"].notna()]
+    out["Early_A"] = (early["time"].to_numpy(), early["logA"].to_numpy())
+    return out
+
+
+def _ssr_terms(p, data):
+    """Per-observable (SSR, n) at parameters p = (k1, k2, SF)."""
+    k1, k2, sf = p
+    terms = {}
+    for name, tr in TREATMENTS.items():
+        t, y = data[name]
+        pred = log10f(sf * chain_B(t, tr["dose"], tr["delay"], k1, k2))
+        terms[name] = (float(np.sum((y - pred) ** 2)), len(y))
+    t, y = data["Early_A"]
+    pred = log10f(chain_A(t, TREATMENTS["Early"]["dose"], TREATMENTS["Early"]["delay"], k1))
+    terms["Early_A"] = (float(np.sum((y - pred) ** 2)), len(y))
+    return terms
+
+
+def _weighted_nll(p, data, sigmas):
+    terms = _ssr_terms(p, data)
+    return sum(ssr / (2.0 * sigmas[k] ** 2) for k, (ssr, n) in terms.items())
+
+
+def frozen_sigmas_at(p, data, k_params=3):
+    """Framework convention: sigma = sqrt(SSR / max(1, n - k/n_observables)),
+    where n_observables counts observables in the same loss config (Early has
+    logB+logA -> 2, Late has logB -> 1)."""
+    terms = _ssr_terms(p, data)
+    n_obs_cfg = {"Early": 2, "Early_A": 2, "Late": 1}
+    return {k: max(np.sqrt(ssr / max(1, n - k_params / n_obs_cfg[k])), 1e-6)
+            for k, (ssr, n) in terms.items()}
+
+
+def fit_mode(x0, data, sigmas):
+    from scipy.optimize import minimize
+    obj = lambda q: _weighted_nll(10.0 ** q, data, sigmas)
+    res = minimize(obj, np.log10(x0), method="Nelder-Mead",
+                   options={"maxiter": 4000, "xatol": 1e-10, "fatol": 1e-12})
+    return 10.0 ** res.x, res.fun
+
+
+def report_gap(df):
+    data = _stack_data(df)
+    # crude sigmas for a first fit, then freeze at the global optimum and refit
+    sigmas = {"Early": SIGMA_LOGB, "Late": SIGMA_LOGB, "Early_A": SIGMA_LOGA}
+    p_true, _ = fit_mode([K1_TRUE, K2_TRUE, SF_TRUE], data, sigmas)
+    sigmas = frozen_sigmas_at(p_true, data)
+    p_true, nll_true = fit_mode(p_true, data, sigmas)
+    p_swap0 = [p_true[1], p_true[0], p_true[2] * p_true[0] / p_true[1]]
+    p_swap, nll_swap = fit_mode(p_swap0, data, sigmas)
+    print(f"  global mode : k1={p_true[0]:.4f}  k2={p_true[1]:.4f}  SF={p_true[2]:.4f}")
+    print(f"  swapped mode: k1={p_swap[0]:.4f}  k2={p_swap[1]:.4f}  SF={p_swap[2]:.4f}")
+    print(f"  frozen sigmas: " + ", ".join(f"{k}={v:.4f}" for k, v in sigmas.items()))
+    print(f"  realized swap-mode dNLL gap = {nll_swap - nll_true:.4f}"
+          f"  (95% threshold = 1.9207)")
+    return nll_swap - nll_true
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--seed", type=int, default=5)
+    ap.add_argument("--out", type=str, default="Flipflop.csv")
+    ap.add_argument("--scan", type=int, default=0,
+                    help="scan seeds 0..N-1 and report each realized gap instead of writing")
+    args = ap.parse_args()
+
+    if args.scan:
+        for s in range(args.scan):
+            df = generate(s)
+            print(f"seed {s}:")
+            report_gap(df)
+    else:
+        df = generate(args.seed)
+        df.to_csv(args.out, index=False, float_format="%.6g")
+        print(f"Wrote {args.out}  (seed={args.seed})")
+        report_gap(df)

pyantigen-1.0.9.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: PyAntiGen
+Version: 1.0.9
+Summary: Short one-line description of what PyAntiGen does
+Author: Open Source Contributor
+Author-email: Don <you@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/you/PyAntiGen
+Keywords: alzheimer,immunology,simulation
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tellurium
+Requires-Dist: scipy
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: numdifftools
+Requires-Dist: openpyxl
+Requires-Dist: matplotlib
+Requires-Dist: pypesto
+Dynamic: author
+Dynamic: license-file
+
+# PyAntiGen
+
+PyAntiGen is a declarative, object-oriented framework for generating compartmental biological models in Antimony format. It is designed to abstract away the repetitive boilerplate of defining reactions and compartments manually, allowing researchers to build complex, scalable models using clean Python syntax.
+
+## Features
+
+- **Object-Oriented Modules:** Encapsulate tissues, flows, synthesis, and excretion into reusable Python classes.
+- **Dynamic Registration:** Automatically binds reactions, compartments, and species to the global model state when a module is instantiated.
+- **Project Scaffolding:** Includes a CLI command to instantly spin up new modeling projects with all necessary directories.
+- **Isotope Tracking:** Natively supports tracking labeled isotopes and generating corresponding parallel reactions.
+
+## Installation
+You can install PyAntiGen into your Python environment with:
+```bash
+pip install pyantigen
+```
+
+You can also install PyAntiGen globally into your preferred Python environment by cloning this repository and running pip:
+
+```bash
+git clone https://github.com/elbert5770/PyAntiGen.git
+cd PyAntiGen
+pip install -e .
+```
+
+## Quick Start: Creating a New Model
+
+Because PyAntiGen is installed as a system-level Python package, you don't need a copy of the framework files in your working directory. 
+
+To start a brand new modeling workspace, just open a terminal and navigate to a folder where you want your project to live (be careful not to build within the PyAntiGen folder itself) and run:
+
+```bash
+pyantigen-create MyNewModel
+```
+
+This will automatically scaffold the following project directory:
+```text
+MyNewModel/
+├── .agents/
+│   └── skills/          (agent skills, e.g. module generation, ODE conversion)
+├── Projects/
+│   ├── Example/         (full example: generate, run + Modules/, Engine/)
+│   │   ├── Model_generate.py
+│   │   ├── Model_run.py
+│   │   └── Modules/     (Data, AntimonyGen, Plots, Simulate, Optimize, Experiment, Events)
+│   └── MyNewModel/      (same structure, Modules/ pre-populated from Example)
+│       ├── Model_generate.py
+│       ├── Model_run.py
+│       └── Modules/     (Data, AntimonyGen, Plots, Simulate, Optimize, Experiment, Events)
+├── antimony_modules/
+│   └── __init__.py      (plus Basic/ for the example)
+├── data/                (Example experiment CSVs copied for the example)
+├── antimony_models/
+│   └── Example/         (Example_parameters.csv, Example_InitialConditions.csv, etc.)
+├── generated/
+│   └── Example/         (reaction dict, rules, etc. after generate)
+├── results/
+│   └── Example/         (plots from Model_run.py)
+├── SBML_models/
+└── pyantigen_settings.json   (e.g. archive_with_timestamp: false)
+```
+
+Every project folder under `Projects/` has a script called `Model_generate.py` that is run to generate the model. `MODEL_NAME` is derived automatically from the enclosing folder name (see `AntiGen_paths.py`), so being in the right project folder is all that's needed to generate/run the correct project. From `MyNewModel/Projects/Example/` run:
+
+```bash
+python Model_generate.py
+```
+
+This generates the model from the specified files in 'antimony_modules' and writes outputs to `antimony_models/Example/` and `generated/Example/`. This is entirely optional as Model_run.py also calls the constructor functions in `Model_generate.py`.
+
+To run a simulation or optimization, you may edit the parameters in `antimony_models/Example/Example_parameters.csv`, derived parameters in `antimony_models/Example/Example_manual.txt`, and initial conditions in `antimony_models/Example/Example_InitialConditions.csv`.
+
+Then, run `Model_run.py` to simulate the Example in Tellurium/RoadRunner:
+
+```bash
+python Model_run.py --simulate Example
+```
+
+To run optimization examples use the --optimize flag:
+
+```bash
+python Model_run.py --optimize Example1
+python Model_run.py --optimize Example2
+python Model_run.py --optimize Example3
+python Model_run.py --optimize Example4
+python Model_run.py --optimize Example5
+```
+
+Each example prints a banner explaining what it demonstrates before the run and a "what to look for" summary after it. All output lands in `results/Example/`, prefixed with the example and group names so runs never overwrite each other — e.g. `Example_Example2_ADpos_profile_likelihood.png`, `Example_Example4_Flipflop_optimization_results.csv`.
+
+Examples 1–3 demonstrate structural identifiability: Example1/2 split the fit so each sub-problem is well-posed, while Example3 deliberately fits two exactly confounded parameters (`SF`/`V_Comp1`) jointly and shows how profile likelihood flags the ridge that likelihood slices and Sobol indices miss.
+
+Examples 4–5 go further and test the *accuracy* of the profile likelihood ΔNLL itself, on a genuinely multimodal problem with a log10 objective. The chain A → B → C observed through `SF*B_Comp1/V_Comp1` has the classic pharmacokinetic "flip-flop" ambiguity — swapping the two rate constants and rescaling `SF` reproduces the data exactly — so the likelihood has two modes separated by a known ΔNLL gap (~2.4 at the NLL optimum, set by a few deliberately noisy observations of A and printed by `data/make_flipflop_data.py`). Example4 starts in the correct basin. Accurate profiles must (a) dip below zero by a known amount (~−2.1), because the fitting objective's per-observable averaging places the fit away from the inference NLL optimum that ΔNLL is anchored to, and (b) show the second mode at ~+0.8 — below the 95% threshold, so the correct confidence set is a union of two disjoint intervals; a walker that stops at the first threshold crossing never finds it, and a first-crossing CI extractor cannot represent it. Example5 starts in the wrong basin: sigmas are frozen at the wrong mode (inflating σ for the A data and deflating every ΔNLL), and the profile must dip to ~−0.98 at the true mode. `Projects/Example/Flipflop_reference.py` recomputes the exact reference profiles from the closed-form solution with scipy (independent of RoadRunner and of the framework's loss code), replicating the pipeline's conventions — fit objective for the anchor, MLE-frozen sigmas, summed NLL — and its `--compare results/Example/<run>.json` mode scores the framework's stored profile traces against the reference automatically.
+
+Your own model lives under `Projects/MyNewModel/`. Modify the code for your model in `Projects/MyNewModel/Modules/`, `Projects/MyNewModel/Model_generate.py`, and `Projects/MyNewModel/Model_run.py`. Your problem will also require new modules in `antimony_modules/` to define the model.
+
+
+### Running from an IDE (Cursor / VS Code)
+
+The **Play** button uses whichever Python interpreter is currently selected. If your environment (conda/venv) isn’t loaded, the run may fail with import or path errors.
+
+1. **Select the correct interpreter**: `Ctrl+Shift+P` (or `Cmd+Shift+P` on macOS) → **Python: Select Interpreter** → choose the environment where you ran `pip install -e .` (e.g. your conda or venv).
+2. **Run from project root**: Open the *project* folder (e.g. `MyNewModel`) as the workspace. Use **Run and Debug** (or Play on `Projects/Example/Model_run.py`); the project root is resolved from the script location so `antimony_models/Example/`, `generated/Example/`, and `results/Example/` resolve correctly.

pyantigen-1.0.9.dist-info/RECORD

@@ -0,0 +1,55 @@
+framework/AntimonyGen.py,sha256=UhPnQ762yAJXAciXU9u5Vju8sTdJSrP-EzRkWu_XvAY,1404
+framework/RxnDict_to_antimony.py,sha256=zStKjg14UBBbi5D4xGjZEPkMXH2igomD1ViEhtW40uw,25208
+framework/TelluriumGen.py,sha256=zyjT9nDE8wgswp9y-uTs1LgiTuRA1FQv5RBu_TXPE00,618
+framework/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+framework/antimony_utils.py,sha256=WT67cxgKSFwxpfwB0bfqYtnsB_SG84ynu6HKIDa2c0k,12341
+framework/cli.py,sha256=YiDGBwT5aAlwmW-hKyA9gfixKrlT_pT3rmSNw_Diq2g,11123
+framework/data_interpolation.py,sha256=nWMYNlJJJgze5qGQj4y1eXelcujrZsy3Dc7_bwEx55A,11982
+framework/isotopomer_tools.py,sha256=7LTiO3mg-Nt0m-pRXmprnoyTyANff_4QUOadbZxHWQ4,1233
+framework/model_generation.py,sha256=34mReS6angE7zcOHA3flz2dXKmutE59C-ryv2hk6YVA,2248
+framework/models.py,sha256=CAwEGZYVPzgR4BX1IjAqcNHDAT9n4_tqjQSJl9bEN-I,7075
+framework/module_base.py,sha256=xlNzbSTMIrgOkNNhQyxyneOCDuia-_ezgPR7qHCKJbc,1260
+framework/pyantigen.py,sha256=PBdOlPsHAHNhE69n6BeN3-nLovqs_Fs0Bw8ajEuKbos,1621
+framework/rate_laws.py,sha256=VVw06MPBgA8H5EaY7xRlW3UntF_90its_U0u-HS5frk,3629
+framework/reaction_creation.py,sha256=n8qb6Dzr2BfBxGmkaEkSkmBlQTHI-1Li-r2kqFBxqE8,1169
+framework/template/Example/AntiGen_paths.py,sha256=BbB-B0Pn0iHjLT67iLWi9U4WEoSkmQpNdflNPzr2mvQ,734
+framework/template/Example/Flipflop_reference.py,sha256=aIYs_eM-0gOoYGInS-pHkeGcewGN7T3gHDO0ufRfqMI,16818
+framework/template/Example/Model_generate.py,sha256=kddZCM1vClC49h3vPvz9hzJtxPWBJTN8aBgy4cnfMbs,1164
+framework/template/Example/Model_run.py,sha256=MxAEIBb37O4KNdu_jZXvup-8Eey2XmIOU2R-gHggCDU,12651
+framework/template/Example/Engine/Anchor_cache.py,sha256=NRxp9m-Kozw7gazG72riG5kaXV1nI0fA-tkr3G9UxIo,7220
+framework/template/Example/Engine/Deadline.py,sha256=21SP1tgj_62DbheVdd2dedtqfEkVrG5H4wLQ0AP9EyE,22259
+framework/template/Example/Engine/Evaluator.py,sha256=5aRnZYVmLKSIYKhAgQFnL57Yx3vrWcj2wZK4qKTfZYo,53221
+framework/template/Example/Engine/Event_times.py,sha256=cd4OJthHWPYHYHr6TEXp7b2_r8EyucAW3u-ls_hTfGQ,19043
+framework/template/Example/Engine/Fast_profile.py,sha256=pOyn-xumPqiEkAtjQYQLXyOfb9NdNNeG4TxfebMZGJ8,31644
+framework/template/Example/Engine/Fit_cache.py,sha256=GWr8y2QsaWdibwdmJ6gLLwvk7L9tNfoaCLPSJYiC_KU,12913
+framework/template/Example/Engine/Identifiability.py,sha256=x9zIhOhM3iqYyJNTevFtxyk4t8Jxpq9NW621ear0Z0g,32070
+framework/template/Example/Engine/Model_optimize.py,sha256=IZtWPEATGMDz_WfBtLLtoGx7Q3_oiIFo-BrpxbSPiDw,69146
+framework/template/Example/Engine/Model_simulate.py,sha256=2cFFePfDwUnTyl04qUM3UR_VQ6YZFrksKLiT_J2V3OE,4293
+framework/template/Example/Engine/Nuisance_sensitivity.py,sha256=qUUmXo8DffgJKAFwTOaiZ-b5qaqkgCyEcnlawqMCBoM,11928
+framework/template/Example/Engine/Optimize.py,sha256=wJmVP_LdNbGOaRL_v0hoWMGcLsX2GOcJZMyXF0FIwN4,313888
+framework/template/Example/Engine/Petab_export.py,sha256=hKAq3USiZdUN-OskkYuhkEgPmDL-uV-Tliz3tPGDmrM,14188
+framework/template/Example/Engine/Preequil_cache.py,sha256=LBVV_tw_B7P_jtnfWW_1X6jX0b3Q7Sg6qjhBeO0cP2M,15895
+framework/template/Example/Engine/Profile_checkpoint.py,sha256=hfO5YCrbao8JOZoCtX1yhcm5PA2tZlp9TArM9AOA9iU,16490
+framework/template/Example/Engine/Results.py,sha256=-QFcDTGCTXF5519c3Fjdqr6MEWAfCqIKSpr8FMphaDA,18832
+framework/template/Example/Engine/Sensitivity_analysis.py,sha256=DqRsjCsIQD9v3GIlW8DR66zvZDg5UHHlbB_q39tMeuQ,12162
+framework/template/Example/Engine/Simulate.py,sha256=EkcsH7pFVta2vAjH3sW1UsrPsM9AmdQftt8xg9m2Hrw,27385
+framework/template/Example/Modules/Data.py,sha256=R24iiJhA2Nt2R4BS1aPZ6I3Pd0x3wNj6T1hP-3Bq3Go,2250
+framework/template/Example/Modules/Events.py,sha256=1ZDpVUToMn1LOH1MVDfY3QwGPKiGvKUJK7YbWjN0w9w,325
+framework/template/Example/Modules/Experiment.py,sha256=g87HshbsMFgM0BdGHi0rbzEASYb6Jdqcz_9Vgi5hBTs,8033
+framework/template/Example/Modules/Loss_config.py,sha256=FTeTZMQeIG6YW0MxaFH0V7LRKxvNtVcy7WbHc398glU,2474
+framework/template/Example/Modules/Observed_species.py,sha256=J44Ts9SuCd7IGhC6n3pdumMgBTV6I9PTtQ6diGUxP7A,215
+framework/template/Example/Modules/Optimizer_settings.py,sha256=xGKhmx7Z8yuTilzdR3xqGtRuRqloG7HPVLjwWOKm5jU,12383
+framework/template/Example/Modules/Plots.py,sha256=Ys9ZLq48XYybZQ_ZYo10lsS8GC77lfcdZi6cN6rx78c,3835
+framework/template/Example/Modules/Solver_settings.py,sha256=RLTyhvqBhRZfCYigdastmnVInoHmUd0dWZ4CS6JsaEA,614
+framework/template/Example/Modules/Update_opt_parameters.py,sha256=GVWKtLqDzAuEyexKh1tMxRK4fxbvk_E_LP29Nd0Taw8,1066
+framework/template/Example/Modules/Update_parameters.py,sha256=g0cvFMwcax0nR02Q-nFRokoF-lqZc07GU-rA1fGWbwE,1961
+framework/template/data/ADneg.csv,sha256=0AFLqSMQzdiP0CnKivcSLhAPGvSTBHHvURYNwjximIc,1649
+framework/template/data/ADpos.csv,sha256=yomwM-351rqRGRG5HRWXVvH7YjCL02htibz1GhUr3F8,1627
+framework/template/data/Flipflop.csv,sha256=Iz9dHh078n9cKMQGTkaO7ujXotL8-yekSIHaMALIgtQ,1097
+framework/template/data/make_flipflop_data.py,sha256=K48EmCgS4N05l2nUXypNXuCS_mJ5P7VTopaxXrO4wd4,7152
+pyantigen-1.0.9.dist-info/licenses/LICENSE,sha256=m8qNO2yS4hZm11HQeYNQ6AM05qIWl3D3cpofjwTPfzY,1070
+pyantigen-1.0.9.dist-info/METADATA,sha256=jE6KYWDEQ2mBWSOOHHZTf7EFyWJ5P_eoGCJeS7zvbv8,8253
+pyantigen-1.0.9.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pyantigen-1.0.9.dist-info/entry_points.txt,sha256=zZGw0nx5OM7k3G9oAdoDbz4S9k8OzuYU72IONHqONZw,66
+pyantigen-1.0.9.dist-info/top_level.txt,sha256=hzpv2xEeSkKTVweFn8I8XnG5zJJOIOTB38-_zgJJSUw,10
+pyantigen-1.0.9.dist-info/RECORD,,

pyantigen-1.0.9.dist-info/WHEEL

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

pyantigen-1.0.9.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pyantigen-create = framework.cli:create_project

pyantigen-1.0.9.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 UW Elbert Lab
+
+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.

pyantigen-1.0.9.dist-info/top_level.txt

@@ -0,0 +1 @@
+framework