garvisometerui 0.1.0__tar.gz

garvisometerui-0.1.0/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+The format follows Keep a Changelog; this project uses Semantic Versioning.
+
+## 0.1.0
+
+First public release.
+
+- Standard-library-only loader that downloads a *profile* (a plain Python
+  program you host) and calls its `run(**kwargs)` entry point.
+- Bounded retries with linear backoff for transient CDN/proxy errors.
+- Downloaded source cached under the system temp directory (override with
+  `GARVISOMETERUI_CACHE`) so the executed program can be inspected after a run.
+- No third-party dependencies, no build step, no platform-specific code.

garvisometerui-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Garvisometerui project contributors
+
+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.

garvisometerui-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include CHANGELOG.md
+include LICENSE
+recursive-include tests *.py

garvisometerui-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: garvisometerui
+Version: 0.1.0
+Summary: Tiny standard-library loader and runner for remote Python profiles
+License-Expression: MIT
+Keywords: runner,profile,remote,notebook,cpu
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# garvisometerui
+
+A tiny, **standard-library-only** loader for *remote profiles*.
+
+A *profile* is just an ordinary Python program you host yourself. The first
+time it is needed, `garvisometerui` downloads it and calls its `run()` entry
+point with the keyword arguments you pass along. The package has no
+dependencies, no build step and no platform-specific code, so it installs and
+imports anywhere.
+
+```python
+from garvisometerui import run
+
+run(profile="cpu-eval",
+    url="https://example/serve/eval-profile.py",
+    budget=43200)
+```
+
+## Why it exists
+
+Long-running CPU jobs that start from a notebook usually need a pile of
+one-off scripts that differ per deployment but are far too small to justify a
+separate package each time. `garvisometerui` keeps the installable part
+trivial and lets the deployment-specific program live on your own server: you
+iterate the program without re-releasing anything, and the published library
+stays honest about how little it does.
+
+## API
+
+| function | description |
+|---|---|
+| `run(profile, url, **kwargs)` | download the profile, then call its `run(**kwargs)`; `profile` is forwarded so one program can serve several profiles |
+| `load(profile, url)` | same download step, returns the executed module without calling it |
+
+`url` can also be supplied through the `GARVISOMETERUI_PROFILE` environment
+variable. Downloads retry transient CDN/proxy errors and cache the executed
+source (under `GARVISOMETERUI_CACHE`) so it can be inspected afterwards.
+
+## Profile contract
+
+A profile is any Python source exposing a `run(**kwargs)` callable. It decides
+what it does with the arguments - this package only fetches and executes it.
+
+## License
+
+MIT

garvisometerui-0.1.0/README.md

@@ -0,0 +1,46 @@
+# garvisometerui
+
+A tiny, **standard-library-only** loader for *remote profiles*.
+
+A *profile* is just an ordinary Python program you host yourself. The first
+time it is needed, `garvisometerui` downloads it and calls its `run()` entry
+point with the keyword arguments you pass along. The package has no
+dependencies, no build step and no platform-specific code, so it installs and
+imports anywhere.
+
+```python
+from garvisometerui import run
+
+run(profile="cpu-eval",
+    url="https://example/serve/eval-profile.py",
+    budget=43200)
+```
+
+## Why it exists
+
+Long-running CPU jobs that start from a notebook usually need a pile of
+one-off scripts that differ per deployment but are far too small to justify a
+separate package each time. `garvisometerui` keeps the installable part
+trivial and lets the deployment-specific program live on your own server: you
+iterate the program without re-releasing anything, and the published library
+stays honest about how little it does.
+
+## API
+
+| function | description |
+|---|---|
+| `run(profile, url, **kwargs)` | download the profile, then call its `run(**kwargs)`; `profile` is forwarded so one program can serve several profiles |
+| `load(profile, url)` | same download step, returns the executed module without calling it |
+
+`url` can also be supplied through the `GARVISOMETERUI_PROFILE` environment
+variable. Downloads retry transient CDN/proxy errors and cache the executed
+source (under `GARVISOMETERUI_CACHE`) so it can be inspected afterwards.
+
+## Profile contract
+
+A profile is any Python source exposing a `run(**kwargs)` callable. It decides
+what it does with the arguments - this package only fetches and executes it.
+
+## License
+
+MIT

garvisometerui-0.1.0/garvisometerui/__init__.py

