osmosis-ai 0.1.8__py3-none-any.whl → 0.2.0__py3-none-any.whl

osmosis_ai/__init__.py

@@ -1,137 +1,15 @@
 """
-osmosis-ai: A library for monkey patching LLM APIs to print all prompts and responses.
+osmosis-ai: A Python library for reward function validation with strict type enforcement.
 
-This module patches various LLM client libraries to send all prompts and responses
-to the OSMOSIS API for logging and monitoring.
+This library provides the @osmosis_reward decorator that enforces standardized
+function signatures for reward functions used in LLM applications.
 
-Currently supported adapters:
-- Anthropic (both sync and async clients)
-- OpenAI (both sync and async clients, v1 and v2 API versions)
-- LangChain (LLMs, Chat Models, and Prompt Templates)
+Features:
+- Type-safe reward function decoration
+- Parameter name and type validation
+- Support for optional configuration parameters
 """
 
+from .utils import osmosis_reward
 
-# Use lazy imports to avoid importing modules during setup
-def _import_modules():
-    global utils, logger, reconfigure_logger
-    global set_log_destination, log_destination, LogDestination
-    global init, enabled, disable_osmosis, enable_osmosis, osmosis_reward
-
-    from . import utils
-    from .logger import logger, reconfigure_logger, set_log_destination, log_destination
-    from .consts import LogDestination
-
-    # Re-export configuration flags for easy access
-    enabled = utils.enabled
-
-    # Export disable and enable functions
-    disable_osmosis = utils.disable_osmosis
-    enable_osmosis = utils.enable_osmosis
-
-    # Re-export initialization function
-    init = utils.init
-    
-    # Export the reward decorator
-    osmosis_reward = utils.osmosis_reward
-
-    # Initialize wrappers as None
-    global wrap_anthropic, wrap_openai, wrap_langchain
-    global wrap_langchain_openai, wrap_langchain_anthropic
-
-    wrap_anthropic = None
-    wrap_openai = None
-    wrap_langchain = None
-    wrap_langchain_openai = None
-    wrap_langchain_anthropic = None
-
-    # Lazily set up anthropic wrapper if available
-    try:
-        from .adapters import anthropic
-
-        wrap_anthropic = anthropic.wrap_anthropic
-        # Apply the wrapper, but don't fail if it doesn't work
-        try:
-            wrap_anthropic()
-        except Exception as e:
-            logger.warning(f"Failed to wrap Anthropic: {str(e)}")
-    except ImportError:
-
-        def wrap_anthropic():
-            logger.warning(
-                "Anthropic support not available. Install Anthropic to use this feature."
-            )
-
-    # Lazily set up OpenAI wrapper if available
-    try:
-        from .adapters import openai
-
-        wrap_openai = openai.wrap_openai
-        # Apply the wrapper, but don't fail if it doesn't work
-        try:
-            wrap_openai()
-        except Exception as e:
-            logger.warning(f"Failed to wrap OpenAI: {str(e)}")
-    except ImportError:
-
-        def wrap_openai():
-            logger.warning(
-                "OpenAI support not available. Install OpenAI to use this feature."
-            )
-
-    # Lazily set up LangChain wrapper if available
-    try:
-        from .adapters import langchain
-
-        wrap_langchain = langchain.wrap_langchain
-        # Apply the wrapper, but don't fail if it doesn't work
-        try:
-            wrap_langchain()
-        except Exception as e:
-            logger.warning(f"Failed to wrap LangChain: {str(e)}")
-    except ImportError:
-
-        def wrap_langchain():
-            logger.warning(
-                "LangChain support not available. Install LangChain to use this feature."
-            )
-
-    # Lazily set up LangChain-OpenAI wrapper if available
-    try:
-        from .adapters import langchain_openai
-
-        wrap_langchain_openai = langchain_openai.wrap_langchain_openai
-        # Apply the wrapper, but don't fail if it doesn't work
-        try:
-            wrap_langchain_openai()
-        except Exception as e:
-            logger.warning(f"Failed to wrap LangChain-OpenAI: {str(e)}")
-    except ImportError:
-
-        def wrap_langchain_openai():
-            logger.warning(
-                "LangChain-OpenAI support not available. Install LangChain and OpenAI to use this feature."
-            )
-
-    # Lazily set up LangChain-Anthropic wrapper if available
-    try:
-        from .adapters import langchain_anthropic
-
-        wrap_langchain_anthropic = langchain_anthropic.wrap_langchain_anthropic
-        # Apply the wrapper, but don't fail if it doesn't work
-        try:
-            wrap_langchain_anthropic()
-        except Exception as e:
-            logger.warning(f"Failed to wrap LangChain-Anthropic: {str(e)}")
-    except ImportError:
-
-        def wrap_langchain_anthropic():
-            logger.warning(
-                "LangChain-Anthropic support not available. Install LangChain and Anthropic to use this feature."
-            )
-
-
-# Initialize the module on first import, but not during installation
-import sys
-
-if "pip" not in sys.modules:
-    _import_modules()
+__all__ = ["osmosis_reward"]

