imurun 0.1.3__py3-none-any.whl

imurun/__init__.py

@@ -0,0 +1,218 @@
+"""
+IMURUN - the Python launcher.
+
+``pip install imurun`` puts a single ``imurun`` command on your PATH. IMURUN
+itself is a compiled program, so this package does the one thing a Python
+install can do that a downloaded file cannot: pick the right build for the
+machine, put it somewhere sensible, and run it.
+
+The first run downloads the matching standalone executable from the project's
+GitHub releases and caches it under ``~/.imurun/python``. Later runs start
+straight away. Nothing is installed system-wide, no administrator rights are
+needed, and the download is verified against the size published with the
+release.
+
+If you would rather install the program itself, see https://imutechz.in and the
+project README - the same command works from npm (``npm install -g imurun``)
+and from a standalone binary.
+"""
+
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import stat
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+__all__ = ["__version__", "main", "launcher_path", "download_url"]
+
+__version__ = "0.1.3"
+
+#: Where the releases live. One place, so a move is a one-line change.
+REPO = "shubham001312/imurun"
+
+#: The fallback channel: the newest published release, whatever it is called.
+LATEST = f"https://github.com/{REPO}/releases/latest/download"
+
+
+def user_home() -> Path:
+    """The user's home directory, resolved the way the platform expects."""
+    override = os.environ.get("IMURUN_HOME")
+    if override:
+        return Path(override).expanduser()
+    return Path.home()
+
+
+def cache_dir() -> Path:
+    """Where the downloaded executable lives."""
+    return user_home() / ".imurun" / "python"
+
+
+def platform_key() -> str:
+    """The release asset name for this machine, e.g. ``imurun-linux-x64``."""
+    system = platform.system().lower()
+    machine = platform.machine().lower()
+
+    if system == "windows":
+        os_name = "windows"
+    elif system == "darwin":
+        os_name = "darwin"
+    else:
+        os_name = "linux"
+
+    if machine in ("x86_64", "amd64", "x64"):
+        arch = "x64"
+    elif machine in ("arm64", "aarch64"):
+        arch = "arm64"
+    elif machine in ("i386", "i686", "x86"):
+        arch = "x64"  # the 32-bit builds are not published; x64 is the closest
+    else:
+        arch = "x64"
+
+    return f"imurun-{os_name}-{arch}"
+
+
+def is_windows() -> bool:
+    return platform.system().lower() == "windows"
+
+
+def binary_name() -> str:
+    """The file name the executable is stored under on this machine."""
+    return f"{platform_key()}.exe" if is_windows() else platform_key()
+
+
+def download_url() -> str:
+    """Where the executable for this machine is fetched from."""
+    return f"{LATEST}/{binary_name()}"
+
+
+def launcher_path() -> Path:
+    """The full path of the cached executable."""
+    return cache_dir() / binary_name()
+
+
+def _chmod_executable(path: Path) -> None:
+    """Make the file runnable. A no-op on Windows, where the bit means nothing."""
+    if is_windows():
+        return
+    mode = path.stat().st_mode
+    path.chmod(mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+
+def download_executable(destination: Path, url: str | None = None) -> Path:
+    """
+    Fetch the executable for this machine.
+
+    The download lands in a temporary file first and is moved into place only
+    once it has arrived whole, so an interrupted download never leaves a
+    truncated program behind that a later run would happily try to execute.
+    """
+    source = url or download_url()
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    partial = destination.with_suffix(destination.suffix + ".part")
+
+    print(f"Downloading IMURUN for this machine…\n  {source}", file=sys.stderr)
+    try:
+        with urllib.request.urlopen(source, timeout=120) as response:
+            total = response.headers.get("Content-Length")
+            expected = int(total) if total and total.isdigit() else 0
+            written = 0
+            with open(partial, "wb") as handle:
+                while True:
+                    chunk = response.read(1 << 20)
+                    if not chunk:
+                        break
+                    handle.write(chunk)
+                    written += len(chunk)
+                    if expected:
+                        percent = int(written * 100 / expected)
+                        print(f"\r  {percent:3d}%  ({written >> 20} MB)", end="", file=sys.stderr)
+        if expected and written != expected:
+            raise OSError(f"the download was incomplete ({written} of {expected} bytes)")
+    except urllib.error.URLError as error:
+        partial.unlink(missing_ok=True)
+        raise SystemExit(
+            f"Could not download IMURUN: {error}\n"
+            f"You can also install it directly:\n"
+            f"  npm install -g imurun\n"
+            f"  or download it from https://github.com/{REPO}/releases/latest"
+        ) from error
+    except BaseException:
+        partial.unlink(missing_ok=True)
+        raise
+
+    if expected:
+        print(file=sys.stderr)
+    _chmod_executable(partial)
+    partial.replace(destination)
+    return destination
+
+
+def ensure_executable() -> Path:
+    """Return the cached executable, downloading it the first time."""
+    path = launcher_path()
+    if path.exists():
+        return path
+    return download_executable(path)
+
+
+def main(argv: list[str] | None = None) -> int:
+    """
+    The ``imurun`` entry point.
+
+    Everything after the command name is handed straight to the program, so
+    ``imurun models install qwen2.5-coder-7b`` behaves exactly as it does when
+    installed any other way.
+    """
+    args = list(sys.argv[1:] if argv is None else argv)
+
+    if args and args[0] in ("--version", "-V"):
+        print(f"imurun {__version__}")
+        return 0
+
+    if args and args[0] in ("--help", "-h") and len(args) == 1:
+        print(__doc__.strip())
+        print(f"\nProject: https://github.com/{REPO}")
+        print("Website: https://imutechz.in")
+        return 0
+
+    executable = ensure_executable()
+
+    # A local build in the source tree wins, so a developer can run the
+    # program they are editing without a download.
+    local = Path.cwd() / "dist" / "imurun.js"
+    if local.exists():
+        return _run_bun(local, args)
+
+    return _run(executable, args)
+
+
+def _run(executable: Path, args: list[str]) -> int:
+    """Run the executable, replacing this process when the platform allows it."""
+    try:
+        os.execv(str(executable), [str(executable), *args])
+    except OSError:
+        # execv replaces the process on POSIX; on Windows it is not available
+        # for the same reason, so the child is spawned and waited on instead.
+        import subprocess
+
+        return subprocess.call([str(executable), *args])
+    return 0
+
+
+def _run_bun(bundle: Path, args: list[str]) -> int:
+    """Run a local bundle with Bun, when Bun is available."""
+    import subprocess
+
+    bun = shutil.which("bun")
+    if bun is None:
+        raise SystemExit("Bun is required to run a local build: https://bun.sh")
+    return subprocess.call([bun, str(bundle), *args])
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

imurun/__main__.py

@@ -0,0 +1,10 @@
+"""The console entry point: ``imurun`` on PATH after ``pip install imurun``."""
+
+from __future__ import annotations
+
+import sys
+
+from . import main
+
+if __name__ == "__main__":
+    sys.exit(main())

imurun-0.1.3.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.5
+Name: imurun
+Version: 0.1.3
+Summary: IMURUN - local-first AI coding agent. Installs, manages and runs local LLMs on your own machine.
+Project-URL: Homepage, https://imutechz.in
+Project-URL: Repository, https://github.com/shubham001312/imurun
+Project-URL: Issues, https://github.com/shubham001312/imurun/issues
+Author-email: Shubham Mallick <dev@imutechz.in>
+License: MIT
+License-File: LICENSE
+Keywords: agent,ai,cli,coding,llama.cpp,llm,local,offline
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# IMURUN — Python launcher
+
+`pip install imurun` puts a single **`imurun`** command on your PATH.
+
+IMURUN itself is a compiled program, so this package does the one thing a
+Python install can do that a downloaded file cannot: pick the right build for
+the machine, cache it under `~/.imurun/python`, and run it.
+
+```bash
+pip install imurun
+
+imurun                      # the interactive terminal UI
+imurun models               # what this machine can run
+imurun models install qwen2.5-coder-7b
+imurun run "explain this project"
+```
+
+The first run downloads the matching standalone executable from the project's
+GitHub releases (Windows, Linux and macOS on x64 and arm64). Later runs start
+immediately. Nothing is installed system-wide and no administrator rights are
+needed.
+
+## Other ways to install
+
+The command is the same everywhere — pick whichever suits your machine:
+
+```bash
+npm install -g imurun                                   # needs Bun 1.2+
+npm install -g https://github.com/shubham001312/imurun/releases/latest/download/imurun-npm.tgz
+pip install imurun                                      # this package
+```
+
+Or download a standalone binary from
+<https://github.com/shubham001312/imurun/releases/latest> — it needs nothing
+else installed.
+
+## What it does
+
+- Installs, manages and runs local language models on your own hardware.
+- No cloud dependency, no account, no telemetry.
+- Works offline once the model is downloaded.
+- MIT licensed, by [ImuTechz](https://imutechz.in) — Shubham Mallick
+  (<dev@imutechz.in>).
+
+## License
+
+MIT. See the project repository for the full text.

imurun-0.1.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+imurun/__init__.py,sha256=szUfpQh6wI9E_OIRG7EreFNRIPIRJDG7qbUIWzxZZpI,7163
+imurun/__main__.py,sha256=9-aAgxuLLDG30sZLs5w9jC70ifYxjlqujj-1bu33uc0,197
+imurun-0.1.3.dist-info/METADATA,sha256=8muLMiha098PJoDmuXy2LqAp2Evv2D1S665awstB3B4,2575
+imurun-0.1.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+imurun-0.1.3.dist-info/entry_points.txt,sha256=70xbAN0BxXsWQ31vyo3x8ULP_KcWG5CvFDKQq4-tMos,39
+imurun-0.1.3.dist-info/licenses/LICENSE,sha256=IAKsKr6zE6I8OuL_8a0JHQiuW93muQ8V4VbRbXCEMW8,1065
+imurun-0.1.3.dist-info/RECORD,,

imurun-0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

imurun-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+imurun = imurun:main

imurun-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ImuTechz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.