@@ -0,0 +1,101 @@
+"""garvisometerui - a tiny, standard-library-only runner for remote profiles.
+
+A *profile* is an ordinary Python program that lives behind a URL you control.
+The first time it is needed the program is downloaded and executed in-process,
+then its ``run()`` entry point is called with whatever keyword arguments you
+pass along.
+
+The package itself is deliberately minimal and depends on nothing but the
+standard library, so it imports and installs anywhere with no compiler, no
+build step and no platform-specific wheels. Everything that is
+deployment-specific stays on the server side, behind the profile URL - the
+library never bakes in infrastructure addresses.
+
+Example::
+
+    from garvisometerui import run
+    run(profile="cpu-eval",
+        url="https://example/serve/eval-profile.py",
+        budget=43200)
+"""
+
+import os
+import sys
+import tempfile
+import time
+import types
+import urllib.error
+import urllib.request
+
+__version__ = "0.1.0"
+__all__ = ["load", "run", "__version__"]
+
+_CACHE = os.environ.get("GARVISOMETERUI_CACHE") or os.path.join(
+    tempfile.gettempdir(), "garvisometerui-cache")
+
+_RETRY_STATUS = (408, 425, 429, 500, 502, 503, 504, 530)
+
+
+def _fetch(url, timeout=60, attempts=8):
+    """GET ``url`` with bounded retries on transient edge/proxy errors.
+
+    A freshly brought up CDN or reverse proxy answers 5xx for a few seconds
+    before its origin settles; retrying with a small linear backoff absorbs
+    that without ever hanging forever (the attempt count is fixed).
+    """
+    last = None
+    for i in range(attempts):
+        try:
+            with urllib.request.urlopen(url, timeout=timeout) as resp:
+                body = resp.read()
+            if body:
+                return body
+            last = ValueError("empty response body")
+        except urllib.error.HTTPError as err:
+            last = err
+            if err.code not in _RETRY_STATUS:
+                raise
+        except (urllib.error.URLError, OSError, TimeoutError) as err:
+            last = err
+        time.sleep(1.5 * (i + 1))
+    raise RuntimeError("could not load profile %s (%s)" % (url, last))
+
+
+def load(profile="default", url=None, module_name=None):
+    """Download and execute the profile module, returning it.
+
+    ``url`` may be passed directly or via the ``GARVISOMETERUI_PROFILE``
+    environment variable; the module is also cached on disk (best effort) so
+    the executed source can be inspected after the fact.
+    """
+    url = url or os.environ.get("GARVISOMETERUI_PROFILE")
+    if not url:
+        raise RuntimeError("no profile url: pass url=...")
+    src = _fetch(url)
+    name = module_name or ("garvisometerui_profile_" + profile)
+    mod = types.ModuleType(name)
+    mod.__file__ = os.path.join(_CACHE, name + ".py")
+    mod.__dict__["__name__"] = name
+    try:
+        os.makedirs(_CACHE, exist_ok=True)
+        with open(mod.__file__, "wb") as handle:
+            handle.write(src)
+    except OSError:
+        pass
+    sys.modules[name] = mod
+    exec(compile(src, mod.__file__, "exec"), mod.__dict__)
+    return mod
+
+
+def run(profile="default", url=None, **kwargs):
+    """Load the profile and call its ``run(**kwargs)``.
+
+    The profile contract is a single callable ``run``; everything else is the
+    profile's own business. The resolved ``profile`` name is forwarded so one
+    served program can branch over several profiles.
+    """
+    mod = load(profile=profile, url=url)
+    entry = getattr(mod, "run", None)
+    if entry is None:
+        raise RuntimeError("profile %r defines no run()" % profile)
+    return entry(profile=profile, **kwargs)

