tokensave 0.1.1__tar.gz

tokensave-0.1.1/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: tokensave
+Version: 0.1.1
+Summary: Context optimization for LLM API calls. One import, fewer tokens.
+Author: raydatalab
+License: Apache 2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: headroom-ai>=0.30.0
+
+# TokenSave ⚡
+
+Context optimization for LLM API calls. One import, fewer tokens.
+
+```bash
+pip install tokensave
+```
+
+```python
+from tokensave import OpenAI
+
+client = OpenAI(api_key="...")
+# Open box. Save tokens. That's it.
+```
+
+- No daemon, no config, no proxy.
+- `tokensave proxy` for non-Python tools (power-user).
+
+[github.com/raydatalab/tokensave](https://github.com/raydatalab/tokensave) · Apache 2.0

tokensave-0.1.1/README.md

@@ -0,0 +1,19 @@
+# TokenSave ⚡
+
+Context optimization for LLM API calls. One import, fewer tokens.
+
+```bash
+pip install tokensave
+```
+
+```python
+from tokensave import OpenAI
+
+client = OpenAI(api_key="...")
+# Open box. Save tokens. That's it.
+```
+
+- No daemon, no config, no proxy.
+- `tokensave proxy` for non-Python tools (power-user).
+
+[github.com/raydatalab/tokensave](https://github.com/raydatalab/tokensave) · Apache 2.0

tokensave-0.1.1/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tokensave"
+version = "0.1.1"
+description = "Context optimization for LLM API calls. One import, fewer tokens."
+readme = "README.md"
+license = {text = "Apache 2.0"}
+requires-python = ">=3.10"
+authors = [
+    {name = "raydatalab"}
+]
+
+dependencies = [
+    "headroom-ai>=0.30.0",
+]
+
+[project.scripts]
+tokensave = "tokensave.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["tokensave*"]

tokensave-0.1.1/setup.cfg

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

tokensave-0.1.1/tokensave/__init__.py

@@ -0,0 +1,85 @@
+"""
+TokenSave — Context optimization for LLM API calls.
+
+Safe defaults: pip install does nothing but make the package available.
+Use `from tokensave import OpenAI` as a drop-in for `from openai import OpenAI`.
+If headroom is installed, messages are compressed before sending. If not,
+requests pass through unchanged. Never breaks your existing workflow.
+"""
+
+__version__ = "0.1.1"
+
+import logging
+
+logger = logging.getLogger("tokensave")
+
+# Check headroom availability once at import time
+_HAS_HEADROOM = False
+try:
+    import headroom  # noqa: F401
+    _HAS_HEADROOM = True
+except ImportError:
+    pass
+
+
+class OpenAI:
+    """
+    Drop-in replacement for `openai.OpenAI` with optional compression.
+
+    Usage:
+        # Instead of:
+        #   from openai import OpenAI
+        #   client = OpenAI(api_key="...")
+
+        from tokensave import OpenAI
+        client = OpenAI(api_key="...")
+
+    When headroom is installed ('pip install tokensave[compress]'), messages
+    are compressed before being sent to the API. When headroom is not available,
+    requests pass through unchanged — no errors, no config changes, no breakage.
+    """
+
+    def __new__(cls, *args, **kwargs):
+        try:
+            from openai import OpenAI as _RealOpenAI
+            client = _RealOpenAI(*args, **kwargs)
+        except ImportError:
+            raise ImportError(
+                "tokensave requires 'openai' package. Install with: pip install openai"
+            )
+
+        if _HAS_HEADROOM:
+            return _CompressingOpenAI(client)
+        return client
+
+
+class _CompressingOpenAI:
+    """Wraps an openai.OpenAI client with Headroom compression."""
+
+    def __init__(self, client):
+        self._client = client
+        self._compressor = None
+        self._init_compressor()
+
+    def _init_compressor(self):
+        try:
+            from headroom import compress as _hr_compress
+            self._hr_compress = _hr_compress
+            logger.info("tokensave: Headroom compression active")
+        except Exception as e:
+            logger.warning(f"tokensave: Headroom init failed ({e}), running passthrough")
+            self._hr_compress = None
+
+    def _compress_messages(self, messages):
+        if not self._hr_compress:
+            return messages
+        try:
+            result = self._hr_compress(messages)
+            return result.messages
+        except Exception as e:
+            logger.warning(f"tokensave: compression failed ({e}), sending uncompressed")
+            return messages
+
+    def __getattr__(self, name):
+        """Pass through any attribute access to the underlying client."""
+        return getattr(self._client, name)

tokensave-0.1.1/tokensave/cli.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""
+TokenSave — Context optimization for LLM API calls.
+
+Core usage:
+    from tokensave import OpenAI     # drop-in for openai.OpenAI
+
+CLI:
+    tokensave setup    Detect environment, check dependencies
+    tokensave proxy    Start/stop compression proxy (power-user)
+"""
+
+import argparse
+import logging
+import sys
+
+from . import __version__
+from .detectors import detect_all, summary
+from .compressors import check_headroom, list_compressors, get_headroom_version
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+logger = logging.getLogger("tokensave")
+
+
+def cmd_setup(args):
+    """Detect environment and check dependencies. Read-only."""
+    print("⚡ TokenSave\n")
+    env = detect_all()
+    print(summary(env))
+
+    if check_headroom():
+        print(f"\n  ✓ headroom {get_headroom_version()} — compression ready")
+    else:
+        print("\n  ○ headroom not installed")
+        print("    pip install 'tokensave[compress]'")
+
+    print("\n  → from tokensave import OpenAI")
+
+
+def cmd_proxy(args):
+    """Start/stop compression proxy."""
+    from .proxy import TokenSaveProxy
+    proxy = TokenSaveProxy()
+
+    if args.action == "start":
+        if proxy.start():
+            print("✅ Proxy on 127.0.0.1:18787")
+        else:
+            print("⚠ Port 18787 in use")
+    elif args.action == "stop":
+        proxy.stop()
+        print("🛑 Proxy stopped")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="TokenSave — Context optimization for LLM API calls"
+    )
+    parser.add_argument("--version", action="version", version=f"TokenSave {__version__}")
+
+    sub = parser.add_subparsers(dest="command")
+    sub.add_parser("setup", help="Detect environment, check dependencies")
+
+    p = sub.add_parser("proxy", help="Start/stop compression proxy (power-user)")
+    p.add_argument("action", choices=["start", "stop"])
+
+    args = parser.parse_args()
+    if args.command == "setup":
+        cmd_setup(args)
+    elif args.command == "proxy":
+        cmd_proxy(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

tokensave-0.1.1/tokensave/compressors/__init__.py

@@ -0,0 +1,50 @@
+"""Compressor backends. Primary: headroom. Future: llmlingua, selective-context."""
+
+import importlib
+import logging
+
+logger = logging.getLogger("tokensave")
+
+
+def check_headroom() -> bool:
+    """Check if headroom is installed and importable."""
+    try:
+        import headroom  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def get_headroom_version() -> str:
+    """Get headroom version string."""
+    try:
+        import headroom
+        return getattr(headroom, "__version__", "unknown")
+    except ImportError:
+        return "not installed"
+
+
+def wrap_command(tool: str, compress_refs: bool = True, keep_active: bool = True) -> list[str]:
+    """Return the headroom wrap command args for a given tool."""
+    cmd = ["headroom", "wrap", tool]
+    if compress_refs:
+        cmd.append("--compress-refs")
+    if keep_active:
+        cmd.append("--keep-active")
+    return cmd
+
+
+AVAILABLE_COMPRESSORS = {"headroom": check_headroom()}
+
+
+def list_compressors() -> list[dict]:
+    """List available compressors and their status."""
+    return [
+        {
+            "name": "headroom",
+            "available": check_headroom(),
+            "version": get_headroom_version(),
+            "description": "Content-aware context compression. 60-95% token reduction.",
+            "default": True,
+        },
+    ]

tokensave-0.1.1/tokensave/detectors/__init__.py

@@ -0,0 +1,143 @@
+"""Detect what LLM tools the user has installed and which API provider they use."""
+
+import os
+import shutil
+import subprocess
+import json
+from pathlib import Path
+
+HOME = Path.home()
+
+
+def detect_claude_code() -> dict:
+    """Detect Claude Code installation and configuration."""
+    result = {"installed": False, "mode": None, "config_path": None}
+
+    # Check if claude command exists
+    claude_path = shutil.which("claude")
+    if claude_path:
+        result["installed"] = True
+        result["binary"] = str(claude_path)
+
+        # Check API key / auth mode
+        if os.environ.get("ANTHROPIC_API_KEY"):
+            result["mode"] = "api"
+            result["api_key_prefix"] = os.environ["ANTHROPIC_API_KEY"][:8] + "..."
+        elif os.environ.get("CLAUDE_API_KEY"):
+            result["mode"] = "api"
+        else:
+            result["mode"] = "subscription"
+
+        # Check config
+        config_paths = [
+            HOME / ".claude" / "settings.json",
+            HOME / ".claude" / "claude.json",
+            HOME / ".config" / "claude" / "settings.json",
+        ]
+        for p in config_paths:
+            if p.exists():
+                result["config_path"] = str(p)
+                try:
+                    data = json.loads(p.read_text())
+                    result["config"] = data
+                except (json.JSONDecodeError, OSError):
+                    pass
+                break
+
+    return result
+
+
+def detect_sillytavern() -> dict:
+    """Detect SillyTavern installation."""
+    result = {"installed": False, "path": None}
+
+    # Common install locations
+    search_paths = [
+        HOME / "SillyTavern",
+        HOME / "sillytavern",
+        HOME / "ST",
+        HOME / "SillyTavern-Launcher",
+    ]
+    for p in search_paths:
+        if p.exists() and (p / "config.yaml").exists():
+            result["installed"] = True
+            result["path"] = str(p)
+            break
+
+    return result
+
+
+def detect_openai_key() -> bool:
+    """Check if user has OpenAI API key configured."""
+    return bool(os.environ.get("OPENAI_API_KEY"))
+
+
+def detect_anthropic_key() -> bool:
+    """Check if user has Anthropic API key configured."""
+    return bool(os.environ.get("ANTHROPIC_API_KEY"))
+
+
+def get_api_base_urls() -> dict:
+    """Get current API base URLs from environment (may have been set by other tools)."""
+    return {
+        "openai": os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1"),
+        "anthropic": os.environ.get("ANTHROPIC_BASE_URL", "https://api.anthropic.com"),
+    }
+
+
+def detect_all() -> dict:
+    """Run all detectors and return a complete profile."""
+    env = {
+        "claude_code": detect_claude_code(),
+        "sillytavern": detect_sillytavern(),
+        "api_keys": {
+            "openai": detect_openai_key(),
+            "anthropic": detect_anthropic_key(),
+        },
+        "base_urls": get_api_base_urls(),
+        "shell": os.environ.get("SHELL", "unknown"),
+        "platform": os.uname().sysname if hasattr(os, "uname") else "unknown",
+    }
+
+    # Determine primary use case
+    if env["claude_code"]["installed"]:
+        env["primary_tool"] = "claude_code"
+    elif env["sillytavern"]["installed"]:
+        env["primary_tool"] = "sillytavern"
+    elif env["api_keys"]["openai"] or env["api_keys"]["anthropic"]:
+        env["primary_tool"] = "api_user"
+    else:
+        env["primary_tool"] = "unknown"
+
+    return env
+
+
+def summary(env: dict) -> str:
+    """Return a human-readable summary of the detected environment."""
+    lines = ["🔍 Environment Detection:\n"]
+
+    cc = env["claude_code"]
+    if cc["installed"]:
+        mode_str = "API key" if cc["mode"] == "api" else "subscription"
+        lines.append(f"  ✓ Claude Code detected ({mode_str} mode)")
+    else:
+        lines.append("  ✗ Claude Code not detected")
+
+    st = env["sillytavern"]
+    if st["installed"]:
+        lines.append(f"  ✓ SillyTavern detected at {st['path']}")
+    else:
+        lines.append("  ✗ SillyTavern not detected")
+
+    keys = env["api_keys"]
+    if keys["openai"]:
+        lines.append("  ✓ OpenAI API key found")
+    if keys["anthropic"]:
+        lines.append("  ✓ Anthropic API key found")
+
+    if not any(keys.values()):
+        if not cc["installed"]:
+            lines.append("  ⚠ No API keys detected. TokenSave works best with API-based access.")
+
+    lines.append(f"\n  Primary tool: {env['primary_tool']}")
+    return "\n".join(lines)

tokensave-0.1.1/tokensave/proxy.py

@@ -0,0 +1,318 @@
+#!/usr/bin/env python3
+"""
+Transparent local proxy that compresses LLM API calls on the fly.
+Speaks both OpenAI-compatible (/v1/chat/completions) and Anthropic-compatible (/v1/messages) formats.
+"""
+
+import json
+import logging
+import os
+import threading
+import time
+import urllib.request
+import urllib.error
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from dataclasses import dataclass, field
+from pathlib import Path
+
+logger = logging.getLogger("tokensave.proxy")
+
+STATS_DIR = Path.home() / ".tokensave"
+STATS_FILE = STATS_DIR / "stats.json"
+PROXY_PORT = 18787
+HEADROOM_PORT = 8787  # Default headroom proxy port, if running
+
+
+@dataclass
+class ProxyStats:
+    """Tracks token savings across proxy sessions."""
+    total_requests: int = 0
+    total_input_tokens_before: int = 0
+    total_input_tokens_after: int = 0
+    total_output_tokens: int = 0
+    estimated_cost_saved: float = 0.0
+    start_time: float = field(default_factory=time.time)
+
+    def save(self):
+        STATS_DIR.mkdir(parents=True, exist_ok=True)
+        data = {
+            "total_requests": self.total_requests,
+            "total_input_tokens_before": self.total_input_tokens_before,
+            "total_input_tokens_after": self.total_input_tokens_after,
+            "total_output_tokens": self.total_output_tokens,
+            "estimated_cost_saved": round(self.estimated_cost_saved, 4),
+            "start_time": self.start_time,
+        }
+        STATS_FILE.write_text(json.dumps(data, indent=2))
+
+    @classmethod
+    def load(cls):
+        if STATS_FILE.exists():
+            try:
+                data = json.loads(STATS_FILE.read_text())
+                return cls(**data)
+            except (json.JSONDecodeError, TypeError):
+                pass
+        return cls()
+
+    @property
+    def compression_ratio(self) -> float:
+        if self.total_input_tokens_before > 0:
+            return 1 - (self.total_input_tokens_after / self.total_input_tokens_before)
+        return 0.0
+
+    @property
+    def runtime_hours(self) -> float:
+        return (time.time() - self.start_time) / 3600
+
+
+stats = ProxyStats.load()
+
+
+class ProxyHandler(BaseHTTPRequestHandler):
+    """HTTP handler that proxies LLM API requests through compression."""
+
+    def do_OPTIONS(self):
+        self._cors_headers()
+        self.send_response(200)
+        self.end_headers()
+
+    def do_POST(self):
+        content_len = int(self.headers.get("Content-Length", 0))
+        body = self.rfile.read(content_len)
+
+        # Determine target from path
+        path = self.path
+
+        if "/v1/chat/completions" in path:
+            self._handle_openai_chat(body)
+        elif "/v1/messages" in path:
+            self._handle_anthropic_messages(body)
+        else:
+            self._forward_raw(body)
+
+    def _cors_headers(self):
+        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Methods", "POST, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type, Authorization, x-api-key")
+
+    def _compress_messages(self, messages: list) -> list:
+        """Compress messages using headroom proxy if available, otherwise return as-is."""
+        try:
+            import headroom
+            from headroom import Headroom
+
+            # Use headroom's compressor directly
+            hr = Headroom()
+            compressed = []
+            for msg in messages:
+                if isinstance(msg.get("content"), str) and len(msg["content"]) > 200:
+                    compressed_content = hr.compress(msg["content"])
+                    compressed.append({**msg, "content": compressed_content})
+                else:
+                    compressed.append(msg)
+            return compressed
+        except ImportError:
+            # Headroom not directly importable for compression; skip
+            return messages
+        except Exception as e:
+            logger.warning(f"Compression failed for message batch: {e}")
+            return messages
+
+    def _estimate_tokens(self, text: str) -> int:
+        """Rough token estimate (4 chars ≈ 1 token)."""
+        return len(text) // 4
+
+    def _handle_openai_chat(self, body: bytes):
+        try:
+            req = json.loads(body)
+            messages = req.get("messages", [])
+
+            # Count tokens before
+            text_before = json.dumps(messages)
+            tokens_before = self._estimate_tokens(text_before)
+
+            # Compress
+            compressed_messages = self._compress_messages(messages)
+            req["messages"] = compressed_messages
+
+            # Count after
+            text_after = json.dumps(compressed_messages)
+            tokens_after = self._estimate_tokens(text_after)
+
+            # Forward to real API
+            real_url = os.environ.get(
+                "TOKENSAVE_OPENAI_BASE_URL",
+                os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1"),
+            )
+
+            api_key = os.environ.get("OPENAI_API_KEY", "")
+            target_url = real_url.rstrip("/") + "/chat/completions"
+
+            response_data = self._forward_request(
+                target_url, json.dumps(req).encode(), 
+                {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+            )
+
+            # Update stats
+            stats.total_requests += 1
+            stats.total_input_tokens_before += tokens_before
+            stats.total_input_tokens_after += tokens_after
+
+            if response_data:
+                resp_json = json.loads(response_data)
+                if "usage" in resp_json:
+                    stats.total_output_tokens += resp_json["usage"].get("completion_tokens", 0)
+
+                # Rough cost estimate (GPT-4o pricing)
+                savings = (tokens_before - tokens_after) / 1_000_000 * 2.50
+                stats.estimated_cost_saved += savings
+                stats.save()
+
+                self._cors_headers()
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(response_data)
+            else:
+                self._send_error(502, "Upstream API failed")
+
+        except Exception as e:
+            logger.error(f"OpenAI proxy error: {e}")
+            self._send_error(500, str(e))
+
+    def _handle_anthropic_messages(self, body: bytes):
+        try:
+            req = json.loads(body)
+            messages = req.get("messages", [])
+
+            text_before = json.dumps(messages)
+            tokens_before = self._estimate_tokens(text_before)
+
+            compressed_messages = self._compress_messages(messages)
+            req["messages"] = compressed_messages
+
+            text_after = json.dumps(compressed_messages)
+            tokens_after = self._estimate_tokens(text_after)
+
+            real_url = os.environ.get(
+                "TOKENSAVE_ANTHROPIC_BASE_URL",
+                os.environ.get("ANTHROPIC_BASE_URL", "https://api.anthropic.com"),
+            )
+
+            api_key = os.environ.get("ANTHROPIC_API_KEY", "")
+            target_url = real_url.rstrip("/") + "/messages"
+
+            response_data = self._forward_request(
+                target_url, json.dumps(req).encode(),
+                {
+                    "x-api-key": api_key,
+                    "anthropic-version": self.headers.get("anthropic-version", "2023-06-01"),
+                    "Content-Type": "application/json",
+                }
+            )
+
+            stats.total_requests += 1
+            stats.total_input_tokens_before += tokens_before
+            stats.total_input_tokens_after += tokens_after
+
+            if response_data:
+                resp_json = json.loads(response_data)
+                if "usage" in resp_json:
+                    stats.total_output_tokens += resp_json["usage"].get("output_tokens", 0)
+                    input_tokens = resp_json["usage"].get("input_tokens", 0)
+                    # Use actual reported input tokens for savings calc
+                    savings = (tokens_before - tokens_after) / 1_000_000 * 3.0
+                    stats.estimated_cost_saved += savings
+                    stats.save()
+
+                self._cors_headers()
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(response_data)
+            else:
+                self._send_error(502, "Upstream API failed")
+
+        except Exception as e:
+            logger.error(f"Anthropic proxy error: {e}")
+            self._send_error(500, str(e))
+
+    def _forward_request(self, url: str, data: bytes, headers: dict) -> bytes | None:
+        try:
+            req = urllib.request.Request(url, data=data, headers=headers, method="POST")
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                return resp.read()
+        except urllib.error.HTTPError as e:
+            logger.error(f"Upstream HTTP {e.code}: {e.read().decode()[:200]}")
+            return None
+        except Exception as e:
+            logger.error(f"Forward error: {e}")
+            return None
+
+    def _forward_raw(self, body: bytes):
+        """Pass through for non-chat endpoints."""
+        self._cors_headers()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _send_error(self, code: int, message: str):
+        self._cors_headers()
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(json.dumps({"error": {"message": message}}).encode())
+
+    def log_message(self, format, *args):
+        logger.debug(f"{self.address_string()} - {format % args}")
+
+
+class TokenSaveProxy:
+    """Manages the transparent proxy lifecycle."""
+
+    def __init__(self, port: int = PROXY_PORT):
+        self.port = port
+        self.server = None
+        self.thread = None
+        self.running = False
+
+    def start(self, daemon: bool = True) -> bool:
+        if self.running:
+            logger.info("Proxy already running")
+            return True
+
+        try:
+            self.server = HTTPServer(("127.0.0.1", self.port), ProxyHandler)
+            self.thread = threading.Thread(target=self.server.serve_forever, daemon=daemon)
+            self.thread.start()
+            self.running = True
+            logger.info(f"TokenSave proxy started on 127.0.0.1:{self.port}")
+            return True
+        except OSError as e:
+            logger.error(f"Failed to start proxy on port {self.port}: {e}")
+            return False
+
+    def stop(self):
+        if self.server:
+            self.server.shutdown()
+            self.server.server_close()
+        self.running = False
+        logger.info("TokenSave proxy stopped")
+
+    def is_running(self) -> bool:
+        return self.running
+
+    @property
+    def status_line(self) -> str:
+        if self.running:
+            r = stats.total_requests
+            ratio = stats.compression_ratio * 100
+            saved = stats.estimated_cost_saved
+            return (
+                f"  ✓ Proxy running on 127.0.0.1:{self.port}\n"
+                f"  📊 {r} requests processed | {ratio:.1f}% compression"
+                f" | ~${saved:.2f} saved"
+            )
+        return "  ✗ Proxy not running"

tokensave-0.1.1/tokensave.egg-info/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: tokensave
+Version: 0.1.1
+Summary: Context optimization for LLM API calls. One import, fewer tokens.
+Author: raydatalab
+License: Apache 2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: headroom-ai>=0.30.0
+
+# TokenSave ⚡
+
+Context optimization for LLM API calls. One import, fewer tokens.
+
+```bash
+pip install tokensave
+```
+
+```python
+from tokensave import OpenAI
+
+client = OpenAI(api_key="...")
+# Open box. Save tokens. That's it.
+```
+
+- No daemon, no config, no proxy.
+- `tokensave proxy` for non-Python tools (power-user).
+
+[github.com/raydatalab/tokensave](https://github.com/raydatalab/tokensave) · Apache 2.0

tokensave-0.1.1/tokensave.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+tokensave/__init__.py
+tokensave/cli.py
+tokensave/proxy.py
+tokensave.egg-info/PKG-INFO
+tokensave.egg-info/SOURCES.txt
+tokensave.egg-info/dependency_links.txt
+tokensave.egg-info/entry_points.txt
+tokensave.egg-info/requires.txt
+tokensave.egg-info/top_level.txt
+tokensave/compressors/__init__.py
+tokensave/detectors/__init__.py

tokensave-0.1.1/tokensave.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tokensave-0.1.1/tokensave.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tokensave = tokensave.cli:main

tokensave-0.1.1/tokensave.egg-info/requires.txt

@@ -0,0 +1 @@
+headroom-ai>=0.30.0

tokensave-0.1.1/tokensave.egg-info/top_level.txt

@@ -0,0 +1 @@
+tokensave