tokenc 0.1.0__tar.gz

tokenc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The Token Company
+
+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.

tokenc-0.1.0/MANIFEST.in

@@ -0,0 +1,6 @@
+include README.md
+include LICENSE
+include requirements.txt
+recursive-include tokenc *.py
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]

tokenc-0.1.0/PKG-INFO

@@ -0,0 +1,272 @@
+Metadata-Version: 2.4
+Name: tokenc
+Version: 0.1.0
+Summary: Python SDK for The Token Company API - Compress LLM inputs to reduce costs
+Home-page: https://github.com/yourusername/tokenc
+Author: The Token Company
+Author-email: The Token Company <support@thetokencompany.com>
+License: MIT
+Project-URL: Homepage, https://thetokencompany.com
+Project-URL: Documentation, https://thetokencompany.com/docs
+Project-URL: Repository, https://github.com/yourusername/tokenc
+Project-URL: Bug Tracker, https://github.com/yourusername/tokenc/issues
+Keywords: llm,compression,tokens,ai,api,cost-optimization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: mypy>=0.950; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# tokenc - Python SDK for The Token Company
+
+A Python client library for compressing LLM inputs to reduce token usage, lower costs, and speed up AI applications.
+
+## Installation
+
+```bash
+pip install tokenc
+```
+
+## Quick Start
+
+```python
+from tokenc import TokenClient
+
+# Initialize the client
+client = TokenClient(api_key="your-api-key")
+
+# Compress text
+response = client.compress_input(
+    input="Your long text here that needs compression...",
+    aggressiveness=0.5
+)
+
+print(f"Compressed text: {response.output}")
+print(f"Original tokens: {response.original_input_tokens}")
+print(f"Compressed tokens: {response.output_tokens}")
+print(f"Tokens saved: {response.tokens_saved}")
+print(f"Compression ratio: {response.compression_ratio:.2f}x")
+```
+
+## Features
+
+- 🚀 Simple and intuitive API
+- 🎯 Type-safe with dataclasses
+- 🔧 Flexible compression settings
+- 📊 Built-in compression metrics
+- ⚡ Context manager support
+- 🛡️ Comprehensive error handling
+
+## Usage Examples
+
+### Basic Compression
+
+```python
+from tokenc import TokenClient
+
+client = TokenClient(api_key="your-api-key")
+
+response = client.compress_input(
+    input="This is a long text that contains lots of unnecessary filler words and redundant information that can be compressed.",
+    aggressiveness=0.5
+)
+
+print(response.output)
+```
+
+### Advanced Compression with Settings
+
+```python
+from tokenc import TokenClient, CompressionSettings
+
+client = TokenClient(api_key="your-api-key")
+
+# Create custom compression settings
+settings = CompressionSettings(
+    aggressiveness=0.7,
+    max_output_tokens=100,
+    min_output_tokens=50
+)
+
+response = client.compress_input(
+    input="Your text here...",
+    compression_settings=settings
+)
+
+print(f"Compression percentage: {response.compression_percentage:.1f}%")
+```
+
+### Using as Context Manager
+
+```python
+from tokenc import TokenClient
+
+with TokenClient(api_key="your-api-key") as client:
+    response = client.compress_input(
+        input="Your text here...",
+        aggressiveness=0.6
+    )
+    print(response.output)
+# Session automatically closed
+```
+
+### Different Compression Levels
+
+```python
+from tokenc import TokenClient
+
+client = TokenClient(api_key="your-api-key")
+
+text = "Your long text here..."
+
+# Light compression - preserve most content
+light = client.compress_input(input=text, aggressiveness=0.2)
+
+# Moderate compression - balanced approach
+moderate = client.compress_input(input=text, aggressiveness=0.5)
+
+# Aggressive compression - maximum savings
+aggressive = client.compress_input(input=text, aggressiveness=0.8)
+```
+
+## Compression Aggressiveness Levels
+
+- **0.1-0.3**: Light compression - Removes obvious filler words
+- **0.4-0.6**: Moderate compression - Balanced approach (recommended)
+- **0.7-0.9**: Aggressive compression - Maximum cost savings
+
+## API Reference
+
+### TokenClient
+
+#### `__init__(api_key: str, base_url: str = ..., timeout: int = 30)`
+
+Initialize the Token Company API client.
+
+**Parameters:**
+- `api_key` (str): Your API key for authentication
+- `base_url` (str, optional): Base URL for the API
+- `timeout` (int, optional): Request timeout in seconds
+
+#### `compress_input(...) -> CompressResponse`
+
+Compress text input for optimized LLM inference.
+
+**Parameters:**
+- `input` (str): The text to compress
+- `model` (str, optional): Model to use (default: "bear-1")
+- `aggressiveness` (float, optional): Compression intensity 0.0-1.0 (default: 0.5)
+- `max_output_tokens` (int, optional): Maximum token count for output
+- `min_output_tokens` (int, optional): Minimum token count for output
+- `compression_settings` (CompressionSettings, optional): Custom settings object
+
+**Returns:**
+- `CompressResponse`: Object containing compressed output and metadata
+
+**Raises:**
+- `AuthenticationError`: Invalid API key
+- `InvalidRequestError`: Invalid request parameters
+- `RateLimitError`: Rate limit exceeded
+- `APIError`: Other API errors
+
+### CompressionSettings
+
+Dataclass for compression configuration.
+
+**Attributes:**
+- `aggressiveness` (float): Compression intensity 0.0-1.0
+- `max_output_tokens` (int | None): Optional maximum output tokens
+- `min_output_tokens` (int | None): Optional minimum output tokens
+
+### CompressResponse
+
+Dataclass for compression results.
+
+**Attributes:**
+- `output` (str): The compressed text
+- `output_tokens` (int): Token count of compressed output
+- `original_input_tokens` (int): Token count of original input
+- `compression_time` (float): Processing duration in seconds
+
+**Properties:**
+- `tokens_saved` (int): Number of tokens saved
+- `compression_ratio` (float): Ratio of original to compressed tokens
+- `compression_percentage` (float): Percentage reduction in tokens
+
+## Error Handling
+
+```python
+from tokenc import TokenClient, AuthenticationError, InvalidRequestError, RateLimitError, APIError
+
+client = TokenClient(api_key="your-api-key")
+
+try:
+    response = client.compress_input(input="Your text...")
+except AuthenticationError:
+    print("Invalid API key")
+except InvalidRequestError as e:
+    print(f"Invalid request: {e}")
+except RateLimitError:
+    print("Rate limit exceeded, please wait")
+except APIError as e:
+    print(f"API error: {e}")
+```
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/tokenc.git
+cd tokenc
+
+# Install in development mode
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+### Code Formatting
+
+```bash
+black tokenc/
+```
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Support
+
+For issues and questions:
+- GitHub Issues: https://github.com/yourusername/tokenc/issues
+- Documentation: https://thetokencompany.com/docs
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

