jaf-py 2.5.10__py3-none-any.whl → 2.5.12__py3-none-any.whl

jaf/a2a/standalone_client.py

@@ -17,6 +17,7 @@ from pydantic import BaseModel, Field
 # Standalone types for the client
 class StandaloneA2AClientConfig(BaseModel):
     """A2A client configuration"""
+
     model_config = {"frozen": True}
 
     base_url: str = Field(alias="baseUrl")
@@ -25,6 +26,7 @@ class StandaloneA2AClientConfig(BaseModel):
 
 class StandaloneA2AClientState(BaseModel):
     """A2A client state"""
+
     model_config = {"frozen": True}
 
     config: StandaloneA2AClientConfig
@@ -32,23 +34,23 @@ class StandaloneA2AClientState(BaseModel):
 
 
 # Client functions
-def create_standalone_a2a_client(base_url: str, config: Optional[Dict[str, Any]] = None) -> StandaloneA2AClientState:
+def create_standalone_a2a_client(
+    base_url: str, config: Optional[Dict[str, Any]] = None
+) -> StandaloneA2AClientState:
     """Pure function to create standalone A2A client"""
     config = config or {}
 
     return StandaloneA2AClientState(
         config=StandaloneA2AClientConfig(
             baseUrl=base_url.rstrip("/"),  # Remove trailing slash
-            timeout=config.get("timeout", 30000)
+            timeout=config.get("timeout", 30000),
         ),
-        sessionId=f"client_{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}"
+        sessionId=f"client_{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}",
     )
 
 
 def create_standalone_message_request(
-    message: str,
-    session_id: str,
-    configuration: Optional[Dict[str, Any]] = None
+    message: str, session_id: str, configuration: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """Pure function to create message request"""
     return {
@@ -61,17 +63,15 @@ def create_standalone_message_request(
                 "parts": [{"kind": "text", "text": message}],
                 "messageId": f"msg_{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}",
                 "contextId": session_id,
-                "kind": "message"
+                "kind": "message",
             },
-            "configuration": configuration
-        }
+            "configuration": configuration,
+        },
     }
 
 
 def create_standalone_streaming_message_request(
-    message: str,
-    session_id: str,
-    configuration: Optional[Dict[str, Any]] = None
+    message: str, session_id: str, configuration: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """Pure function to create streaming message request"""
     return {
@@ -84,17 +84,15 @@ def create_standalone_streaming_message_request(
                 "parts": [{"kind": "text", "text": message}],
                 "messageId": f"msg_{int(time.time() * 1000)}_{uuid.uuid4().hex[:8]}",
                 "contextId": session_id,
-                "kind": "message"
+                "kind": "message",
             },
-            "configuration": configuration
-        }
+            "configuration": configuration,
+        },
     }
 
 
 async def send_standalone_http_request(
-    url: str,
-    body: Dict[str, Any],
-    timeout: int = 30000
+    url: str, body: Dict[str, Any], timeout: int = 30000
 ) -> Dict[str, Any]:
     """Pure function to send HTTP request"""
     timeout_seconds = timeout / 1000.0
