gla-api 1.2.5__cp314-none-any.whl

gla_api/_models/runtime.sha256.json

@@ -0,0 +1,12 @@
+{
+ "v2": {
+  "GLA.pyc": "5674069b1bbe4ab350dded4d0c6f0f70e32e4620b2a06ba05d5f064e4c32e72c",
+  "gla_brain_dual.pyc": "bb1d50d2e6be52fcb63cdaff3499df14320dec80dee69ea030d4ee930365d1b9",
+  "linguistic_safety.pyc": "8f41aefda9a3b9340ef41b2077a4ecad39c57905ae9b8cf87509b88bbba0cae7"
+ },
+ "v3": {
+  "GLA.pyc": "1b2807b496fe6c24e86dc43fce2d61eda448fd7b78d3e89b8770ab2260eab7c9",
+  "gla_brain_dual.pyc": "7934c0dd289751f7525009f78d5d43d3374525af9f5cbb87be0a8034f4af7782",
+  "linguistic_safety.pyc": "99cbff4471bcbb47581bdab4ea98e652a38e43241c22886d02dd6db8c6bec023"
+ }
+}

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=YI27f7dMWWd_2xwTC7yXzDWB_rZ1TEwzTcYWt0-HXw4,1498
+gla_api/__main__.pyc,sha256=Hm7zJViYS-K4qrhINSMAHqJHxXlf8dHor2nn8LT4XSA,251
+gla_api/_models/runtime.sha256.json,sha256=baSVmvyQwLkj_7xdzwiU15VynfUN--UZXoQsQxCQ6Gs,573
+gla_api/_models/v2/GLA.pyc,sha256=VnQGmxu-SrNQ3e1NDG8PcOMuRiCyoGugXV8GTkwy5yw,1377176
+gla_api/_models/v2/gla_brain_dual.pyc,sha256=ux1Q0ua-Uvy2PNr_NJnfFDIN7IDe5p6gMNTukwNl0bk,70045
+gla_api/_models/v2/linguistic_safety.pyc,sha256=j0Gu_amjuTQO9Bsgd6TsrTnFeQWum4z4dQm4i7ugyuc,67983
+gla_api/_models/v3/GLA.pyc,sha256=GygHtJb-bCTobcQ_zi1h7aRI_Xt40-ibh3CrImDqt8k,1509465
+gla_api/_models/v3/gla_brain_dual.pyc,sha256=eTTA3SiXUfdSUAn3jV1D0zdFJa-fXLuHvgqANPSvd4I,75961
+gla_api/_models/v3/linguistic_safety.pyc,sha256=mcv_RHG8u0dYG9q06pjmUqOOQyQcIohtAt1tuMa-wCM,74169
+gla_api/_version.pyc,sha256=pFx1pv6gEg-fc9jZbjrwF36j-LofS49ljuEhkFskaT0,253
+gla_api/answer.pyc,sha256=ONe8mGPJQzIFpi4WDbxpUmOe1MP0RtS_2KZz3aOnzyw,7077
+gla_api/cli.pyc,sha256=o8z3Akav5pu9LbfF9yocSRwcxk1kNhWiPnp6PZd_2WU,91790
+gla_api/client.pyc,sha256=fxjIZBpumBI8-Dd5HZxpxGIyu7WsB_h0yPR77NRPTHs,33424
+gla_api/doctor.pyc,sha256=eHqciMQeQpwdPgtVkP1dkumXaASSMpAgXSAfJ_yDF1s,14399
+gla_api/envfile.pyc,sha256=gR2RVJtXT_SYtFSuvCWxvfmolD9paIgwEiN8wh23XyM,9830
+gla_api/model.pyc,sha256=JXpzplXzp-gBZk1GASDHHPSocAISNarOGBoJ8RHxN3c,27993
+gla_api/paths.pyc,sha256=yigL6nA-jkL7gjSDyseYI6niLXFDgqhP0Np0r_ApthY,10077
+gla_api/runtime/__init__.pyc,sha256=Fy0SX9LVra5_39xtkg28IVhT95cRysJRSRXVO-dYXVE,830
+gla_api/runtime/devices.pyc,sha256=VqU8qGAfA2gmlbrm9XXayUoc_pWT_skNmYZ3U5zuwVg,9625
+gla_api/runtime/loader.pyc,sha256=RMiRZYt4MGTVFUdZXZYtmsooFaB26GOWax9Kuwrtn1A,11472
+gla_api/runtime/locate.pyc,sha256=BmK3MOPUmFm_wXSEUl8D58V42zLWEcLcdRGDkT5HjaY,21203
+gla_api/runtime/ops.pyc,sha256=MF_0qlAscksaOtAu59YuKPdchecya_TejSCNMre1VJU,23818
+gla_api/runtime/precision.pyc,sha256=7S9AVnCV6KtulAdYM5jNUNQPUFb2Z-xg1T-E7w4DZlE,36586
+gla_api/runtime/prepare.pyc,sha256=jMldci004ZdCfPX_aMY_paOHrz1hYam_Dru-cHQdSZU,7995
+gla_api/runtime/worker.pyc,sha256=hIjR1Gzz6Zyz5YQH0UovhsDZf1BddvoHeXQYS7CGlZ4,16199
+gla_api/safety.pyc,sha256=HzdUiNtuw4Lso1PwUlVO-KNJCkqCaSGFQmRFSlmeNJ8,4901
+gla_api/server/__init__.pyc,sha256=q4L8QwHEeLO93BRkG8pKJGwpyuSZYybBNMhTjKc9Y8o,847
+gla_api/server/app.pyc,sha256=qEtX_08xyMwzyPTjanw12cuSYmDEOWSYj2JIlkC3aN8,89551
+gla_api/server/hooks.pyc,sha256=TYJqzPxQEa8R-IRuzQTBI-IeIxScK4AzNm9-cJVkS1Y,5871
+gla_api/server/metrics.pyc,sha256=8icVwKZVHmEfgyJufTe81Z2vN9Eq96-Lchu_Ekx3Q6g,7829
+gla_api/server/pool.pyc,sha256=YTNun9GO6ACqq6-hEWkmcEAJrGzaEY-KI4kgpyCmNsk,64914
+gla_api/server/run.pyc,sha256=rvRG3Qg2FUAtph_wqQcwT0oKPXaPmDHjmQChmascQqw,4723
+gla_api/server/schemas.pyc,sha256=tQLSljFJq9R9Vx4f_Fu6bEZgyCSc63iHFWsIQkCPGxo,7370
+gla_api/server/settings.pyc,sha256=Sowdf_qDt8Y-MMNCS7ZHoSfr7lgAFsVY8XenoeKd_Ww,16166
+gla_api/server/state.pyc,sha256=by2gD-_yQCmuM6-l9swtd8ByCaVeYuyy5xmjZ7B7mk4,16899
+gla_api/server/store.pyc,sha256=hxPtwD9RY1dXdKz3jaKFWJrlZvpf9YScnENzBCrkxgQ,47138
+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=KaUipm2a3idv5nydeQYHIUmZ5Hx27bd6OcF_e1jnSWg,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: cp314-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