osmosis_ai/consts.py

@@ -1,17 +1,3 @@
-from enum import Enum
-
-# Extract package metadata
+# package metadata
 package_name = "osmosis-ai"
-package_version = "0.1.8"
-
-indent = 2  # Number of spaces to use for indentation in pretty print
-osmosis_api_url = "https://osmosis.gulp.dev"
-
-DEFAULT_LOG_DESTINATION = "none"  # "none" or "stdout" or "stderr" or "file"
-
-
-class LogDestination(Enum):
-    NONE = "none"
-    STDOUT = "stdout"
-    STDERR = "stderr"
-    FILE = "file"
+package_version = "0.2.0"

osmosis_ai/utils.py

@@ -1,120 +1,62 @@
-"""
-Utility functions for osmosisadapters
-"""
 
-import json
-from datetime import datetime, timezone
-from typing import Any, Dict, Callable
-import xxhash
 import functools
-
-# Import constants
-from .consts import osmosis_api_url
-
-# Import logger
-from .logger import logger
-
-# Global configuration
-enabled = True
-osmosis_api_key = None  # Will be set by init()
-_initialized = False
-
-
-def init(api_key: str) -> None:
-    """
-    Initialize osmosiswith the OSMOSIS API key.
-
-    Args:
-        api_key: The OSMOSIS API key for logging LLM usage
-    """
-    global osmosis_api_key, _initialized
-    osmosis_api_key = api_key
-    _initialized = True
-
-
-def disable_osmosis() -> None:
-    global enabled
-    enabled = False
-
-
-def enable_osmosis() -> None:
-    global enabled
-    enabled = True
-
-
-def send_to_osmosis(
-    query: Dict[str, Any], response: Dict[str, Any], status: int = 200
-) -> None:
-    """
-    Send query and response data to the OSMOSIS API using AWS Firehose.
-
-    Args:
-        query: The query/request data
-        response: The response data
-        status: The HTTP status code (default: 200)
-    """
-    if not enabled or not osmosis_api_key:
-        return
-
-    if not _initialized:
-        logger.warning("osmosisnot initialized. Call osmosis_ai.init(api_key) first.")
-        return
-
-    try:
-        # Import requests only when needed
-        import requests
-
-        # Create headers
-        headers = {"Content-Type": "application/json", "x-api-key": osmosis_api_key}
-
-        # Prepare main data payload
-        data = {
-            "owner": xxhash.xxh32(osmosis_api_key.encode("utf-8")).hexdigest(),
-            "date": int(datetime.now(timezone.utc).timestamp()),
-            "query": query,
-            "response": response,
-            "status": status,
-        }
-
-        logger.info(f"Sending data to OSMOSIS API: {data}")
-
-        # Send main data payload
-        response_data = requests.post(
-            f"{osmosis_api_url}/ingest",
-            headers=headers,
-            data=json.dumps(data).replace("\n", "") + "\n",
-        )
-
-        if response_data.status_code != 200:
-            logger.warning(
-                f"OSMOSIS API returned status {response_data.status_code} for data with error: {response_data.text}"
-            )
-
-    except ImportError:
-        logger.warning(
-            "Requests library not installed. Please install it with 'pip install requests'."
-        )
-    except Exception as e:
-        logger.warning(f"Failed to send data to OSMOSIS API: {str(e)}")
+import inspect
+from typing import Callable
 
 
 def osmosis_reward(func: Callable) -> Callable:
     """
-    Decorator for reward functions.
-    
+    Decorator for reward functions that enforces the signature:
+    (solution_str: str, ground_truth: str, extra_info: dict = None) -> float
+
     Args:
         func: The reward function to be wrapped
-        
+
     Returns:
         The wrapped function
-        
+
+    Raises:
+        TypeError: If the function doesn't have the required signature or doesn't return a float
+
     Example:
         @osmosis_reward
-        def calculate_reward(state, action):
-            return state.score + action.value
+        def calculate_reward(solution_str: str, ground_truth: str, extra_info: dict = None) -> float:
+            return some_calculation(solution_str, ground_truth)
     """