@@ -104,10 +102,7 @@ async def send_standalone_http_request(
             response = await client.post(
                 url,
                 json=body,
-                headers={
-                    "Content-Type": "application/json",
-                    "Accept": "application/json"
-                }
+                headers={"Content-Type": "application/json", "Accept": "application/json"},
             )
 
             if not response.is_success:
@@ -120,8 +115,7 @@ async def send_standalone_http_request(
 
 
 async def send_standalone_a2a_request(
-    client: StandaloneA2AClientState,
-    request: Dict[str, Any]
+    client: StandaloneA2AClientState, request: Dict[str, Any]
 ) -> Dict[str, Any]:
     """Pure function to send A2A request"""
     url = f"{client.config.base_url}/a2a"
@@ -129,9 +123,7 @@ async def send_standalone_a2a_request(
 
 
 async def send_standalone_message(
-    client: StandaloneA2AClientState,
-    message: str,
-    configuration: Optional[Dict[str, Any]] = None
+    client: StandaloneA2AClientState, message: str, configuration: Optional[Dict[str, Any]] = None
 ) -> str:
     """Pure function to send message"""
     request = create_standalone_message_request(message, client.session_id, configuration)
@@ -145,9 +137,7 @@ async def send_standalone_message(
 
 
 async def stream_standalone_message(
-    client: StandaloneA2AClientState,
-    message: str,
-    configuration: Optional[Dict[str, Any]] = None
+    client: StandaloneA2AClientState, message: str, configuration: Optional[Dict[str, Any]] = None
 ) -> AsyncGenerator[Dict[str, Any], None]:
     """Pure function to stream message"""
     request = create_standalone_streaming_message_request(message, client.session_id, configuration)
@@ -161,12 +151,8 @@ async def stream_standalone_message(
                 "POST",
                 url,
                 json=request,
-                headers={
-                    "Content-Type": "application/json",
-                    "Accept": "text/event-stream"
-                }
+                headers={"Content-Type": "application/json", "Accept": "text/event-stream"},
             ) as response:
-
                 if not response.is_success:
                     raise Exception(f"HTTP {response.status_code}: {response.text}")
 
@@ -197,10 +183,7 @@ async def get_standalone_agent_card(client: StandaloneA2AClientState) -> Dict[st
     url = f"{client.config.base_url}/.well-known/agent-card"
 
     async with httpx.AsyncClient(timeout=client.config.timeout / 1000.0) as http_client:
-        response = await http_client.get(
-            url,
-            headers={"Accept": "application/json"}
-        )
+        response = await http_client.get(url, headers={"Accept": "application/json"})
 
         if not response.is_success:
             raise Exception(f"Failed to get agent card: HTTP {response.status_code}")
@@ -212,7 +195,7 @@ async def send_standalone_message_to_agent(
     client: StandaloneA2AClientState,
     agent_name: str,
     message: str,
-    configuration: Optional[Dict[str, Any]] = None
+    configuration: Optional[Dict[str, Any]] = None,
 ) -> str:
     """Pure function to send message to specific agent"""
     request = create_standalone_message_request(message, client.session_id, configuration)
@@ -288,7 +271,9 @@ async def connect_to_standalone_a2a_agent(base_url: str) -> Dict[str, Any]:
         async for event in stream_standalone_message(client, message, config):
             yield event
 
-    async def ask_agent(agent_name: str, message: str, config: Optional[Dict[str, Any]] = None) -> str:
+    async def ask_agent(
+        agent_name: str, message: str, config: Optional[Dict[str, Any]] = None
+    ) -> str:
         return await send_standalone_message_to_agent(client, agent_name, message, config)
 
     return {
@@ -296,7 +281,7 @@ async def connect_to_standalone_a2a_agent(base_url: str) -> Dict[str, Any]:
         "agent_card": agent_card,
         "ask": ask,
         "stream": stream,
-        "ask_agent": ask_agent
+        "ask_agent": ask_agent,
     }
 
 
@@ -308,7 +293,9 @@ async def main_example():
         connection = await connect_to_standalone_a2a_agent("http://localhost:3000")
 
         print("Connected to A2A server!")
-        print(f"Available agents: {[skill['name'] for skill in connection['agent_card']['skills']]}")
+        print(
+            f"Available agents: {[skill['name'] for skill in connection['agent_card']['skills']]}"
+        )
 
         # Send a message
         response = await connection["ask"]("Hello, how can you help me?")

jaf/a2a/tests/__init__.py

@@ -5,7 +5,7 @@ Comprehensive tests for the Agent-to-Agent Communication Protocol implementation
 
 Test Structure:
 - test_types.py: Core type validation and Pydantic model tests
-- test_protocol.py: JSON-RPC protocol handler tests  
+- test_protocol.py: JSON-RPC protocol handler tests
 - test_client.py: HTTP client functionality tests
 - test_agent.py: Agent creation and execution tests
 - test_integration.py: End-to-end integration tests
@@ -13,13 +13,13 @@ Test Structure:
 Usage:
     # Run all A2A tests
     python -m pytest jaf/a2a/tests/
-    
+
     # Run specific test file
     python -m pytest jaf/a2a/tests/test_types.py
-    
+
     # Run with verbose output
     python -m pytest jaf/a2a/tests/ -v
-    
+
     # Run with coverage
     python -m pytest jaf/a2a/tests/ --cov=jaf.a2a
 
@@ -55,20 +55,19 @@ def run_all_tests():
     # Configure pytest for async tests
     pytest_args = [
         str(test_dir),
-        "-v",                    # Verbose output
-        "--tb=short",           # Short traceback format
+        "-v",  # Verbose output
+        "--tb=short",  # Short traceback format
         "--asyncio-mode=auto",  # Auto async mode
-        "-x",                   # Stop on first failure
+        "-x",  # Stop on first failure
     ]
 
     # Add coverage if available
     try:
         import pytest_cov
-        pytest_args.extend([
-            "--cov=jaf.a2a",
-            "--cov-report=term-missing",
-            "--cov-report=html:htmlcov"
-        ])
+
+        pytest_args.extend(
+            ["--cov=jaf.a2a", "--cov-report=term-missing", "--cov-report=html:htmlcov"]
+        )
     except ImportError:
         print("pytest-cov not available, skipping coverage report")
 
@@ -93,12 +92,7 @@ def run_specific_test(test_name: str):
         print(f"Test file not found: {test_path}")
         return 1
 
-    pytest_args = [
-        str(test_path),
-        "-v",
-        "--tb=short",
-        "--asyncio-mode=auto"
-    ]
+    pytest_args = [str(test_path), "-v", "--tb=short", "--asyncio-mode=auto"]
 
     return pytest.main(pytest_args)
 
@@ -108,12 +102,7 @@ def run_integration_tests_only():
     test_dir = Path(__file__).parent
     integration_test = test_dir / "test_integration.py"
 
-    pytest_args = [
-        str(integration_test),
-        "-v",
-        "--tb=short",
-        "--asyncio-mode=auto"
-    ]
+    pytest_args = [str(integration_test), "-v", "--tb=short", "--asyncio-mode=auto"]
 
     return pytest.main(pytest_args)
 
@@ -127,7 +116,7 @@ def run_unit_tests_only():
         "-v",
         "--tb=short",
         "--asyncio-mode=auto",
-        "--ignore=test_integration.py"
+        "--ignore=test_integration.py",
     ]
 
     return pytest.main(pytest_args)
@@ -137,14 +126,8 @@ def run_unit_tests_only():
 def pytest_configure(config):
     """Configure pytest for A2A tests"""
     # Add custom markers
-    config.addinivalue_line(
-        "markers",
-        "integration: mark test as integration test"
-    )
-    config.addinivalue_line(
-        "markers",
-        "slow: mark test as slow running"
-    )
+    config.addinivalue_line("markers", "integration: mark test as integration test")
+    config.addinivalue_line("markers", "slow: mark test as slow running")
 
 
 # Test collection

jaf/a2a/tests/run_tests.py

@@ -93,10 +93,7 @@ def build_pytest_args(mode: str, args: argparse.Namespace) -> List[str]:
     if mode == "all":
         pytest_args.append(str(test_dir))
     elif mode == "unit":
-        pytest_args.extend([
-            str(test_dir),
-            "--ignore=" + str(test_dir / "test_integration.py")
-        ])
+        pytest_args.extend([str(test_dir), "--ignore=" + str(test_dir / "test_integration.py")])
     elif mode == "integration":
         pytest_args.append(str(test_dir / "test_integration.py"))
     elif mode in ["types", "protocol", "client", "agent"]:
@@ -105,10 +102,7 @@ def build_pytest_args(mode: str, args: argparse.Namespace) -> List[str]:
         pytest_args.append(str(test_dir))
 
     # Add asyncio support
-    pytest_args.extend([
-        "--asyncio-mode=auto",
-        "--tb=short"
-    ])
+    pytest_args.extend(["--asyncio-mode=auto", "--tb=short"])
 
     # Verbosity
     if args.verbose:
@@ -126,6 +120,7 @@ def build_pytest_args(mode: str, args: argparse.Namespace) -> List[str]:
     if args.parallel:
         try:
             import pytest_xdist
+
             pytest_args.extend(["-n", "auto"])
         except ImportError:
             print("⚠️  pytest-xdist not available, running sequentially")
@@ -134,10 +129,8 @@ def build_pytest_args(mode: str, args: argparse.Namespace) -> List[str]:
     if args.coverage:
         try:
             import pytest_cov
-            pytest_args.extend([
-                "--cov=jaf.a2a",
-                "--cov-report=term-missing"
-            ])
+
+            pytest_args.extend(["--cov=jaf.a2a", "--cov-report=term-missing"])
 
             if args.html:
                 pytest_args.append("--cov-report=html:htmlcov")
@@ -151,10 +144,8 @@ def build_pytest_args(mode: str, args: argparse.Namespace) -> List[str]:
     if args.html and not args.coverage:
         try:
             import pytest_html
-            pytest_args.extend([
-                "--html=test_report.html",
-                "--self-contained-html"
-            ])
+
+            pytest_args.extend(["--html=test_report.html", "--self-contained-html"])
         except ImportError:
             print("⚠️  pytest-html not available, skipping HTML report")
 
@@ -181,6 +172,7 @@ def run_tests(mode: str, args: argparse.Namespace) -> int:
     # Import and run pytest
     try:
         import pytest
+
         exit_code = pytest.main(pytest_args)
     except ImportError:
         print("❌ pytest not available")
@@ -210,7 +202,7 @@ def main():
     parser = argparse.ArgumentParser(
         description="JAF A2A Test Runner",
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__
+        epilog=__doc__,
     )
 
     parser.add_argument(
@@ -218,50 +210,22 @@ def main():
         nargs="?",
         default="all",
         choices=["all", "unit", "integration", "types", "protocol", "client", "agent"],
-        help="Test mode to run (default: all)"
+        help="Test mode to run (default: all)",
     )
 
-    parser.add_argument(
-        "-v", "--verbose",
-        action="store_true",
-        help="Verbose output"
-    )
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
 
-    parser.add_argument(
-        "-q", "--quiet",
-        action="store_true",
-        help="Minimal output"
-    )
+    parser.add_argument("-q", "--quiet", action="store_true", help="Minimal output")
 
-    parser.add_argument(
-        "--coverage",
-        action="store_true",
-        help="Generate coverage report"
-    )
+    parser.add_argument("--coverage", action="store_true", help="Generate coverage report")
 
-    parser.add_argument(
-        "--html",
-        action="store_true",
-        help="Generate HTML reports"
-    )
+    parser.add_argument("--html", action="store_true", help="Generate HTML reports")
 
-    parser.add_argument(
-        "--xml",
-        action="store_true",
-        help="Generate XML coverage report"
-    )
+    parser.add_argument("--xml", action="store_true", help="Generate XML coverage report")
 
-    parser.add_argument(
-        "--failfast",
-        action="store_true",
-        help="Stop on first failure"
-    )
+    parser.add_argument("--failfast", action="store_true", help="Stop on first failure")
 
-    parser.add_argument(
-        "--parallel",
-        action="store_true",
-        help="Run tests in parallel"
-    )
+    parser.add_argument("--parallel", action="store_true", help="Run tests in parallel")
 
     args = parser.parse_args()