sib-agent 0.1.0__tar.gz

sib_agent-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: sib-agent
+Version: 0.1.0
+Summary: SIB: Self-Improving Benchmark agent framework
+Author-email: Hexo <sib@hexo.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/hexo/sib
+Project-URL: Repository, https://github.com/hexo/sib
+Keywords: ai,benchmarks,self-improving,agents
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# SIB (Self-Improving Benchmark)
+
+A framework for building self-improving AI agents that autonomously refine their performance on benchmark tasks.
+
+## Installation
+
+```bash
+pip install sib-agent
+```
+
+## Usage
+
+```python
+from sib import Generation, GenerationLog, ScoreTracker
+
+# Track generations in a self-improvement loop
+log = GenerationLog()
+
+gen = log.new_generation(config={"model": "claude-sonnet", "temperature": 0.7})
+# ... run your agent ...
+gen.finish(result={"accuracy": 0.82})
+
+gen = log.new_generation(config={"model": "claude-sonnet", "temperature": 0.5})
+# ... run improved agent ...
+gen.finish(result={"accuracy": 0.91})
+
+# Find the best generation
+best = log.best("accuracy")
+print(best.generation_id, best.result)  # 1 {'accuracy': 0.91}
+
+# Save and reload logs
+log.save("run_log.json")
+log = GenerationLog.load("run_log.json")
+
+# Track scores across generations
+tracker = ScoreTracker()
+tracker.record("accuracy", 0.82)
+tracker.record("accuracy", 0.91)
+
+summary = tracker.summarise("accuracy")
+print(summary.improvement)   # 0.09
+print(summary.is_improving)  # True
+```
+
+## License
+
+MIT

sib_agent-0.1.0/README.md

@@ -0,0 +1,47 @@
+# SIB (Self-Improving Benchmark)
+
+A framework for building self-improving AI agents that autonomously refine their performance on benchmark tasks.
+
+## Installation
+
+```bash
+pip install sib-agent
+```
+
+## Usage
+
+```python
+from sib import Generation, GenerationLog, ScoreTracker
+
+# Track generations in a self-improvement loop
+log = GenerationLog()
+
+gen = log.new_generation(config={"model": "claude-sonnet", "temperature": 0.7})
+# ... run your agent ...
+gen.finish(result={"accuracy": 0.82})
+
+gen = log.new_generation(config={"model": "claude-sonnet", "temperature": 0.5})
+# ... run improved agent ...
+gen.finish(result={"accuracy": 0.91})
+
+# Find the best generation
+best = log.best("accuracy")
+print(best.generation_id, best.result)  # 1 {'accuracy': 0.91}
+
+# Save and reload logs
+log.save("run_log.json")
+log = GenerationLog.load("run_log.json")
+
+# Track scores across generations
+tracker = ScoreTracker()
+tracker.record("accuracy", 0.82)
+tracker.record("accuracy", 0.91)
+
+summary = tracker.summarise("accuracy")
+print(summary.improvement)   # 0.09
+print(summary.is_improving)  # True
+```
+
+## License
+
+MIT

sib_agent-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sib-agent"
+version = "0.1.0"
+description = "SIB: Self-Improving Benchmark agent framework"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Hexo", email = "sib@hexo.ai" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+keywords = ["ai", "benchmarks", "self-improving", "agents"]
+
+[project.urls]
+Homepage = "https://github.com/hexo/sib"
+Repository = "https://github.com/hexo/sib"
+
+[tool.setuptools.packages.find]
+include = ["sib*"]

sib_agent-0.1.0/setup.cfg

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

sib_agent-0.1.0/sib/__init__.py

@@ -0,0 +1,8 @@
+"""SIB: Self-Improving Benchmark agent framework."""
+
+__version__ = "0.1.0"
+
+from sib.generations import Generation, GenerationLog
+from sib.metrics import ScoreTracker
+
+__all__ = ["Generation", "GenerationLog", "ScoreTracker"]

sib_agent-0.1.0/sib/generations.py

@@ -0,0 +1,101 @@
+"""Track and manage iterative agent generations."""
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class Generation:
+    """A single generation in a self-improvement loop.
+
+    Captures the inputs, outputs, and timing of one iteration so that
+    downstream analysis can compare generations side-by-side.
+    """
+
+    generation_id: int
+    config: dict[str, Any] = field(default_factory=dict)
+    result: dict[str, Any] = field(default_factory=dict)
+    started_at: float = field(default_factory=time.time)
+    finished_at: float | None = None
+
+    def finish(self, result: dict[str, Any] | None = None) -> None:
+        """Mark the generation as complete and optionally attach a result."""
+        self.finished_at = time.time()
+        if result is not None:
+            self.result = result
+
+    @property
+    def elapsed_seconds(self) -> float | None:
+        if self.finished_at is None:
+            return None
+        return self.finished_at - self.started_at
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "generation_id": self.generation_id,
+            "config": self.config,
+            "result": self.result,
+            "started_at": self.started_at,
+            "finished_at": self.finished_at,
+            "elapsed_seconds": self.elapsed_seconds,
+        }
+
+
+class GenerationLog:
+    """Append-only log of generations, persistable to JSON."""
+
+    def __init__(self) -> None:
+        self._generations: list[Generation] = []
+
+    def new_generation(self, config: dict[str, Any] | None = None) -> Generation:
+        """Create and register the next generation."""
+        gen = Generation(
+            generation_id=len(self._generations),
+            config=config or {},
+        )
+        self._generations.append(gen)
+        return gen
+
+    def __len__(self) -> int:
+        return len(self._generations)
+
+    def __getitem__(self, idx: int) -> Generation:
+        return self._generations[idx]
+
+    def __iter__(self):
+        return iter(self._generations)
+
+    def best(self, metric: str, higher_is_better: bool = True) -> Generation | None:
+        """Return the generation with the best value for *metric* in its result."""
+        scored = [g for g in self._generations if metric in g.result]
+        if not scored:
+            return None
+        return (max if higher_is_better else min)(
+            scored, key=lambda g: g.result[metric]
+        )
+
+    def save(self, path: str | Path) -> None:
+        """Write the full log to a JSON file."""
+        Path(path).write_text(
+            json.dumps([g.to_dict() for g in self._generations], indent=2)
+        )
+
+    @classmethod
+    def load(cls, path: str | Path) -> GenerationLog:
+        """Load a log from a JSON file previously created by *save*."""
+        log = cls()
+        for entry in json.loads(Path(path).read_text()):
+            gen = Generation(
+                generation_id=entry["generation_id"],
+                config=entry.get("config", {}),
+                result=entry.get("result", {}),
+                started_at=entry.get("started_at", 0),
+                finished_at=entry.get("finished_at"),
+            )
+            log._generations.append(gen)
+        return log

