signalwire-sdk 3.0.2.dev63__tar.gz → 3.0.2.dev64__tar.gz

{signalwire_sdk-3.0.2.dev63 → signalwire_sdk-3.0.2.dev64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire-sdk
-Version: 3.0.2.dev63
+Version: 3.0.2.dev64
 Summary: SignalWire SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_sdk-3.0.2.dev63 → signalwire_sdk-3.0.2.dev64}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "signalwire-sdk"
-version = "3.0.2.dev63"
+version = "3.0.2.dev64"
 description = "SignalWire SDK"
 authors = [
     {name = "SignalWire Team", email = "info@signalwire.com"}
@@ -166,6 +166,40 @@ signalwire = [
 target-version = "py310"
 line-length = 88
 
+[tool.ruff.lint]
+# E4/E7/E9 + F are the ruff defaults (E501 line-length intentionally excluded —
+# formatting is owned by `ruff format`, not the linter). B = flake8-bugbear
+# (likely-bug patterns), S = flake8-bandit (security smells).
+select = ["E4", "E7", "E9", "F", "B", "S", "C4", "PERF", "SIM", "PTH", "RET", "RUF"]
+
+[tool.ruff.lint.per-file-ignores]
+# Tests are built on assert; bandit's S101 is noise there.
+"tests/**" = ["S101"]
+# sw-agent-dokku is a developer-run deploy CLI that shells out to git/ssh with
+# fixed list-form arg vectors (shell=False, so no shell interpolation). The
+# dynamic parts (app name, dokku host, config vars) are the operator's own CLI
+# args for their own deployment — not untrusted server input. S603 (subprocess
+# call) and S607 (partial executable path: git/ssh resolved via PATH, the normal
+# idiom) are expected and safe across this file.
+"signalwire/signalwire/cli/dokku.py" = ["S603", "S607"]
+
+[tool.ruff.lint.flake8-bugbear]
+# FastAPI's dependency-injection idiom puts Depends()/Query()/etc. in argument
+# defaults on purpose; B008 (function-call-in-default) is a false positive for it.
+# Both the bare (`from fastapi import Depends`) and qualified forms are listed
+# because the code imports these names directly.
+extend-immutable-calls = [
+    "Depends", "fastapi.Depends",
+    "Query", "fastapi.Query",
+    "Body", "fastapi.Body",
+    "Header", "fastapi.Header",
+    "Cookie", "fastapi.Cookie",
+    "Path", "fastapi.Path",
+    "Form", "fastapi.Form",
+    "File", "fastapi.File",
+    "Security", "fastapi.Security",
+]
+
 [tool.mypy]
 python_version = "3.10"
 files = ["signalwire/signalwire"]

{signalwire_sdk-3.0.2.dev63 → signalwire_sdk-3.0.2.dev64}/signalwire/signalwire/__init__.py

@@ -17,7 +17,7 @@ from .core.logging_config import configure_logging
 
 configure_logging()
 
-__version__ = "3.0.2.dev63"
+__version__ = "3.0.2.dev64"
 
 # Import core classes for easier access.
 # These imports are intentionally placed after configure_logging() so the SDK's
@@ -148,26 +148,26 @@ def RestClient(*args, **kwargs):
 __all__ = [
     "AgentBase",
     "AgentServer",
-    "SWMLService",
-    "SWMLBuilder",
-    "FunctionResult",
-    "SWAIGFunction",
-    "DataMap",
-    "create_simple_api_tool",
-    "create_expression_tool",
-    "ContextBuilder",
+    "BedrockAgent",
     "Context",
-    "Step",
+    "ContextBuilder",
+    "DataMap",
+    "FunctionResult",
     "GatherInfo",
     "GatherQuestion",
-    "create_simple_context",
-    "SwaigFunctionResult",
+    "RestClient",
+    "SWAIGFunction",
+    "SWMLBuilder",
+    "SWMLService",
     "SchemaValidationError",
+    "Step",
+    "SwaigFunctionResult",
     "WebService",
+    "add_skill_directory",
+    "create_expression_tool",
+    "create_simple_api_tool",
+    "create_simple_context",
     "list_skills",
     "list_skills_with_params",
     "register_skill",
-    "add_skill_directory",
-    "BedrockAgent",
-    "RestClient",
 ]

{signalwire_sdk-3.0.2.dev63 → signalwire_sdk-3.0.2.dev64}/signalwire/signalwire/agent_server.py

@@ -11,6 +11,7 @@ AgentServer - Class for hosting multiple SignalWire AI Agents in a single server
 
 import os
 import re
+from pathlib import Path
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
 try:
@@ -19,11 +20,12 @@ try:
 except ImportError:
     raise ImportError(
         "fastapi and uvicorn are required. Install them with: pip install fastapi uvicorn"
-    )
+    ) from None
 
 from signalwire.core.agent_base import AgentBase
 from signalwire.core.swml_service import SWMLService
 from signalwire.core.logging_config import get_logger
+import contextlib
 
 
 class AgentServer:
@@ -41,7 +43,10 @@ class AgentServer:
     """
 
     def __init__(
-        self, host: str = "0.0.0.0", port: int = 3000, log_level: str = "info"
+        self,
+        host: str = "0.0.0.0",  # noqa: S104  # intended server default: listen on all interfaces (overridable)
+        port: int = 3000,
+        log_level: str = "info",
     ):
         """
         Initialize a new agent server
@@ -61,7 +66,7 @@ class AgentServer:
         self.app = FastAPI(
             title="SignalWire AI Agents",
             description="Hosted SignalWire AI Agents",
-            version="3.0.2.dev63",
+            version="3.0.2.dev64",
             redirect_slashes=False,
             docs_url=None,
             redoc_url=None,
@@ -198,10 +203,7 @@ class AgentServer:
                 if target_route:
                     self.logger.info(f"Routing SIP request to {target_route}")
                     return target_route
-                else:
-                    self.logger.warning(
-                        f"No route found for SIP username: {sip_username}"
-                    )
+                self.logger.warning(f"No route found for SIP username: {sip_username}")
 
             # No routing needed (will be handled by the current agent)
             return None
@@ -372,11 +374,10 @@ class AgentServer:
 
         if mode == "cgi":
             return self._handle_cgi_request()
-        elif mode == "lambda":
+        if mode == "lambda":
             return self._handle_lambda_request(event, context)
-        else:
-            # Server mode - use existing logic
-            return self._run_server(host, port)
+        # Server mode - use existing logic
+        return self._run_server(host, port)
 
     def _handle_cgi_request(self) -> str:
         """Handle CGI request using same routing logic as server"""
@@ -405,7 +406,7 @@ class AgentServer:
                         swml, content_type="application/json"
                     )
                 except Exception as e:
-                    self.logger.error(f"Failed to generate SWML: {str(e)}")
+                    self.logger.error(f"Failed to generate SWML: {e!s}")
                     error_response = {"error": "Failed to generate SWML"}
                     return self._format_cgi_response(
                         error_response, status="500 Internal Server Error"
@@ -449,7 +450,7 @@ class AgentServer:
                         )
 
                     except Exception as e:
-                        self.logger.error(f"SWAIG function failed: {str(e)}")
+                        self.logger.error(f"SWAIG function failed: {e!s}")
                         error_response = {"error": "SWAIG function failed"}
                         return self._format_cgi_response(
                             error_response, status="500 Internal Server Error"
@@ -499,7 +500,7 @@ class AgentServer:
                         )
 
                     except Exception as e:
-                        self.logger.error(f"Function call failed: {str(e)}")
+                        self.logger.error(f"Function call failed: {e!s}")
                         error_response = {"error": "Function call failed"}
                         return self._format_cgi_response(
                             error_response, status="500 Internal Server Error"
@@ -544,7 +545,7 @@ class AgentServer:
                         "body": json.dumps(swml) if isinstance(swml, dict) else swml,
                     }
                 except Exception as e:
-                    self.logger.error(f"Failed to generate SWML: {str(e)}")
+                    self.logger.error(f"Failed to generate SWML: {e!s}")
                     return {
                         "statusCode": 500,
                         "headers": {"Content-Type": "application/json"},
@@ -568,10 +569,8 @@ class AgentServer:
                         # Get POST data from Lambda event body
                         post_data = {}
                         if event and "body" in event and event["body"]:
-                            try:
+                            with contextlib.suppress(json.JSONDecodeError, ValueError):
                                 post_data = json.loads(event["body"])
-                            except (json.JSONDecodeError, ValueError):
-                                pass
 
                         result = agent._execute_swaig_function(
                             function_name, post_data, None, None
@@ -585,7 +584,7 @@ class AgentServer:
                         }
 
                     except Exception as e:
-                        self.logger.error(f"Function call failed: {str(e)}")
+                        self.logger.error(f"Function call failed: {e!s}")
                         return {
                             "statusCode": 500,
                             "headers": {"Content-Type": "application/json"},
@@ -607,10 +606,7 @@ class AgentServer:
         import sys
 
         # Format the body
-        if isinstance(data, dict):
-            body = json.dumps(data)
-        else:
-            body = str(data)
+        body = json.dumps(data) if isinstance(data, dict) else str(data)
 
         # Build CGI response with headers
         response_lines = [
@@ -668,10 +664,10 @@ class AgentServer:
 
         # Validate SSL configuration if enabled
         if ssl_enabled:
-            if not ssl_cert_path or not os.path.exists(ssl_cert_path):
+            if not ssl_cert_path or not Path(ssl_cert_path).exists():
                 self.logger.warning(f"SSL cert not found: {ssl_cert_path}")
                 ssl_enabled = False
-            elif not ssl_key_path or not os.path.exists(ssl_key_path):
+            elif not ssl_key_path or not Path(ssl_key_path).exists():
                 self.logger.warning(f"SSL key not found: {ssl_key_path}")
                 ssl_enabled = False
 
@@ -687,7 +683,7 @@ class AgentServer:
             display_host = f"{host}:{port}"
 
         self.logger.info(f"Starting server on {protocol}://{display_host}")
-        for route, agent in self.agents.items():
+        for agent in self.agents.values():
             # include_source defaults False -> 2-tuple at runtime; index to
             # avoid the union-tuple unpack ambiguity mypy sees.
             creds = agent.get_basic_auth_credentials()
@@ -860,7 +856,7 @@ class AgentServer:
                 if full_path == route.lstrip("/"):
                     # This is a request to an agent's root without trailing slash
                     return await agent._handle_root_request(request)
-                elif full_path.startswith(route.lstrip("/") + "/"):
+                if full_path.startswith(route.lstrip("/") + "/"):
                     # This is a request to an agent's sub-path
                     relative_path = full_path[len(route.lstrip("/")) :]
                     relative_path = relative_path.lstrip("/")
@@ -872,21 +868,18 @@ class AgentServer:
                     clean_path = relative_path.rstrip("/")
                     if clean_path == "debug":
                         return await agent._handle_debug_request(request)
-                    elif clean_path == "swaig":
+                    if clean_path == "swaig":
                         from fastapi import Response
 
                         return await agent._handle_swaig_request(request, Response())
-                    elif clean_path == "post_prompt":
+                    if clean_path == "post_prompt":
                         return await agent._handle_post_prompt_request(request)
-                    elif clean_path == "check_for_input":
+                    if clean_path == "check_for_input":
                         return await agent._handle_check_for_input_request(request)
 
                     # Check for custom routing callbacks
                     if hasattr(agent, "_routing_callbacks"):
-                        for (
-                            callback_path,
-                            callback_fn,
-                        ) in agent._routing_callbacks.items():
+                        for callback_path in agent._routing_callbacks:
                             cb_path_clean = callback_path.strip("/")
                             if clean_path == cb_path_clean:
                                 request.state.callback_path = callback_path
@@ -895,7 +888,7 @@ class AgentServer:
             # No matching agent - check for static files
             if hasattr(self, "_static_directories"):
                 # Check each static directory route
-                for static_route, static_dir in self._static_directories.items():
+                for static_route in self._static_directories:
                     # For root static route, serve any unmatched path
                     if static_route == "" or static_route == "/":
                         response = self._serve_static_file(full_path, "")

{signalwire_sdk-3.0.2.dev63 → signalwire_sdk-3.0.2.dev64}/signalwire/signalwire/cli/build_search.py

@@ -27,7 +27,7 @@ def _mask_connection_string(conn_str):
                 + (f":{parsed.port}" if parsed.port else "")
             )
             return urlunparse(masked)
-    except Exception:
+    except Exception:  # noqa: S110  # best-effort password masking for display; falls through to "****" on any parse failure
         pass
     return "****"
 
@@ -538,7 +538,7 @@ Examples:
                             },
                         }
 
-                        with open(json_path, "w", encoding="utf-8") as f:
+                        with json_path.open("w", encoding="utf-8") as f:
                             json.dump(chunk_data, f, indent=2, ensure_ascii=False)
 
                         chunk_files_created.append(json_path)
@@ -548,7 +548,7 @@ Examples:
                         # Accumulate all chunks for single file output
                         all_chunks.extend(chunks)
 
-                except Exception as e:
+                except Exception as e:  # noqa: PERF203  # per-iteration error isolation: one failed file must not abort the batch
                     print(f"Error processing {file_path}: {e}")
                     if args.verbose:
                         import traceback
@@ -567,7 +567,7 @@ Examples:
                     },
                 }
 