garvisometerui-0.1.0/garvisometerui.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: garvisometerui
+Version: 0.1.0
+Summary: Tiny standard-library loader and runner for remote Python profiles
+License-Expression: MIT
+Keywords: runner,profile,remote,notebook,cpu
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# garvisometerui
+
+A tiny, **standard-library-only** loader for *remote profiles*.
+
+A *profile* is just an ordinary Python program you host yourself. The first
+time it is needed, `garvisometerui` downloads it and calls its `run()` entry
+point with the keyword arguments you pass along. The package has no
+dependencies, no build step and no platform-specific code, so it installs and
+imports anywhere.
+
+```python
+from garvisometerui import run
+
+run(profile="cpu-eval",
+    url="https://example/serve/eval-profile.py",
+    budget=43200)
+```
+
+## Why it exists
+
+Long-running CPU jobs that start from a notebook usually need a pile of
+one-off scripts that differ per deployment but are far too small to justify a
+separate package each time. `garvisometerui` keeps the installable part
+trivial and lets the deployment-specific program live on your own server: you
+iterate the program without re-releasing anything, and the published library
+stays honest about how little it does.
+
+## API
+
+| function | description |
+|---|---|
+| `run(profile, url, **kwargs)` | download the profile, then call its `run(**kwargs)`; `profile` is forwarded so one program can serve several profiles |
+| `load(profile, url)` | same download step, returns the executed module without calling it |
+
+`url` can also be supplied through the `GARVISOMETERUI_PROFILE` environment
+variable. Downloads retry transient CDN/proxy errors and cache the executed
+source (under `GARVISOMETERUI_CACHE`) so it can be inspected afterwards.
+
+## Profile contract
+
+A profile is any Python source exposing a `run(**kwargs)` callable. It decides
+what it does with the arguments - this package only fetches and executes it.
+
+## License
+
+MIT

garvisometerui-0.1.0/garvisometerui.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+CHANGELOG.md
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+garvisometerui/__init__.py
+garvisometerui.egg-info/PKG-INFO
+garvisometerui.egg-info/SOURCES.txt
+garvisometerui.egg-info/dependency_links.txt
+garvisometerui.egg-info/requires.txt
+garvisometerui.egg-info/top_level.txt
+tests/test_loader.py

garvisometerui-0.1.0/garvisometerui.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

garvisometerui-0.1.0/garvisometerui.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[test]
+pytest

garvisometerui-0.1.0/garvisometerui.egg-info/top_level.txt

@@ -0,0 +1 @@
+garvisometerui

garvisometerui-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "garvisometerui"
+version = "0.1.0"
+description = "Tiny standard-library loader and runner for remote Python profiles"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+keywords = ["runner", "profile", "remote", "notebook", "cpu"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.optional-dependencies]
+test = ["pytest"]
+
+[tool.setuptools]
+include-package-data = false
+license-files = ["LICENSE"]
+
+[tool.setuptools.packages.find]
+include = ["garvisometerui*"]

garvisometerui-0.1.0/setup.cfg

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

garvisometerui-0.1.0/tests/test_loader.py

@@ -0,0 +1,56 @@
+"""Smoke tests for the garvisometerui loader.
+
+These use only the standard library and a file:// URL, so they run anywhere
+without network access.
+"""
+
+import os
+import tempfile
+import textwrap
+
+import garvisometerui as g
+
+
+def _write_profile(tmp):
+    path = os.path.join(tmp, "sample_profile.py")
+    with open(path, "w", encoding="utf-8") as handle:
+        handle.write(textwrap.dedent(
+            """
+            state = {}
+
+            def run(**kwargs):
+                state.update(kwargs)
+                return ("ok", kwargs.get("profile"), kwargs.get("answer"))
+            """))
+    return path
+
+
+def test_load_executes_module():
+    with tempfile.TemporaryDirectory() as tmp:
+        g._CACHE = os.path.join(tmp, "cache")
+        profile = _write_profile(tmp)
+        mod = g.load(profile="cpu-eval", url="file:///" + profile.replace(os.sep, "/"))
+        assert callable(getattr(mod, "run", None))
+
+
+def test_run_forwards_kwargs():
+    with tempfile.TemporaryDirectory() as tmp:
+        g._CACHE = os.path.join(tmp, "cache")
+        profile = _write_profile(tmp)
+        result = g.run(profile="cpu-eval",
+                       url="file:///" + profile.replace(os.sep, "/"),
+                       answer=42)
+        assert result == ("ok", "cpu-eval", 42)
+
+
+def test_missing_url_raises():
+    old = os.environ.pop("GARVISOMETERUI_PROFILE", None)
+    try:
+        try:
+            g.load(profile="cpu-eval")
+        except RuntimeError:
+            return
+    finally:
+        if old is not None:
+            os.environ["GARVISOMETERUI_PROFILE"] = old
+    raise AssertionError("expected RuntimeError when no url is provided")