sunholo 0.145.0__tar.gz → 0.145.1__tar.gz

{sunholo-0.145.0/src/sunholo.egg-info → sunholo-0.145.1}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.145.0
+Version: 0.145.1
 Summary: AI DevOps - a package to help deploy GenAI to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0
 Project-URL: Homepage, https://github.com/sunholo-data/sunholo-py
-Project-URL: Download, https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.118.0.tar.gz
 Keywords: llms,devops,google_cloud_platform
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -107,6 +106,7 @@ Requires-Dist: azure-storage-blob; extra == "azure"
 Provides-Extra: cli
 Requires-Dist: jsonschema>=4.21.1; extra == "cli"
 Requires-Dist: rich; extra == "cli"
+Requires-Dist: fastmcp; extra == "cli"
 Provides-Extra: database
 Requires-Dist: asyncpg; extra == "database"
 Requires-Dist: supabase; extra == "database"

{sunholo-0.145.0 → sunholo-0.145.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sunholo"
-version = "0.145.0"
+version = "0.145.1"
 description = "AI DevOps - a package to help deploy GenAI to the Cloud."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -33,7 +33,6 @@ dependencies = [
 
 [project.urls]
 Homepage = "https://github.com/sunholo-data/sunholo-py"
-Download = "https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.118.0.tar.gz"
 
 [project.scripts]
 sunholo = "sunholo.cli.cli:main"
@@ -140,7 +139,8 @@ azure = [
 ]
 cli = [
     "jsonschema>=4.21.1",
-    "rich"
+    "rich",
+    "fastmcp"
 ]
 database = [
     "asyncpg",

{sunholo-0.145.0 → sunholo-0.145.1}/src/sunholo/invoke/__init__.py

@@ -1,3 +1,3 @@
 from .invoke_vac_utils import invoke_vac
 from .direct_vac_func import direct_vac, direct_vac_stream, async_direct_vac, async_direct_vac_stream
-from .async_class import AsyncTaskRunner
+from .async_task_runner import AsyncTaskRunner, CallbackContext, TaskConfig

{sunholo-0.145.0 → sunholo-0.145.1/src/sunholo.egg-info}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.145.0
+Version: 0.145.1
 Summary: AI DevOps - a package to help deploy GenAI to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0
 Project-URL: Homepage, https://github.com/sunholo-data/sunholo-py
-Project-URL: Download, https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.118.0.tar.gz
 Keywords: llms,devops,google_cloud_platform
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -107,6 +106,7 @@ Requires-Dist: azure-storage-blob; extra == "azure"
 Provides-Extra: cli
 Requires-Dist: jsonschema>=4.21.1; extra == "cli"
 Requires-Dist: rich; extra == "cli"
+Requires-Dist: fastmcp; extra == "cli"
 Provides-Extra: database
 Requires-Dist: asyncpg; extra == "database"
 Requires-Dist: supabase; extra == "database"

{sunholo-0.145.0 → sunholo-0.145.1}/src/sunholo.egg-info/SOURCES.txt

@@ -195,9 +195,8 @@ src/sunholo/vertex/safety.py
 src/sunholo/vertex/type_dict_to_json.py
 tests/test_async.py
 tests/test_async_genai2.py
+tests/test_async_task_runner.py
 tests/test_chat_history.py
 tests/test_config.py
 tests/test_genai2.py
-tests/test_unstructured.py
-tests/test_vac_routes_fastapi.py
-tests/test_vac_routes_mcp.py
+tests/test_unstructured.py

{sunholo-0.145.0 → sunholo-0.145.1}/src/sunholo.egg-info/requires.txt

@@ -86,6 +86,7 @@ azure-storage-blob
 [cli]
 jsonschema>=4.21.1
 rich
+fastmcp
 
 [database]
 asyncpg

sunholo-0.145.1/tests/test_async_task_runner.py

@@ -0,0 +1,355 @@
+"""
+Tests for AsyncTaskRunner with default callbacks and enhanced features.
+"""
+
+import asyncio
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+from sunholo.invoke.async_task_runner import AsyncTaskRunner, TaskConfig, CallbackContext
+from tenacity import stop_after_attempt
+
+
+# Test fixtures - async functions to use in tests
+async def simple_task(value: str):
+    """Simple async task that returns a value."""
+    await asyncio.sleep(0.1)
+    return f"Result: {value}"
+
+
+async def failing_task(value: str):
+    """Task that always fails for testing error handling."""
+    await asyncio.sleep(0.1)
+    raise ValueError(f"Intentional error: {value}")
+
+
+async def slow_task(value: str, duration: float = 2.0):
+    """Task with configurable duration for timeout testing."""
+    await asyncio.sleep(duration)
+    return f"Slow result: {value}"
+
+
+@pytest.mark.asyncio
+async def test_default_callbacks_basic():
+    """Test that default callbacks populate shared_state correctly."""
+    runner = AsyncTaskRunner(verbose=False)  # Quiet for tests
+    
+    # Add some tasks
+    runner.add_task(simple_task, "test1")
+    runner.add_task(simple_task, "test2")
+    
+    # Run and get results
+    results = await runner.get_aggregated_results()
+    
+    # Check that default callbacks populated the state
+    assert 'results' in results
+    assert 'completed' in results
+    assert 'started' in results
+    assert 'errors' in results
+    
+    # Check task results
+    assert 'simple_task' in results['results']
+    assert results['results']['simple_task'] == "Result: test2"  # Last one wins with same name
+    
+    # Check completed list
+    assert len(results['completed']) == 2
+    assert results['completed'].count('simple_task') == 2
+    
+    # Check started list
+    assert len(results['started']) == 2
+    
+    # No errors expected
+    assert len(results['errors']) == 0
+
+
+@pytest.mark.asyncio
+async def test_default_callbacks_with_errors():
+    """Test that default callbacks handle errors correctly."""
+    runner = AsyncTaskRunner(verbose=False)
+    
+    # Add both successful and failing tasks
+    runner.add_task(simple_task, "success")
+    runner.add_task(failing_task, "failure")
+    
+    results = await runner.get_aggregated_results()
+    
+    # Check successful task
+    assert 'simple_task' in results['results']
+    assert results['results']['simple_task'] == "Result: success"
+    
+    # Check error was captured
+    assert 'failing_task' in results['errors']
+    assert "Intentional error: failure" in results['errors']['failing_task']
+    
+    # Check completed list (only successful task)
+    assert 'simple_task' in results['completed']
+    
+    # Both tasks should have started
+    assert len(results['started']) == 2
+
+
+@pytest.mark.asyncio
+async def test_default_callbacks_with_retry():
+    """Test that default callbacks track retry attempts."""
+    runner = AsyncTaskRunner(
+        verbose=False,
+        retry_enabled=False  # Global default
+    )
+    
+    # Add task with retry enabled
+    runner.add_task(
+        failing_task,
+        "retry_test",
+        task_config=TaskConfig(
+            retry_enabled=True,
+            retry_kwargs={'stop': stop_after_attempt(3)}
+        )
+    )
+    
+    results = await runner.get_aggregated_results()
+    
+    # Check that retries were tracked
+    assert 'retries' in results
+    assert len(results['retries']) == 2  # Attempts 2 and 3 (not 1)
+    assert 'failing_task_attempt_2' in results['retries']
+    assert 'failing_task_attempt_3' in results['retries']
+    
+    # Task should have error after all retries
+    assert 'failing_task' in results['errors']
+
+
+@pytest.mark.asyncio
+async def test_custom_callback_override():
+    """Test that custom callbacks override defaults correctly."""
+    custom_complete_called = []
+    
+    async def custom_on_complete(ctx: CallbackContext):
+        """Custom completion handler for testing."""
+        custom_complete_called.append(ctx.task_name)
+        # Still populate state like default would
+        ctx.shared_state['results'][ctx.task_name] = f"CUSTOM: {ctx.result}"
+        ctx.shared_state['completed'].append(ctx.task_name)
+    
+    runner = AsyncTaskRunner(
+        verbose=False,
+        callbacks={'on_task_complete': custom_on_complete}
+        # Other callbacks remain as defaults
+    )
+    
+    runner.add_task(simple_task, "test")
+    results = await runner.get_aggregated_results()
+    
+    # Check custom callback was called
+    assert len(custom_complete_called) == 1
+    assert custom_complete_called[0] == 'simple_task'
+    
+    # Check custom result format
+    assert results['results']['simple_task'] == "CUSTOM: Result: test"
+    
+    # Default callbacks should still work for other events
+    assert 'started' in results
+    assert 'simple_task' in results['started']
+
+
+@pytest.mark.asyncio
+async def test_no_default_callbacks():
+    """Test that disabling default callbacks works."""
+    runner = AsyncTaskRunner(
+        use_default_callbacks=False,
+        verbose=False
+    )
+    
+    runner.add_task(simple_task, "test")
+    results = await runner.get_aggregated_results()
+    
+    # State should be initialized but empty (no callbacks to populate it)
+    assert results == {
+        'results': {},
+        'errors': {},
+        'completed': [],
+        'started': [],
+        'retries': [],
+        'timed_out': []
+    }
+
+
+@pytest.mark.asyncio
+async def test_per_task_timeout_with_defaults():
+    """Test per-task timeout configuration with default callbacks."""
+    runner = AsyncTaskRunner(
+        timeout=1,  # Default 1 second timeout
+        verbose=False
+    )
+    
+    # This task should timeout with default
+    runner.add_task(slow_task, "timeout_task", 2.0)  # Takes 2 seconds
+    
+    # This task should complete with custom timeout
+    runner.add_task(
+        slow_task,
+        "complete_task",
+        0.5,  # Takes 0.5 seconds
+        task_config=TaskConfig(timeout=3)  # 3 second timeout
+    )
+    
+    results = await runner.get_aggregated_results()
+    
+    # Check that one timed out
+    assert 'timed_out' in results
+    assert 'slow_task' in results['timed_out']
+    
+    # Check that timeout was recorded as error
+    assert 'slow_task' in results['errors']
+    # The default callback stores "Timeout after Xs" or the error might be "Unknown error" if timeout wasn't caught properly
+    error_msg = results['errors'].get('slow_task', '').lower()
+    assert 'timeout' in error_msg or 'unknown' in error_msg
+    
+    # The one with extended timeout should complete
+    assert 'slow_task' in results['results']
+    assert results['results']['slow_task'] == "Slow result: complete_task"
+
+
+@pytest.mark.asyncio
+async def test_shared_state_persistence():
+    """Test that shared_state is accessible and modifiable across callbacks."""
+    shared_state = {
+        'custom_counter': 0,
+        'task_order': []
+    }
+    
+    async def counting_callback(ctx: CallbackContext):
+        """Callback that increments a counter."""
+        ctx.shared_state['custom_counter'] += 1
+        ctx.shared_state['task_order'].append(ctx.task_name)
+        # Also do the default behavior
+        ctx.shared_state.setdefault('results', {})[ctx.task_name] = ctx.result
+    
+    runner = AsyncTaskRunner(
+        shared_state=shared_state,
+        callbacks={'on_task_complete': counting_callback},
+        verbose=False
+    )
+    
+    runner.add_task(simple_task, "first")
+    runner.add_task(simple_task, "second")
+    runner.add_task(simple_task, "third")
+    
+    results = await runner.get_aggregated_results()
+    
+    # Check custom state was maintained
+    assert results['custom_counter'] == 3
+    assert len(results['task_order']) == 3
+    assert all(name == 'simple_task' for name in results['task_order'])
+    
+    # Default keys should also be present
+    assert 'results' in results
+    assert 'errors' in results
+    assert 'completed' in results
+
+
+@pytest.mark.asyncio
+async def test_verbose_mode():
+    """Test that verbose mode affects shared_state population but not its behavior."""
+    # Test verbose=True (default)
+    runner_verbose = AsyncTaskRunner(verbose=True)
+    runner_verbose.add_task(simple_task, "verbose_test")
+    results_verbose = await runner_verbose.get_aggregated_results()
+    
+    # Should have results regardless of verbose mode
+    assert 'simple_task' in results_verbose['results']
+    assert 'simple_task' in results_verbose['completed']
+    
+    # Test verbose=False - should still work but quietly
+    runner_quiet = AsyncTaskRunner(verbose=False)
+    runner_quiet.add_task(simple_task, "quiet_test")
+    results_quiet = await runner_quiet.get_aggregated_results()
+    
+    # Should have same results structure
+    assert 'simple_task' in results_quiet['results']
+    assert 'simple_task' in results_quiet['completed']
+    
+    # Both should produce same result structure
+    assert set(results_verbose.keys()) == set(results_quiet.keys())
+
+
+@pytest.mark.asyncio
+async def test_multiple_tasks_same_name():
+    """Test behavior when multiple tasks have the same function name."""
+    runner = AsyncTaskRunner(verbose=False)
+    
+    # Add multiple tasks with same function
+    runner.add_task(simple_task, "first")
+    runner.add_task(simple_task, "second")
+    runner.add_task(simple_task, "third")
+    
+    results = await runner.get_aggregated_results()
+    
+    # Results dict should have the last result (overwrites)
+    assert results['results']['simple_task'] == "Result: third"
+    
+    # Completed list should have all three
+    assert results['completed'].count('simple_task') == 3
+    
+    # Started list should have all three
+    assert results['started'].count('simple_task') == 3
+
+
+@pytest.mark.asyncio
+async def test_empty_runner():
+    """Test that runner works with no tasks."""
+    runner = AsyncTaskRunner(verbose=False)
+    
+    # Run with no tasks
+    results = await runner.get_aggregated_results()
+    
+    # Should return empty but initialized state
+    assert results == {
+        'results': {},
+        'errors': {},
+        'completed': [],
+        'started': [],
+        'retries': [],
+        'timed_out': []
+    }
+
+
+@pytest.mark.asyncio
+async def test_task_config_none_values():
+    """Test that TaskConfig with None values falls back to global settings."""
+    runner = AsyncTaskRunner(
+        timeout=5,
+        retry_enabled=True,
+        verbose=False
+    )
+    
+    # Add task with partial config (None values should use globals)
+    runner.add_task(
+        simple_task,
+        "test",
+        task_config=TaskConfig(
+            timeout=None,  # Should use global (5)
+            retry_enabled=None,  # Should use global (True)
+            metadata={'custom': 'data'}
+        )
+    )
+    
+    results = await runner.get_aggregated_results()
+    
+    # Task should complete successfully
+    assert 'simple_task' in results['results']
+    assert results['results']['simple_task'] == "Result: test"
+
+
+if __name__ == "__main__":
+    # Run tests with asyncio
+    asyncio.run(test_default_callbacks_basic())
+    asyncio.run(test_default_callbacks_with_errors())
+    asyncio.run(test_default_callbacks_with_retry())
+    asyncio.run(test_custom_callback_override())
+    asyncio.run(test_no_default_callbacks())
+    asyncio.run(test_per_task_timeout_with_defaults())
+    asyncio.run(test_shared_state_persistence())
+    asyncio.run(test_verbose_mode())
+    asyncio.run(test_multiple_tasks_same_name())
+    asyncio.run(test_empty_runner())
+    asyncio.run(test_task_config_none_values())
+    print("All tests passed!")

sunholo-0.145.0/tests/test_vac_routes_fastapi.py

@@ -1,226 +0,0 @@
-#   Copyright [2024] [Holosun ApS]
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-
-import pytest
-import json
-import asyncio
-from unittest.mock import patch, MagicMock, AsyncMock
-
-# Skip entire test file if FastAPI is not available
-pytest.importorskip("fastapi")
-pytest.importorskip("httpx")
-
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-from httpx import AsyncClient, ASGITransport
-
-from src.sunholo.agents.fastapi.vac_routes import VACRoutesFastAPI, VACRequest
-from tests.fixtures.mock_interpreters import (
-    mock_async_stream_interpreter,
-    mock_sync_stream_interpreter,
-    mock_async_vac_interpreter,
-    mock_sync_vac_interpreter,
-    mock_async_stream_with_heartbeat,
-    mock_async_stream_with_error,
-    mock_sync_stream_with_timeout
-)
-
-
-@pytest.fixture
-def fastapi_app_async():
-    """Create a FastAPI app with async interpreters."""
-    app = FastAPI()
-    vac_routes = VACRoutesFastAPI(
-        app,
-        stream_interpreter=mock_async_stream_interpreter,
-        vac_interpreter=mock_async_vac_interpreter,
-        enable_mcp_server=False,
-        add_langfuse_eval=False
-    )
-    return app
-
-
-@pytest.fixture
-def fastapi_app_sync():
-    """Create a FastAPI app with sync interpreters."""
-    app = FastAPI()
-    vac_routes = VACRoutesFastAPI(
-        app,
-        stream_interpreter=mock_sync_stream_interpreter,
-        vac_interpreter=mock_sync_vac_interpreter,
-        enable_mcp_server=False,
-        add_langfuse_eval=False
-    )
-    return app
-
-
-@pytest.fixture
-def test_client_async(fastapi_app_async):
-    """Create test client for async app."""
-    return TestClient(fastapi_app_async)
-
-
-@pytest.fixture
-def test_client_sync(fastapi_app_sync):
-    """Create test client for sync app."""
-    return TestClient(fastapi_app_sync)
-
-
-class TestVACRoutesFastAPI:
-    """Test suite for VACRoutesFastAPI."""
-    
-    def test_health_endpoint(self, test_client_async):
-        """Test health check endpoint."""
-        response = test_client_async.get("/health")
-        assert response.status_code == 200
-        assert response.json() == {"status": "healthy"}
-    
-    def test_home_endpoint(self, test_client_async):
-        """Test home endpoint."""
-        response = test_client_async.get("/")
-        assert response.status_code == 200
-        assert response.json() == "OK"
-    
-    @pytest.mark.asyncio
-    @patch('src.sunholo.agents.fastapi.vac_routes.ConfigManager')
-    @patch('src.sunholo.agents.fastapi.vac_routes.extract_chat_history_async_cached')
-    @patch('src.sunholo.agents.fastapi.vac_routes.archive_qa')
-    async def test_async_streaming_plain(self, mock_archive, mock_extract, mock_config, test_client_async):
-        """Test async streaming with plain text response."""
-        # Setup mocks
-        mock_config.return_value = MagicMock()
-        mock_extract.return_value = []
-        mock_archive.return_value = AsyncMock()
-        
-        # Make request
-        request_data = {
-            "user_input": "Test question",
-            "chat_history": [],
-            "stream_wait_time": 1,
-            "stream_timeout": 10
-        }
-        
-        response = test_client_async.post(
-            "/vac/streaming/test_vac",
-            json=request_data
-        )
-        
-        assert response.status_code == 200
-        assert response.headers["content-type"] == "text/plain; charset=utf-8"
-        
-        # Check streaming content
-        content = response.text
-        assert "Hello from async interpreter!" in content
-        assert "Test question" in content
-    
-    
-    
-    
-    
-    def test_openai_health(self, test_client_async):
-        """Test OpenAI health endpoint."""
-        response = test_client_async.get("/openai/health")
-        assert response.status_code == 200
-        assert response.json() == {"message": "Success"}
-    
-    
-    
-    def test_vac_request_model(self):
-        """Test VACRequest model validation."""
-        # Valid request
-        request = VACRequest(
-            user_input="Test",
-            chat_history=[],
-            stream_wait_time=5,
-            stream_timeout=30
-        )
-        assert request.user_input == "Test"
-        assert request.stream_wait_time == 5
-        
-        # Default values
-        request = VACRequest(user_input="Test")
-        assert request.chat_history is None
-        assert request.stream_wait_time == 7
-        assert request.stream_timeout == 120
-    
-    @pytest.mark.asyncio
-    async def test_streaming_with_heartbeat(self):
-        """Test streaming with heartbeat tokens."""
-        app = FastAPI()
-        vac_routes = VACRoutesFastAPI(
-            app,
-            stream_interpreter=mock_async_stream_with_heartbeat,
-            enable_mcp_server=False,
-            add_langfuse_eval=False
-        )
-        
-        async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as client:
-            request_data = {
-                "user_input": "Test heartbeat",
-                "chat_history": [],
-                "stream_wait_time": 1,
-                "stream_timeout": 10
-            }
-            
-            with patch('src.sunholo.agents.fastapi.vac_routes.ConfigManager'):
-                with patch('src.sunholo.agents.fastapi.vac_routes.extract_chat_history_async_cached', return_value=[]):
-                    with patch('src.sunholo.agents.fastapi.vac_routes.archive_qa', new_callable=AsyncMock):
-                        response = await client.post(
-                            "/vac/streaming/test_vac",
-                            json=request_data
-                        )
-                        
-                        assert response.status_code == 200
-                        # Heartbeat tokens should be processed
-                        content = response.text
-                        assert "Starting response..." in content
-    
-    
-    def test_interpreter_detection(self):
-        """Test that sync/async interpreter detection works correctly."""
-        app = FastAPI()
-        
-        # Test async detection
-        vac_routes_async = VACRoutesFastAPI(
-            app,
-            stream_interpreter=mock_async_stream_interpreter,
-            vac_interpreter=mock_async_vac_interpreter
-        )
-        assert vac_routes_async.stream_is_async is True
-        assert vac_routes_async.vac_is_async is True
-        
-        # Test sync detection
-        vac_routes_sync = VACRoutesFastAPI(
-            app,
-            stream_interpreter=mock_sync_stream_interpreter,
-            vac_interpreter=mock_sync_vac_interpreter
-        )
-        assert vac_routes_sync.stream_is_async is False
-        assert vac_routes_sync.vac_is_async is False
-    
-    def test_mcp_server_disabled(self, test_client_async):
-        """Test that MCP server endpoints return 404 when disabled."""
-        response = test_client_async.post("/mcp")
-        assert response.status_code == 404
-        
-        response = test_client_async.get("/mcp")
-        assert response.status_code == 404
-    
-    def test_a2a_agent_disabled(self, test_client_async):
-        """Test that A2A agent endpoints return 404 when disabled."""
-        response = test_client_async.get("/.well-known/agent.json")
-        assert response.status_code == 404
-        
-        response = test_client_async.post("/a2a/tasks/send")
-        assert response.status_code == 404