gridlinegpu 0.1.7__tar.gz → 0.1.9__tar.gz

{gridlinegpu-0.1.7 → gridlinegpu-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridlinegpu
-Version: 0.1.7
+Version: 0.1.9
 Summary: Python client for Gridline YAML workload routing
 Author: Gridline GPU
 License: Proprietary
@@ -18,15 +18,147 @@ Requires-Dist: unicodedata2==16.0.0; extra == "source-contract"
 
 # Gridline Python SDK
 
+Run your own Python code on one GPU as a finite job (**source runs**: batch inference, fine-tuning,
+evaluation) and get your declared output files back, verified. The package also submits legacy YAML
+routing workloads, and installs the `gridline` command in the same Python environment on macOS and
+Linux.
+
+## Self-serve quickstart (source runs)
+
+1. **Sign up** at https://gridlinegpu.com/signup and verify your email.
+2. **Request access** at https://gridlinegpu.com/get-started: accept the partner beta terms and
+   describe your use case in a few lines.
+3. **Wait for approval.** Gridline approves each request by hand and grants your account beta
+   credit; the get-started page shows the status. There is no payment step: jobs draw on that
+   credit.
+4. **Install** the SDK with the source extra (Python 3.10 or newer):
+
+   ```sh
+   python -m pip install 'gridlinegpu[source-contract]>=0.1.9,<0.2'
+   ```
+
+5. **Create a token** once. Browser approval saves a private, scoped token file; it is never
+   printed. Keep it out of source control and AI chats. Then check your access and credit:
+
+   ```sh
+   gridline setup --apply
+   gridline access          # prints your status and the next step; "approved" means you can run
+   python -c "from gridlinegpu import GridlineClient; print(GridlineClient().credits()['availableUsdMicros'])"
+   ```
+
+6. **Run a first job** on the curated `gridline/hf-torch-2.5@r1` runtime (CPython 3.11, CUDA 12.4,
+   torch 2.5.1, transformers 4.46.3). Put two files in an empty folder. `gridline.yaml`:
+
+   ```yaml
+   version: 2
+   name: first-job
+   task:
+     kind: application
+     class: inference
+     source:
+       include: [job.py]
+     command: [python, job.py]
+   runtime: gridline/hf-torch-2.5@r1
+   outputs:
+     results:
+       path: outputs/results.json
+       max_bytes: 1048576
+   resources:
+     gpu:
+       count: 1
+       minimum_vram_gib: 8
+   ```
+
+   and `job.py`:
+
+   ```python
+   import json, os, torch
+
+   os.makedirs("outputs", exist_ok=True)
+   x = torch.randn(1024, 1024, device="cuda")
+   with open("outputs/results.json", "w") as f:
+       json.dump({"gpu": torch.cuda.get_device_name(0), "sum": float((x @ x).sum())}, f)
+   ```
+
+   Then submit it, wait, and download the verified output:
+
+   ```python
+   from gridlinegpu import GridlineClient, SubmissionOutcomeUnknown
+
+   client = GridlineClient()
+   try:
+       job = client.run("gridline.yaml")
+   except SubmissionOutcomeUnknown as error:
+       job = client.resume(error.submission_id)  # never run() again for the same submission
+   result = job.wait()                            # a local timeout never cancels the job
+   print(result.outcome, result.failure_code)
+   if result.succeeded:
+       job.outputs("results")                     # length and SHA-256 checked
+   print(job.report()["settlement"])              # what the job held, charged and released
+   ```
+
+   Gridline's curated-beta example (`examples/workloads/curated-beta/`) is the same job with a
+   small text generation step.
+
+7. **Fine-tune.** The fine-tune example (`examples/workloads/finetune-lora-smollm2/`,
+   `gridline-models.yaml`) trains LoRA and QLoRA adapters for SmolLM2-135M on the
+   `gridline/hf-finetune-2.5@r1` runtime. `models:` makes the platform fetch the pinned base model
+   into `models/base` before your code starts; your code never downloads it:
+
+   ```yaml
+   version: 2
+   name: finetune-lora
+   task:
+     kind: application
+     class: training
+     source:
+       include: [train.py, data/train.jsonl, data/eval.jsonl]
+     command: [python, train.py]
+   runtime:
+     curated: gridline/hf-finetune-2.5@r1
+   models:
+     base:
+       source: hf://HuggingFaceTB/SmolLM2-135M
+       revision: 93efa2f097d58c2a74874c7e644dbc9b0cee75a2
+       files: [config.json, generation_config.json, model.safetensors, special_tokens_map.json,
+               tokenizer.json, tokenizer_config.json]
+   outputs:
+     metrics:
+       path: outputs/metrics.json
+       max_bytes: 262144
+     lora_adapter:
+       path: outputs/lora/adapter_model.safetensors
+       max_bytes: 33554432
+     lora_config:
+       path: outputs/lora/adapter_config.json
+       max_bytes: 65536
+   resources:
+     gpu:
+       count: 1
+       minimum_vram_gib: 16
+   ```
+
+   `train.py` loads `models/base` with `local_files_only=True`, trains, and writes each declared
+   file under `outputs/`. Submit it like the first job. **Mark every output you need as required**
+   (the default). For now an optional output written after a required one may be left out of the
+   results, even when the job succeeds.
+
+Without approved access, `run()` is refused with `partner_not_admitted` before anything is
+submitted, and the error points back to the get-started page. Source runs need the
+`source-contract` extra: it stays optional because one of its packages (`unicodedata2`) has no
+prebuilt wheel for some platforms (for example CPython 3.12+ on Linux aarch64), where it needs a C
+compiler. Without it, the YAML commands and `client.access()` still work and source calls raise
+`source_dependencies_missing` with the install line. The "Source runs (beta)" section below has the
+limits, costs and failure codes.
+
+## YAML routing workloads
+
 Submit one YAML workload through Gridline's authenticated API. The Python client stages
 files referenced by YAML, returns a route for review, then launches only that exact
-fresh plan when you supply a cost ceiling and idempotency key. The package also installs
-the `gridline` command in the same Python environment on macOS and Linux.
-
-## Install
+fresh plan when you supply a cost ceiling and idempotency key.
 
 ```sh
-python -m pip install 'gridlinegpu>=0.1.4,<0.2'
+python -m pip install 'gridlinegpu>=0.1.9,<0.2'
 ```
 
 Run browser setup once. It creates a 30-day scoped token in a private file, attempts to
@@ -134,19 +266,20 @@ its existing completion behavior and does not stream progress callbacks.
 ## Source runs (beta)
 
 Source runs send your own Python code and inputs to one GPU, run it as a finite job on an
-operator-qualified **curated runtime**, and return your declared output files. They are in
-an invite-only beta, funded by credits Gridline grants to design partners: there is no
-top-up or payment step in the SDK. Install the source extra and turn the beta on in your
-shell:
+operator-qualified **curated runtime**, and return your declared output files. They are in a
+beta funded by credits Gridline grants to each approved account: there is no top-up or payment
+step in the SDK. Request access first (see the quickstart above); `client.access()` and
+`gridline access` show where your request stands.
 
 ```sh
-python -m pip install 'gridlinegpu[source-contract]>=0.1.7,<0.2'
-export GRIDLINE_SOURCE_SDK_ENABLED=true
+python -m pip install 'gridlinegpu[source-contract]>=0.1.9,<0.2'
 gridline setup --apply   # once: saves a private, scoped token file
+gridline access          # "approved" before your first run
 ```
 
-Without `GRIDLINE_SOURCE_SDK_ENABLED=true`, `run()` raises `GridlineError` with code
-`source_lane_disabled` and touches no file, token or network.
+Since 0.1.9 the SDK has no switch of its own: `GRIDLINE_SOURCE_SDK_ENABLED` is ignored, and the
+server decides access (`partner_not_admitted` or `partner_suspended` refuse a run before anything
+is submitted).
 
 **The workload.** Put a `gridline.yaml` beside your code. Name a curated runtime instead of
 declaring dependencies: `gridline/hf-torch-2.5@r1` provides CPython 3.11 and CUDA 12.4 with
@@ -186,11 +319,20 @@ and home directories are the platform's and cannot be redirected (`TMPDIR`,
 - Inputs: each local input file is at most 512 MiB.
 - Outputs: declare each one under `outputs`. Each file is at most 128 MiB (`max_bytes`;
   8 MiB when omitted), at most 1 GiB in total, and at most 32 outputs per job.
+- Outputs are required unless marked `required: false`. During the beta, an optional
+  output can be left out of the results even when your code wrote it; the job still
+  succeeds. Keep every output you need required.
 - No network at run time (details below): the code, inputs and models it needs must
   arrive with the job.
 - Leave out `budget` and `execution.deadline_seconds`: beta routing places jobs best-effort
   and refuses either constraint (`budget_feasibility_unknown` /
   `deadline_feasibility_unknown`).
+- One GPU per job (`resources.gpu.count: 1`).
+- Credit holds: while a job runs, its funded hour window holds about $1.78 of your credit (one
+  hour of compute plus a 5-minute stop at the $1.50 per hour price ceiling, disk and settlement).
+  A few minutes after the machine is removed, the job is charged what it actually used and the
+  rest of the hold is released. `client.credits()` shows granted, held, charged and available
+  credit; a run with too little available credit is refused with `credit_insufficient`.
 
 **Run it.** `run()` validates, captures your selected files, uploads them and returns a
 `JobHandle` once the job is admitted. Everything after that happens server-side.
@@ -213,11 +355,48 @@ print(job.report()["settlement"])  # reserved, held, charged and released credit
 ```
 
 `job.status()` reads the current state without waiting, and `job.cancel()` requests a stop.
+`job.isolation_tier()` names the isolation tier the job's code ran under (`kernel_cgroup` or
+`hardened_user_separation`, see the security page), or `None` before a machine is allocated.
+Under `hardened_user_separation` each process of your code has an 8 GiB data-memory limit
+(and 4 GiB per written file): an allocation past it fails inside your code (`MemoryError` in
+Python), so the job usually ends `workload_runtime_failed`, not `workload_out_of_memory`.
 `client.history(limit=20)` lists your recent jobs, newest first. `report()` and `history()`
 raise `report_unavailable` / `history_unavailable` until those reads are switched on for
 the beta; the job itself is unaffected. A complete minimal
 job is in `examples/workloads/curated-beta/`.
 
+**Fine-tuning (beta): LoRA/QLoRA on `gridline/hf-finetune-2.5@r1`.** The
+runtime provides CPython 3.11 and CUDA 12.4 with `torch==2.5.1`, `transformers==4.46.3`,
+`peft==0.13.2`, `trl==0.12.1`, `bitsandbytes==0.44.1`, `accelerate==1.1.1` and
+`datasets==3.1.0`. Your code has no network, so name the base model under `models:` with a
+pinned Hugging Face commit revision; the platform fetches and verifies it into
+`models/base` before your code starts:
+
+```yaml
+runtime: gridline/hf-finetune-2.5@r1
+models:
+  base:
+    source: hf://HuggingFaceTB/SmolLM2-135M
+    revision: 93efa2f097d58c2a74874c7e644dbc9b0cee75a2
+    files: [config.json, model.safetensors, tokenizer.json, tokenizer_config.json]
+outputs:
+  lora_adapter:
+    path: outputs/lora/adapter_model.safetensors
+    max_bytes: 33554432
+  lora_config:
+    path: outputs/lora/adapter_config.json
+    max_bytes: 65536
+```
+
+A complete job (LoRA in bf16 and QLoRA in 4-bit on SmolLM2-135M) is
+`examples/workloads/finetune-lora-smollm2/gridline-models.yaml`. Keep every adapter output
+required (see the limits above): each file at most 128 MiB, at most 1 GiB per job, one GPU.
+Under `hardened_user_separation` each process has an 8 GiB data-memory limit, so load the
+base model straight to the GPU (`device_map` or 4-bit loading) rather than building it in
+CPU memory. While a job runs, about $1.78 of credits is held per window of about an hour;
+it settles at the actual cost after teardown (the acceptance job cost about $0.06). Full
+fine-tunes that return merged weights need larger outputs and are coming soon.
+
 The rest of this section describes how source runs behave.
 
 **Network.** Source runs have no network access, only Unix domain sockets. No TCP or UDP,
@@ -229,12 +408,13 @@ offline error. Declare models and inputs: they are fetched by the platform, not
 code, and staged before your code starts. io_uring is not available either. If the
 machine cannot enforce this isolation, your code does not start and the job ends with
 `isolation_unsupported`: "The allocated machine cannot enforce the workload's required
-isolation." Submit a new run; contact support if it repeats.
+isolation." The job's credit hold is released and you are not charged for it. Submit a
+new run; contact support if it repeats.
 
 **Pinned models.** Gridline fetches each declared model at its pinned commit. If a pinned
 model file has changed or is missing when it is fetched for your run, the run stops and
-that attempt is used up; it is not retried. A machine was already started, so your
-provider bills its time. During the canary, a used-up attempt costs at most about $0.50:
+that attempt is used up; it is not retried. A machine was already started, so its time
+is charged to your credits. During the beta, a used-up attempt costs at most about $0.50:
 up to roughly 20 minutes (15 minutes of startup plus one 5-minute stop cycle) at the $1.50
 per hour price ceiling, disk included.
 Check that pinned models are still public, then run again.
@@ -245,5 +425,5 @@ machine was started and this attempt was not charged. Trying the next matching o
 no matching GPU is left and no machine was started for the job, it ends with
 `routing_attempts_exhausted`: "No matching GPU was available right now. No machine was
 started for this job, so these attempts were not charged. Try again later or widen the GPU
-choice." A machine that did start is billed by your provider for the time it ran, whatever
+choice." A machine that did start is charged to your credits for the time it ran, whatever
 the outcome.

{gridlinegpu-0.1.7 → gridlinegpu-0.1.9}/README.md

@@ -1,14 +1,146 @@
 # Gridline Python SDK
 
+Run your own Python code on one GPU as a finite job (**source runs**: batch inference, fine-tuning,
+evaluation) and get your declared output files back, verified. The package also submits legacy YAML
+routing workloads, and installs the `gridline` command in the same Python environment on macOS and
+Linux.
+
+## Self-serve quickstart (source runs)
+
+1. **Sign up** at https://gridlinegpu.com/signup and verify your email.
+2. **Request access** at https://gridlinegpu.com/get-started: accept the partner beta terms and
+   describe your use case in a few lines.
+3. **Wait for approval.** Gridline approves each request by hand and grants your account beta
+   credit; the get-started page shows the status. There is no payment step: jobs draw on that
+   credit.
+4. **Install** the SDK with the source extra (Python 3.10 or newer):
+
+   ```sh
+   python -m pip install 'gridlinegpu[source-contract]>=0.1.9,<0.2'
+   ```
+
+5. **Create a token** once. Browser approval saves a private, scoped token file; it is never
+   printed. Keep it out of source control and AI chats. Then check your access and credit:
+
+   ```sh
+   gridline setup --apply
+   gridline access          # prints your status and the next step; "approved" means you can run
+   python -c "from gridlinegpu import GridlineClient; print(GridlineClient().credits()['availableUsdMicros'])"
+   ```
+
+6. **Run a first job** on the curated `gridline/hf-torch-2.5@r1` runtime (CPython 3.11, CUDA 12.4,
+   torch 2.5.1, transformers 4.46.3). Put two files in an empty folder. `gridline.yaml`:
+
+   ```yaml
+   version: 2
+   name: first-job
+   task:
+     kind: application
+     class: inference
+     source:
+       include: [job.py]
+     command: [python, job.py]
+   runtime: gridline/hf-torch-2.5@r1
+   outputs:
+     results:
+       path: outputs/results.json
+       max_bytes: 1048576
+   resources:
+     gpu:
+       count: 1
+       minimum_vram_gib: 8
+   ```
+
+   and `job.py`:
+
+   ```python
+   import json, os, torch
+
+   os.makedirs("outputs", exist_ok=True)
+   x = torch.randn(1024, 1024, device="cuda")
+   with open("outputs/results.json", "w") as f:
+       json.dump({"gpu": torch.cuda.get_device_name(0), "sum": float((x @ x).sum())}, f)
+   ```
+
+   Then submit it, wait, and download the verified output:
+
+   ```python
+   from gridlinegpu import GridlineClient, SubmissionOutcomeUnknown
+
+   client = GridlineClient()
+   try:
+       job = client.run("gridline.yaml")
+   except SubmissionOutcomeUnknown as error:
+       job = client.resume(error.submission_id)  # never run() again for the same submission
+   result = job.wait()                            # a local timeout never cancels the job
+   print(result.outcome, result.failure_code)
+   if result.succeeded:
+       job.outputs("results")                     # length and SHA-256 checked
+   print(job.report()["settlement"])              # what the job held, charged and released
+   ```
+
+   Gridline's curated-beta example (`examples/workloads/curated-beta/`) is the same job with a
+   small text generation step.
+
+7. **Fine-tune.** The fine-tune example (`examples/workloads/finetune-lora-smollm2/`,
+   `gridline-models.yaml`) trains LoRA and QLoRA adapters for SmolLM2-135M on the
+   `gridline/hf-finetune-2.5@r1` runtime. `models:` makes the platform fetch the pinned base model
+   into `models/base` before your code starts; your code never downloads it:
+
+   ```yaml
+   version: 2
+   name: finetune-lora
+   task:
+     kind: application
+     class: training
+     source:
+       include: [train.py, data/train.jsonl, data/eval.jsonl]
+     command: [python, train.py]
+   runtime:
+     curated: gridline/hf-finetune-2.5@r1
+   models:
+     base:
+       source: hf://HuggingFaceTB/SmolLM2-135M
+       revision: 93efa2f097d58c2a74874c7e644dbc9b0cee75a2
+       files: [config.json, generation_config.json, model.safetensors, special_tokens_map.json,
+               tokenizer.json, tokenizer_config.json]
+   outputs:
+     metrics:
+       path: outputs/metrics.json
+       max_bytes: 262144
+     lora_adapter:
+       path: outputs/lora/adapter_model.safetensors
+       max_bytes: 33554432
+     lora_config:
+       path: outputs/lora/adapter_config.json
+       max_bytes: 65536
+   resources:
+     gpu:
+       count: 1
+       minimum_vram_gib: 16
+   ```
+
+   `train.py` loads `models/base` with `local_files_only=True`, trains, and writes each declared
+   file under `outputs/`. Submit it like the first job. **Mark every output you need as required**
+   (the default). For now an optional output written after a required one may be left out of the
+   results, even when the job succeeds.
+
+Without approved access, `run()` is refused with `partner_not_admitted` before anything is
+submitted, and the error points back to the get-started page. Source runs need the
+`source-contract` extra: it stays optional because one of its packages (`unicodedata2`) has no
+prebuilt wheel for some platforms (for example CPython 3.12+ on Linux aarch64), where it needs a C
+compiler. Without it, the YAML commands and `client.access()` still work and source calls raise
+`source_dependencies_missing` with the install line. The "Source runs (beta)" section below has the
+limits, costs and failure codes.
+
+## YAML routing workloads
+
 Submit one YAML workload through Gridline's authenticated API. The Python client stages
 files referenced by YAML, returns a route for review, then launches only that exact
-fresh plan when you supply a cost ceiling and idempotency key. The package also installs
-the `gridline` command in the same Python environment on macOS and Linux.
-
-## Install
+fresh plan when you supply a cost ceiling and idempotency key.
 
 ```sh
-python -m pip install 'gridlinegpu>=0.1.4,<0.2'
+python -m pip install 'gridlinegpu>=0.1.9,<0.2'
 ```
 
 Run browser setup once. It creates a 30-day scoped token in a private file, attempts to
@@ -116,19 +248,20 @@ its existing completion behavior and does not stream progress callbacks.
 ## Source runs (beta)
 
 Source runs send your own Python code and inputs to one GPU, run it as a finite job on an
-operator-qualified **curated runtime**, and return your declared output files. They are in
-an invite-only beta, funded by credits Gridline grants to design partners: there is no
-top-up or payment step in the SDK. Install the source extra and turn the beta on in your
-shell:
+operator-qualified **curated runtime**, and return your declared output files. They are in a
+beta funded by credits Gridline grants to each approved account: there is no top-up or payment
+step in the SDK. Request access first (see the quickstart above); `client.access()` and
+`gridline access` show where your request stands.
 
 ```sh
-python -m pip install 'gridlinegpu[source-contract]>=0.1.7,<0.2'
-export GRIDLINE_SOURCE_SDK_ENABLED=true
+python -m pip install 'gridlinegpu[source-contract]>=0.1.9,<0.2'
 gridline setup --apply   # once: saves a private, scoped token file
+gridline access          # "approved" before your first run
 ```
 
-Without `GRIDLINE_SOURCE_SDK_ENABLED=true`, `run()` raises `GridlineError` with code
-`source_lane_disabled` and touches no file, token or network.
+Since 0.1.9 the SDK has no switch of its own: `GRIDLINE_SOURCE_SDK_ENABLED` is ignored, and the
+server decides access (`partner_not_admitted` or `partner_suspended` refuse a run before anything
+is submitted).
 
 **The workload.** Put a `gridline.yaml` beside your code. Name a curated runtime instead of
 declaring dependencies: `gridline/hf-torch-2.5@r1` provides CPython 3.11 and CUDA 12.4 with
@@ -168,11 +301,20 @@ and home directories are the platform's and cannot be redirected (`TMPDIR`,
 - Inputs: each local input file is at most 512 MiB.
 - Outputs: declare each one under `outputs`. Each file is at most 128 MiB (`max_bytes`;
   8 MiB when omitted), at most 1 GiB in total, and at most 32 outputs per job.
+- Outputs are required unless marked `required: false`. During the beta, an optional
+  output can be left out of the results even when your code wrote it; the job still
+  succeeds. Keep every output you need required.
 - No network at run time (details below): the code, inputs and models it needs must
   arrive with the job.
 - Leave out `budget` and `execution.deadline_seconds`: beta routing places jobs best-effort
   and refuses either constraint (`budget_feasibility_unknown` /
   `deadline_feasibility_unknown`).
+- One GPU per job (`resources.gpu.count: 1`).
+- Credit holds: while a job runs, its funded hour window holds about $1.78 of your credit (one
+  hour of compute plus a 5-minute stop at the $1.50 per hour price ceiling, disk and settlement).
+  A few minutes after the machine is removed, the job is charged what it actually used and the
+  rest of the hold is released. `client.credits()` shows granted, held, charged and available
+  credit; a run with too little available credit is refused with `credit_insufficient`.
 
 **Run it.** `run()` validates, captures your selected files, uploads them and returns a
 `JobHandle` once the job is admitted. Everything after that happens server-side.
@@ -195,11 +337,48 @@ print(job.report()["settlement"])  # reserved, held, charged and released credit
 ```
 
 `job.status()` reads the current state without waiting, and `job.cancel()` requests a stop.
+`job.isolation_tier()` names the isolation tier the job's code ran under (`kernel_cgroup` or
+`hardened_user_separation`, see the security page), or `None` before a machine is allocated.
+Under `hardened_user_separation` each process of your code has an 8 GiB data-memory limit
+(and 4 GiB per written file): an allocation past it fails inside your code (`MemoryError` in
+Python), so the job usually ends `workload_runtime_failed`, not `workload_out_of_memory`.
 `client.history(limit=20)` lists your recent jobs, newest first. `report()` and `history()`
 raise `report_unavailable` / `history_unavailable` until those reads are switched on for
 the beta; the job itself is unaffected. A complete minimal
 job is in `examples/workloads/curated-beta/`.
 
