gla-api 1.0.0__cp312-none-any.whl

gla_api-1.0.0.dist-info/METADATA

@@ -0,0 +1,473 @@
+Metadata-Version: 2.1
+Name: gla-api
+Version: 1.0.0
+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
+Author: ATEC (Advancement Through Engineering & Creation)
+Maintainer: ATEC (Advancement Through Engineering & Creation)
+Home-page: https://pypi.org/project/gla-api/
+Project-URL: Homepage, https://pypi.org/project/gla-api/
+Project-URL: Documentation, https://github.com/FWKTechnologies/CodeMind-Code-Intelligence
+Project-URL: License, https://github.com/FWKTechnologies/CodeMind-Code-Intelligence/blob/main/LICENSE
+Keywords: GLA,Graph-Language Assistant,ATEC,code,AI,LLM,API,OpenAI-compatible,server
+Requires-Python: >=3.11,<3.14
+License: Proprietary
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: License :: Other/Proprietary License
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: torch>=2.4
+Requires-Dist: safetensors>=0.4.5
+Requires-Dist: psutil>=5.9
+Requires-Dist: tree-sitter-language-pack>=1.0,<2
+Requires-Dist: pypdf>=4.0
+Requires-Dist: fastapi>=0.115,<1
+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"
+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/**
+
+| | |
+|---|---|
+| Runs | **GLA 2.0** and **GLA 3.0** (the version is detected from the model folder) |
+| Operating systems | Windows 10/11 (64-bit), Linux (x86-64) |
+| Python | 3.11, 3.12 or 3.13 |
+| GPU | NVIDIA, any number (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 and precision](#9-gpus-and-precision)
+10. [Security](#10-security)
+11. [Troubleshooting](#11-troubleshooting)
+12. [Coming from codemindai-api](#12-coming-from-codemindai-api)
+
+---
+
+## 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), 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`, `--precision`, `--workers-per-gpu`,
+`--max-queue`, `--max-output-tokens`, `--default-rpm`, `--hooks`, `--ssl-certfile`/`--ssl-keyfile` and more
+(`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]` | 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 |
+| `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? |
+
+`--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
+```
+
+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. 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 |
+
+Interactive API docs: `gla-api config set docs 1`, `gla-api restart`, then open
+`http://127.0.0.1:8000/docs` (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`.
+
+**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).
+
+**Always on (Linux):** run `gla-api serve --supervise` from a systemd service. **Windows:** a Task Scheduler
+task "At log on" running `gla-api start`.
+
+**Public internet:** put HTTPS in front (a reverse proxy such as 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`) 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.
+
+---
+
+## 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` |
+| `precision` | `auto` | `auto`, `fp32`, `bf16`, `fp16`, `fp8`, `fp4` |
+| `admin_token` | made by `init` | controls `/admin` and keys — keep it secret |
+| `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) |
+| `request_timeout` | `300` | seconds per request |
+| `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 |
+| `hooks` | — | your `before_request` / `after_response` module |
+| `log_level` | `INFO` | |
+
+`gla-api config show` lists what is set and what is in use.
+
+---
+
+## 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()
+```
+
+`load(path, precision="auto", device="auto", devices=None, split=False, fp8="auto", safety=True, verify=False,
+warmup=True, threads=0, before=None, after=None)`
+
+`chat(prompt | messages=[...], system="", mode="auto"|"text"|"code", language=None, temperature=0.8, max_tokens=0)`
+returns an **`Answer`**: `text`, `mode`, `uncertain`, `confidence`, `reason`, `questions`, `language`,
+`language_supported`, `score`, `raw`. `str(answer)` is the text.
+
+Also: `code()`, `stream()`, `chat_many()`, `validate()`, `ground()`, `count_tokens()`, `add_hook()`, `info`, `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())
+```
+
+The client needs nothing but Python — use it on your web server while the model runs on a GPU machine. Errors raise
+`gla_api.APIError` with `status`, `code` and `message`.
+
+---
+
+## 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 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. Rough GPU memory for the weights:
+GLA 2.0 (≈6.1 B parameters) ≈ 12 GB in BF16, 6 GB in FP8, 4 GB in FP4; GLA 3.0 (≈17.9 B) ≈ 36 GB, 18 GB, 11 GB.
+A GLA 3.0 model can also be split over two GPUs: `load(path, devices="all", split=True)`.
+
+---
+
+## 10. Security
+
+- **Model folders are data only** (`safetensors`, no pickle): loading a model never runs code from it. Every load
+  checks the files; `gla-api verify` checks each SHA-256.
+- **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.
+- **The admin token** controls `/admin`; keep `.env` private (`gla-api backup` copies it — keep backups private
+  too).
+- Request size limits, content screening of requests and answers, and secret redaction 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=True` for GLA 3.0 |
+| `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 |
+
+---
+
+## 12. Coming from codemindai-api
+
+`gla-api` 1.0.0 is the new name of the library previously published as `codemindai-api`, the model's earlier name
+being CodeMind. Moving over takes two commands:
+
+```bash
+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`.
+Nothing else has to change:
+
+- **Folders, keys and settings carry over.** `codemindai_api_data/` (and the older `codemindai_data/`) is moved to
+  `gla_api_data/` the first time it is needed, with every API key, usage record and the audit log; the cache folder
+  moves the same way.
+- **Old names still work:** model folder `Model_CodeMind/`, API keys `cm_live_...`, settings `CODEMIND_...` and the
+  request option `codemind` are all accepted next to `Model_GLA/`, `gla_live_...`, `GLA_...` and `gla`.
+
+New in this release: one install command with the API server included; `setup`, `start` / `stop` / `restart` /
+`status` / `logs`, `key create | list | show | update | rotate | revoke | usage`, `audit`, `config`, `backup`,
+`bench`, `check-update` and `--dir`; `chat` without a question opens a conversation and `--url` asks a running
+server; `gla_api.Client` for using a server from Python; graceful stop on Windows and Linux and log rotation.
+
+---
+
+## 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/FWKTechnologies/CodeMind-Code-Intelligence

gla_api-1.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+gla_api/__init__.pyc,sha256=K8eI6MKuJcnNCyOBIoVI2HTnj4MCm-DN6UMrd_T7VU8,1018
+gla_api/__main__.pyc,sha256=tLU3IQ7Qoh1ms3UTZwDvTxeX09N38vzC4LX--8urmZs,215
+gla_api/_answer.pyc,sha256=BdjATNG3KOLzG9bw6Wv5d0Jk40QOpZMjL1qmqXuRPMw,3447
+gla_api/_paths.pyc,sha256=zYZbKRbfUTiXB6aUR-W1x9B-qJ9wwPkDPQ-OTNEKAVE,6185
+gla_api/_runtime/v2/CodeMind.pyc,sha256=_vTawFzfq3cb5uA_ceseSpT3YCqLS_6_hhzPSfCuKBE,1441466
+gla_api/_runtime/v2/codemind_brain_dual.pyc,sha256=I6bzlXrswh9-9ZzSOxWW_ZvK3EH3Y5FqB5SJcvyVmsQ,89162
+gla_api/_runtime/v2/linguistic_safety.pyc,sha256=vi9eK4c45hDYXPE3fa9gxfBDbwaE13WBy4Uk2eBXks0,67157
+gla_api/_runtime/v3/CodeMind.pyc,sha256=FKRSVLDgDD6PgrBP5yKCe875pJ3OCX4wgPX61Dx2E9w,1451632
+gla_api/_runtime/v3/codemind_brain_dual.pyc,sha256=bNAwqMv1o4svUdaYqFWGTIq1y9DSSV6wAD-Oi2DYypo,94616
+gla_api/_runtime/v3/linguistic_safety.pyc,sha256=DNwvcnCiWzm2iix16D-k4LCr0n0DpzcfeF0-dAnRYUM,68236
+gla_api/api.pyc,sha256=O5eUBYaOBK-vm3EHDIWQHOwoCbNIdUnn48b15RjnhRM,29217
+gla_api/cli.pyc,sha256=bRUUlxFmNTNbKsBfSgOz1xqmz-WSqr0fny6n37rN8sQ,72748
+gla_api/client.pyc,sha256=1q4g7zd61iuG4n2qSsSr3zMtmr-FAeIguxSkMn7yLR8,16895
+gla_api/engine.pyc,sha256=D4bphaao4Ojy8D0AfLi_OepfL38QfyQFGKuJCc4bB1U,71556
+gla_api/pool.pyc,sha256=Kp4YtcD7_9eS3kMfBbBez0gHtwxcwsxQQ4BbQlt8x0A,51291
+gla_api/server.pyc,sha256=410MrySXn1YlQKnWYjojZqQL5YiJL1xDwVQQ7laYcs8,123038
+gla_api/store.pyc,sha256=w768AtdiN4UDWA6WGW5eV365sgEZ42125VpexKebjKY,57218
+gla_api-1.0.0.dist-info/METADATA,sha256=sUtahyraCc3Kv7T-1YzLogmJW15ldCYz7vq2223Uaq8,21467
+gla_api-1.0.0.dist-info/WHEEL,sha256=CC0jpaOav8vea1YBDBB9lH5Ywf5ye9HcawI_KiEitTo,86
+gla_api-1.0.0.dist-info/entry_points.txt,sha256=aeHJRkFYS6A48JlONqIlKTRIk9oIXStsGa467ssy0Fk,45
+gla_api-1.0.0.dist-info/top_level.txt,sha256=kyHlFVdlSBr-1ddC_3um7Qw9Rp8tMkYXVkDz8k8VGLE,8
+gla_api-1.0.0.dist-info/RECORD,,

gla_api-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: gla-api-build
+Root-Is-Purelib: true
+Tag: cp312-none-any

gla_api-1.0.0.dist-info/entry_points.txt

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

gla_api-1.0.0.dist-info/top_level.txt

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