contextpress 0.4.0__tar.gz → 0.5.0__tar.gz

{contextpress-0.4.0 → contextpress-0.5.0}/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to `contextpress` are recorded here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2026-07-22
+
+- **`compress_async()`** — async wrapper around ``compress()`` for asyncio apps.
+- **`compare_presets()`** — dry-run low/medium/high on the same messages and compare stats.
+- **`CompressionStats.to_dict()` / `CompressionResult.to_dict()`** — JSON-friendly export.
+- **`GeminiBackend`** — Google Gemini Tier 2 adapter (optional ``google-generativeai``).
+- Example: `examples/benchmark_presets.py`.
+
 ## [0.4.0] - 2026-07-20
 
 - **`preview()` / `dry_run=True`** — simulate compression and get stats without changing messages (Tier 1 only; no LLM calls).

{contextpress-0.4.0 → contextpress-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: contextpress
-Version: 0.4.0
+Version: 0.5.0
 Summary: Deterministic context compression for LLM chat, RAG, and agent pipelines
 Project-URL: Homepage, https://github.com/Taha-azizi/contextpress
 Project-URL: Documentation, https://github.com/Taha-azizi/contextpress#readme
@@ -234,6 +234,7 @@ Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Provides-Extra: llm
 Requires-Dist: anthropic>=0.18; extra == 'llm'
+Requires-Dist: google-generativeai>=0.8.0; extra == 'llm'
 Requires-Dist: ollama>=0.3.0; extra == 'llm'
 Requires-Dist: openai>=1.0; extra == 'llm'
 Description-Content-Type: text/markdown
@@ -307,6 +308,20 @@ if cm.fits_budget(messages, 4000):
     ...
 ```
 
+**Compare presets** (0.5+):
+
+```python
+rows = cm.compare_presets(messages, token_budget=500)
+for preset, stats in rows.items():
+    print(preset, stats.tokens_saved)
+```
+
+**Async** (0.5+):
+
+```python
+out = await cm.compress_async(messages, token_budget=2000)
+```
+
 ### Custom stages (0.3+)
 
 Register a `BaseStrategy` and include it in `stages=`:
@@ -386,7 +401,7 @@ ContextManager(type="agent")
 | **Techniques** | Rules, TF–IDF, cosine similarity, NLTK, Sumy extractive summarization, tiktoken | Your provider’s chat/completions API (you supply the client) |
 | **API key** | None | Required for your chosen provider (OpenAI, Anthropic, …) |
 | **Determinism** | Deterministic for a fixed input and settings | Non-deterministic (model sampling) |
-| **How to enable** | Default: `ContextManager()` runs Tier 1 only | Pass `llm_backend=` (`OpenAIBackend`, `AnthropicBackend`, **`OllamaBackend`**, or custom `LLMBackend`) |
+| **How to enable** | Default: `ContextManager()` runs Tier 1 only | Pass `llm_backend=` (`OpenAIBackend`, `AnthropicBackend`, `GeminiBackend`, **`OllamaBackend`**, or custom `LLMBackend`) |
 
 **Note:** `ContextManager(model="gpt-4")` is only for **tiktoken** encoding when counting tokens in the **budget** stage. It does **not** call that model unless you also pass **`llm_backend`**.
 

{contextpress-0.4.0 → contextpress-0.5.0}/README.md

@@ -67,6 +67,20 @@ if cm.fits_budget(messages, 4000):
     ...
 ```
 
+**Compare presets** (0.5+):
+
+```python
+rows = cm.compare_presets(messages, token_budget=500)
+for preset, stats in rows.items():
+    print(preset, stats.tokens_saved)
+```
+
+**Async** (0.5+):
+
+```python
+out = await cm.compress_async(messages, token_budget=2000)
+```
+
 ### Custom stages (0.3+)
 
 Register a `BaseStrategy` and include it in `stages=`:
@@ -146,7 +160,7 @@ ContextManager(type="agent")
 | **Techniques** | Rules, TF–IDF, cosine similarity, NLTK, Sumy extractive summarization, tiktoken | Your provider’s chat/completions API (you supply the client) |
 | **API key** | None | Required for your chosen provider (OpenAI, Anthropic, …) |
 | **Determinism** | Deterministic for a fixed input and settings | Non-deterministic (model sampling) |
-| **How to enable** | Default: `ContextManager()` runs Tier 1 only | Pass `llm_backend=` (`OpenAIBackend`, `AnthropicBackend`, **`OllamaBackend`**, or custom `LLMBackend`) |
+| **How to enable** | Default: `ContextManager()` runs Tier 1 only | Pass `llm_backend=` (`OpenAIBackend`, `AnthropicBackend`, `GeminiBackend`, **`OllamaBackend`**, or custom `LLMBackend`) |
 
 **Note:** `ContextManager(model="gpt-4")` is only for **tiktoken** encoding when counting tokens in the **budget** stage. It does **not** call that model unless you also pass **`llm_backend`**.
 

{contextpress-0.4.0 → contextpress-0.5.0}/contextpress/__init__.py

@@ -16,7 +16,7 @@ __all__ = [
     "CompressionResult",
     "CompressionStats",
 ]
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 
 def __getattr__(name: str) -> Any:

{contextpress-0.4.0 → contextpress-0.5.0}/contextpress/core.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import copy
 import warnings
 from typing import TYPE_CHECKING, Any
@@ -86,6 +87,20 @@ class ContextManager:
         )
         return preview.stats.tokens_after <= token_budget
 
