Metadata-Version: 2.4
Name: g2n-enterprise
Version: 3.0.2
Summary: A platform to optimize AND run PyTorch models: license-gated compiler (enhanced planner, persistent cache, multi-accelerator routing), a quantum circuit simulator with batched parameter sweeps, plus a model registry, inference server, and local LLM runtime (int4 quantization, partial offload, hf:/gguf: sources, streaming generation), on top of open-core g2n.
Author: g2n
License: Proprietary
Project-URL: Homepage, https://g2n.dev
Keywords: pytorch,triton,compiler,gpu,npu,inference,serving,model-server,license,quantum,quantum-simulator
Requires-Python: >=3.10
Description-Content-Type: text/markdown
Requires-Dist: cryptography>=41.0
Requires-Dist: torch>=2.11.0
Requires-Dist: g2n>=1.5.0
Requires-Dist: g2n-native<0.2,>=0.1; sys_platform == "linux" and platform_machine == "x86_64"
Requires-Dist: triton>=3.6
Requires-Dist: transformers>=4.44
Requires-Dist: llama-cpp-python>=0.3
Provides-Extra: all
Requires-Dist: g2n-enterprise; extra == "all"
Provides-Extra: dev
Requires-Dist: pytest>=7; extra == "dev"

# g2n — optimize and run PyTorch models

g2n is a PyTorch platform with two halves:

- **Optimize** — a `torch.compile` backend: custom fusion passes, Triton
  kernels, a persistent compile cache, and (on Enterprise) full autotuning.
  Honest framing: steady-state latency is ~`torch.compile` parity on most
  blocks — the wins are cold-start time (cached kernels load in <1 ms per
  restart), VRAM, and the serving layer.
- **Run** — a serving layer that turns those models into a production
  inference node: model registry, HTTP server, dynamic batching, quantization
  (int8w/int4w), CUDA-graph replay, and VRAM management for small GPUs.
  This includes **local LLMs**: `hf:` and `gguf:` models with
  packed int4 quantization (fused int4 GEMM on CUDA — faster, lower-VRAM
  decode), partial CPU offload for models bigger than VRAM, and streaming
  generation over HTTP.

It also ships a **quantum circuit simulator** (`g2n.quantum`) — a classical
statevector simulator built on torch, for developing and testing quantum
algorithms. It is a simulator, not quantum hardware, and never claims otherwise.

```python
import torch, g2n_enterprise as g2n

g2n.activate("G2N-XXXX-XXXX-XXXX")        # once per machine; cached offline

# Optimize: drop-in
model = g2n.compile(my_model)              # or torch.compile(m, backend="g2n")

# Run: registry -> HTTP inference node on :8900
g2n.register_model("clf", "torchscript:/models/clf.pt",
                   precision="int8w",      # weight-only int8: ~4x less weight memory
                   cuda_graph=True, max_batch=16)
g2n.serve()                                # GET/POST http://host:8900/v1/...

# Run a local LLM (Pro+): int4w fits an 8B model on a 6 GB card
g2n.register_model("qwen", "hf:Qwen/Qwen2.5-7B-Instruct",
                   framework="llm", precision="int4w")
g2n.generate("qwen", "Hello!", on_token=print)
```

## Install

```bash
pip install g2n-enterprise   # full stack: torch, triton, open-core g2n,
                             # transformers (hf: LLMs), llama.cpp (gguf: LLMs)
pip install g2n              # open-core only (free, Community tier)
```

The full runtime ships in the base install — no extras to remember. (One
caveat: `llama-cpp-python` compiles from source, so the install needs a C/C++
toolchain, or a prebuilt wheel from the llama-cpp-python docs.)

Python ≥ 3.10. Everything degrades gracefully: no GPU → CPU paths; no license →
Community tier; a compile failure → your unmodified model. Your code never
breaks because of g2n.

## Tiers

| | Community (free) | Pro ($49/mo) | Enterprise ($499/mo) |
|---|:--:|:--:|:--:|
| Hybrid fusion + JIT codegen | ✓ | ✓ | ✓ |
| Enhanced buffer planner (memory fusion) | | ✓ | ✓ |
| Persistent compile cache | | ✓ | ✓ |
| Model registry + inference server | | ✓ | ✓ |
| Quantum simulator: unlimited qubits + fusion | ≤24 qubits | ✓ | ✓ |
| Dynamic request batching | | | ✓ |
| Batched quantum parameter sweeps | | | ✓ |
| Multi-accelerator routing + max-autotune | | | ✓ |
| Validated model-zoo configs, priority support | | | ✓ |

Buy at [g2n.dev](https://g2n.dev) · seats: Pro 5, Enterprise 25 · 14-day Pro
trial on request (sales@g2n.dev).

## Documentation

Full documentation lives at **<https://g2n.dev/docs>**.

| Doc | What it answers |
|---|---|
| [Overview](https://g2n.dev/docs/overview) | What g2n is, how the pieces fit, what it is NOT |
| [Getting started](https://g2n.dev/docs/getting-started) | Install → activate → first compile → first serve |
| [Optimize](https://g2n.dev/docs/compiler-internals) | The compiler: what each tier unlocks, cache, autotune |
| [Serving](https://g2n.dev/docs/serving) | The inference node: precision/quantization, batching, HTTP API |
| [LLM](https://g2n.dev/docs/local-llms) | Local LLMs: hf:/gguf: engines, int4w/fp8w, SDPA, offload, streaming /generate |
| [Quantum](https://g2n.dev/docs/quantum-simulator) | The circuit simulator |
| [Licensing](https://g2n.dev/docs/licensing-and-activation) | Keys, activation, seats, offline use, renewal |

## Honest numbers, always

g2n never ships fabricated benchmarks. Every published number is measured by a
script in `benchmarks/` on named hardware, and the tooling to measure on
**your** hardware is built in:

```python
import g2n_enterprise as g2n
from g2n_enterprise.serve.reference import example_inputs
g2n.benchmark("mlp", example_inputs(batch=32), rounds=200)
# -> eager vs optimized median latency + peak VRAM, on THIS box
```

Speedups depend on your model and GPU. Measure before you trust — that
includes our numbers.
