wsm 0.1.0__tar.gz

wsm-0.1.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: wsm
+Version: 0.1.0
+Summary: WSM (Weight Space Mods): Python model weight editing
+Project-URL: Repository, https://github.com/thoriqakbar0/wsm
+Project-URL: Documentation, https://github.com/thoriqakbar0/wsm/blob/main/README.md
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Provides-Extra: tinker
+Requires-Dist: tinker==0.39.0; extra == "tinker"
+Provides-Extra: trial
+Requires-Dist: modal==1.6.3; extra == "trial"
+Requires-Dist: tinker==0.39.0; extra == "trial"
+Requires-Dist: jinja2>=3.1.6; extra == "trial"
+Provides-Extra: spindle
+Requires-Dist: modal==1.6.3; extra == "spindle"
+Requires-Dist: tinker==0.39.0; extra == "spindle"
+Requires-Dist: jinja2>=3.1.6; extra == "spindle"
+Provides-Extra: editing
+Requires-Dist: torch; extra == "editing"
+Requires-Dist: transformers; extra == "editing"
+Requires-Dist: safetensors; extra == "editing"
+
+# WSM (Weight Space Mods)
+
+WSM is a Python SDK for model weight editing. Access named tensors, change weights, evaluate the result, and save a standalone checkpoint.
+
+Requires Python 3.12 or later. The core package has no third-party runtime dependencies.
+
+```sh
+pip install wsm
+wsm --help
+```
+
+Install the model dependencies to load a local snapshot:
+
+```sh
+pip install 'wsm[editing]'
+```
+
+```python
+from wsm import WeightModel
+
+model = WeightModel.load("/path/to/local/snapshot")
+model.weights["model.norm.weight"][:16].mul_(0.95)
+result = model.evaluate([{"prompt": "Say hello.", "target": "Hello!"}])
+model.save("/path/to/new-checkpoint")
+```
+
+The supported Python API consists of `WeightModel` and `execute_program`. Read the [project documentation](https://github.com/thoriqakbar0/wsm#readme) for CLI usage, execution trust, and optional Modal and Spindle trials. Spindle requires a separate pinned source installation documented in the [trial guide](https://github.com/thoriqakbar0/wsm/blob/main/docs/trials.md).

wsm-0.1.0/README.md

@@ -0,0 +1,27 @@
+# WSM (Weight Space Mods)
+
+WSM is a Python SDK for model weight editing. Access named tensors, change weights, evaluate the result, and save a standalone checkpoint.
+
+Requires Python 3.12 or later. The core package has no third-party runtime dependencies.
+
+```sh
+pip install wsm
+wsm --help
+```
+
+Install the model dependencies to load a local snapshot:
+
+```sh
+pip install 'wsm[editing]'
+```
+
+```python
+from wsm import WeightModel
+
+model = WeightModel.load("/path/to/local/snapshot")
+model.weights["model.norm.weight"][:16].mul_(0.95)
+result = model.evaluate([{"prompt": "Say hello.", "target": "Hello!"}])
+model.save("/path/to/new-checkpoint")
+```
+
+The supported Python API consists of `WeightModel` and `execute_program`. Read the [project documentation](https://github.com/thoriqakbar0/wsm#readme) for CLI usage, execution trust, and optional Modal and Spindle trials. Spindle requires a separate pinned source installation documented in the [trial guide](https://github.com/thoriqakbar0/wsm/blob/main/docs/trials.md).

wsm-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wsm"
+version = "0.1.0"
+description = "WSM (Weight Space Mods): Python model weight editing"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+
+[project.urls]
+Repository = "https://github.com/thoriqakbar0/wsm"
+Documentation = "https://github.com/thoriqakbar0/wsm/blob/main/README.md"
+
+[project.scripts]
+wsm = "wsm.cli:main"
+
+[project.optional-dependencies]
+tinker = ["tinker==0.39.0"]
+trial = ["modal==1.6.3", "tinker==0.39.0", "jinja2>=3.1.6"]
+spindle = ["modal==1.6.3", "tinker==0.39.0", "jinja2>=3.1.6"]
+editing = ["torch", "transformers", "safetensors"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

wsm-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wsm-0.1.0/src/wsm/__init__.py

@@ -0,0 +1,14 @@
+"""Python tools for editing, evaluating, and saving model weights."""
+
+__version__ = "0.1.0"
+__all__ = ["WeightModel", "execute_program"]
+
+
+def __getattr__(name):
+    if name == "WeightModel":
+        from .editing import WeightModel
+        return WeightModel
+    if name == "execute_program":
+        from .program import execute_program
+        return execute_program
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

wsm-0.1.0/src/wsm/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

wsm-0.1.0/src/wsm/_publication.py

@@ -0,0 +1,19 @@
+"""Atomic checkpoint publication without replacing an existing destination."""
+import ctypes
+import errno
+import os
+
+from .errors import WeightlessError
+
+
+def _publish(source, destination):
+    rename = getattr(ctypes.CDLL(None, use_errno=True), "renameat2", None)
+    if rename is None:
+        raise WeightlessError("unsupported_platform", "Atomic exclusive export requires renameat2")
+    rename.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, ctypes.c_uint]
+    rename.restype = ctypes.c_int
+    if rename(-100, os.fsencode(source), -100, os.fsencode(destination), 1) != 0:
+        code = ctypes.get_errno()
+        if code in (errno.EEXIST, errno.ENOTEMPTY):
+            raise WeightlessError("export_exists", "Destination already exists")
+        raise OSError(code, os.strerror(code), str(destination))

wsm-0.1.0/src/wsm/cli.py

@@ -0,0 +1,78 @@
+"""Commands for trusted Python weight editing."""
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from . import __version__
+from .errors import WeightlessError
+
+
+def parser():
+    root = argparse.ArgumentParser(prog="wsm", description="Edit model weights with trusted Python. No command opens the TUI.")
+    root.add_argument('--version', action='version', version=f'wsm {__version__}')
+    commands = root.add_subparsers(dest='command')
+    execute = commands.add_parser('execute', help='Execute a trusted Python file defining edit(model)')
+    execute.add_argument('program', type=Path)
+    execute.add_argument('--model', type=Path, required=True)
+    execute.add_argument('--output', type=Path, required=True)
+    execute.add_argument('--cases', type=Path, required=True)
+    execute.add_argument('--device', default='cpu')
+    commands.add_parser('tui', help='Open the Python editing terminal')
+    trial = commands.add_parser("trial", help="Run or watch an experimental Modal coding trial")
+    trial_commands = trial.add_subparsers(dest="trial_command", required=True)
+    preflight = trial_commands.add_parser("preflight", help="Validate explicit task, policy, and price configuration offline")
+    preflight.add_argument("--config", type=Path, required=True)
+    trial_run = trial_commands.add_parser("run", help="Run one fixed-model Modal trial and hosted Tinker update")
+    trial_run.add_argument("--config", type=Path, required=True)
+    trial_run.add_argument("--output", type=Path, required=True)
+    trial_view = trial_commands.add_parser("view", help="Read the public trial journal without control access")
+    trial_view.add_argument("directory", type=Path)
+    trial_view.add_argument("--follow", action="store_true")
+    weights = trial_commands.add_parser("weights", help="Read retained tensor shapes or numerical values")
+    weights.add_argument("checkpoint", type=Path, help="Retained safetensors file")
+    weights.add_argument("--tensor")
+    weights.add_argument("--indices", type=int, nargs="+")
+    return root
+
+
+def main(argv=None):
+    args = parser().parse_args(argv)
+    try:
+        if args.command == "trial":
+            from .trial_poc import inspect_weights, load_config, run_poc, watch
+            if args.trial_command == "view":
+                watch(args.directory, follow=args.follow)
+            elif args.trial_command == "weights":
+                print(json.dumps(inspect_weights(args.checkpoint, tensor=args.tensor, indices=args.indices),
+                                 indent=2, allow_nan=False))
+            else:
+                config = load_config(args.config)
+                result = ({"valid": True, "cloud_calls": 0, "budget_usd": config["budget"]["max_usd"]}
+                          if args.trial_command == "preflight" else run_poc(config, args.output))
+                print(json.dumps(result, indent=2, allow_nan=False))
+            return 0
+        if args.command in (None, 'tui'):
+            if not sys.stdin.isatty() or not sys.stdout.isatty():
+                raise WeightlessError('terminal_required', 'The TUI requires a terminal; use --help for scriptable commands')
+            from .tui import launch
+            return launch()
+        from .program import execute_program
+        cases = json.loads(args.cases.read_text())
+        result = execute_program(args.program, model_path=args.model, output=args.output,
+                                 device=args.device, cases=cases)
+        print(json.dumps(result, allow_nan=False, indent=2))
+        return 0 if result.get('state') == 'published' else 1
+    except KeyboardInterrupt:
+        message = (f"Interrupted. Inspect {args.output / 'run.json'} and its checkpoint before retrying."
+                   if args.command == 'execute' else 'Interrupted.')
+        print(json.dumps({'error': {'code': 'interrupted', 'message': message}}), file=sys.stderr)
+        return 130
+    except (Exception, SystemExit) as error:
+        print(json.dumps({'error': {'code': getattr(error, 'code', 'execution_error'),
+                                    'type': type(error).__name__, 'message': str(error)}}), file=sys.stderr)
+        return 1
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

wsm-0.1.0/src/wsm/coding_tui.py

@@ -0,0 +1,79 @@
+"""Terminal controls for the same Python execution command used by coding agents."""
+import curses
+import json
+import os
+from pathlib import Path
+import signal
+import subprocess
+import sys
+import tempfile
+
+
+def stop(process, first_signal):
+    try:
+        os.killpg(process.pid, first_signal)
+    except ProcessLookupError:
+        pass
+    try:
+        process.wait(timeout=10)
+    except subprocess.TimeoutExpired:
+        pass
+    finally:
+        try:
+            os.killpg(process.pid, signal.SIGKILL)
+        except ProcessLookupError:
+            pass
+        process.wait(timeout=10)
+
+
+def execute(screen):
+    from .tui import prompt, put, show_result
+
+    program = Path(prompt(screen, "Python editing file defining edit(model)")).expanduser().resolve()
+    show_result(screen, "Review Python source before execution", program.read_text().splitlines())
+    model = Path(prompt(screen, "Local model snapshot directory")).expanduser().resolve()
+    cases = Path(prompt(screen, "Public evaluation cases JSON")).expanduser().resolve()
+    output = Path(prompt(screen, "New output directory")).expanduser().resolve()
+    device = prompt(screen, "Torch device", default="cpu")
+    command = [sys.executable, "-m", "wsm", "execute", str(program), "--model", str(model),
+               "--cases", str(cases), "--output", str(output), "--device", device]
+    process = None
+    with tempfile.TemporaryFile(mode="w+b") as log:
+        try:
+            process = subprocess.Popen(command, stdin=subprocess.DEVNULL, stdout=log,
+                                       stderr=subprocess.STDOUT, start_new_session=True)
+            screen.timeout(100)
+            while process.poll() is None:
+                screen.erase()
+                put(screen, 1, "WSM / execute Python", attr=curses.A_BOLD)
+                put(screen, 3, str(program))
+                state = "starting"
+                try:
+                    state = json.loads((output / "run.json").read_text()).get("state", state)
+                except (OSError, ValueError):
+                    pass
+                put(screen, 5, "State  " + state)
+                put(screen, 7, "Output  " + str(output))
+                put(screen, 9, "Ctrl-C interrupts execution. Publication is recorded in run.json.")
+                screen.refresh()
+                try:
+                    screen.get_wch()
+                except curses.error:
+                    pass
+        except KeyboardInterrupt:
+            if process is not None:
+                stop(process, signal.SIGINT)
+        finally:
+            screen.timeout(-1)
+            if process is not None:
+                stop(process, signal.SIGTERM)
+        log.seek(0, 2)
+        log.seek(max(0, log.tell() - 16000))
+        text = log.read(16000).decode('utf-8', errors='replace')
+    try:
+        result = json.loads((output / "run.json").read_text())
+    except (OSError, ValueError):
+        result = {"state": "unknown", "output": str(output),
+                  "detail": "Inspect output before retrying. No completion receipt was readable."}
+    show_result(screen, "Python execution result", {"run": result, "process_output": text})
+    return result