+    def compare_presets(
+        self,
+        messages: Any,
+        token_budget: int | None = None,
+        *,
+        presets: tuple[str, ...] = ("low", "medium", "high"),
+    ) -> dict[str, CompressionStats]:
+        """Dry-run each compression preset and return stats keyed by preset name."""
+        results: dict[str, CompressionStats] = {}
+        for preset in presets:
+            preview = self.preview(messages, token_budget=token_budget, compression=preset)
+            results[preset] = preview.stats
+        return results
+
     def preview(
         self,
         messages: Any,
@@ -176,6 +191,29 @@ class ContextManager:
             return CompressionResult(messages=messages_out, stats=stats)
         return messages_out
 
+    async def compress_async(
+        self,
+        messages: Any,
+        token_budget: int | None = None,
+        *,
+        compression: str | None = None,
+        stages: list[str] | None = None,
+        disable: list[str] | None = None,
+        return_stats: bool = False,
+        dry_run: bool = False,
+    ) -> Any | CompressionResult:
+        """Async wrapper around ``compress()`` (runs in a worker thread)."""
+        return await asyncio.to_thread(
+            self.compress,
+            messages,
+            token_budget,
+            compression=compression,
+            stages=stages,
+            disable=disable,
+            return_stats=return_stats,
+            dry_run=dry_run,
+        )
+
     def set_compression(self, compression: str) -> None:
         """Change the default preset for subsequent ``compress()`` calls (low / medium / high)."""
         self._compression = normalize_compression_level(compression)

{contextpress-0.4.0 → contextpress-0.5.0}/contextpress/llm/__init__.py

@@ -1,5 +1,6 @@
 from contextpress.llm.adapters import (
     AnthropicBackend,
+    GeminiBackend,
     OllamaBackend,
     OpenAIBackend,
     OpenAICompatibleBackend,
@@ -11,5 +12,6 @@ __all__ = [
     "OpenAIBackend",
     "OpenAICompatibleBackend",
     "AnthropicBackend",
+    "GeminiBackend",
     "OllamaBackend",
 ]

{contextpress-0.4.0 → contextpress-0.5.0}/contextpress/llm/adapters.py

@@ -262,3 +262,50 @@ class OpenAICompatibleBackend(OpenAIBackend):
             client=OpenAI(base_url=base_url, api_key=api_key),
             model=model,
         )
+
+
+class GeminiBackend(LLMBackend):
+    """
+    Adapter for Google Gemini via ``google-generativeai``.
+
+    Requires: ``pip install google-generativeai``
+
+    Usage::
+
+        import google.generativeai as genai
+        from contextpress.llm.adapters import GeminiBackend
+
+        genai.configure(api_key=\"...\")
+        backend = GeminiBackend(model=genai.GenerativeModel(\"gemini-2.0-flash\"))
+        cm = ContextManager(type=\"chat\", llm_backend=backend)
+    """
+
+    def __init__(self, model: Any):
+        self.model = model
+
+    def _generate(self, prompt: str, *, max_tokens: int) -> str:
+        resp = self.model.generate_content(
+            prompt,
+            generation_config={"max_output_tokens": max(64, int(max_tokens))},
+        )
+        text = getattr(resp, "text", None)
+        return str(text).strip() if text else ""
+
+    def summarize(self, text: str, max_tokens: int) -> str:
+        try:
+            out = self._generate(f"Summarize concisely:\n\n{text}", max_tokens=max_tokens)
+            return out if out else text
+        except Exception as exc:
+            warnings.warn(f"contextpress GeminiBackend.summarize failed: {exc}", stacklevel=2)
+            raise
+
+    def deduplicate(self, turns: list[str]) -> list[int]:
+        if len(turns) <= 1:
+            return list(range(len(turns)))
+        prompt = f"{DEDUP_SYSTEM_PROMPT}\n\n{format_numbered_turns(turns)}"
+        try:
+            out = self._generate(prompt, max_tokens=128)
+            return parse_keep_indices(out, len(turns))
+        except Exception as exc:
+            warnings.warn(f"contextpress GeminiBackend.deduplicate failed: {exc}", stacklevel=2)
+            return list(range(len(turns)))

{contextpress-0.4.0 → contextpress-0.5.0}/contextpress/stats.py

@@ -60,6 +60,27 @@ class CompressionStats:
     def tokens_saved(self) -> int:
         return max(0, self.tokens_before - self.tokens_after)
 
+    def to_dict(self) -> dict[str, Any]:
+        """JSON-serializable snapshot of this run."""
+        return {
+            "turns_before": self.turns_before,
+            "turns_after": self.turns_after,
+            "turns_removed": self.turns_removed,
+            "tokens_before": self.tokens_before,
+            "tokens_after": self.tokens_after,
+            "tokens_saved": self.tokens_saved,
+            "stages_run": list(self.stages_run),
+            "turn_delta_by_stage": dict(self.turn_delta_by_stage),
+            "llm_tier_applied": self.llm_tier_applied,
+            "llm_dedup_turns_before": self.llm_dedup_turns_before,
+            "llm_dedup_turns_after": self.llm_dedup_turns_after,
+            "compression_level": self.compression_level,
+            "context_type": self.context_type,
+            "token_budget": self.token_budget,
+            "dry_run": self.dry_run,
+            "warnings_emitted": list(self.warnings_emitted),
+        }
+
 
 @dataclass
 class CompressionResult:
@@ -67,3 +88,9 @@ class CompressionResult:
 
     messages: Any
     stats: CompressionStats
+
+    def to_dict(self, *, include_messages: bool = True) -> dict[str, Any]:
+        data = {"stats": self.stats.to_dict()}
+        if include_messages:
+            data["messages"] = self.messages
+        return data

contextpress-0.5.0/examples/benchmark_presets.py

@@ -0,0 +1,23 @@
+"""Compare compression presets on the same fixture (dry run)."""
+
+from contextpress import ContextManager
+
+messages = [
+    {"role": "system", "content": "You are helpful."},
+    {"role": "user", "content": "Old topic: " + "blah " * 40},
+    {"role": "assistant", "content": "Basically, honestly, " + "yak " * 40},
+    {"role": "user", "content": "What is 2+2?"},
+    {"role": "assistant", "content": "Four."},
+]
+
+cm = ContextManager(type="chat")
+rows = cm.compare_presets(messages, token_budget=200)
+
+print(f"{'preset':<8} {'tokens':>12} {'saved':>8} {'turns':>12}")
+for preset, stats in rows.items():
+    print(
+        f"{preset:<8} "
+        f"{stats.tokens_before:>5}->{stats.tokens_after:<5} "
+        f"{stats.tokens_saved:>8} "
+        f"{stats.turns_before:>5}->{stats.turns_after:<5}"
+    )

{contextpress-0.4.0 → contextpress-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "contextpress"
-version = "0.4.0"
+version = "0.5.0"
 description = "Deterministic context compression for LLM chat, RAG, and agent pipelines"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -44,7 +44,7 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = ["pytest>=7.0", "pytest-cov>=4.0", "black", "ruff"]
-llm = ["openai>=1.0", "anthropic>=0.18", "ollama>=0.3.0"]
+llm = ["openai>=1.0", "anthropic>=0.18", "ollama>=0.3.0", "google-generativeai>=0.8.0"]
 
 [project.urls]
 Homepage = "https://github.com/Taha-azizi/contextpress"

contextpress-0.5.0/tests/test_v05.py

@@ -0,0 +1,66 @@
+import asyncio
+from unittest.mock import MagicMock
+
+from contextpress import ContextManager
+from contextpress.llm.adapters import GeminiBackend
+from contextpress.stats import CompressionStats
+
+
+def test_stats_to_dict():
+    stats = CompressionStats(
+        turns_before=5,
+        turns_after=3,
+        tokens_before=100,
+        tokens_after=60,
+        stages_run=["filler", "budget"],
+        compression_level="medium",
+    )
+    d = stats.to_dict()
+    assert d["turns_removed"] == 2
+    assert d["tokens_saved"] == 40
+    assert d["stages_run"] == ["filler", "budget"]
+
+
+def test_result_to_dict():
+    cm = ContextManager()
+    result = cm.preview([{"role": "user", "content": "hello basically"}], token_budget=100)
+    d = result.to_dict()
+    assert "stats" in d and "messages" in d
+    assert d["stats"]["dry_run"] is True
+
+
+def test_compare_presets():
+    cm = ContextManager(type="chat")
+    messages = [
+        {"role": "user", "content": "hello basically there"},
+        {"role": "assistant", "content": "sounds good"},
+    ]
+    rows = cm.compare_presets(messages, token_budget=500)
+    assert set(rows) == {"low", "medium", "high"}
+    assert all(isinstance(v, CompressionStats) for v in rows.values())
+
+
+def test_compress_async():
+    async def _run() -> list:
+        cm = ContextManager(type="chat")
+        return await cm.compress_async(
+            [{"role": "user", "content": "hello basically"}],
+            token_budget=200,
+        )
+
+    out = asyncio.run(_run())
+    assert isinstance(out, list)
+
+
+def test_gemini_backend_summarize():
+    model = MagicMock()
+    model.generate_content.return_value = MagicMock(text="summary")
+    backend = GeminiBackend(model=model)
+    assert backend.summarize("long text", 50) == "summary"
+
+
+def test_gemini_backend_deduplicate():
+    model = MagicMock()
+    model.generate_content.return_value = MagicMock(text="0, 2")
+    backend = GeminiBackend(model=model)
+    assert backend.deduplicate(["a", "b", "c", "d"]) == [0, 2]