gla-api 1.2.5__cp312-none-any.whl

gla_api/_models/runtime.sha256.json

@@ -0,0 +1,12 @@
+{
+ "v2": {
+  "GLA.pyc": "ab9e97e4f9b790dc73759fe58d8f2eaeb10beb22ca000ab78d9a434d90f15d40",
+  "gla_brain_dual.pyc": "0e4b5cee96ed725d1cd922c6c2a8791ccd4c1480564720f77f2e39b547d9098c",
+  "linguistic_safety.pyc": "69ec621edc161eae5412ee627f6c87418cdeedcfbcef981d252fd719989ac40b"
+ },
+ "v3": {
+  "GLA.pyc": "c68aa5dd41a40d5d7e20f09aae3eca5a7f3ac2df929805bb2cd8059a375361c9",
+  "gla_brain_dual.pyc": "ba8727f1c9aaa3e09bdc736baa177c49954801e0b28a4ed9d3746d2abf5fde74",
+  "linguistic_safety.pyc": "d9c99c0fac9d06cb3fcc582a16a45782b248373539a24b5a6e51b999fb4a55bb"
+ }
+}

gla_api-1.2.5.dist-info/METADATA

@@ -0,0 +1,574 @@
+Metadata-Version: 2.1
+Name: gla-api
+Version: 1.2.5
+Summary: The official library for GLA (Graph-Language Assistant) models by ATEC - run, serve and manage them from Python or as an OpenAI-compatible API server
+Requires-Python: >=3.11,<3.15
+License: Proprietary
+Author: ATEC (Advancement Through Engineering & Creation)
+Maintainer: ATEC (Advancement Through Engineering & Creation)
+Keywords: GLA,Graph-Language Assistant,ATEC,code,AI,LLM,API,OpenAI-compatible,server
+Project-URL: Homepage, https://pypi.org/project/gla-api/
+Project-URL: Documentation, https://github.com/ATECTechnologies/Graph-Language-Assistant
+Project-URL: License, https://github.com/ATECTechnologies/Graph-Language-Assistant/blob/main/LICENSE
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: torch>=2.5
+Requires-Dist: numpy>=1.26
+Requires-Dist: safetensors>=0.4.5
+Requires-Dist: psutil>=5.9
+Requires-Dist: tree-sitter>=0.23
+Requires-Dist: tree-sitter-language-pack>=1.24,<2; python_version < '3.14'
+Requires-Dist: pypdf>=4.0
+Requires-Dist: starlette>=0.40,<2
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: pydantic>=2.7,<3
+Provides-Extra: server
+Requires-Dist: redis>=5.0; extra == "server"
+Requires-Dist: psycopg[binary]>=3.2; extra == "server"
+Provides-Extra: grammars
+Requires-Dist: tree-sitter-language-pack>=1.24,<2; extra == "grammars"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Description-Content-Type: text/markdown
+
+# gla-api
+
+**The official library for GLA models — Graph-Language Assistant, by ATEC (Advancement Through Engineering & Creation).**
+
+`gla-api` runs a trained GLA model on your own computer or server and manages everything around it: an
+OpenAI-compatible API server for your websites and apps, API keys with limits, a background service you can start and
+stop, a chat in the terminal, speed tests, backups and a full system check. Windows and Linux, one or many NVIDIA GPUs.
+
+```bash
+pip install gla-api
+```
+
+Library page: **https://pypi.org/project/gla-api/**
+
+| | |
+|---|---|
+| Version | **1.2.5** |
+| Runs | **GLA 2.0** and **GLA 3.0** (the version is detected from the model folder) — the GLA 3.0 release needs 1.2.1 or newer |
+| Code | compiled to native code (Windows `.pyd`, Linux `.so`) |
+| Operating systems | Windows 10/11 (64-bit), Linux (x86-64) |
+| Python | 3.11, 3.12, 3.13 or 3.14 (also the free-threaded 3.14t) |
+| GPU | NVIDIA, any number; a 3.x model can be split over 2 or 3 GPUs per copy (a CPU works for testing) |
+| Precision | FP32, BF16, FP16, FP8, FP4 — tested on your GPU, with automatic fallback |
+| License | Proprietary (ATEC). Not open source — see [License](#license) |
+
+---
+
+## Contents
+
+1. [Install](#1-install)
+2. [Start in one minute](#2-start-in-one-minute)
+3. [Every command](#3-every-command)
+4. [Run the API server](#4-run-the-api-server)
+5. [API keys](#5-api-keys)
+6. [Settings](#6-settings)
+7. [Use it from Python](#7-use-it-from-python)
+8. [Call the server from any language](#8-call-the-server-from-any-language)
+9. [GPUs, splitting and precision](#9-gpus-splitting-and-precision)
+10. [Security](#10-security)
+11. [Troubleshooting](#11-troubleshooting)
+12. [What is new in 1.2.5 / upgrading](#12-what-is-new-in-125--upgrading)
+
+---
+
+## 1. Install
+
+```bash
+pip install gla-api
+```
+
+That one command installs the model runtime **and** the API server. Check it:
+
+```bash
+gla-api --version
+gla-api doctor --quick
+```
+
+**NVIDIA GPU on Windows:** `pip` installs the CPU build of PyTorch by default. For your GPU, install the CUDA build
+first (once), then the library:
+
+```bash
+pip install torch --index-url https://download.pytorch.org/whl/cu128
+pip install gla-api
+```
+
+Update later with `pip install --upgrade gla-api` (`gla-api check-update` tells you when there is a new version).
+
+> **`pip` not found on Windows?** Use `py -m pip install gla-api` and `py -m gla_api <command>` — they
+> work the same everywhere. To get the short commands, reinstall Python with **"Add python.exe to PATH"** ticked.
+
+**Several servers sharing one database (optional):** `pip install "gla-api[server]"` adds Redis and PostgreSQL
+support. A single server needs nothing extra.
+
+---
+
+## 2. Start in one minute
+
+```bash
+mkdir my-gla && cd my-gla
+gla-api setup --owner my-website
+```
+
+`setup` does everything a new folder needs, in one step:
+
+1. creates `.env` with a secret **admin token** and the model folder **`Model_GLA/`**;
+2. checks the model folder;
+3. creates your first **API key** and prints it (once — copy it).
+
+Then copy the exported GLA model's files into `Model_GLA/` and:
+
+```bash
+gla-api start        # API server in the background:  http://127.0.0.1:8000/v1
+gla-api status       # running? model loaded? how busy?
+gla-api chat "Write a Python function that reverses a string"
+gla-api stop
+```
+
+A model folder holds only data — weights (`safetensors`), configuration, tokenizer and documents. No code is ever run
+from it. A folder named `Model_CodeMind/` is found too.
+
+---
+
+## 3. Every command
+
+Every command has its own help: `gla-api <command> --help`. All of them also work as
+`py -m gla_api <command>` (or `python -m gla_api <command>`).
+
+### Set up and check
+
+| command | what it does |
+|---|---|
+| `gla-api setup [--owner NAME] [--start]` | everything for a new folder: `.env`, `Model_GLA/`, first API key, next steps |
+| `gla-api init` | only `.env` (admin token) and `Model_GLA/` |
+| `gla-api doctor [--quick]` | full check: Python packages, PyTorch, every GPU, FP8 self-test, model files (SHA-256), tokenizer, disks, key database → **READY** or the exact problem |
+| `gla-api info` | model version, size, runtime, PyTorch, GPUs (does not load the model) |
+| `gla-api verify` | checks every model file against its SHA-256 |
+| `gla-api prefetch` | downloads the code-parser grammars once (run before taking a machine offline) |
+
+### Run the server
+
+| command | what it does |
+|---|---|
+| `gla-api start [options]` | starts the API server **in the background** (keeps running after you close the window) |
+| `gla-api stop [--timeout 60] [--force]` | stops it — answers that are running finish first |
+| `gla-api restart [options]` | stop + start (same options as before unless you give new ones) |
+| `gla-api status [--json]` | running or not, model ready or loading, uptime, workers, queue, served, errors |
+| `gla-api logs [-n 50] [-f]` | the background server's log (`-f` keeps following it) |
+| `gla-api serve [options]` | runs the server **in this window** (Ctrl+C stops it); `--supervise` restarts it after a crash |
+
+`start`, `restart` and `serve` take the same options: `--host`, `--port`, `--gpus`, `--split`, `--precision`, `--fp8`,
+`--workers-per-gpu`, `--min-workers-per-gpu`, `--max-queue`, `--max-connections`, `--max-output-tokens`,
+`--default-rpm`, `--default-concurrency`, `--request-timeout`, `--hooks`, `--ssl-certfile`/`--ssl-keyfile`, `--docs`
+(`gla-api serve --help`). `start --wait-ready` waits until the model is loaded.
+
+### Use the model
+
+| command | what it does |
+|---|---|
+| `gla-api chat "question"` | one answer |
+| `gla-api chat` | a conversation in the terminal (`/mode code`, `/lang rust`, `/clear`, `/exit`) |
+| `gla-api chat --code --language rust "..."` | a code answer in a chosen language |
+| `gla-api chat --url http://HOST:8000 --key gla_live_...` | ask a running server (streams the answer) |
+| `gla-api chat --json "..."` | the full answer as JSON (confidence, reason, questions, ...) |
+| `gla-api bench [-n 5] [--url ...]` | answer speed: seconds per answer, tokens per second |
+
+### API keys and data
+
+| command | what it does |
+|---|---|
+| `gla-api key create --owner NAME [limits]` | a new key, printed once |
+| `gla-api key list [--owner NAME] [--all] [--json]` | every key (never the secrets) |
+| `gla-api key show ID` | one key's settings |
+| `gla-api key update ID [limits]` | change limits, name, allowed IPs/websites, expiry (`--expires-days 0` = never) |
+| `gla-api key rotate ID [--grace 3600]` | a new secret with the same settings (the old one can keep working for a while) |
+| `gla-api key revoke ID` | disable a key at once |
+| `gla-api key usage ID` / `--owner NAME` | requests and tokens per day |
+| `gla-api audit` | recent admin actions (created, updated, rotated, revoked ...) |
+| `gla-api gen-token` | a strong random token |
+| `gla-api backup [--out DIR]` | a safe copy of the key database, its secret and `.env` (also while the server runs) |
+
+### Settings and updates
+
+| command | what it does |
+|---|---|
+| `gla-api config show` | every setting of this folder (secrets masked) and the main values in use |
+| `gla-api config set NAME VALUE` | save one, e.g. `config set port 9000` |
+| `gla-api config unset NAME` | remove one |
+| `gla-api config path` | where the `.env` file is |
+| `gla-api check-update` | is a newer `gla-api` on PyPI? |
+| `gla-api service show \| install \| remove` | keep the server running: a systemd service (Linux) or a task at log-on (Windows) |
+
+`--dir FOLDER` before any command works in that folder instead of the current one: `gla-api --dir D:\gla status`.
+
+---
+
+## 4. Run the API server
+
+```bash
+gla-api start                       # this computer only: http://127.0.0.1:8000/v1
+gla-api start --host 0.0.0.0        # reachable from other computers in your network
+gla-api start --split 3             # GLA 3.x: each copy of the model spread over 3 GPUs
+```
+
+The server uses **every GPU** of the machine, loads as many copies of the model per GPU as fit, adds copies under load
+and releases them when idle, and spreads the requests over all of them. A crashed or frozen copy is restarted on its
+own; a GPU that cannot run the chosen precision steps down safely (fp4 → fp8, fp8 kernels → bf16). It is
+**OpenAI-compatible**:
+
+| endpoint | for |
+|---|---|
+| `POST /v1/chat/completions` | answers (with `"stream": true` the answer arrives piece by piece) |
+| `POST /v1/completions` | plain text completion |
+| `POST /v1/code/validate` | checks code: valid, score, issues |
+| `POST /v1/ground` | exact math and physics with units |
+| `GET /v1/models`, `/v1/me`, `/v1/usage` | the model, this key's limits, this key's usage |
+| `GET /health`, `/ready` | is the process up / is the model loaded |
+| `/admin/keys ...`, `/admin/stats`, `/admin/workers`, `/admin/audit`, `POST /admin/model/reload` | management with the admin token (reload = new model without stopping) |
+| `GET /metrics` | Prometheus metrics |
+
+API description: `gla-api config set docs 1`, `gla-api restart`, then open `http://127.0.0.1:8000/docs` (or
+`/openapi.json`). Off by default, so a public server does not show them. The model folder also contains
+`API_REFERENCE.md`.
+
+**Extra options per request** go in a `gla` object: `{"gla": {"mode": "code", "language": "rust"}}` (`mode`: `auto`,
+`text` or `code`). Answers carry the same object back with `confidence`, `uncertain`, `reason` and `questions`.
+
+**Streaming behind a proxy.** While the model writes, a streaming answer sends a keep-alive line every 15 seconds
+(`stream_keepalive`), so proxies such as Cloudflare or nginx do not close a long answer.
+
+**Safe retries.** Send `Idempotency-Key: <unique id>`: a retry with the same key and body returns the first answer
+instead of generating again (kept 24 h). `gla_api.Client` does this for you.
+
+**Your own code around every answer:** `gla-api start --hooks my_hooks.py`, where `my_hooks.py` defines
+`before_request(ctx)` (change or refuse a request) and/or `after_response(ctx, result)` (change the answer). Both may
+be `async def`.
+
+**Always on:** `gla-api service install` — on Linux it writes a systemd service (`serve --supervise`, restarted after
+a crash and at boot), on Windows a task that starts the server when you log on. `gla-api service show` prints it first.
+
+**Public internet:** put HTTPS in front (a reverse proxy such as Cloudflare, Caddy or nginx, or
+`--ssl-certfile`/`--ssl-keyfile`) and keep `trusted_proxies` set to the proxy's address.
+
+---
+
+## 5. API keys
+
+Apps and websites call the server with an API key: `Authorization: Bearer gla_live_...`.
+
+```bash
+gla-api key create --owner my-website --rpm 120 --daily-tokens 2000000 --allowed-origins https://example.com
+gla-api key list
+gla-api key update KEY_ID --rpm 0            # 0 = unlimited
+gla-api key rotate KEY_ID --grace 3600       # new secret; the old one works one more hour
+gla-api key usage --owner my-website
+gla-api key revoke KEY_ID
+```
+
+Limits per key — each can be `0` for unlimited: requests per minute (`--rpm`), tokens per day (`--daily-tokens`),
+parallel requests (`--concurrency`), tokens per answer (`--max-tokens`), priority 0–9 (`--priority`), allowed IP
+addresses (`--allowed-ips`), allowed websites (`--allowed-origins`), expiry (`--expires-days`), scopes (`--scopes`:
+`chat`, `code`, `validate`, `ground`, `usage`) and test keys (`--env test`).
+
+Keys are stored only as HMAC-SHA256 hashes: even a stolen database contains no usable keys. Keys made by earlier
+versions (`cm_...`) keep working. A key that appears in an answer is redacted.
+
+---
+
+## 6. Settings
+
+Settings live in the `.env` file of the folder you run the server from (made by `setup`/`init`). Change them with
+`gla-api config set NAME VALUE` (then `gla-api restart`), or set the same names as environment variables with the
+`GLA_` prefix (`GLA_PORT=9000`). The earlier prefix `CODEMIND_` still works.
+
+| name | default | meaning |
+|---|---|---|
+| `model` | `./Model_GLA` | model folder |
+| `host` | `127.0.0.1` | `0.0.0.0` = reachable from the network |
+| `port` | `8000` | |
+| `gpus` | `auto` | `auto`, `0,1`, or `cpu` |
+| `split` | `off` | GLA 3.x: `2` or `3` GPUs per copy, `auto` = 3 when the GPUs divide into threes, else 2 |
+| `precision` | `auto` | `auto`, `fp32`, `bf16`, `fp16`, `fp8`, `fp4` |
+| `fp8` | `auto` | FP8 kernel: `rowwise`, `tensor`, `dequant`, `off` |
+| `max_workers_per_gpu` / `min_workers_per_gpu` | `3` / `1` | model copies per GPU (fitted to memory and load) |
+| `admin_token` | made by `init` | controls `/admin` and keys — keep it secret |
+| `admin_ips` | `local` | where `/admin` may be called from: `local` (this computer and private networks), a list of IPs / networks, or `*` (anywhere — the token is still needed) |
+| `ip_rpm` | `0` | requests per minute per client address on `/v1` (`0` = off; behind a proxy set `trusted_proxies`) |
+| `verify_model` | `first` | model files' SHA-256 before the server loads them: `first` (once, remembered until a file changes), `always`, `size` (sizes only) |
+| `default_rpm` | `60` | requests per minute for new keys (`0` = unlimited) |
+| `default_concurrency` | `16` | parallel requests per key |
+| `max_output_tokens` | `8192` | per answer (`0` = unlimited) |
+| `max_queue` | `1024` | waiting requests before "busy" (`0` = unlimited) |
+| `max_connections` | `8192` | open connections (`0` = unlimited) |
+| `request_timeout` | `300` | seconds per request |
+| `stream_keepalive` | `15` | seconds between keep-alive lines of a streaming answer |
+| `cache_ttl` | `600` | seconds a deterministic answer (temperature 0) is reused |
+| `cors_origins` | — | websites allowed to call from a browser |
+| `trusted_proxies` | `127.0.0.1` | your HTTPS proxy's address |
+| `data_dir` | `./gla_api_data` | keys, usage, audit log, server log, backups |
+| `database_url` / `redis_url` | SQLite / none | PostgreSQL and Redis for several servers (`GLA_KEY_PEPPER` must then be the same on all) |
+| `hooks` | — | your `before_request` / `after_response` module |
+| `safety` / `redact_output` | `1` / `1` | content screening / secret redaction |
+| `docs` | `0` | `/docs` and `/openapi.json` |
+| `log_level` / `log_json` | `INFO` / `0` | |
+
+`gla-api config show` lists what is set and what is in use. A JSON file with the same names can be given with
+`gla-api --config settings.json serve`.
+
+---
+
+## 7. Use it from Python
+
+### The model in your own program
+
+```python
+import gla_api
+
+model = gla_api.load("./Model_GLA")              # first GPU (CPU if none); FP8 where it pays off
+
+print(model.chat("What is the difference between a process and a thread?"))
+
+ans = model.code("A thread-safe LRU cache", language="python")
+print(ans.text, ans.confidence, ans.uncertain)
+
+for piece in model.stream("Explain this regex: ^\\d{3}-\\d{4}$"):
+    print(piece, end="", flush=True)
+
+print(model.validate("SELECT * FROM users WHERE id = ' + user_id", language="sql")["issues"])
+print(model.ground("speed of a 2 kg object after falling 10 m"))
+
+big = gla_api.load("./Model_GLA", precision="fp8", devices="all")      # one copy on every GPU
+answers = big.chat_many([f"Explain error code E{i}" for i in range(100)])     # spread over all of them
+big.close()
+
+huge = gla_api.load("./Model_GLA", devices="all", split=3)   # GLA 3.x: each copy over 3 GPUs (split=2: over 2)
+```
+
+`load(path, precision="auto", device="auto", devices=None, split=False, fp8="auto", safety=True, verify=False,
+warmup=True, threads=0, web_search=False, before=None, after=None)` — `gla_api.load("echo")` gives a tiny test model
+(no GPU, no files) for trying out your code.
+
+`chat(prompt | messages=[...], system="", mode="auto"|"text"|"code", language=None, temperature=0.8, top_p=0.92,
+max_tokens=0, stop=None)` returns an **`Answer`**: `text`, `mode`, `uncertain`, `confidence`, `reason`, `questions`,
+`sources`, `language`, `language_supported`, `score`, `finish_reason`, `usage`, `raw`. `str(answer)` is the text.
+
+Also: `code()`, `stream()`, `chat_many()`, `achat()` / `acode()` (asyncio), `validate()`, `ground()`, `count_tokens()`,
+`add_hook()`, `info`, `devices`, `runtime`, `close()`; `with gla_api.load(...) as model:` closes it for you.
+
+### A running server (no GPU or model files on this machine)
+
+```python
+import gla_api
+
+gla = gla_api.Client("http://127.0.0.1:8000", api_key="gla_live_...")   # or GLA_URL / GLA_API_KEY
+print(gla.chat("Explain what a mutex is"))
+print(gla.code("Binary search", language="rust").text)
+for piece in gla.stream("Write a haiku about graphs"):
+    print(piece, end="", flush=True)
+print(gla.ready(), gla.models(), gla.me(), gla.usage(days=7))
+
+admin = gla_api.Client("http://127.0.0.1:8000", admin_token="...")      # or GLA_ADMIN_TOKEN
+new = admin.create_key("my-website", rpm=120)
+print(new["key"])                                                        # shown only here
+admin.rotate_key(new["id"], grace_seconds=3600)
+print(admin.stats())
+```
+
+```python
+async with gla_api.AsyncClient("http://127.0.0.1:8000", api_key="gla_live_...") as gla:    # asyncio programs
+    print(await gla.chat("Hello"))
+    async for piece in gla.stream("Tell me about graphs"):
+        print(piece, end="")
+```
+
+The client needs nothing but Python — use it on your web server while the model runs on a GPU machine. A busy or
+rate-limited answer (503 / 429) is retried after the server's `Retry-After` (`retries=2`), always with an
+`Idempotency-Key`, so a retry never produces a second answer. Errors raise `gla_api.APIError` with `status`, `code`,
+`message`, `retry_after` and `request_id`.
+
+---
+
+## 8. Call the server from any language
+
+Any OpenAI SDK works — point it at your server:
+
+```python
+from openai import OpenAI
+client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="gla_live_...")
+r = client.chat.completions.create(model="gla-3.0", messages=[{"role": "user", "content": "Hello"}])
+print(r.choices[0].message.content)
+```
+
+```javascript
+const r = await fetch("http://127.0.0.1:8000/v1/chat/completions", {
+  method: "POST",
+  headers: { "Authorization": "Bearer gla_live_...", "Content-Type": "application/json" },
+  body: JSON.stringify({ messages: [{ role: "user", content: "Hello" }], gla: { mode: "auto" } }),
+});
+console.log((await r.json()).choices[0].message.content);
+```
+
+```bash
+curl http://127.0.0.1:8000/v1/chat/completions -H "Authorization: Bearer gla_live_..." \
+     -H "Content-Type: application/json" -d '{"messages":[{"role":"user","content":"Hello"}]}'
+```
+
+The model ID is `gla-<version>` (see `GET /v1/models`); any ID is accepted.
+
+---
+
+## 9. GPUs, splitting and precision
+
+| `precision` | weights | use it for |
+|---|---|---|
+| `fp32` | 4 bytes | exact reference |
+| `bf16` | 2 bytes | the same quality, half the memory (RTX 30xx and newer) |
+| `fp16` | 2 bytes | older GPUs without BF16 |
+| `fp8` | 1 byte | FP8 tensor cores on RTX 40xx/50xx, Hopper, Blackwell (elsewhere FP8 storage, BF16 compute) |
+| `fp4` | ~5 bits | the smallest |
+| `auto` | | FP8 when the GPU passes a numeric self-test, else BF16; FP32 on CPU |
+
+Every choice is tested on the real GPU and falls back safely instead of failing. The router, the writer's output layer
+and small layers stay at the compute precision. Approximate memory for one copy of GLA 3.0 (≈ 21.2 B parameters):
+≈ 45 GB in BF16, ≈ 24 GB in FP8, ≈ 14 GB in FP4; GLA 2.0 (≈ 6.1 B): ≈ 12 GB, 6 GB, 4 GB.
+
+**Splitting (GLA 3.x).** When one GPU is too small for a whole copy, spread each copy over several GPUs:
+
+| | GPU 1 | GPU 2 | GPU 3 |
+|---|---|---|---|
+| `split=3` | encoder + Brain A + router | Brain B + Brain C | writer |
+| `split=2` | encoder + Brain A + Brain B | Brain C + writer | |
+
+`gla_api.load(path, devices="all", split=3)` in Python; `gla-api start --split 3` (or `config set split 3`) for the
+server, which then runs one copy per group of GPUs (6 GPUs → 2 copies). `split=True` / `auto` picks 3 when the GPUs
+divide into threes, else 2.
+
+---
+
+## 10. Security
+
+- **Model folders are data only** (`safetensors`, no pickle): loading a model never runs code from it. The server
+  checks every file's SHA-256 before its first load (`verify_model`); `gla-api verify` checks them by hand.
+- **Native code.** The library and the model runtime are compiled to native machine code, carry no source,
+  comments or docstrings, and refuse to run when an installed runtime file was changed (reinstall to repair).
+- **This machine only by default:** the server listens on 127.0.0.1 unless you pass `--host 0.0.0.0`.
+- **API keys** are stored as HMAC-SHA256 hashes; per-key limits, IP and website allow-lists, expiry, rotation with a
+  grace period and an audit log of every admin action; repeated wrong keys lock the address out for a while (logged
+  as `auth.lockout`). Keys never appear in full in logs or answers.
+- **The admin token** controls `/admin`, which by default answers only this computer and private networks
+  (`admin_ips`); keep `.env` private (`gla-api backup` copies it — keep backups private too).
+- **`gla-api doctor`** also reports risky settings: plain HTTP on a public address, a short admin token, an open admin
+  API, screening switched off, readable secret files.
+- Request size limits (checked before a body is read), content screening of requests and answers, and redaction of
+  secrets (including API keys) in answers.
+- **No internet needed to answer.** Only the code-parser grammars are downloaded once (`gla-api prefetch`).
+- For the public internet: HTTPS in front, `--host 0.0.0.0` only behind it.
+
+---
+
+## 11. Troubleshooting
+
+| you see | do this |
+|---|---|
+| `pip` / `gla-api` is not recognized (Windows) | use `py -m pip ...` and `py -m gla_api ...`, or reinstall Python with "Add python.exe to PATH" |
+| `doctor`: `no trained model found` | normal before you have a model: copy the exported model files into `Model_GLA/` |
+| `doctor`: `GPUs - 0 found` | install the CUDA build of PyTorch ([Install](#1-install)) and a current NVIDIA driver |
+| `FP8 self-test - selected 'dequant'` | normal on GPUs without FP8 tensor cores — FP8 storage with BF16 compute is used |
+| `status`: `model: loading` | the model is still loading — wait, or `gla-api start --wait-ready` |
+| `cannot reach http://...` | the server is not running: `gla-api start`, then `gla-api logs` |
+| out of GPU memory | `--precision fp8` or `fp4`, fewer `--workers-per-gpu`, or `--split 2` / `3` for GLA 3.x |
+| `split needs a 3.x model` | GLA 2.0 runs on one GPU per copy — drop `split` |
+| `model folder is incomplete` | copy the whole folder again; `gla-api verify` names the bad file |
+| `this process already runs the v2 runtime` | GLA 2.x and 3.x models need separate processes |
+| a long streaming answer is cut by a proxy | lower `stream_keepalive` (e.g. 10) or raise the proxy's read timeout |
+| `Admin API not allowed from this address` | call it from the server itself or your private network, or set `admin_ips` |
+| `model files failed the check` | a file is damaged or incomplete: copy the model folder again, then `gla-api restart` |
+| `the model runtime of this installation was changed` | `pip install --force-reinstall gla-api` |
+
+---
+
+## 12. What is new in 1.2.5 / upgrading
+
+```bash
+pip install --upgrade "gla-api>=1.2.5"
+```
+
+Folders, keys, settings and code written for 1.0.x and 1.2.x keep working unchanged.
+
+New in 1.2.5:
+
+- **Faster answers (GLA 3.0):** the answer is written with a preallocated memory of the text so far and each new
+  word is one recorded GPU program (CUDA graph) instead of hundreds of separate launches - about 10x more words per
+  second on the same GPU, with the same sampling (temperature, top-p, top-k, repetition penalty) and the same answers
+  for the same random draws' distribution.
+- **Faster understanding (GLA 3.0):** the graph layers compute every node type and relation in one pass; the batch
+  goes to the GPU in one transfer.
+- **Better code graphs:** data flow of assignments and C / C++ parameters fixed; the parser is safe with many threads.
+- **Python 3.14** and the free-threaded **3.14t** (GIL off). On 3.14 install the grammars with
+  `pip install "gla-api[grammars]"`; 3.11-3.13 get them automatically.
+- **Updated GLA 2.0 and GLA 3.0 runtimes** (the current model code); WinCore is no longer used.
+
+New in 1.2.3:
+
+- **Updated GLA 2.0 and GLA 3.0 runtimes** (the current model code): checkpoints are found in `Model-GLA` /
+  `Models/Model-GLA` (the folder GLA training now writes to) as well as `Model_GLA`; GLA 3.0 answers carry a
+  readability check (`raw["gibberish"]`, 0-1) and an unreadable answer comes back as "not sure" with
+  `reason="unreadable"` instead of mixed-up tokens; fixes for checkpoints saved after a second training round.
+- Use 1.2.3 for every GLA 2.0 / 3.0 model trained with the current code; 1.2.2 is withdrawn.
+
+New in 1.2.2:
+
+- **Native code** for Windows and Linux; the model runtime ships without comments or docstrings and is checked
+  against its SHA-256 before it runs.
+- The server checks the model files' SHA-256 before the first load (`verify_model`); `gla_api.load(...,
+  verify="first")` does the same in Python.
+- `/admin` answers only this computer and private networks by default (`admin_ips`); `ip_rpm` limits requests per
+  client address; lock-outs after wrong keys are written to the audit log; keys are shortened in every log line;
+  stricter response headers.
+- `gla-api service install` keeps the server running (systemd / Windows log-on task); `gla-api doctor` checks the
+  security settings.
+
+New in 1.2.1:
+
+- **Runs the GLA 3.0 release** (connected graphs, global attention, 24 / 18 / 34-layer brains, 40-layer writer).
+- **Split copies** of 3.x models over 2 or 3 GPUs — in `gla_api.load(..., split=3)` and in the server (`--split`).
+- **Lighter server**: Starlette + uvicorn directly (FastAPI is no longer installed); `/docs` and `/openapi.json` still
+  available with `docs=1`.
+- **Streaming keep-alive** for long answers behind proxies; streams start at once and stop the work when the client
+  leaves.
+- **`AsyncClient`**, `Model.achat()` / `acode()`, `Client.complete()`, `wait_ready()`, `get_key()`, `audit()`,
+  `owner_usage()`; automatic, idempotent retries in the client.
+- **Answers** carry `sources`, `finish_reason` and `usage`; `stop` sequences in Python too; `validate(language="auto")`
+  detects the language.
+- **Hooks** may be `async def`; API keys in answers are redacted; better worker supervision (precision step-down per
+  GPU, one-at-a-time rolling reload, faster recovery).
+- `GLA_RUNTIME_DIR`: run the model code from another folder (for model developers).
+
+Coming from `codemindai-api`: `pip uninstall codemindai-api`, `pip install gla-api`, then use `gla-api` where you used
+`codemindai-api` and `import gla_api` where you used `import codemindai_api`. Folders (`codemindai_api_data/`), keys
+(`cm_live_...`), settings (`CODEMIND_...`) and the request option `codemind` are all accepted.
+
+---
+
+## License
+
+GLA models and `gla-api` are **proprietary** software of **ATEC (Advancement Through Engineering & Creation)**.
+They are licensed, not sold, and are **not open source**. Each GLA model version comes with its own license, which
+governs how you may use it; in short, you may use GLA 2.0 and 3.0 commercially to power your own websites, apps and
+API services, but you may never sell the model, and you must always credit ATEC:
+
+> **Built with GLA &lt;version&gt; by ATEC**
+
+The library is licensed only to run GLA models and may not be decompiled or reverse-engineered. Licenses and technical
+documentation: https://github.com/ATECTechnologies/Graph-Language-Assistant

gla_api-1.2.5.dist-info/RECORD

@@ -0,0 +1,42 @@
+gla_api/__init__.pyc,sha256=2XE-eBSES8zGfx_bW6Myi-lCXQKuLzVO2u5JLZRuELw,1359
+gla_api/__main__.pyc,sha256=NLX2DAYj8oRnNjwYPtIqBZysypUhhuBE9jCXBSWhcX8,245
+gla_api/_models/runtime.sha256.json,sha256=c3i8-E9mh3cZAtDRvKjZuIl-y5K3yqAKy-paarOz9ew,562
+gla_api/_models/v2/GLA.pyc,sha256=q56X5Pm3kNxzdZ_ljY8urrEL6yLKAAq3jZpDTZDxXUA,1207895
+gla_api/_models/v2/gla_brain_dual.pyc,sha256=Dktc7pbtcl0c2SLGwqh5HM1MFIBWRyD3fy45tUfZCYw,60753
+gla_api/_models/v2/linguistic_safety.pyc,sha256=aexiHtwWHq5UEu5if2yHQYze7c-875gdJS_XGZiaxAs,57054
+gla_api/_models/v3/GLA.pyc,sha256=xoql3UGkDV1-IPCarj7KWn86wt-SmAW7LNgFmjdTYck,1321960
+gla_api/_models/v3/gla_brain_dual.pyc,sha256=uocn8cmqo-Cb3HNrqhd8SZVIAeCyik7Z03RtKr9f3nQ,65703
+gla_api/_models/v3/linguistic_safety.pyc,sha256=2cmcD6ydBss_zFgqFqRXgrJINzU5oktablG5mftKVbs,62801
+gla_api/_version.pyc,sha256=yjGd-Xwonf6vxT0ZwRkT9KVT1cVUqdNXPNNoWcfU6es,251
+gla_api/answer.pyc,sha256=aKfQXLrDw3lolyMrfGwjInPc5_Iu1wj7ZddNvDYA2Uw,5918
+gla_api/cli.pyc,sha256=ABfJH75qcIGtVoIyiL1J5SNJvCmo5OPP0HLgGc46eko,80481
+gla_api/client.pyc,sha256=t2GReCb3h4MrWtNnleHHLiroUxvBHimkkze38Mtw8Lk,26057
+gla_api/doctor.pyc,sha256=Zdwi6wRZUc75N5pUEIbPMcMzu8tAnDxzGVTurCyUDBc,12763
+gla_api/envfile.pyc,sha256=wNMiTHCQaFdynOPXM_0Z7N4fxqwERjH6V8KeqXf1m74,7726
+gla_api/model.pyc,sha256=Hnzv_tIEgj7MphMOlfbVSbruCgpMz80epdxJE9tKKDM,22943
+gla_api/paths.pyc,sha256=FHtQAa2Zji2KDY9rIdWZQJUz_O_MfTpeXfuw4mg4SY8,7832
+gla_api/runtime/__init__.pyc,sha256=a7U9_QlRBszImQRLAo-MhOnFoKhsBViNWHGMMFJM3Xo,833
+gla_api/runtime/devices.pyc,sha256=SOi88uxr0AUTfXjtB4BCCUWMpono3T3DGWNr97zHztg,8072
+gla_api/runtime/loader.pyc,sha256=wyIQq1k6Ydsts4x4fh9Er6WzHb2vlwhpjuJb0J4QpW4,10080
+gla_api/runtime/locate.pyc,sha256=-yDcFMAFeDPHgwmziGq--X5FkfYt9D-YHgBipwb7BbQ,17977
+gla_api/runtime/ops.pyc,sha256=Ys4kVU3_7SVSmeHJqIzoXn3ZMiGXe-N9AP11rBQSZZY,18624
+gla_api/runtime/precision.pyc,sha256=cnxsLfwRjKy3aw02hmeriEOGdAGpd72OziAESEJnv8o,31342
+gla_api/runtime/prepare.pyc,sha256=bnhEZEikAt5xjjP0h8sJMID3Wd63YzAiSIG6RPQl1J0,6927
+gla_api/runtime/worker.pyc,sha256=jgEjiWn2wO5YYn2Yr2fFH048emO7ERctRWnWdMwipNU,14475
+gla_api/safety.pyc,sha256=ZJvUH1eueArBjxpmeTCHUD3SfgOf75o1B9xcYCrp_oA,4008
+gla_api/server/__init__.pyc,sha256=TJXxDfaLWcOw732fsoEamcfDbPbS5gRCkLGkDlrLJ5E,852
+gla_api/server/app.pyc,sha256=gEaQ9Ddk5nMWnSdsJGi2BIkhropA_b7qopSX32uWvJs,75260
+gla_api/server/hooks.pyc,sha256=hyD3vf79ZdxohHTd4NXCuzPLnN8W2M2UmDOz61g7JwY,5032
+gla_api/server/metrics.pyc,sha256=2xaC0l31xPeGXUA0ybg7JMHaNwJ80zHSyXH8fSfkC6o,6695
+gla_api/server/pool.pyc,sha256=RGDF6VRoNzo0GC1mPYnZTa42k9WKDpjNZvPvdwZus8s,55676
+gla_api/server/run.pyc,sha256=lfJOL3p1CvHiRpE7QT74UO8Xa09boSkW80lcL8tsdGM,4092
+gla_api/server/schemas.pyc,sha256=j8j6e7Qi1PAj9pnV9wDsXGw75XEe-1_qEoxaSxcsd1A,7123
+gla_api/server/settings.pyc,sha256=D6Ce-vQiahdSxqe2DT2o3Th8-x_pP_ySEbluM5I9L6g,16020
+gla_api/server/state.pyc,sha256=zAhXGMtTs2GCB-GhF8HeAF3bijxTgBGXt_XJKV6O3Eo,14110
+gla_api/server/store.pyc,sha256=E4mLaahpusZChRFUkb_FY2MrFUJ5JkejYsblrYy1j1I,39419
+gla_api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gla_api-1.2.5.dist-info/METADATA,sha256=b0tLK4uuu8wwOa-aJo51iKFCk5ezwf9ETsXqxxWNaPM,29513
+gla_api-1.2.5.dist-info/WHEEL,sha256=D6BNkmK7I_wIg39ysjMg2Bvyp5FGKGxhZNENtfIG6o4,102
+gla_api-1.2.5.dist-info/entry_points.txt,sha256=aeHJRkFYS6A48JlONqIlKTRIk9oIXStsGa467ssy0Fk,45
+gla_api-1.2.5.dist-info/top_level.txt,sha256=kyHlFVdlSBr-1ddC_3um7Qw9Rp8tMkYXVkDz8k8VGLE,8
+gla_api-1.2.5.dist-info/RECORD,,

gla_api-1.2.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: gla-api tools/build_wheels.py
+Root-Is-Purelib: true
+Tag: cp312-none-any

gla_api-1.2.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gla-api = gla_api.cli:main

gla_api-1.2.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+gla_api