sib_agent-0.1.0/sib/metrics.py

@@ -0,0 +1,77 @@
+"""Lightweight score tracking across self-improvement generations."""
+
+from __future__ import annotations
+
+import statistics
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class ScoreSummary:
+    """Immutable summary statistics for a sequence of scores."""
+
+    metric: str
+    values: tuple[float, ...]
+    mean: float
+    median: float
+    stdev: float | None
+    best: float
+    worst: float
+    higher_is_better: bool
+
+    @property
+    def latest(self) -> float:
+        return self.values[-1]
+
+    @property
+    def improvement(self) -> float:
+        """Absolute change from first to last value."""
+        return self.values[-1] - self.values[0]
+
+    @property
+    def is_improving(self) -> bool:
+        """True if the latest value is better than the first."""
+        delta = self.improvement
+        return delta > 0 if self.higher_is_better else delta < 0
+
+
+class ScoreTracker:
+    """Collect per-generation scores for one or more metrics and summarise them."""
+
+    def __init__(self, higher_is_better: bool = True) -> None:
+        self.higher_is_better = higher_is_better
+        self._scores: dict[str, list[float]] = {}
+
+    def record(self, metric: str, value: float) -> None:
+        """Append a score for *metric*."""
+        self._scores.setdefault(metric, []).append(value)
+
+    @property
+    def metrics(self) -> list[str]:
+        return list(self._scores)
+
+    def values(self, metric: str) -> list[float]:
+        return list(self._scores.get(metric, []))
+
+    def summarise(self, metric: str) -> ScoreSummary:
+        """Return a :class:`ScoreSummary` for the given metric.
+
+        Raises ``KeyError`` if the metric has never been recorded.
+        """
+        vals = self._scores[metric]
+        cmp = max if self.higher_is_better else min
+        worst_fn = min if self.higher_is_better else max
+        return ScoreSummary(
+            metric=metric,
+            values=tuple(vals),
+            mean=statistics.mean(vals),
+            median=statistics.median(vals),
+            stdev=statistics.stdev(vals) if len(vals) > 1 else None,
+            best=cmp(vals),
+            worst=worst_fn(vals),
+            higher_is_better=self.higher_is_better,
+        )
+
+    def summarise_all(self) -> dict[str, ScoreSummary]:
+        """Return summaries for every recorded metric."""
+        return {m: self.summarise(m) for m in self._scores}

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

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: sib-agent
+Version: 0.1.0
+Summary: SIB: Self-Improving Benchmark agent framework
+Author-email: Hexo <sib@hexo.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/hexo/sib
+Project-URL: Repository, https://github.com/hexo/sib
+Keywords: ai,benchmarks,self-improving,agents
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# SIB (Self-Improving Benchmark)
+
+A framework for building self-improving AI agents that autonomously refine their performance on benchmark tasks.
+
+## Installation
+
+```bash
+pip install sib-agent
+```
+
+## Usage
+
+```python
+from sib import Generation, GenerationLog, ScoreTracker
+
+# Track generations in a self-improvement loop
+log = GenerationLog()
+
+gen = log.new_generation(config={"model": "claude-sonnet", "temperature": 0.7})
+# ... run your agent ...
+gen.finish(result={"accuracy": 0.82})
+
+gen = log.new_generation(config={"model": "claude-sonnet", "temperature": 0.5})
+# ... run improved agent ...
+gen.finish(result={"accuracy": 0.91})
+
+# Find the best generation
+best = log.best("accuracy")
+print(best.generation_id, best.result)  # 1 {'accuracy': 0.91}
+
+# Save and reload logs
+log.save("run_log.json")
+log = GenerationLog.load("run_log.json")
+
+# Track scores across generations
+tracker = ScoreTracker()
+tracker.record("accuracy", 0.82)
+tracker.record("accuracy", 0.91)
+
+summary = tracker.summarise("accuracy")
+print(summary.improvement)   # 0.09
+print(summary.is_improving)  # True
+```
+
+## License
+
+MIT

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

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+sib/__init__.py
+sib/generations.py
+sib/metrics.py
+sib_agent.egg-info/PKG-INFO
+sib_agent.egg-info/SOURCES.txt
+sib_agent.egg-info/dependency_links.txt
+sib_agent.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+sib