openrunner-sdk 0.2.0__tar.gz → 0.4.0__tar.gz

{openrunner_sdk-0.2.0 → openrunner_sdk-0.4.0}/.gitignore

@@ -224,3 +224,4 @@ __marimo__/
 # Streamlit
 .streamlit/secrets.toml
 data/
+.data/

{openrunner_sdk-0.2.0 → openrunner_sdk-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openrunner-sdk
-Version: 0.2.0
+Version: 0.4.0
 Summary: OpenRunner SDK - W&B-compatible ML experiment tracking client
 Project-URL: Homepage, https://github.com/jqueguiner/openrunner
 Project-URL: Repository, https://github.com/jqueguiner/openrunner
@@ -21,9 +21,11 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1
 Requires-Dist: httpx>=0.27
+Requires-Dist: nvidia-ml-py>=12.0
 Requires-Dist: pillow>=10.0
 Requires-Dist: psutil>=6.0
 Provides-Extra: dev
+Requires-Dist: numpy>=1.24; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Provides-Extra: fastai
@@ -238,6 +240,175 @@ print(run.config)      # Config object
 print(run.summary)     # Summary object
 ```
 
+### HTML
+
+```python
+# Log raw HTML for rich reports, custom visualizations, or formatted output
+openrunner.log({"report": openrunner.Html("<h1>Training Report</h1><p>Loss converged at epoch 42.</p>")})
+```
+
+### Histograms
+
+```python
+import numpy as np
+
+weights = np.random.randn(10000)
+openrunner.log({"weight_dist": openrunner.Histogram(weights, num_bins=50)})
+```
+
+### Plotly Charts
+
+```python
+import plotly.graph_objects as go
+
+fig = go.Figure(data=go.Scatter(x=[1, 2, 3], y=[4, 5, 6]))
+openrunner.log({"interactive_plot": openrunner.Plotly(fig)})
+```
+
+### Point Clouds
+
+```python
+import numpy as np
+
+points = np.random.randn(1000, 3)
+colors = np.random.randint(0, 255, (1000, 3), dtype=np.uint8)
+openrunner.log({"lidar": openrunner.PointCloud3D(points, colors=colors)})
+```
+
+### Bounding Boxes
+
+```python
+img = openrunner.Image("photo.jpg")
+boxes = [{"position": {"minX": 10, "minY": 20, "maxX": 100, "maxY": 150}, "class_id": 0}]
+openrunner.log({"detections": openrunner.BoundingBoxes2D(img, boxes, class_labels={0: "cat"})})
+```
+
+### Audio
+
+```python
+import numpy as np
+
+# From numpy array (mono, float32, -1 to 1)
+audio = openrunner.Audio(np.random.randn(44100).astype(np.float32), sample_rate=44100)
+openrunner.log({"audio_sample": audio})
+```
+
+### Video
+
+```python
+# From file path
+openrunner.log({"demo": openrunner.Video("output.mp4", caption="training demo")})
+```
+
+### Matplotlib Figures
+
+```python
+import matplotlib.pyplot as plt
+
+plt.figure()
+plt.plot([1, 2, 3], [4, 5, 6])
+openrunner.log({"chart": openrunner.MatplotlibFigure()})  # captures current figure
+plt.close()
+```
+
+## LLM Tracing
+
+Trace LLM API calls for debugging and cost tracking.
+
+```python
+import openrunner
+
+openrunner.init(project="llm-app")
+
+# Auto-trace OpenAI calls
+openrunner.trace.patch_openai()
+
+# Or manually trace any function
+@openrunner.trace
+def generate(prompt):
+    return client.chat.completions.create(
+        model="gpt-4", messages=[{"role": "user", "content": prompt}]
+    )
+```
+
+## Hyperparameter Sweeps
+
+Run distributed hyperparameter searches.
+
+```python
+import openrunner
+
+sweep_config = {
+    "method": "bayes",
+    "metric": {"name": "val_loss", "goal": "minimize"},
+    "parameters": {
+        "lr": {"min": 1e-5, "max": 1e-2, "distribution": "log_uniform"},
+        "epochs": {"values": [10, 20, 50]},
+    },
+}
+
+sweep_id = openrunner.sweep(sweep_config, project="my-project")
+
+def train():
+    run = openrunner.init()
+    lr = openrunner.config.lr
+    # ... training loop ...
+    openrunner.finish()
+
+openrunner.agent(sweep_id, function=train, count=20)
+```
+
+## Remote Launch
+
+Submit training jobs to remote infrastructure.
+
+```python
+import openrunner
+
+job = openrunner.launch(
+    project="my-project",
+    config={"lr": 0.001, "epochs": 50},
+    resource="gpu-a100",
+)
+
+job.wait()  # block until finished
+print(job.state)  # "finished"
+```
+
+## Model Registry
+
+Version and alias models for production deployment.
+
+```python
+# Log a model with aliases
+artifact = openrunner.Artifact(name="classifier", type="model")
+artifact.add_file("model.pt")
+openrunner.link_artifact(artifact, aliases=["staging"])
+
+# Use a model by alias
+model_dir = openrunner.use_artifact("classifier:production")
+```
+
+## Alerts
+
+Send notifications when training reaches milestones or encounters issues.
+
+```python
+openrunner.alert(title="Training complete", text="Final accuracy: 95.2%", level="INFO")
+openrunner.alert(title="Loss spike detected", level="WARN")
+```
+
+## Query API
+
+Read-only access to runs, metrics, and projects for analysis and dashboards.
+
+```python
+api = openrunner.Api()
+runs = api.runs("my-project", filters={"state": "finished"})
+for run in runs:
+    print(f"{run.name}: {run.summary.get('accuracy')}")
+```
+
 ## Migrating from W&B
 
 Change one import — everything else stays the same:
@@ -302,6 +473,67 @@ trainer = pl.Trainer(logger=logger)
 trainer.fit(model)
 ```
 
+### Keras
+
+```python
+from openrunner.integration.keras import OpenRunnerCallback
+
+openrunner.init(project="keras-example")
+
+model.fit(x_train, y_train, callbacks=[OpenRunnerCallback()])
+
+openrunner.finish()
+```
+
+### XGBoost
+
+```python
+from openrunner.integration.xgboost import OpenRunnerCallback
+
+openrunner.init(project="xgboost-example")
+
+bst = xgb.train(params, dtrain, callbacks=[OpenRunnerCallback()])
+
+openrunner.finish()
+```
+
+### scikit-learn
+
+```python
+from openrunner.integration.sklearn import log_model
+
+openrunner.init(project="sklearn-example")
+model.fit(X_train, y_train)
+log_model(model)  # Logs parameters and metrics
+openrunner.finish()
+```
+
+### FastAI
+
+```python
+from openrunner.integration.fastai import OpenRunnerCallback
+
+openrunner.init(project="fastai-example")
+
+learn = cnn_learner(dls, resnet34, cbs=[OpenRunnerCallback()])
+learn.fine_tune(5)
+
+openrunner.finish()
+```
+
+### LangChain
+
+```python
+from openrunner.integration.langchain import OpenRunnerTracer
+
+openrunner.init(project="langchain-example")
+
+tracer = OpenRunnerTracer()
+chain.invoke({"input": "Hello"}, config={"callbacks": [tracer]})
+
+openrunner.finish()
+```
+
 ## Offline Mode
 
 Train without connectivity, sync later:

{openrunner_sdk-0.2.0 → openrunner_sdk-0.4.0}/README.md

@@ -190,6 +190,175 @@ print(run.config)      # Config object
 print(run.summary)     # Summary object
 ```
 
+### HTML
+
+```python
+# Log raw HTML for rich reports, custom visualizations, or formatted output
+openrunner.log({"report": openrunner.Html("<h1>Training Report</h1><p>Loss converged at epoch 42.</p>")})
+```
+
+### Histograms
+
+```python
+import numpy as np
+
+weights = np.random.randn(10000)
+openrunner.log({"weight_dist": openrunner.Histogram(weights, num_bins=50)})
+```
+
+### Plotly Charts
+
+```python
+import plotly.graph_objects as go
+
+fig = go.Figure(data=go.Scatter(x=[1, 2, 3], y=[4, 5, 6]))
+openrunner.log({"interactive_plot": openrunner.Plotly(fig)})
+```
+
+### Point Clouds
+
+```python
+import numpy as np
+
+points = np.random.randn(1000, 3)
+colors = np.random.randint(0, 255, (1000, 3), dtype=np.uint8)
+openrunner.log({"lidar": openrunner.PointCloud3D(points, colors=colors)})
+```
+
+### Bounding Boxes
+
+```python
+img = openrunner.Image("photo.jpg")
+boxes = [{"position": {"minX": 10, "minY": 20, "maxX": 100, "maxY": 150}, "class_id": 0}]
+openrunner.log({"detections": openrunner.BoundingBoxes2D(img, boxes, class_labels={0: "cat"})})
+```
+
+### Audio
+
+```python
+import numpy as np
+
+# From numpy array (mono, float32, -1 to 1)
+audio = openrunner.Audio(np.random.randn(44100).astype(np.float32), sample_rate=44100)
+openrunner.log({"audio_sample": audio})
+```
+
+### Video
+
+```python
+# From file path
+openrunner.log({"demo": openrunner.Video("output.mp4", caption="training demo")})
+```
+
+### Matplotlib Figures
+
+```python
+import matplotlib.pyplot as plt
+
+plt.figure()
+plt.plot([1, 2, 3], [4, 5, 6])
+openrunner.log({"chart": openrunner.MatplotlibFigure()})  # captures current figure
+plt.close()
+```
+
+## LLM Tracing
+
+Trace LLM API calls for debugging and cost tracking.
+
+```python
+import openrunner
+
+openrunner.init(project="llm-app")
+
+# Auto-trace OpenAI calls
+openrunner.trace.patch_openai()
+
+# Or manually trace any function
+@openrunner.trace
+def generate(prompt):
+    return client.chat.completions.create(
+        model="gpt-4", messages=[{"role": "user", "content": prompt}]
+    )
+```
+
+## Hyperparameter Sweeps
+
+Run distributed hyperparameter searches.
+
+```python
+import openrunner
+
+sweep_config = {
+    "method": "bayes",
+    "metric": {"name": "val_loss", "goal": "minimize"},
+    "parameters": {
+        "lr": {"min": 1e-5, "max": 1e-2, "distribution": "log_uniform"},
+        "epochs": {"values": [10, 20, 50]},
+    },
+}
+
+sweep_id = openrunner.sweep(sweep_config, project="my-project")
+
+def train():
+    run = openrunner.init()
+    lr = openrunner.config.lr
+    # ... training loop ...
+    openrunner.finish()
+
+openrunner.agent(sweep_id, function=train, count=20)
+```
+
+## Remote Launch
+
+Submit training jobs to remote infrastructure.
+
+```python
+import openrunner
+
+job = openrunner.launch(
+    project="my-project",
+    config={"lr": 0.001, "epochs": 50},
+    resource="gpu-a100",
+)
+
+job.wait()  # block until finished
+print(job.state)  # "finished"
+```
+
+## Model Registry
+
+Version and alias models for production deployment.
+
+```python
+# Log a model with aliases
+artifact = openrunner.Artifact(name="classifier", type="model")
+artifact.add_file("model.pt")
+openrunner.link_artifact(artifact, aliases=["staging"])
+
+# Use a model by alias
+model_dir = openrunner.use_artifact("classifier:production")
+```
+
+## Alerts
+
+Send notifications when training reaches milestones or encounters issues.
+
+```python
+openrunner.alert(title="Training complete", text="Final accuracy: 95.2%", level="INFO")
+openrunner.alert(title="Loss spike detected", level="WARN")
+```
+
+## Query API
+
+Read-only access to runs, metrics, and projects for analysis and dashboards.
+
+```python
+api = openrunner.Api()
+runs = api.runs("my-project", filters={"state": "finished"})
+for run in runs:
+    print(f"{run.name}: {run.summary.get('accuracy')}")
+```
+
 ## Migrating from W&B
 
 Change one import — everything else stays the same:
@@ -254,6 +423,67 @@ trainer = pl.Trainer(logger=logger)
 trainer.fit(model)
 ```
 
+### Keras
+
+```python
+from openrunner.integration.keras import OpenRunnerCallback
+
+openrunner.init(project="keras-example")
+
+model.fit(x_train, y_train, callbacks=[OpenRunnerCallback()])
+
+openrunner.finish()
+```
+
+### XGBoost
+
+```python
+from openrunner.integration.xgboost import OpenRunnerCallback
+
+openrunner.init(project="xgboost-example")
+
+bst = xgb.train(params, dtrain, callbacks=[OpenRunnerCallback()])
+
+openrunner.finish()
+```
+
+### scikit-learn
+
+```python
+from openrunner.integration.sklearn import log_model
+
+openrunner.init(project="sklearn-example")
+model.fit(X_train, y_train)
+log_model(model)  # Logs parameters and metrics
+openrunner.finish()
+```
+
+### FastAI
+
+```python
+from openrunner.integration.fastai import OpenRunnerCallback
+
+openrunner.init(project="fastai-example")
+
+learn = cnn_learner(dls, resnet34, cbs=[OpenRunnerCallback()])
+learn.fine_tune(5)
+
+openrunner.finish()
+```
+
+### LangChain
+
+```python
+from openrunner.integration.langchain import OpenRunnerTracer
+
+openrunner.init(project="langchain-example")
+
+tracer = OpenRunnerTracer()
+chain.invoke({"input": "Hello"}, config={"callbacks": [tracer]})
+
+openrunner.finish()
+```
+
 ## Offline Mode
 
 Train without connectivity, sync later:

{openrunner_sdk-0.2.0 → openrunner_sdk-0.4.0}/openrunner/__init__.py

@@ -8,11 +8,16 @@ Public API:
     openrunner.summary      -> Summary proxy
     openrunner.run          -> active Run or None
     openrunner.Image        -> Image class for media logging
+    openrunner.Html         -> Html class for raw HTML logging
     openrunner.Table        -> Table class for structured data
     openrunner.Audio        -> Audio class for audio logging
     openrunner.Video        -> Video class for video logging
     openrunner.Histogram    -> Histogram class for distribution logging
     openrunner.Plotly       -> Plotly class for interactive charts
+    openrunner.PlotlyChart  -> Enhanced Plotly with static PNG fallback
+    openrunner.MatplotlibFigure -> Capture matplotlib figure as PNG
+    openrunner.PointCloud3D -> 3D point cloud visualization
+    openrunner.Embedding    -> Embedding projection (t-SNE/PCA/UMAP)
     openrunner.BoundingBoxes2D -> Bounding box overlay on images
     openrunner.Artifact     -> Artifact class for versioned file collections
     openrunner.Api          -> Query API for read-only access to runs/projects
@@ -26,6 +31,10 @@ Public API:
     openrunner.LaunchJob    -> Job handle with .wait() and .cancel()
     openrunner.trace        -> Decorator for LLM call tracing
     openrunner.trace.patch_openai -> Auto-trace OpenAI chat completions
+    openrunner.Prompt       -> Versioned prompt management (get/render/publish)
+    openrunner.evaluate     -> Run LLM evaluation against a dataset
+    openrunner.scorer       -> Decorator to mark a function as an eval scorer
+    openrunner.scorers      -> Built-in scorers (exact_match, contains, etc.)
 """
 
 from __future__ import annotations
@@ -36,14 +45,30 @@ from typing import Any
 
 from openrunner.artifact import Artifact
 from openrunner.config import Config
+from openrunner.prompt import Prompt
 from openrunner.launch import LaunchJob, launch, from_run as _launch_from_run
-from openrunner.media import Audio, BoundingBoxes2D, Histogram, Image, Plotly, Table, Video
+from openrunner.media import (
+    Audio,
+    BoundingBoxes2D,
+    Embedding,
+    Histogram,
+    Html,
+    Image,
+    MatplotlibFigure,
+    Plotly,
+    PlotlyChart,
+    PointCloud3D,
+    Table,
+    Video,
+)
 from openrunner.query_api import Api
 from openrunner.run import Run
 from openrunner.settings import SDKSettings
 from openrunner.summary import Summary
 from openrunner.sweep import agent, sweep
+from openrunner.evaluation import evaluate, scorer
 from openrunner.trace import trace, patch_openai as _patch_openai
+import openrunner.scorers as scorers
 
 # Attach from_run as a method on the launch function for
 # openrunner.launch.from_run() syntax
@@ -53,7 +78,7 @@ launch.from_run = _launch_from_run  # type: ignore[attr-defined]
 # openrunner.trace.patch_openai() syntax
 trace.patch_openai = _patch_openai  # type: ignore[attr-defined]
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"
 
 logger = logging.getLogger("openrunner")
 
@@ -352,6 +377,32 @@ def use_artifact(
         return None
 
 
+def should_stop() -> bool:
+    """Check if the server has requested the active run to stop.
+
+    Returns False if no active run. Users call this in their training
+    loop: ``if openrunner.should_stop(): break``
+    """
+    if _active_run is None:
+        return False
+    return _active_run.should_stop
+
+
+def log_text(text: str) -> None:
+    """Log explicit text to the console log without printing. Never raises.
+
+    Args:
+        text: Text string to log.
+    """
+    try:
+        if _active_run is None:
+            logger.warning("openrunner.log_text(): no active run")
+            return
+        _active_run.log_text(text)
+    except Exception as e:
+        logger.warning("openrunner.log_text() failed: %s", e)
+
+
 @property  # type: ignore[misc]
 def run() -> Run | None:
     """Return the active run, or None."""