-                with open(args.output, "w", encoding="utf-8") as f:
+                with Path(args.output).open("w", encoding="utf-8") as f:
                     json.dump(output_data, f, indent=2, ensure_ascii=False)
 
                 print(f"✓ Exported {len(all_chunks)} chunks to {args.output}")
@@ -577,7 +577,7 @@ Examples:
                 )
                 total_chunks = 0
                 for chunk_file in chunk_files_created:
-                    with open(chunk_file) as fh:
+                    with chunk_file.open() as fh:
                         total_chunks += len(json.load(fh)["chunks"])
                 print(f"  Total chunks: {total_chunks}")
 
@@ -634,7 +634,11 @@ Examples:
             # Check if the index was actually created
             import os
 
-            if os.path.exists(args.output):
+            # Rationale for PTH110 suppression below: tests patch global
+            # os.path.exists separately from pathlib.Path.exists to drive this
+            # post-build check; Path.exists() would pick up the unrelated Path
+            # mock and break the test seam.
+            if os.path.exists(args.output):  # noqa: PTH110
                 print(f"\n✓ Search index created successfully: {args.output}")
             else:
                 print("\n✗ Search index creation failed - no files were processed")
@@ -771,10 +775,11 @@ def search_command():
         args.model = MODEL_ALIASES[args.model]
 
     # Validate keyword weight if provided