+**Fine-tuning (beta): LoRA/QLoRA on `gridline/hf-finetune-2.5@r1`.** The
+runtime provides CPython 3.11 and CUDA 12.4 with `torch==2.5.1`, `transformers==4.46.3`,
+`peft==0.13.2`, `trl==0.12.1`, `bitsandbytes==0.44.1`, `accelerate==1.1.1` and
+`datasets==3.1.0`. Your code has no network, so name the base model under `models:` with a
+pinned Hugging Face commit revision; the platform fetches and verifies it into
+`models/base` before your code starts:
+
+```yaml
+runtime: gridline/hf-finetune-2.5@r1
+models:
+  base:
+    source: hf://HuggingFaceTB/SmolLM2-135M
+    revision: 93efa2f097d58c2a74874c7e644dbc9b0cee75a2
+    files: [config.json, model.safetensors, tokenizer.json, tokenizer_config.json]
+outputs:
+  lora_adapter:
+    path: outputs/lora/adapter_model.safetensors
+    max_bytes: 33554432
+  lora_config:
+    path: outputs/lora/adapter_config.json
+    max_bytes: 65536
+```
+
+A complete job (LoRA in bf16 and QLoRA in 4-bit on SmolLM2-135M) is
+`examples/workloads/finetune-lora-smollm2/gridline-models.yaml`. Keep every adapter output
+required (see the limits above): each file at most 128 MiB, at most 1 GiB per job, one GPU.
+Under `hardened_user_separation` each process has an 8 GiB data-memory limit, so load the
+base model straight to the GPU (`device_map` or 4-bit loading) rather than building it in
+CPU memory. While a job runs, about $1.78 of credits is held per window of about an hour;
+it settles at the actual cost after teardown (the acceptance job cost about $0.06). Full
+fine-tunes that return merged weights need larger outputs and are coming soon.
+
 The rest of this section describes how source runs behave.
 
 **Network.** Source runs have no network access, only Unix domain sockets. No TCP or UDP,