+    # Validate function signature
+    sig = inspect.signature(func)
+    params = list(sig.parameters.values())
+
+    # Check parameter count
+    if len(params) < 2 or len(params) > 3:
+        raise TypeError(f"Function {func.__name__} must have 2-3 parameters, got {len(params)}")
+
+    # Check first parameter: solution_str: str
+    if params[0].name != 'solution_str':
+        raise TypeError(f"First parameter must be named 'solution_str', got '{params[0].name}'")
+    if params[0].annotation != str:
+        raise TypeError(f"First parameter 'solution_str' must be annotated as str, got {params[0].annotation}")
+
+    # Check second parameter: ground_truth: str
+    if params[1].name != 'ground_truth':
+        raise TypeError(f"Second parameter must be named 'ground_truth', got '{params[1].name}'")
+    if params[1].annotation != str:
+        raise TypeError(f"Second parameter 'ground_truth' must be annotated as str, got {params[1].annotation}")
+
+    # Check third parameter if present: extra_info: dict = None
+    if len(params) == 3:
+        if params[2].name != 'extra_info':
+            raise TypeError(f"Third parameter must be named 'extra_info', got '{params[2].name}'")
+        if params[2].annotation != dict:
+            raise TypeError(f"Third parameter 'extra_info' must be annotated as dict, got {params[2].annotation}")
+        if params[2].default is inspect.Parameter.empty:
+            raise TypeError("Third parameter 'extra_info' must have a default value of None")
+
     @functools.wraps(func)
     def wrapper(*args, **kwargs):
-        return func(*args, **kwargs)
-    
+        result = func(*args, **kwargs)
+        if not isinstance(result, float):
+            raise TypeError(f"Function {func.__name__} must return a float, got {type(result).__name__}")
+        return result
+
     return wrapper