-    if args.keyword_weight is not None:
-        if args.keyword_weight < 0.0 or args.keyword_weight > 1.0:
-            print("Error: --keyword-weight must be between 0.0 and 1.0")
-            sys.exit(1)
+    if args.keyword_weight is not None and (
+        args.keyword_weight < 0.0 or args.keyword_weight > 1.0
+    ):
+        print("Error: --keyword-weight must be between 0.0 and 1.0")
+        sys.exit(1)
 
     # Validate backend configuration
     if args.backend == "pgvector" and not args.connection_string:
@@ -1540,17 +1545,17 @@ Examples:
             sys.argv.pop(1)
             validate_command()
             return
-        elif sys.argv[1] == "search":
+        if sys.argv[1] == "search":
             # Remove 'search' from argv and call search_command
             sys.argv.pop(1)
             search_command()
             return
-        elif sys.argv[1] == "remote":
+        if sys.argv[1] == "remote":
             # Remove 'remote' from argv and call remote_command
             sys.argv.pop(1)
             remote_command()
             return
-        elif sys.argv[1] == "migrate":
+        if sys.argv[1] == "migrate":
             # Remove 'migrate' from argv and call migrate_command
             sys.argv.pop(1)
             migrate_command()

{signalwire_sdk-3.0.2.dev63 → signalwire_sdk-3.0.2.dev64}/signalwire/signalwire/cli/core/agent_loader.py