tokenc-0.1.0/README.md

@@ -0,0 +1,233 @@
+# tokenc - Python SDK for The Token Company
+
+A Python client library for compressing LLM inputs to reduce token usage, lower costs, and speed up AI applications.
+
+## Installation
+
+```bash
+pip install tokenc
+```
+
+## Quick Start
+
+```python
+from tokenc import TokenClient
+
+# Initialize the client
+client = TokenClient(api_key="your-api-key")
+
+# Compress text
+response = client.compress_input(
+    input="Your long text here that needs compression...",
+    aggressiveness=0.5
+)
+
+print(f"Compressed text: {response.output}")
+print(f"Original tokens: {response.original_input_tokens}")
+print(f"Compressed tokens: {response.output_tokens}")
+print(f"Tokens saved: {response.tokens_saved}")
+print(f"Compression ratio: {response.compression_ratio:.2f}x")
+```
+
+## Features
+
+- 🚀 Simple and intuitive API
+- 🎯 Type-safe with dataclasses
+- 🔧 Flexible compression settings
+- 📊 Built-in compression metrics
+- ⚡ Context manager support
+- 🛡️ Comprehensive error handling
+
+## Usage Examples
+
+### Basic Compression
+
+```python
+from tokenc import TokenClient
+
+client = TokenClient(api_key="your-api-key")
+
+response = client.compress_input(
+    input="This is a long text that contains lots of unnecessary filler words and redundant information that can be compressed.",
+    aggressiveness=0.5
+)
+
+print(response.output)
+```
+
+### Advanced Compression with Settings
+
+```python
+from tokenc import TokenClient, CompressionSettings
+
+client = TokenClient(api_key="your-api-key")
+
+# Create custom compression settings
+settings = CompressionSettings(
+    aggressiveness=0.7,
+    max_output_tokens=100,
+    min_output_tokens=50
+)
+
+response = client.compress_input(
+    input="Your text here...",
+    compression_settings=settings
+)
+
+print(f"Compression percentage: {response.compression_percentage:.1f}%")
+```
+
+### Using as Context Manager
+
+```python
+from tokenc import TokenClient
+
+with TokenClient(api_key="your-api-key") as client:
+    response = client.compress_input(
+        input="Your text here...",
+        aggressiveness=0.6
+    )
+    print(response.output)
+# Session automatically closed
+```
+
+### Different Compression Levels
+
+```python
+from tokenc import TokenClient
+
+client = TokenClient(api_key="your-api-key")
+
+text = "Your long text here..."
+
+# Light compression - preserve most content
+light = client.compress_input(input=text, aggressiveness=0.2)
+
+# Moderate compression - balanced approach
+moderate = client.compress_input(input=text, aggressiveness=0.5)
+
+# Aggressive compression - maximum savings
+aggressive = client.compress_input(input=text, aggressiveness=0.8)
+```
+
+## Compression Aggressiveness Levels
+
+- **0.1-0.3**: Light compression - Removes obvious filler words
+- **0.4-0.6**: Moderate compression - Balanced approach (recommended)
+- **0.7-0.9**: Aggressive compression - Maximum cost savings
+
+## API Reference
+
+### TokenClient
+
+#### `__init__(api_key: str, base_url: str = ..., timeout: int = 30)`
+
+Initialize the Token Company API client.
+
+**Parameters:**
+- `api_key` (str): Your API key for authentication
+- `base_url` (str, optional): Base URL for the API
+- `timeout` (int, optional): Request timeout in seconds
+
+#### `compress_input(...) -> CompressResponse`
+
+Compress text input for optimized LLM inference.
+
+**Parameters:**
+- `input` (str): The text to compress
+- `model` (str, optional): Model to use (default: "bear-1")
+- `aggressiveness` (float, optional): Compression intensity 0.0-1.0 (default: 0.5)
+- `max_output_tokens` (int, optional): Maximum token count for output
+- `min_output_tokens` (int, optional): Minimum token count for output
+- `compression_settings` (CompressionSettings, optional): Custom settings object
+
+**Returns:**
+- `CompressResponse`: Object containing compressed output and metadata
+
+**Raises:**
+- `AuthenticationError`: Invalid API key
+- `InvalidRequestError`: Invalid request parameters
+- `RateLimitError`: Rate limit exceeded
+- `APIError`: Other API errors
+
+### CompressionSettings
+
+Dataclass for compression configuration.
+
+**Attributes:**
+- `aggressiveness` (float): Compression intensity 0.0-1.0
+- `max_output_tokens` (int | None): Optional maximum output tokens
+- `min_output_tokens` (int | None): Optional minimum output tokens
+
+### CompressResponse
+
+Dataclass for compression results.
+
+**Attributes:**
+- `output` (str): The compressed text
+- `output_tokens` (int): Token count of compressed output
+- `original_input_tokens` (int): Token count of original input
+- `compression_time` (float): Processing duration in seconds
+
+**Properties:**
+- `tokens_saved` (int): Number of tokens saved
+- `compression_ratio` (float): Ratio of original to compressed tokens
+- `compression_percentage` (float): Percentage reduction in tokens
+
+## Error Handling
+
+```python
+from tokenc import TokenClient, AuthenticationError, InvalidRequestError, RateLimitError, APIError
+
+client = TokenClient(api_key="your-api-key")
+
+try:
+    response = client.compress_input(input="Your text...")
+except AuthenticationError:
+    print("Invalid API key")
+except InvalidRequestError as e:
+    print(f"Invalid request: {e}")
+except RateLimitError:
+    print("Rate limit exceeded, please wait")
+except APIError as e:
+    print(f"API error: {e}")
+```
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/tokenc.git
+cd tokenc
+
+# Install in development mode
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+### Code Formatting
+
+```bash
+black tokenc/
+```
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Support
+
+For issues and questions:
+- GitHub Issues: https://github.com/yourusername/tokenc/issues
+- Documentation: https://thetokencompany.com/docs
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

