veris-ai 0.1.1__tar.gz → 0.2.0__tar.gz

veris_ai-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,43 @@
+name: Publish to PyPI
+
+on:
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.13'
+
+      - name: Install dependencies
+        run: |
+          curl -LsSf https://astral.sh/uv/install.sh | sh
+          uv sync
+          uv pip install python-semantic-release
+
+      - name: Configure Git
+        run: |
+          git config --global user.name "GitHub Actions"
+          git config --global user.email "actions@github.com"
+
+      - name: Version and Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          uv run semantic-release version
+          uv run semantic-release publish
+
+      - name: Push changes
+        run: |
+          git push
+          git push --tags

veris_ai-0.2.0/.github/workflows/test.yml

@@ -0,0 +1,44 @@
+name: Tests
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install uv
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+
+    - name: Install dependencies
+      run: |
+        uv venv
+        uv pip install -e .[dev]
+
+    - name: Run code quality checks with Ruff
+      run: |
+        uv run ruff check .
+        uv run ruff format --check .
+
+    - name: Run type checks with mypy
+      run: |
+        uv run mypy src/veris_ai tests
+
+    - name: Run tests with pytest
+      run: |
+        uv run pytest tests/ --cov=veris_ai --cov-report=xml --cov-report=term-missing

veris_ai-0.2.0/CHANGELOG.md

