topoexploit 0.1.0__py3-none-any.whl

topoexploit-0.1.0.dist-info/METADATA

@@ -0,0 +1,523 @@
+Metadata-Version: 2.4
+Name: topoexploit
+Version: 0.1.0
+Summary: TopoExploit: complex-valued spectral language model for security tasks (vulnerability analysis, patch analysis, exploit development), trained on ExploitGym.
+Author: grisun0
+License: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/grisuno/TopoExploit
+Project-URL: Documentation, https://github.com/grisuno/TopoExploit#readme
+Project-URL: Issues, https://github.com/grisuno/TopoExploit/issues
+Keywords: language-model,code-generation,security,exploit,red-team,complex-valued,quaternion,spectral,grassmannian,hrm,transformer
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.1
+Requires-Dist: numpy>=1.24
+Requires-Dist: safetensors>=0.4
+Requires-Dist: tiktoken>=0.5
+Provides-Extra: train
+Requires-Dist: datasets>=2.14; extra == "train"
+Requires-Dist: huggingface-hub>=0.20; extra == "train"
+Provides-Extra: lens
+Requires-Dist: huggingface-hub>=0.20; extra == "lens"
+Provides-Extra: api
+Requires-Dist: fastapi>=0.100; extra == "api"
+Requires-Dist: uvicorn>=0.22; extra == "api"
+Requires-Dist: xgrammar>=0.2.2; extra == "api"
+Provides-Extra: structured
+Requires-Dist: xgrammar>=0.2.2; extra == "structured"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Dynamic: license-file
+
+# TopoExploit
+
+A 122M parameter complex-valued autoregressive language model trained on
+ExploitGym for security tasks: vulnerability analysis, patch analysis, and
+exploit development. It inherits the TopoGPT-2 spectral architecture and is
+instrumented with spectral and geometric diagnostics over training dynamics.
+
+This repository contains the model definition, the ExploitGym curriculum
+trainer (with EWC + replay anti-forgetting), a small-to-large weight
+transfer tool, and an inference engine tailored to exploit-related tasks.
+
+The work is documented in detail in `topogpt3.md`.
+
+## Documentation
+
+- [Quick Start](quickstart.md) — Get running in under five minutes.
+- [Tutorial](tutorial.md) — Step-by-step guide from installation to custom training.
+- [Essential Concepts](essentials.md) — Core ideas behind complex-valued spectral operators, Grassmannian diagnostics, and HRM.
+- [Command Cheatsheet](cheatsheet.md) — Quick reference for CLI commands and Python API.
+- [Comparison](comparison.md) — How TopoExploit relates to similar small-scale and security-focused models.
+- [Claude Integration Guide](claude.md) — Using TopoExploit with Anthropic models and hybrid pipelines.
+- [Technical Paper](topogpt3.md) — Full experimental write-up and results.
+
+## Motivation
+
+Most security and code models scale through size. TopoExploit explores the
+opposite direction: whether better representations can let a much smaller
+model learn programming and vulnerability structure efficiently. Source code
+and binary patches carry strong internal structure (recursion, composition,
+scope, repeated motifs), and complex-valued parameters may encode phase
+relationships that capture this structure more compactly than real-valued
+weights of equal count.
+
+By training on real-world vulnerabilities through the ExploitGym benchmark,
+the model aims to reason over C/C++ userspace programs, the V8 engine, and
+the Linux kernel — producing vulnerability analyses, patch explanations, and
+exploit strategies.
+
+## Checkpoints
+
+Latest trained weights live under `checkpoints_topoexploit/last/` and are
+stored as safetensors plus an optimizer file and a JSON state.
+
+## Architecture summary
+
+- Autoregressive transformer with complex-valued spectral operators.
+- Quaternion-inspired layers for parameter efficiency.
+- A Gauss-style optimization for complex multiplication: three real multiplications per contraction instead of four.
+- Sliding window attention (`ATTN_WINDOW`) with configurable window size to control KV-cache memory footprint in long sequences. Set to 0 for full attention or a positive integer for local attention with O(W * S) complexity.
+- Latent memory tokens (`N_MEMORY_TOKENS`) for fixed-size context compression across long sequence segments.
+- Approximately 122M parameters at the `large` scale.
+
+The base architecture lives in `topogpt3/model.py`. The ExploitGym curriculum
+trainer and the Grassmannian / Fisher / phase diagnostics live in
+`topogpt3/train.py`.
+
+## Training pipeline
+
+Training proceeds through a three-tier curriculum over the ExploitGym
+dataset:
+
+1. Vulnerability analysis (sequence length 256, 6 epochs)
+2. Patch analysis (sequence length 512, 3 epochs)
+3. Exploit development (sequence length 768, 4 epochs)
+
+Each tier maintains disjoint train, validation and holdout splits. The
+holdout is never used during training; it is reserved to measure true
+generalization at the end of each tier and at the end of the full pipeline.
+
+### Anti-forgetting: EWC + Replay
+
+Because the tiers are trained sequentially on different task distributions,
+the trainer supports Elastic Weight Consolidation (EWC) and replay buffers to
+mitigate catastrophic forgetting:
+
+- `--ewc-lambda` (default 5000) — strength of the EWC penalty on important parameters.
+- `--replay-ratio` (default 0.25) — fraction of replay samples mixed into each batch.
+- `--fisher-batches` (default 50) — number of batches used to estimate the Fisher information.
+
+This is the recommended retraining pass when continuing from an earlier
+checkpoint.
+
+### Weight transfer
+
+A small (24.5M) TopoGPT-2 checkpoint can seed a large (122M) TopoExploit
+model. `transfer_weights.py` copies matching layers directly, pads
+embedding and linear projections, copies matching spectral frequency bins,
+and randomly initializes the rest:
+
+```
+python transfer_weights.py \
+    --from checkpoints_topogpt3/last/model.safetensors \
+    --to checkpoints_topoexploit/last/model.safetensors \
+    --scale-from small --scale-to large
+```
+
+Checkpoints are written atomically to `checkpoints_topoexploit/last/`.
+Older `step_*` directories are still loadable for backwards compatibility.
+
+## Optimization diagnostics
+
+At regular intervals the trainer extracts the kernel tensor, performs a
+truncated SVD on the leading 16 modes, normalizes them, and records:
+
+- accumulated phase between consecutive normalized dominant kernels,
+- net angular drift `W` (a winding-like proxy),
+- empirical Fisher spectral gap `Delta_F = lambda_r - lambda_{r+1}`,
+- dominant rank `r` from an elbow rule on the singular values.
+
+Grassmannian tracking history is written to `checkpoints_topoexploit/grass_history.jsonl`
+and training metrics to `topoexploit_history.jsonl`.
+
+## Inference
+
+The primary inference entry point for exploit tasks is `infer_exploitgym.py`,
+which loads the 122M model and generates from prompts derived from the
+ExploitGym repository. It supports three tiers:
+`vulnerability_analysis`, `patch_analysis`, and `exploit_development`.
+
+Single prompt:
+
+```
+python infer_exploitgym.py --prompt "Analyze this vulnerability:" \
+    --tier vulnerability_analysis --device cuda
+```
+
+Evaluate on holdout tasks:
+
+```
+python infer_exploitgym.py --eval-holdout --tier exploit_development \
+    --max-samples 50 --device cuda
+```
+
+Interactive prompt REPL:
+
+```
+python infer_exploitgym.py --interactive --device cuda
+```
+
+You can also use the standard autoregressive and hierarchical recursive
+reasoning (HRM) samplers from the underlying package.
+
+## One-shot scripts
+
+`run_exploitgym.sh` drives the full prepare / transfer / train / eval
+pipeline:
+
+```
+./run_exploitgym.sh prepare     -- clone repo + tokenize data
+./run_exploitgym.sh transfer    -- transfer weights from small model
+./run_exploitgym.sh train       -- train from scratch
+./run_exploitgym.sh train-init  -- train with transferred weights
+./run_exploitgym.sh eval        -- evaluate on holdout
+./run_exploitgym.sh full        -- prepare + transfer + train + eval
+```
+
+`run_exploitgym_v2.sh` runs the EWC + replay retraining pass:
+
+```
+./run_exploitgym_v2.sh v2-full     -- train v2 with EWC + replay, then eval
+./run_exploitgym_v2.sh v2-train    -- train only
+./run_exploitgym_v2.sh v2-infer    -- interactive inference
+./run_exploitgym_v2.sh v2-eval     -- holdout eval on all three tiers
+```
+
+## Repository layout
+
+```
+.
+├── topogpt3/                  pip-installable package
+│   ├── __init__.py            public API re-exports
+│   ├── model.py               base TopoGPT2 architecture, tokenizer, helpers
+│   ├── train.py               ExploitGym curriculum trainer + diagnostics + EWC/replay
+│   ├── exploitgym_config.py   TopoExploit training configuration
+│   ├── exploitgym_loader.py   ExploitGym data loader
+│   ├── ewc.py                 Elastic Weight Consolidation helpers
+│   ├── inference.py           standard autoregressive sampler
+│   ├── inference_hrm.py       hierarchical recursive reasoning sampler
+│   ├── continuation.py        auto-continuation engine (detect + resume truncated output)
+│   ├── lens_model.py          Jacobian-lens model adapter (LensModel protocol)
+│   ├── jlens.py               Jacobian lens fitting + application pipeline
+│   └── api_server.py          OpenAI-compatible HTTP API server (hardened)
+├── tests/                     BDD test suite
+├── eval/                      HumanEval benchmark harness
+│   ├── harness.py             evaluation pipeline
+│   ├── samplers.py            sampler registry (standard / HRM)
+│   ├── sandbox.py             sandboxed test executor
+│   ├── analysis.py            pass@k / metrics reporting
+│   └── diag_static.py         static checkpoint diagnostics
+├── infer_exploitgym.py        exploit-task inference entry point
+├── transfer_weights.py        small-to-large weight transfer tool
+├── run_exploitgym.sh          prepare / transfer / train / eval pipeline
+├── run_exploitgym_v2.sh       EWC + replay retraining pipeline
+├── app.py                     example entry point for downstream projects
+├── Makefile                   convenience targets for all common commands
+├── pyproject.toml             package metadata, dependencies, console scripts
+├── README.md                  this file
+├── topogpt3.md                full paper write-up
+├── quickstart.md              five-minute getting started guide
+├── tutorial.md                step-by-step usage tutorial
+├── essentials.md              core concepts explained
+├── cheatsheet.md              command and API quick reference
+├── comparison.md              comparison with similar models
+├── claude.md                  integration guide for Claude and Anthropic
+├── synthetic_dataset.py       optional synthetic dataset helper
+├── docs/                      HTML documentation and assets
+└── workflows/                 GitHub Actions workflows
+```
+
+## Requirements
+
+- Python 3.10 or newer
+- PyTorch with CUDA recommended (CPU works for small scales)
+- `safetensors`
+- `tiktoken` (BPE tokenizer)
+- `numpy`
+- `datasets` and `huggingface-hub` for data preparation (optional extra `[train]`)
+
+## Installation
+
+From a checkout of this repository:
+
+```
+pip install -e .
+```
+
+Extra dependencies:
+
+```
+pip install -e ".[train]"   # datasets, huggingface-hub
+pip install -e ".[lens]"    # huggingface-hub
+pip install -e ".[api]"     # fastapi, uvicorn, xgrammar (for the agent harness)
+pip install -e ".[dev]"     # pytest, ruff
+```
+
+Or install everything at once:
+
+```
+pip install -e ".[train,lens,api,dev]"
+```
+
+### Structured outputs and deterministic seeds
+
+The API server adopts the structured-output surface used by DeepInfer and
+OpenAI. Constrained decoding is powered by
+[xgrammar](https://github.com/mlc-ai/xgrammar) and works for both streaming
+and non-streaming requests.
+
+```bash
+# JSON Schema (OpenAI response_format)
+curl -s http://localhost:8800/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages":[{"role":"user","content":"Return a target as JSON."}],
+    "response_format":{
+      "type":"json_schema",
+      "json_schema":{
+        "name":"target",
+        "schema":{
+          "type":"object",
+          "properties":{"host":{"type":"string"},"port":{"type":"integer"}},
+          "required":["host","port"],
+          "additionalProperties":false
+        }
+      }
+    },
+    "seed":42
+  }'
+
+# Regex constraint (DeepInfer-style so_args)
+curl -s http://localhost:8800/v1/completions \
+  -H "Content-Type: application/json" \
+  -d '{"prompt":"CVE: ","so_args":{"schema_type":"regex","schema":"CVE-[0-9]{4}-[0-9]{4,7}"},"seed":7}'
+
+# EBNF grammar
+curl -s http://localhost:8800/v1/completions \
+  -H "Content-Type: application/json" \
+  -d '{"prompt":"","so_args":{"schema_type":"ebnf","schema":"root ::= \"status=\" (\"ok\" | \"fail\")"}}'
+```
+
+- `response_format.type` accepts `text`, `json_object`, `json_schema`,
+  `regex`, and `grammar`.
+- `so_args.schema_type` accepts `json`, `regex`, and `ebnf`, matching
+  DeepInfer's `SamplingParams`.
+- `seed` fixes the sampling RNG per request; identical prompts and
+  parameters produce identical output.
+- `auto_continue` cannot be combined with a structured-output constraint.
+- xgrammar ships with the `api` and `structured` extras:
+  `pip install -e ".[api]"` or `pip install -e ".[structured]"`.
+
+## Command-line usage
+
+Prepare and tokenize ExploitGym data:
+
+```
+python -m topogpt3.train --exploitgym --prepare-exploitgym --force-prepare
+```
+
+Run the full ExploitGym curriculum:
+
+```
+python -m topogpt3.train --exploitgym --train
+```
+
+Train with EWC + replay anti-forgetting:
+
+```
+python -m topogpt3.train --exploitgym --train --from-scratch \
+    --ewc-lambda 5000 --replay-ratio 0.25 --fisher-batches 50
+```
+
+Evaluate on the combined holdout:
+
+```
+python -m topogpt3.train --exploitgym --eval-holdout
+```
+
+Run exploit-task inference:
+
+```
+python infer_exploitgym.py --interactive --device cuda
+```
+
+### Makefile
+
+A `Makefile` at the repo root wraps common tasks. Run `make help` to see all
+targets.
+
+```
+make install           pip install -e ".[train,lens,api,dev]"
+make test              run full test suite
+make lint              ruff check + format
+make train             full curriculum training
+make infer             standard inference (prompt=def fibonacci)
+make infer-continue    inference with auto-continuation
+make infer-hrm         HRM inference
+make infer-think       HRM thinking mode with auto-continuation
+make jlens             Jacobian lens demo (fit 4 prompts)
+make api               start API server on port 8800 (no auth)
+make api-auth          start API server with authentication
+make eval              HumanEval benchmark (all 164 problems)
+make eval-sample       HumanEval single problem
+make pi                clone, build, and configure Pi agent
+make pi-setup          write provider config to ~/.pi/agent/models.json
+make pi-run            launch Pi pointed at local API
+make clean             remove __pycache__ and .pyc files
+```
+
+## Checkpoint compatibility
+
+The model is always built with the maximum sequence length across all
+curriculum tiers, so positional embeddings keep a fixed shape regardless of
+which tier is used as the entry point. Existing safetensors weights load
+without shape mismatch when restarting at a different tier.
+
+As of the 2026-08 sliding window update, the RoPE (Rotary Position Embedding)
+caches are stored as non-persistent buffers under the names `_cos_cache` and
+`_sin_cache`. Checkpoints from earlier versions that contain `cos_cache` and
+`sin_cache` are safely ignored during loading with `strict=False`. The caches
+are recomputed to match the current `MAX_SEQ_LEN` configuration at model
+instantiation time. Memory tokens (`memory_tokens`) are a new parameter
+introduced alongside the latent compression feature; missing this key in
+older checkpoints is harmless and produces a warning during load.
+
+## Limitations
+
+This is an exploratory small-scale study. The model is 122M parameters and is
+trained on a limited curriculum derived from the ExploitGym benchmark. The
+phase and angular drift measurements are diagnostics, not rigorous
+mathematical invariants. A real-valued control of the same parameter count,
+broader benchmarks, and longer training are needed before drawing stronger
+conclusions.
+
+Early generations show syntactic continuity and local semantic consistency.
+Exploit correctness and strong algorithmic reasoning remain limited at this
+scale and training duration.
+
+## Related work
+
+A 25M-parameter Transformer implementation designed to study language
+acquisition as a condensed matter phenomenon. Unlike traditional LLMs,
+TopoGPT-2 is engineered to reach a Topological Insulator state — a phase where
+grammatical and logical invariants are protected by a spectral gap. Using the
+Tiny Stories corpus:
+
+- [https://github.com/grisuno/TopoGPT2](https://github.com/grisuno/TopoGPT2)
+
+The ExploitGym benchmark used for training:
+
+- [https://github.com/ExploitGym](https://github.com/ExploitGym)
+
+## Citation
+
+If you build on this work, please cite:
+
+- [https://doi.org/10.5281/zenodo.20388757](https://doi.org/10.5281/zenodo.20388757)
+
+```
+grisuno, "TopoExploit: Exploring Complex-Valued Representations in Small
+Security Models", 2026.
+```
+
+## License
+
+AGPL v3.
+
+<<<<<<< HEAD
+
+---
+### Topo Journey
+If you are interested in this project, explore the architecture evolution:
+- [TopoGPT3](https://github.com/grisuno/TopoGPT3): Next evolution of the Topo model.
+- [LazyOwn](https://github.com/grisuno/LazyOwn): RedTeam/APT framework where Topo concepts are applied.
+
+=======
+>>>>>>> 50c3f62 (3d awesome vieew in doc sphere and some ablation)
+
+<!-- readmenator-kb-link -->
+## Knowledge Base
+
+This project has been analyzed by [ReadMenator](https://github.com/grisuno/ReadMenator),
+a zero-token polyglot static analysis tool. Regenerate with
+`pip install readmenator && readmenator . --rebuild`. Analysis outputs:
+
+- **[KNOWLEDGE_BASE.md](./KNOWLEDGE_BASE.md)** -- Full architecture reference with all
+  classes, functions, imports, dependency graphs, UML class diagrams, security
+  audit findings, community analysis, taint paths, hotspots, cycles, and more.
+- **[readmenator-agent/](./readmenator-agent/)** -- Agent-friendly, grep-optimized index.
+  - `INDEX.md` -- Quick reference: what each file does
+  - `SYMBOLS.md` -- Every symbol with file:line
+  - `ARCHITECTURE.md` -- Internal dependency pairs + external imports
+  - `API.md` -- Public function contracts
+  - `GOTCHAS.md` -- Change warnings (blast radius, cycles, hotspots)
+  - `SECURITY.md` -- Findings by severity with fix hints
+  - `MEMORY.md` -- Rules, workflow, style, deliverables, session log
+  - `MANIFEST.json` -- Freshness (git_commit + source_fingerprint) + read order
+  - `KB_<subsystem>.md` -- Per-subsystem context
+  - `recipes/*.md` -- Grounded task guides (add-function, fix-cycle, ...)
+- **[readmenator-wiki/](./readmenator-wiki/)** -- Navigable wiki (start here for the big picture).
+  - `index.md` -- Entry point: overview, reading order, god nodes, connections
+  - `community_*.md` -- One synthesis page per code community
+  - `connections.json` -- Typed bridges between communities
+  - `queries.md` -- Suggested questions + answer log
+  - `REPORT.md` -- Honest audit: coverage, confidence, limits
+- **[readmenator-graphrag/](./readmenator-graphrag/)** -- Zero-token GraphRAG index.
+  - `index.json` + `REPORTS.md` -- Query with `readmenator . ask "<question>"`
+- **[readmenator-apidocs/](./readmenator-apidocs/)** -- API reference (Sphinx/Doxygen style).
+  - `index.md` + `modules/*.md` -- Signatures, parameters, returns, raises, examples, call graphs
+  - `architecture.md` -- Tiered architecture + execution flows (control flow, call tree, sequence)
+  - `classes.md`, `genindex.md`, `COVERAGE.md` -- Hierarchy, A-Z index, doc coverage + warnings
+  - `index.html` + `api/` -- Offline searchable browser and machine-readable model (`api/index.json`, `api/modules/*.jsonl` one entity per line)
+- **[readmenator-maps/](./readmenator-maps/)** -- Interactive gallery (`index.html`).
+  - 5 system maps: architecture, workflow, sequence, dataflow, lifecycle
+  - `graph-force.html` -- Force-graph explorer (2D/3D, reach, paths, lenses)
+  - `graph-bundle.html` -- Edge bundle explorer (circle + sphere)
+  - `components.html` -- Component diagrams
+- **[docs/](./docs/)** -- Static site (GitHub Pages ready).
+  - Gallery copy + `llms.txt` (agent entry point) + `md/` docs + video
+- **[readmenator-diagrams/](./readmenator-diagrams/)** -- Component diagrams.
+  - `analysis.json` + `graph LR` markdown + per-component pages + `index.html`
+- **[readmenator-rules/](./readmenator-rules/)** -- Suggested Semgrep rules (`*.yml`),
+  `yara_rules.yar` (YARA-lite) + `exclusions.yaml` (false-positive blocklist)
+- **[readmenator.mp4](./readmenator.mp4)** -- Cinematic synthwave overview video
+- **[.cursorrules](./.cursorrules)** -- Generated AI assistant rules
+- **[readmenator_audit.sarif](./readmenator_audit.sarif)** -- SARIF v2.1.0 audit (when security scan is on)
+
+Cache (`.readmenator_cache/`), packaged agent skills (`.claude/skills/`), and the
+GitHub wiki mirror are also produced on `run`/`--rebuild`.
+
+AI agents: Read `readmenator-wiki/index.md` first for the big picture, then `readmenator-agent/INDEX.md` for grep-friendly lookup.
+Developers: Read `KNOWLEDGE_BASE.md` for full architecture reference, open `readmenator-maps/index.html` for the visual gallery.
+<!-- /readmenator-kb-link -->
+
+<!-- deploynator-footer -->
+
+---
+
+Deployed with [deploynator](https://github.com/grisuno/deploynator)
+
+<!-- /deploynator-footer -->

topoexploit-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+topoexploit-0.1.0.dist-info/licenses/LICENSE,sha256=DZak_2itbUtvHzD3E7GNUYSRK6jdOJ-GqncQ2weavLA,34523
+topogpt3/__init__.py,sha256=C9bdpdHixfcEjMH6lKEM49IBZrF6YvlcR-LnYYQKJJ4,3284
+topogpt3/__main__.py,sha256=glBegCokjJcM3awATP6ratxt-6Pk1crS9tsBunyDDLU,1832
+topogpt3/api_server.py,sha256=MhZZB2EhS9zimygBTAw20e4eAFrlkFC3m2aLy8TC6NY,45534
+topogpt3/continuation.py,sha256=BBMgSqn0ojeQZpEgt1ECJtxsBpGrPKL0zT0WVpPgwYA,3222
+topogpt3/ewc.py,sha256=kQUtppQZh6VcXHW2qMZLHUMltbfKxvIjbHsRchPiovE,12902
+topogpt3/exploitgym_config.py,sha256=NG9rWRfp2dhUZ67NiHhmfkyj-WIQKsmyBSnmDzTErSw,4230
+topogpt3/exploitgym_loader.py,sha256=wkP3sxpf_VlFtB1F-T0ggrFEu5Wc3bnyTz6dYhQYXIg,15580
+topogpt3/hodge_cm.py,sha256=9SLPkYqw3YswAtWU8dmjIsUqM089GUpcJZefHOdJjuo,5748
+topogpt3/inference.py,sha256=MdO0CbA3u_QdMaVFaBCNUi2LIqq999rjy6FMK1pSVoo,27335
+topogpt3/inference_hrm.py,sha256=1xU1vWSobkCc7KaqnTLY6zCHX8R8Wpo-94254BmQkyE,62336
+topogpt3/jlens.py,sha256=MalmL2wTXHqTYuDgm30VZ6rVfTDyvvi4jbLwR34t-Q4,34653
+topogpt3/lens_model.py,sha256=z1yVkCxSbjhrTFWPFGMmdQObMgCE7WYlFrJgLMqHHOo,13417
+topogpt3/merged_config.py,sha256=eYmMjOk5sfg573PKelfYEJ7YWhs7Sh4lauZCmlmv-4s,6819
+topogpt3/model.py,sha256=lVShuqWa-Y2mgpZUR1AMqYO_620xOdo_7gB0PMF-cL4,159651
+topogpt3/structured_output.py,sha256=eYMnMKGisbbEUw33RRFQorfpCmzJYGj_DnzWvYqyQUA,9098
+topogpt3/train.py,sha256=3z70i6H7N9vF8Ka4VZV4JaWIt98PN02_nzYEWrqEP6g,83652
+topogpt3/vanilla_control.py,sha256=Wab1BCKM9DVh9RjOYxdSdsn1CJnrXcuPRr3r0aZqUOc,9813
+topoexploit-0.1.0.dist-info/METADATA,sha256=x1knvU0abqKUDJrBLQ7gvX-Iz_uMGAq74X-YrvEUFTI,22215
+topoexploit-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+topoexploit-0.1.0.dist-info/entry_points.txt,sha256=tyVyYQozcAf01_hT-MPTvIuAu1C7dved5C3UaEuYtJc,229
+topoexploit-0.1.0.dist-info/top_level.txt,sha256=9TksQMQrSlsnTDcgyh9EVJCeMIi-v0Ibbxil3ncVJtY,9
+topoexploit-0.1.0.dist-info/RECORD,,

topoexploit-0.1.0.dist-info/WHEEL

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

topoexploit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+topogpt3-api = topogpt3.api_server:main
+topogpt3-infer = topogpt3.inference:main
+topogpt3-infer-hrm = topogpt3.inference_hrm:main
+topogpt3-jlens = topogpt3.jlens:_demo_jlens
+topogpt3-train = topogpt3.train:main