tokenc-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=45", "wheel", "setuptools_scm[toml]>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tokenc"
+version = "0.1.0"
+description = "Python SDK for The Token Company API - Compress LLM inputs to reduce costs"
+readme = "README.md"
+authors = [
+    {name = "The Token Company", email = "support@thetokencompany.com"}
+]
+license = {text = "MIT"}
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+keywords = ["llm", "compression", "tokens", "ai", "api", "cost-optimization"]
+requires-python = ">=3.7"
+dependencies = [
+    "requests>=2.25.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=3.0.0",
+    "black>=22.0.0",
+    "mypy>=0.950",
+    "flake8>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://thetokencompany.com"
+Documentation = "https://thetokencompany.com/docs"
+Repository = "https://github.com/yourusername/tokenc"
+"Bug Tracker" = "https://github.com/yourusername/tokenc/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["tokenc*"]
+exclude = ["tests*", "examples*"]

tokenc-0.1.0/requirements.txt

@@ -0,0 +1 @@
+requests>=2.25.0

tokenc-0.1.0/setup.cfg

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

tokenc-0.1.0/setup.py

@@ -0,0 +1,44 @@
+"""
+Setup configuration for tokenc package
+"""
+
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="tokenc",
+    version="0.1.0",
+    author="The Token Company",
+    description="Python SDK for The Token Company API - Compress LLM inputs to reduce costs",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/tokenc",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "requests>=2.25.0",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=7.0.0",
+            "pytest-cov>=3.0.0",
+            "black>=22.0.0",
+            "mypy>=0.950",
+            "flake8>=4.0.0",
+        ],
+    },
+)