@@ -0,0 +1,33 @@
+# CHANGELOG
+
+
+## v0.2.0 (2025-04-18)
+
+### Chores
+
+- Update changelog for 0.1.1
+  ([`24d7139`](https://github.com/veris-ai/veris-python-sdk/commit/24d713943737abcea6394258e5129ae0a55cb869))
+
+- Update semantic release config
+  ([`6f745e0`](https://github.com/veris-ai/veris-python-sdk/commit/6f745e09263703cfe034ba688b96e4da50759889))
+
+### Continuous Integration
+
+- Add workflows for release ([#3](https://github.com/veris-ai/veris-python-sdk/pull/3),
+  [`3c160e7`](https://github.com/veris-ai/veris-python-sdk/commit/3c160e7e928ed1efb42825b767084df5d451edb5))
+
+- Fix publish ci workflow ([#4](https://github.com/veris-ai/veris-python-sdk/pull/4),
+  [`47f23e1`](https://github.com/veris-ai/veris-python-sdk/commit/47f23e19cd04b60ab0ae087b6d70b4748350393c))
+
+### Features
+
+- Remove dependencies and use linter ([#2](https://github.com/veris-ai/veris-python-sdk/pull/2),
+  [`4b8c43b`](https://github.com/veris-ai/veris-python-sdk/commit/4b8c43b551265ff9c994f53d29a7ef185b7e3286))
+
+
+## v0.1.1 (2025-04-17)
+
+### Features
+
+- Updates to package for publishing ([#1](https://github.com/veris-ai/veris-python-sdk/pull/1),
+  [`c6f460e`](https://github.com/veris-ai/veris-python-sdk/commit/c6f460ea6e2f8472c120370a14f67f1d8c28626c))

{veris_ai-0.1.1 → veris_ai-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: veris-ai
-Version: 0.1.1
+Version: 0.2.0
 Summary: A Python package for Veris AI tools
 Project-URL: Homepage, https://github.com/veris-ai/veris-python-sdk
 Project-URL: Bug Tracker, https://github.com/veris-ai/veris-python-sdk/issues
@@ -9,8 +9,6 @@ License-Expression: MIT
 License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.24.0
-Requires-Dist: python-dotenv>=1.0.0
-Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: dev
 Requires-Dist: black>=23.7.0; extra == 'dev'
 Requires-Dist: mypy>=1.5.1; extra == 'dev'

{veris_ai-0.1.1 → veris_ai-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "veris-ai"
-version = "0.1.1"
+version = "0.2.0"
 description = "A Python package for Veris AI tools"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -13,9 +13,7 @@ authors = [
     { name = "Mehdi Jamei", email = "mehdi@veris.ai" }
 ]
 dependencies = [
-    "typing-extensions>=4.0.0",
     "httpx>=0.24.0",
-    "python-dotenv>=1.0.0",
 ]
 
 [project.optional-dependencies]
@@ -97,4 +95,36 @@ known-first-party = ["veris_ai"]
 convention = "google"
 
 [tool.ruff.per-file-ignores]
-"tests/*" = ["S101", "D103", "ANN401"] 
+"tests/*" = [
+    "D",    # Ignore documentation requirements
+    "ANN",  # Ignore type annotation requirements
+    "S",    # Ignore security warnings
+    "ARG",  # Ignore unused arguments
+    "PLR",  # Ignore pylint refactor suggestions
+    "N",    # Ignore naming conventions
+    "T201", # Ignore print statements
+    "E",    # Ignore style errors
+    "F",    # Ignore pyflakes warnings
+    "B",    # Ignore bugbear warnings
+    "C4",   # Ignore comprehension warnings
+    "UP",   # Ignore upgrade suggestions
+    "SLF",  # Ignore self warnings
+    "ERA",  # Ignore eradicate warnings
+    "PD",   # Ignore pandas warnings
+    "PGH",  # Ignore pygrep-hooks
+    "PL",   # Ignore pylint warnings
+    "PT"    # Ignore pytest warnings
+]
+
+[tool.semantic_release]
+version_variables = ["pyproject.toml:version"]
+branch = "master"
+changelog_file = "CHANGELOG.md"
+build_command = "uv build"
+dist_path = "dist/"
+upload_to_repository = true
+repository_url = "https://upload.pypi.org/legacy/"
+commit_message = "chore: release v{version}"
+commit_parser = "angular"
+major_on_zero = false
+tag_format = "v{version}" 

{veris_ai-0.1.1 → veris_ai-0.2.0}/src/veris_ai/tool_mock.py

@@ -3,62 +3,81 @@ import json
 import logging
 import os
 from collections.abc import Callable
+from contextlib import suppress
 from functools import wraps
-from typing import Any, Union, get_type_hints
+from typing import Any, TypeVar, Union, get_args, get_origin, get_type_hints
 
 import httpx
 
 logger = logging.getLogger(__name__)
 
+T = TypeVar("T")  # Generic type for return value
+
+
 class ToolMock:
     """Class for mocking tool calls."""
-    def __init__(self):
-        self.endpoint = os.getenv("VERIS_MOCK_ENDPOINT_URL")
-        if not self.endpoint:
-            raise ValueError("VERIS_MOCK_ENDPOINT_URL environment variable is not set")
-        # Default timeout of 30 seconds
-        self.timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "30.0"))
 
-    def _convert_to_type(self, value: Any, target_type: type) -> Any: # type: ignore
+    def __init__(self) -> None:
+        """Initialize the ToolMock class."""
+
+    def _convert_to_type(self, value: object, target_type: type) -> object:
         """Convert a value to the specified type."""
-        if target_type == Any:
+        if target_type is Any:
             return value
-            
+
         # Handle basic types
         if target_type in (str, int, float, bool):
             return target_type(value)
-            
+
         # Handle List types
-        if hasattr(target_type, "__origin__") and target_type.__origin__ == list:
+        origin = get_origin(target_type)
+        if origin is list:
             if not isinstance(value, list):
-                raise ValueError(f"Expected list but got {type(value)}")
-            item_type = target_type.__args__[0]
+                error_msg = f"Expected list but got {type(value)}"
+                raise ValueError(error_msg)
+            item_type = get_args(target_type)[0]
             return [self._convert_to_type(item, item_type) for item in value]
-            
+
         # Handle Dict types
-        if hasattr(target_type, "__origin__") and target_type.__origin__ == dict:
+        if origin is dict:
             if not isinstance(value, dict):
-                raise ValueError(f"Expected dict but got {type(value)}")
-            key_type, value_type = target_type.__args__
-            return {self._convert_to_type(k, key_type): self._convert_to_type(v, value_type) 
-                   for k, v in value.items()}
-            
+                error_msg = f"Expected dict but got {type(value)}"
+                raise ValueError(error_msg)
+            key_type, value_type = get_args(target_type)
+            return {
+                self._convert_to_type(k, key_type): self._convert_to_type(v, value_type)
+                for k, v in value.items()
+            }
+
         # Handle Union types
-        if hasattr(target_type, "__origin__") and target_type.__origin__ == Union:
-            for possible_type in target_type.__args__:
+        if origin is Union:
+            error_msg = (
+                f"Could not convert {value} to any of the union types {get_args(target_type)}"
+            )
+            for possible_type in get_args(target_type):
                 try:
                     return self._convert_to_type(value, possible_type)
                 except (ValueError, TypeError):
                     continue
-            raise ValueError(f"Could not convert {value} to any of the union types {target_type.__args__}") # noqa
-            
+            raise ValueError(error_msg)
+
         # For other types, try direct conversion
         return target_type(value)
 
     def mock(self, func: Callable) -> Callable:
         """Decorator for mocking tool calls."""
+        endpoint = os.getenv("VERIS_MOCK_ENDPOINT_URL")
+        if not endpoint:
+            error_msg = "VERIS_MOCK_ENDPOINT_URL environment variable is not set"
+            raise ValueError(error_msg)
+        # Default timeout of 30 seconds
+        timeout = float(os.getenv("VERIS_MOCK_TIMEOUT", "30.0"))
+
         @wraps(func)
-        async def wrapper(*args, **kwargs):
+        async def wrapper(
+            *args: tuple[object, ...],
+            **kwargs: dict[str, object],
+        ) -> object:
             # Check if we're in simulation mode
             env_mode = os.getenv("ENV", "").lower()
             if env_mode != "simulation":
@@ -68,16 +87,16 @@ class ToolMock:
             logger.info(f"Simulating function: {func.__name__}")
             sig = inspect.signature(func)
             type_hints = get_type_hints(func)
-            
+
             # Extract return type object (not just the name)
             return_type_obj = type_hints.pop("return", Any)
-            
+
             # Create parameter info
             params_info = {}
             bound_args = sig.bind(*args, **kwargs)
             bound_args.apply_defaults()
-            
-            ctx = bound_args.arguments.pop('ctx', None)
+
+            ctx = bound_args.arguments.pop("ctx", None)
             session_id = None
             if ctx:
                 try:
@@ -97,31 +116,29 @@ class ToolMock:
             payload = {
                 "session_id": session_id,
                 "tool_call": {
-                    'function_name': func.__name__,
-                    'parameters': params_info,
-                    'return_type': return_type_obj.__name__,
-                    'docstring': docstring,
-                }
+                    "function_name": func.__name__,
+                    "parameters": params_info,
+                    "return_type": return_type_obj.__name__,
+                    "docstring": docstring,
+                },
             }
 
             # Send request to endpoint with timeout
-            async with httpx.AsyncClient(timeout=self.timeout) as client:
-                response = await client.post(self.endpoint, json=payload)
+            async with httpx.AsyncClient(timeout=timeout) as client:
+                response = await client.post(endpoint, json=payload)
                 response.raise_for_status()
                 mock_result = response.json()["result"]
                 logger.info(f"Mock response: {mock_result}")
-                
+
                 # Parse the mock result if it's a string
                 if isinstance(mock_result, str):
-                    try:
+                    with suppress(json.JSONDecodeError):
                         mock_result = json.loads(mock_result)
-                    except json.JSONDecodeError:
-                        # If it's not valid JSON, treat it as a raw string
-                        pass
-                
+
                 # Convert the mock result to the expected return type
                 return self._convert_to_type(mock_result, return_type_obj)
 
         return wrapper
 
+
 veris = ToolMock()

veris_ai-0.2.0/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for the veris_ai package."""

veris_ai-0.2.0/tests/conftest.py

@@ -0,0 +1,46 @@
+import os
+from unittest.mock import patch
+
+import pytest
+
+
+class MockContext:
+    class RequestContext:
+        class LifespanContext:
+            def __init__(self):
+                self.session_id = "test-session"
+
+        def __init__(self):
+            self.lifespan_context = self.LifespanContext()
+
+    def __init__(self):
+        self.request_context = self.RequestContext()
+
+
+@pytest.fixture
+def mock_context():
+    return MockContext()
+
+
+@pytest.fixture
+def simulation_env():
+    with patch.dict(
+        os.environ,
+        {
+            "VERIS_MOCK_ENDPOINT_URL": "http://test-endpoint",
+            "ENV": "simulation",
+        },
+    ):
+        yield
+
+
+@pytest.fixture
+def production_env():
+    with patch.dict(
+        os.environ,
+        {
+            "VERIS_MOCK_ENDPOINT_URL": "http://test-endpoint",
+            "ENV": "production",
+        },
+    ):
+        yield

veris_ai-0.2.0/tests/test_tool_mock.py

@@ -0,0 +1,223 @@
+import os
+from typing import Any, Union
+from unittest.mock import AsyncMock, Mock, patch
+
+import httpx
+import pytest
+
+from veris_ai import veris
+
+
+@pytest.fixture
+def tool_mock():
+    return veris
+
+
+# Test type conversion
+@pytest.mark.parametrize(
+    "value,target_type,expected",
+    [
+        ("42", int, 42),
+        (42, str, "42"),
+        ("3.14", float, 3.14),
+        ("true", bool, True),
+        ([1, 2, 3], list[int], [1, 2, 3]),
+        (["1", "2"], list[int], [1, 2]),
+        ({"a": 1}, dict[str, int], {"a": 1}),
+        ("42", Union[int, str], 42),
+        ("abc", Union[int, str], "abc"),
+    ],
+)
+def test_convert_to_type(tool_mock, value, target_type, expected):
+    result = tool_mock._convert_to_type(value, target_type)
+    assert result == expected
+    assert isinstance(result, type(expected))
+
+
+def test_convert_to_type_invalid(tool_mock):
+    with pytest.raises(ValueError):
+        tool_mock._convert_to_type("not a list", list[int])
+
+
+def test_convert_to_type_dict_invalid(tool_mock):
+    with pytest.raises(ValueError, match="Expected dict but got <class 'str'>"):
+        tool_mock._convert_to_type("not a dict", dict[str, int])
+
+
+def test_convert_to_type_union_all_fail(tool_mock):
+    with pytest.raises(ValueError, match="Could not convert abc to any of the union types"):
+        tool_mock._convert_to_type("abc", Union[int, float])
+
+
+def test_convert_to_type_custom_type(tool_mock):
+    class CustomType:
+        def __init__(self, value):
+            self.value = value
+
+    result = tool_mock._convert_to_type("test", CustomType)
+    assert isinstance(result, CustomType)
+    assert result.value == "test"
+
+
+# Test mock decorator
+@pytest.mark.asyncio
+async def test_mock_decorator_simulation_mode(simulation_env):
+    @veris.mock
+    async def test_func(param1: str, param2: int) -> dict[str, Any]:
+        return {"result": "real"}
+
+    mock_response = {"result": {"mocked": True}}
+
+    with patch("httpx.AsyncClient") as mock_client:
+        mock_response_obj = Mock()
+        mock_response_obj.json.return_value = mock_response
+        mock_response_obj.raise_for_status.return_value = None
+
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+            return_value=mock_response_obj,
+        )
+
+        result = await test_func("test", 42)
+        assert result == {"mocked": True}
+
+
+@pytest.mark.asyncio
+async def test_mock_decorator_production_mode(production_env):
+    @veris.mock
+    async def test_func(param1: str, param2: int) -> dict:
+        return {"result": "real"}
+
+    result = await test_func("test", 42)
+    assert result == {"result": "real"}
+
+
+@pytest.mark.asyncio
+async def test_mock_with_context(simulation_env, mock_context):
+    @veris.mock
+    async def test_func(ctx) -> dict:
+        return {"result": "real"}
+
+    mock_response = {"result": {"mocked": True}}
+
+    with patch("veris_ai.tool_mock.httpx.AsyncClient") as mock_client:
+        mock_response_obj = Mock()
+        mock_response_obj.json.return_value = mock_response
+        mock_response_obj.raise_for_status.return_value = None
+
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+            return_value=mock_response_obj,
+        )
+
+        result = await test_func(mock_context)
+        first_call = mock_client.return_value.__aenter__.return_value.post.call_args
+        assert (
+            first_call.kwargs["json"]["session_id"]
+            == mock_context.request_context.lifespan_context.session_id
+        )
+        assert result == {"mocked": True}
+
+
+@pytest.mark.asyncio
+async def test_mock_without_context(simulation_env):
+    @veris.mock
+    async def test_func() -> dict:
+        return {"result": "real"}
+
+    mock_response = {"result": {"mocked": True}}
+
+    with patch("veris_ai.tool_mock.httpx.AsyncClient") as mock_client:
+        mock_response_obj = Mock()
+        mock_response_obj.json.return_value = mock_response
+        mock_response_obj.raise_for_status.return_value = None
+
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+            return_value=mock_response_obj,
+        )
+
+        result = await test_func()
+        first_call = mock_client.return_value.__aenter__.return_value.post.call_args
+        assert first_call.kwargs["json"]["session_id"] == None
+        assert result == {"mocked": True}
+
+
+@pytest.mark.asyncio
+async def test_mock_with_malformed_context(simulation_env):
+    @veris.mock
+    async def test_func(ctx) -> dict:
+        return {"result": "real"}
+
+    mock_response = {"result": {"mocked": True}}
+
+    with patch("veris_ai.tool_mock.httpx.AsyncClient") as mock_client:
+        mock_response_obj = Mock()
+        mock_response_obj.json.return_value = mock_response
+        mock_response_obj.raise_for_status.return_value = None
+
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+            return_value=mock_response_obj,
+        )
+
+        result = await test_func({"unknown": "unknown"})
+        first_call = mock_client.return_value.__aenter__.return_value.post.call_args
+        assert first_call.kwargs["json"]["session_id"] == None
+        assert result == {"mocked": True}
+
+
+# Test error handling
+@pytest.mark.asyncio
+async def test_mock_http_error(simulation_env):
+    @veris.mock
+    async def test_func(param1: str) -> dict:
+        return {"result": "real"}
+
+    with patch("httpx.AsyncClient") as mock_client:
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+            side_effect=httpx.HTTPError("Mock HTTP Error"),
+        )
+
+        with pytest.raises(httpx.HTTPError):
+            await test_func("test")
+
+
+@pytest.mark.asyncio
+async def test_mock_missing_endpoint():
+    with (
+        patch.dict(os.environ, {"VERIS_MOCK_ENDPOINT_URL": ""}),
+        pytest.raises(ValueError, match="VERIS_MOCK_ENDPOINT_URL environment variable is not set"),
+    ):
+
+        @veris.mock
+        async def test_func():
+            return {"result": "real"}
+
+
+@pytest.mark.asyncio
+async def test_mock_invalid_endpoint(simulation_env):
+    with patch.dict(os.environ, {"VERIS_MOCK_ENDPOINT_URL": ""}), pytest.raises(ValueError):
+
+        @veris.mock
+        async def test_func():
+            return {"result": "real"}
+
+        await test_func()
+
+
+@pytest.mark.asyncio
+async def test_mock_string_json_response(simulation_env):
+    @veris.mock
+    async def test_func() -> dict:
+        return {"result": "real"}
+
+    mock_response = {"result": '{"key": "value"}'}
+
+    with patch("httpx.AsyncClient") as mock_client:
+        mock_response_obj = Mock()
+        mock_response_obj.json.return_value = mock_response
+        mock_response_obj.raise_for_status.return_value = None
+
+        mock_client.return_value.__aenter__.return_value.post = AsyncMock(
+            return_value=mock_response_obj,
+        )
+
+        result = await test_func()
+        assert result == {"key": "value"}