@@ -124,7 +124,7 @@ def _discover_services_impl(service_path: str) -> List[Dict[str, Any]]:
         # Clean up sys.path if we added to it
         if sys_path_added:
             sys.path.remove(module_dir)
-        raise ImportError(f"Failed to load service module: {e}")
+        raise ImportError(f"Failed to load service module: {e}") from e
     finally:
         # Clean up sys.path after successful load too
         if sys_path_added and module_dir in sys.path:
@@ -308,7 +308,7 @@ def _load_service_impl(
         # Clean up sys.path if we added to it
         if sys_path_added:
             sys.path.remove(module_dir)
-        raise ImportError(f"Failed to load service module: {e}")
+        raise ImportError(f"Failed to load service module: {e}") from e
     finally:
         # Clean up sys.path after successful load too
         if sys_path_added and module_dir in sys.path:
@@ -320,15 +320,18 @@ def _load_service_impl(
     # If service_identifier is specified and prefer_route is True, try to find by route first
     if service_identifier and prefer_route:
         # First, try to find an existing instance with matching route
-        for name, obj in vars(module).items():
-            if isinstance(obj, SWMLService) and hasattr(obj, "route"):
-                if obj.route == service_identifier:
-                    service = obj
-                    break
+        for obj in vars(module).values():
+            if (
+                isinstance(obj, SWMLService)
+                and hasattr(obj, "route")
+                and obj.route == service_identifier
+            ):
+                service = obj
+                break
 
         # If not found, try instantiating classes to check their routes
         if service is None:
-            for name, obj in vars(module).items():
+            for obj in vars(module).values():
                 if (
                     isinstance(obj, type)
                     and issubclass(obj, SWMLService)
@@ -344,7 +347,7 @@ def _load_service_impl(
                         ):
                             service = temp_instance
                             break
-                    except Exception:
+                    except Exception:  # noqa: S110  # intentional: skip classes that can't be instantiated during discovery
                         # Skip classes that can't be instantiated
                         pass
 
@@ -357,7 +360,7 @@ def _load_service_impl(
                 except Exception as e:
                     raise ValueError(
                         f"No service found with route '{service_identifier}' and failed to instantiate class '{service_identifier}': {e}"
-                    )
+                    ) from e
             elif isinstance(obj, SWMLService):
                 service = obj
 
@@ -382,7 +385,7 @@ def _load_service_impl(
                 except Exception as e:
                     raise ValueError(
                         f"Failed to instantiate service class '{service_identifier}': {e}"
-                    )
+                    ) from e
             elif isinstance(obj, SWMLService):
                 # It's already an instance
                 service = obj
@@ -461,7 +464,7 @@ def _load_service_impl(
                             "service_name": service_name,
                         }
                     )
-                except Exception:
+                except Exception:  # noqa: PERF203  # per-iteration error isolation: one class that fails to instantiate must not abort discovery
                     # If instantiation fails, still include the class
                     service_info.append(
                         {

{signalwire_sdk-3.0.2.dev63 → signalwire_sdk-3.0.2.dev64}/signalwire/signalwire/cli/core/argparse_helpers.py

@@ -104,20 +104,14 @@ def parse_function_arguments(
         # DataMap function
         if "parameters" in func_schema:
             params = func_schema["parameters"]
-            if "properties" in params:
-                parameters = params["properties"]
-            else:
-                parameters = params
+            parameters = params.get("properties", params)
         else:
             parameters = func_schema
     else:
         # Regular SWAIG function
         if hasattr(func_schema, "parameters") and func_schema.parameters:
             params = func_schema.parameters
-            if "properties" in params:
-                parameters = params["properties"]
-            else:
-                parameters = params
+            parameters = params.get("properties", params)
 
     # Parse arguments
     while i < len(function_args_list):
@@ -165,8 +159,7 @@ def parse_function_arguments(
                             f"CLI flag --{param_name} must come BEFORE --exec, not after.\n"
                             f"Example: swaig-test file.py --{param_name} --exec function_name"
                         )
-                    else:
-                        raise ValueError(f"Parameter --{param_name} requires a value")
+                    raise ValueError(f"Parameter --{param_name} requires a value")
 
                 value = function_args_list[i + 1]
 
@@ -177,14 +170,14 @@ def parse_function_arguments(
                     except ValueError:
                         raise ValueError(
                             f"Parameter --{param_name} must be an integer, got: {value}"
-                        )
+                        ) from None
                 elif param_type == "number":
                     try:
                         parsed_args[param_key] = float(value)
                     except ValueError:
                         raise ValueError(
                             f"Parameter --{param_name} must be a number, got: {value}"
-                        )
+                        ) from None
                 elif param_type == "array":
                     # Handle comma-separated arrays
                     parsed_args[param_key] = [item.strip() for item in value.split(",")]

{signalwire_sdk-3.0.2.dev63 → signalwire_sdk-3.0.2.dev64}/signalwire/signalwire/cli/core/service_loader.py

@@ -108,7 +108,7 @@ class ServiceCapture:
                     # Module might have called run/serve which we intercepted
                     if not self.captured_services:
                         # If we didn't capture anything, the error is real
-                        raise ImportError(f"Failed to load service module: {e}")
+                        raise ImportError(f"Failed to load service module: {e}") from e
         finally:
             # Always restore original methods
             self._restore_patches()
@@ -196,11 +196,10 @@ async def simulate_request_to_service(
         import json
 
         return json.loads(result.body.decode())
-    elif isinstance(result, dict):
+    if isinstance(result, dict):
         return result
-    else:
-        # Try to get content from response
-        return {"error": "Unable to parse response"}
+    # Try to get content from response
+    return {"error": "Unable to parse response"}
 
 
 def load_and_simulate_service(
@@ -263,7 +262,7 @@ def load_and_simulate_service(
             )
 
     # Simulate the request
-    assert service is not None  # guaranteed by the selection logic above
+    assert service is not None  # noqa: S101  # type-narrowing invariant (not input validation): guaranteed by the selection logic above
     return asyncio.run(
         simulate_request_to_service(
             service,
@@ -317,19 +316,16 @@ def discover_agents_in_file(agent_path: str) -> List[Dict[str, Any]]:
     services = capturer.capture(agent_path)
 
     # Convert to old format
-    agents_found = []
-    for service in services:
-        if isinstance(service, AgentBase):
-            agents_found.append(
-                {
-                    "name": service.name,
-                    "class_name": service.__class__.__name__,
-                    "type": "instance",
-                    "agent_name": service.name,
-                    "route": service.route,
-                    "description": service.__class__.__doc__,
-                    "object": service,
-                }
-            )
-
-    return agents_found
+    return [
+        {
+            "name": service.name,
+            "class_name": service.__class__.__name__,
+            "type": "instance",
+            "agent_name": service.name,
+            "route": service.route,
+            "description": service.__class__.__doc__,
+            "object": service,
+        }
+        for service in services
+        if isinstance(service, AgentBase)
+    ]