tokenc-0.1.0/tokenc/__init__.py

@@ -0,0 +1,36 @@
+"""
+tokenc - Python SDK for The Token Company API
+
+A Python client library for compressing LLM inputs to reduce token usage,
+lower costs, and speed up AI applications.
+"""
+
+from tokenc.client import TokenClient
+from tokenc.types import (
+    CompressionSettings,
+    CompressRequest,
+    CompressResponse,
+)
+from tokenc.errors import (
+    TokenCError,
+    AuthenticationError,
+    InvalidRequestError,
+    APIError,
+    RateLimitError,
+)
+from tokenc.constants import Model
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "TokenClient",
+    "CompressionSettings",
+    "CompressRequest",
+    "CompressResponse",
+    "TokenCError",
+    "AuthenticationError",
+    "InvalidRequestError",
+    "APIError",
+    "RateLimitError",
+    "Model",
+]

tokenc-0.1.0/tokenc/client.py

@@ -0,0 +1,161 @@
+"""
+Token Company API Client
+"""
+
+from typing import Optional
+import requests
+
+from tokenc.constants import API_BASE_URL, DEFAULT_TIMEOUT, Model
+from tokenc.types import CompressionSettings, CompressResponse
+from tokenc.errors import (
+    AuthenticationError,
+    InvalidRequestError,
+    APIError,
+    RateLimitError,
+)
+
+
+class TokenClient:
+    """
+    Client for interacting with The Token Company API.
+
+    Example:
+        >>> from tokenc import TokenClient
+        >>> client = TokenClient(api_key="your-api-key")
+        >>> response = client.compress_input(
+        ...     input="Your long text here...",
+        ...     aggressiveness=0.5
+        ... )
+        >>> print(response.output)
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = API_BASE_URL,
+        timeout: int = DEFAULT_TIMEOUT,
+    ):
+        """
+        Initialize the Token Company API client.
+
+        Args:
+            api_key: Your API key for authentication
+            base_url: Base URL for the API (default: https://api.thetokencompany.com)
+            timeout: Request timeout in seconds (default: 30)
+        """
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self._session = self._create_session()
+
+    def _create_session(self) -> requests.Session:
+        """Create a requests session with default headers."""
+        session = requests.Session()
+        session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        })
+        return session
+
+    def _handle_error(self, response: requests.Response) -> None:
+        """Handle API error responses."""
+        if response.status_code == 401:
+            raise AuthenticationError("Invalid API key")
+        elif response.status_code == 400:
+            error_msg = response.json().get("error", "Invalid request")
+            raise InvalidRequestError(error_msg)
+        elif response.status_code == 429:
+            raise RateLimitError("Rate limit exceeded")
+        elif response.status_code >= 500:
+            raise APIError(f"Server error: {response.status_code}")
+        else:
+            raise APIError(f"API error: {response.status_code}")
+
+    def compress_input(
+        self,
+        input: str,
+        model: str = Model.BEAR_1,
+        aggressiveness: float = 0.5,
+        max_output_tokens: Optional[int] = None,
+        min_output_tokens: Optional[int] = None,
+        compression_settings: Optional[CompressionSettings] = None,
+    ) -> CompressResponse:
+        """
+        Compress text input for optimized LLM inference.
+
+        Args:
+            input: The text to compress
+            model: Model to use for compression (default: "bear-1")
+            aggressiveness: Compression intensity from 0.0 to 1.0 (default: 0.5)
+                - 0.1-0.3: Light compression (obvious filler removal)
+                - 0.4-0.6: Moderate compression (balanced approach)
+                - 0.7-0.9: Aggressive compression (maximum cost savings)
+            max_output_tokens: Optional maximum token count for output
+            min_output_tokens: Optional minimum token count for output
+            compression_settings: Optional CompressionSettings object. If provided,
+                individual parameters (aggressiveness, max_output_tokens,
+                min_output_tokens) are ignored.
+
+        Returns:
+            CompressResponse containing the compressed output and metadata
+
+        Raises:
+            AuthenticationError: If API key is invalid
+            InvalidRequestError: If request parameters are invalid
+            RateLimitError: If rate limit is exceeded
+            APIError: For other API errors
+
+        Example:
+            >>> response = client.compress_input(
+            ...     input="This is a very long text that needs compression...",
+            ...     aggressiveness=0.7,
+            ...     max_output_tokens=100
+            ... )
+            >>> print(f"Compressed: {response.output}")
+            >>> print(f"Saved {response.original_input_tokens - response.output_tokens} tokens")
+        """
+        # Build compression settings
+        if compression_settings is None:
+            compression_settings = CompressionSettings(
+                aggressiveness=aggressiveness,
+                max_output_tokens=max_output_tokens,
+                min_output_tokens=min_output_tokens,
+            )
+
+        # Build request payload
+        payload = {
+            "model": model,
+            "input": input,
+            "compression_settings": compression_settings.to_dict(),
+        }
+
+        # Make API request
+        try:
+            response = self._session.post(
+                f"{self.base_url}/v1/compress",
+                json=payload,
+                timeout=self.timeout,
+            )
+
+            if not response.ok:
+                self._handle_error(response)
+
+            data = response.json()
+            return CompressResponse.from_dict(data)
+
+        except requests.exceptions.Timeout:
+            raise APIError("Request timeout")
+        except requests.exceptions.RequestException as e:
+            raise APIError(f"Request failed: {str(e)}")
+
+    def close(self) -> None:
+        """Close the HTTP session."""
+        self._session.close()
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.close()

tokenc-0.1.0/tokenc/constants.py

@@ -0,0 +1,12 @@
+"""
+Constants for The Token Company API
+"""
+
+
+class Model:
+    """Available compression models."""
+    BEAR_1 = "bear-1"
+
+
+API_BASE_URL = "https://api.thetokencompany.com"
+DEFAULT_TIMEOUT = 30

tokenc-0.1.0/tokenc/errors.py

@@ -0,0 +1,28 @@
+"""
+Custom exceptions for The Token Company API
+"""
+
+
+class TokenCError(Exception):
+    """Base exception for all Token Company API errors."""
+    pass
+
+
+class AuthenticationError(TokenCError):
+    """Raised when API authentication fails."""
+    pass
+
+
+class InvalidRequestError(TokenCError):
+    """Raised when the request parameters are invalid."""
+    pass
+
+
+class APIError(TokenCError):
+    """Raised when the API returns an error."""
+    pass
+
+
+class RateLimitError(TokenCError):
+    """Raised when the API rate limit is exceeded."""
+    pass

tokenc-0.1.0/tokenc/types.py

@@ -0,0 +1,116 @@
+"""
+Type definitions for The Token Company API
+"""
+
+from typing import Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class CompressionSettings:
+    """
+    Settings for text compression.
+
+    Attributes:
+        aggressiveness: Compression intensity from 0.0 to 1.0 (default: 0.5)
+        max_output_tokens: Optional maximum token count for output
+        min_output_tokens: Optional minimum token count for output
+    """
+    aggressiveness: float = 0.5
+    max_output_tokens: Optional[int] = None
+    min_output_tokens: Optional[int] = None
+
+    def __post_init__(self):
+        """Validate compression settings."""
+        if not 0.0 <= self.aggressiveness <= 1.0:
+            raise ValueError("aggressiveness must be between 0.0 and 1.0")
+
+        if self.max_output_tokens is not None and self.max_output_tokens < 1:
+            raise ValueError("max_output_tokens must be positive")
+
+        if self.min_output_tokens is not None and self.min_output_tokens < 1:
+            raise ValueError("min_output_tokens must be positive")
+
+        if (
+            self.max_output_tokens is not None
+            and self.min_output_tokens is not None
+            and self.min_output_tokens > self.max_output_tokens
+        ):
+            raise ValueError("min_output_tokens cannot exceed max_output_tokens")
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary format for API requests."""
+        return {
+            "aggressiveness": self.aggressiveness,
+            "max_output_tokens": self.max_output_tokens,
+            "min_output_tokens": self.min_output_tokens,
+        }
+
+
+@dataclass
+class CompressRequest:
+    """
+    Request for text compression.
+
+    Attributes:
+        model: Model to use for compression
+        input: The text to compress
+        compression_settings: Settings for compression
+    """
+    model: str
+    input: str
+    compression_settings: CompressionSettings
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary format for API requests."""
+        return {
+            "model": self.model,
+            "input": self.input,
+            "compression_settings": self.compression_settings.to_dict(),
+        }
+
+
+@dataclass
+class CompressResponse:
+    """
+    Response from text compression.
+
+    Attributes:
+        output: The compressed text
+        output_tokens: Token count of the compressed output
+        original_input_tokens: Token count of the original input
+        compression_time: Processing duration in seconds
+    """
+    output: str
+    output_tokens: int
+    original_input_tokens: int
+    compression_time: float
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "CompressResponse":
+        """Create from API response dictionary."""
+        return cls(
+            output=data["output"],
+            output_tokens=data["output_tokens"],
+            original_input_tokens=data["original_input_tokens"],
+            compression_time=data["compression_time"],
+        )
+
+    @property
+    def tokens_saved(self) -> int:
+        """Calculate the number of tokens saved by compression."""
+        return self.original_input_tokens - self.output_tokens
+
+    @property
+    def compression_ratio(self) -> float:
+        """Calculate the compression ratio (original/compressed)."""
+        if self.output_tokens == 0:
+            return 0.0
+        return self.original_input_tokens / self.output_tokens
+
+    @property
+    def compression_percentage(self) -> float:
+        """Calculate the percentage reduction in tokens."""
+        if self.original_input_tokens == 0:
+            return 0.0
+        return (self.tokens_saved / self.original_input_tokens) * 100

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

@@ -0,0 +1,272 @@
+Metadata-Version: 2.4
+Name: tokenc
+Version: 0.1.0
+Summary: Python SDK for The Token Company API - Compress LLM inputs to reduce costs
+Home-page: https://github.com/yourusername/tokenc
+Author: The Token Company
+Author-email: The Token Company <support@thetokencompany.com>
+License: MIT
+Project-URL: Homepage, https://thetokencompany.com
+Project-URL: Documentation, https://thetokencompany.com/docs
+Project-URL: Repository, https://github.com/yourusername/tokenc
+Project-URL: Bug Tracker, https://github.com/yourusername/tokenc/issues
+Keywords: llm,compression,tokens,ai,api,cost-optimization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: mypy>=0.950; extra == "dev"
+Requires-Dist: flake8>=4.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# tokenc - Python SDK for The Token Company
+
+A Python client library for compressing LLM inputs to reduce token usage, lower costs, and speed up AI applications.
+
+## Installation
+
+```bash
+pip install tokenc
+```
+
+## Quick Start
+
+```python
+from tokenc import TokenClient
+
+# Initialize the client
+client = TokenClient(api_key="your-api-key")
+
+# Compress text
+response = client.compress_input(
+    input="Your long text here that needs compression...",
+    aggressiveness=0.5
+)
+
+print(f"Compressed text: {response.output}")
+print(f"Original tokens: {response.original_input_tokens}")
+print(f"Compressed tokens: {response.output_tokens}")
+print(f"Tokens saved: {response.tokens_saved}")
+print(f"Compression ratio: {response.compression_ratio:.2f}x")
+```
+
+## Features
+
+- 🚀 Simple and intuitive API
+- 🎯 Type-safe with dataclasses
+- 🔧 Flexible compression settings
+- 📊 Built-in compression metrics
+- ⚡ Context manager support
+- 🛡️ Comprehensive error handling
+
+## Usage Examples
+
+### Basic Compression
+
+```python
+from tokenc import TokenClient
+
+client = TokenClient(api_key="your-api-key")
+
+response = client.compress_input(
+    input="This is a long text that contains lots of unnecessary filler words and redundant information that can be compressed.",
+    aggressiveness=0.5
+)
+
+print(response.output)
+```
+
+### Advanced Compression with Settings
+
+```python
+from tokenc import TokenClient, CompressionSettings
+
+client = TokenClient(api_key="your-api-key")
+
+# Create custom compression settings
+settings = CompressionSettings(
+    aggressiveness=0.7,
+    max_output_tokens=100,
+    min_output_tokens=50
+)
+
+response = client.compress_input(
+    input="Your text here...",
+    compression_settings=settings
+)
+
+print(f"Compression percentage: {response.compression_percentage:.1f}%")
+```
+
+### Using as Context Manager
+
+```python
+from tokenc import TokenClient
+
+with TokenClient(api_key="your-api-key") as client:
+    response = client.compress_input(
+        input="Your text here...",
+        aggressiveness=0.6
+    )
+    print(response.output)
+# Session automatically closed
+```
+
+### Different Compression Levels
+
+```python
+from tokenc import TokenClient
+
+client = TokenClient(api_key="your-api-key")
+
+text = "Your long text here..."
+
+# Light compression - preserve most content
+light = client.compress_input(input=text, aggressiveness=0.2)
+
+# Moderate compression - balanced approach
+moderate = client.compress_input(input=text, aggressiveness=0.5)
+
+# Aggressive compression - maximum savings
+aggressive = client.compress_input(input=text, aggressiveness=0.8)
+```
+
+## Compression Aggressiveness Levels
+
+- **0.1-0.3**: Light compression - Removes obvious filler words
+- **0.4-0.6**: Moderate compression - Balanced approach (recommended)
+- **0.7-0.9**: Aggressive compression - Maximum cost savings
+
+## API Reference
+
+### TokenClient
+
+#### `__init__(api_key: str, base_url: str = ..., timeout: int = 30)`
+
+Initialize the Token Company API client.
+
+**Parameters:**
+- `api_key` (str): Your API key for authentication
+- `base_url` (str, optional): Base URL for the API
+- `timeout` (int, optional): Request timeout in seconds
+
+#### `compress_input(...) -> CompressResponse`
+
+Compress text input for optimized LLM inference.
+
+**Parameters:**
+- `input` (str): The text to compress
+- `model` (str, optional): Model to use (default: "bear-1")
+- `aggressiveness` (float, optional): Compression intensity 0.0-1.0 (default: 0.5)
+- `max_output_tokens` (int, optional): Maximum token count for output
+- `min_output_tokens` (int, optional): Minimum token count for output
+- `compression_settings` (CompressionSettings, optional): Custom settings object
+
+**Returns:**
+- `CompressResponse`: Object containing compressed output and metadata
+
+**Raises:**
+- `AuthenticationError`: Invalid API key
+- `InvalidRequestError`: Invalid request parameters
+- `RateLimitError`: Rate limit exceeded
+- `APIError`: Other API errors
+
+### CompressionSettings
+
+Dataclass for compression configuration.
+
+**Attributes:**
+- `aggressiveness` (float): Compression intensity 0.0-1.0
+- `max_output_tokens` (int | None): Optional maximum output tokens
+- `min_output_tokens` (int | None): Optional minimum output tokens
+
+### CompressResponse
+
+Dataclass for compression results.
+
+**Attributes:**
+- `output` (str): The compressed text
+- `output_tokens` (int): Token count of compressed output
+- `original_input_tokens` (int): Token count of original input
+- `compression_time` (float): Processing duration in seconds
+
+**Properties:**
+- `tokens_saved` (int): Number of tokens saved
+- `compression_ratio` (float): Ratio of original to compressed tokens
+- `compression_percentage` (float): Percentage reduction in tokens
+
+## Error Handling
+
+```python
+from tokenc import TokenClient, AuthenticationError, InvalidRequestError, RateLimitError, APIError
+
+client = TokenClient(api_key="your-api-key")
+
+try:
+    response = client.compress_input(input="Your text...")
+except AuthenticationError:
+    print("Invalid API key")
+except InvalidRequestError as e:
+    print(f"Invalid request: {e}")
+except RateLimitError:
+    print("Rate limit exceeded, please wait")
+except APIError as e:
+    print(f"API error: {e}")
+```
+
+## Development
+
+### Setup Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/tokenc.git
+cd tokenc
+
+# Install in development mode
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+### Code Formatting
+
+```bash
+black tokenc/
+```
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Support
+
+For issues and questions:
+- GitHub Issues: https://github.com/yourusername/tokenc/issues
+- Documentation: https://thetokencompany.com/docs
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

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

@@ -0,0 +1,16 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+tokenc/__init__.py
+tokenc/client.py
+tokenc/constants.py
+tokenc/errors.py
+tokenc/types.py
+tokenc.egg-info/PKG-INFO
+tokenc.egg-info/SOURCES.txt
+tokenc.egg-info/dependency_links.txt
+tokenc.egg-info/requires.txt
+tokenc.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,8 @@
+requests>=2.25.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=3.0.0
+black>=22.0.0
+mypy>=0.950
+flake8>=4.0.0

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

@@ -0,0 +1 @@
+tokenc