@@ -211,12 +390,13 @@ offline error. Declare models and inputs: they are fetched by the platform, not
 code, and staged before your code starts. io_uring is not available either. If the
 machine cannot enforce this isolation, your code does not start and the job ends with
 `isolation_unsupported`: "The allocated machine cannot enforce the workload's required
-isolation." Submit a new run; contact support if it repeats.
+isolation." The job's credit hold is released and you are not charged for it. Submit a
+new run; contact support if it repeats.
 
 **Pinned models.** Gridline fetches each declared model at its pinned commit. If a pinned
 model file has changed or is missing when it is fetched for your run, the run stops and
-that attempt is used up; it is not retried. A machine was already started, so your
-provider bills its time. During the canary, a used-up attempt costs at most about $0.50:
+that attempt is used up; it is not retried. A machine was already started, so its time
+is charged to your credits. During the beta, a used-up attempt costs at most about $0.50:
 up to roughly 20 minutes (15 minutes of startup plus one 5-minute stop cycle) at the $1.50
 per hour price ceiling, disk included.
 Check that pinned models are still public, then run again.
@@ -227,5 +407,5 @@ machine was started and this attempt was not charged. Trying the next matching o
 no matching GPU is left and no machine was started for the job, it ends with
 `routing_attempts_exhausted`: "No matching GPU was available right now. No machine was
 started for this job, so these attempts were not charged. Try again later or widen the GPU
-choice." A machine that did start is billed by your provider for the time it ran, whatever
+choice." A machine that did start is charged to your credits for the time it ran, whatever
 the outcome.

{gridlinegpu-0.1.7 → gridlinegpu-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gridlinegpu"
-version = "0.1.7"
+version = "0.1.9"
 description = "Python client for Gridline YAML workload routing"
 readme = "README.md"
 requires-python = ">=3.10"

{gridlinegpu-0.1.7 → gridlinegpu-0.1.9}/src/gridlinegpu/__init__.py

@@ -17,7 +17,8 @@ def __getattr__(name):
     first use. Without the extra, ``gridlinegpu.JobHandle`` raises GridlineError
     ``source_dependencies_missing``, which is also an AttributeError (``hasattr`` is False; a
     ``from gridlinegpu import JobHandle`` raises Python's ImportError). It joins ``__all__``
-    at activation, when the extra becomes a base dependency."""
+    if the extra becomes a base dependency (it stays optional in 0.1.9: unicodedata2 publishes
+    no wheel for some platforms, such as CPython 3.12+ on Linux aarch64)."""
     if name == "JobHandle":
         from ._source_public import job_handle_type