osmosis_ai-0.2.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: osmosis-ai
+Version: 0.2.0
+Summary: Adds reward functionality to LLM client libraries
+Author-email: Osmosis AI <jake@osmosis.ai>
+License: MIT License
+        
+        Copyright (c) 2025 Gulp AI
+        
+        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. 
+Project-URL: Homepage, https://github.com/Osmosis-AI/osmosis-sdk-python
+Project-URL: Issues, https://github.com/Osmosis-AI/osmosis-sdk-python/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# osmosis-ai
+
+A Python library that provides reward functionality for LLM applications with strict type enforcement.
+
+## Installation
+
+```bash
+pip install osmosis-ai
+```
+
+For development:
+```bash
+git clone https://github.com/Osmosis-AI/osmosis-sdk-python
+cd osmosis-sdk-python
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from osmosis_ai import osmosis_reward
+
+@osmosis_reward
+def simple_reward(solution_str: str, ground_truth: str, extra_info: dict = None) -> float:
+    """Basic exact match reward function."""
+    return 1.0 if solution_str.strip() == ground_truth.strip() else 0.0
+
+# Use the reward function
+score = simple_reward("hello world", "hello world")  # Returns 1.0
+```
+
+## Required Function Signature
+
+All functions decorated with `@osmosis_reward` must have exactly this signature:
+
+```python
+@osmosis_reward
+def your_function(solution_str: str, ground_truth: str, extra_info: dict = None) -> float:
+    # Your reward logic here
+    return float_score
+```
+
+### Parameters
+
+- **`solution_str: str`** - The solution string to evaluate (required)
+- **`ground_truth: str`** - The correct/expected answer (required)
+- **`extra_info: dict = None`** - Optional dictionary for additional configuration
+
+### Return Value
+
+- **`-> float`** - Must return a float value representing the reward score
+
+The decorator will raise a `TypeError` if the function doesn't match this exact signature or doesn't return a float.
+
+## Examples
+
+See the [`examples/`](examples/) directory for complete examples:
+
+```python
+@osmosis_reward
+def case_insensitive_match(solution_str: str, ground_truth: str, extra_info: dict = None) -> float:
+    """Case-insensitive string matching with partial credit."""
+    match = solution_str.lower().strip() == ground_truth.lower().strip()
+
+    if extra_info and 'partial_credit' in extra_info:
+        if not match and extra_info['partial_credit']:
+            len_diff = abs(len(solution_str) - len(ground_truth))
+            if len_diff <= 2:
+                return 0.5
+
+    return 1.0 if match else 0.0
+
+@osmosis_reward
+def numeric_tolerance(solution_str: str, ground_truth: str, extra_info: dict = None) -> float:
+    """Numeric comparison with configurable tolerance."""
+    try:
+        solution_num = float(solution_str.strip())
+        truth_num = float(ground_truth.strip())
+
+        tolerance = extra_info.get('tolerance', 0.01) if extra_info else 0.01
+        return 1.0 if abs(solution_num - truth_num) <= tolerance else 0.0
+    except ValueError:
+        return 0.0
+```
+
+## Running Examples
+
+```bash
+python examples/reward_functions.py
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Run tests and examples
+5. Submit a pull request
+
+## Links
+
+- [Homepage](https://github.com/Osmosis-AI/osmosis-sdk-python)
+- [Issues](https://github.com/Osmosis-AI/osmosis-sdk-python/issues)

osmosis_ai-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+osmosis_ai/__init__.py,sha256=P1w65jE23XhFLW6BEOaiMat-EoANgKwSYBIQFPCS3Xc,445
+osmosis_ai/consts.py,sha256=Ojd7wWs0Xc7vJQqfjtxYNoWiaFbgk3ChHV5fPk3l6MI,72
+osmosis_ai/utils.py,sha256=y6b-qy3nl_xFvURaDWKHFzkCJCFyzI8L0Wc1dHHZBm4,2465
+osmosis_ai-0.2.0.dist-info/licenses/LICENSE,sha256=FV2ZmyhdCYinoLLvU_ci-7pZ3DeNYY9XqZjVjOd3h94,1064
+osmosis_ai-0.2.0.dist-info/METADATA,sha256=7MzdHQmlJjnN5Mf-KSTVExh99aoxJu-91mM_KB6lEhM,4725
+osmosis_ai-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+osmosis_ai-0.2.0.dist-info/top_level.txt,sha256=UPNRTKIBSrxsJVNxwXnLCqSoBS4bAiL_3jMtjvf5zEY,11
+osmosis_ai-0.2.0.dist-info/RECORD,,

{osmosis_ai-0.1.8.dist-info → osmosis_ai-0.2.0.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Gulp AI
+Copyright (c) 2025 Gulp AI
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

osmosis_ai/adapters/__init__.py

@@ -1,9 +0,0 @@
-"""
-Adapters package for Osmosis
-
-This package contains various adapters for different LLM providers.
-Each adapter is conditionally imported based on installed dependencies.
-"""
-
-# Don't include adapters in __all__ as they're imported conditionally
-__all__ = []