Error: {query_params['error'][0]}
+Error: {query_params["error"][0]}
You can close this window and return to the terminal.
diff --git a/paper_experiments/doc_qa_task/doc_qa.py b/paper_experiments/doc_qa_task/doc_qa.py index af2cf86a..a999de11 100644 --- a/paper_experiments/doc_qa_task/doc_qa.py +++ b/paper_experiments/doc_qa_task/doc_qa.py @@ -100,7 +100,7 @@ def generate_docqa_baseline_response( # print(f"Top {num_documents} documents: {documents_search_results_sorted_by_relevance}") # compute truncation length - extra_text = BASELINE_PROMPT + f"Question: {question}" + f"Answer:" + extra_text = BASELINE_PROMPT + f"Question: {question}" + "Answer:" padding = count_tokens(extra_text) + 1000 truncation_length = int((config.default_llm_config.context_window - padding) / num_documents) print("Token size", config.default_llm_config.context_window) @@ -114,7 +114,7 @@ def generate_docqa_baseline_response( if i >= num_documents: break - doc_prompt = f"Document [{i+1}]: {doc} \n" + doc_prompt = f"Document [{i + 1}]: {doc} \n" # truncate (that's why the performance goes down as x-axis increases) if truncation_length is not None: diff --git a/paper_experiments/doc_qa_task/llm_judge_doc_qa.py b/paper_experiments/doc_qa_task/llm_judge_doc_qa.py index c6ff6cfe..c7d1d385 100644 --- a/paper_experiments/doc_qa_task/llm_judge_doc_qa.py +++ b/paper_experiments/doc_qa_task/llm_judge_doc_qa.py @@ -124,7 +124,7 @@ if __name__ == "__main__": if a in response: found = True - if not found and not "INSUFFICIENT INFORMATION" in response: + if not found and "INSUFFICIENT INFORMATION" not in response: # inconclusive: pass to llm judge print(question) print(answer) diff --git a/paper_experiments/nested_kv_task/nested_kv.py b/paper_experiments/nested_kv_task/nested_kv.py index 4f439072..2f259227 100644 --- a/paper_experiments/nested_kv_task/nested_kv.py +++ b/paper_experiments/nested_kv_task/nested_kv.py @@ -61,13 +61,13 @@ def archival_memory_text_search(self, query: str, page: Optional[int] = 0) -> Op try: page = int(page) except: - raise ValueError(f"'page' argument must be an integer") + raise ValueError("'page' argument must be an integer") count = 10 results = self.persistence_manager.archival_memory.storage.query_text(query, limit=count, offset=page * count) total = len(results) num_pages = math.ceil(total / count) - 1 # 0 index if len(results) == 0: - results_str = f"No results found." + results_str = "No results found." else: results_pref = f"Showing {len(results)} of {total} results (page {page}/{num_pages}):" results_formatted = [f"memory: {d.text}" for d in results] @@ -253,8 +253,8 @@ if __name__ == "__main__": # overwrite kv_d[current_key] = next_key - print(f"Nested {i+1}") - print(f"Done") + print(f"Nested {i + 1}") + print("Done") def get_nested_key(original_key, kv_d): key = original_key diff --git a/pyproject.toml b/pyproject.toml index 53acd84f..062c53f2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -67,6 +67,7 @@ dependencies = [ "certifi>=2025.6.15", "markitdown[docx,pdf,pptx]>=0.1.2", "orjson>=3.11.1", + "ruff[dev]>=0.12.10", ] [project.scripts] @@ -108,11 +109,8 @@ dev = [ "pytest-mock>=3.14.0", "pytest-json-report>=1.5.0", "pexpect>=4.9.0", - "black[jupyter]>=24.4.2", "pre-commit>=3.5.0", "pyright>=1.1.347", - "autoflake>=2.3.0", - "isort>=5.13.2", "ipykernel>=6.29.5", "ipdb>=0.13.13", ] @@ -149,18 +147,46 @@ build-backend = "hatchling.build" [tool.hatch.build.targets.wheel] packages = ["letta"] -[tool.black] -line-length = 140 -target-version = ['py310', 'py311', 'py312', 'py313'] -extend-exclude = "examples/*" -[tool.isort] -profile = "black" -line_length = 140 -multi_line_output = 3 -include_trailing_comma = true -force_grid_wrap = 0 -use_parentheses = true +[tool.ruff] +line-length = 140 +target-version = "py312" +extend-exclude = [ + "examples/*", + "tests/data/*", +] + +[tool.ruff.lint] +select = [ + "E", # pycodestyle errors + "W", # pycodestyle warnings + "F", # pyflakes + "I", # isort +] +ignore = [ + "E501", # line too long (handled by formatter) + "E402", # module import not at top of file + "E711", # none-comparison + "E712", # true-false-comparison + "E722", # bare except + "E721", # type comparison + "F401", # unused import + "F821", # undefined name + "F811", # redefined while unused + "F841", # local variable assigned but never used + "W293", # blank line contains whitespace +] + +[tool.ruff.lint.isort] +force-single-line = false +combine-as-imports = true +split-on-trailing-comma = true + +[tool.ruff.format] +quote-style = "double" +indent-style = "space" +skip-magic-trailing-comma = false +line-ending = "auto" [tool.pytest.ini_options] asyncio_mode = "auto" diff --git a/tests/helpers/endpoints_helper.py b/tests/helpers/endpoints_helper.py index 72b91b69..bef12971 100644 --- a/tests/helpers/endpoints_helper.py +++ b/tests/helpers/endpoints_helper.py @@ -143,7 +143,7 @@ def assert_invoked_send_message_with_keyword(messages: Sequence[LettaMessage], k # Message field not in send_message if "message" not in arguments: raise InvalidToolCallError( - messages=[target_message], explanation=f"send_message function call does not have required field `message`" + messages=[target_message], explanation="send_message function call does not have required field `message`" ) # Check that the keyword is in the message arguments @@ -151,7 +151,7 @@ def assert_invoked_send_message_with_keyword(messages: Sequence[LettaMessage], k keyword = keyword.lower() arguments["message"] = arguments["message"].lower() - if not keyword in arguments["message"]: + if keyword not in arguments["message"]: raise InvalidToolCallError(messages=[target_message], explanation=f"Message argument did not contain keyword={keyword}") diff --git a/tests/helpers/utils.py b/tests/helpers/utils.py index 2d4036ef..72df6806 100644 --- a/tests/helpers/utils.py +++ b/tests/helpers/utils.py @@ -12,8 +12,7 @@ from letta.schemas.enums import MessageRole from letta.schemas.file import FileAgent from letta.schemas.memory import ContextWindowOverview from letta.schemas.tool import Tool -from letta.schemas.user import User -from letta.schemas.user import User as PydanticUser +from letta.schemas.user import User, User as PydanticUser from letta.server.rest_api.routers.v1.agents import ImportedAgentsResponse from letta.server.server import SyncServer @@ -66,7 +65,6 @@ def retry_until_success(max_attempts=10, sleep_time_seconds=4): def decorator_retry(func): @functools.wraps(func) def wrapper(*args, **kwargs): - for attempt in range(1, max_attempts + 1): try: return func(*args, **kwargs) @@ -124,32 +122,32 @@ def comprehensive_agent_checks(agent: AgentState, request: Union[CreateAgent, Up assert agent.llm_config == request.llm_config, f"LLM config mismatch: {agent.llm_config} != {request.llm_config}" # Assert embedding configuration - assert ( - agent.embedding_config == request.embedding_config - ), f"Embedding config mismatch: {agent.embedding_config} != {request.embedding_config}" + assert agent.embedding_config == request.embedding_config, ( + f"Embedding config mismatch: {agent.embedding_config} != {request.embedding_config}" + ) # Assert memory blocks if hasattr(request, "memory_blocks"): - assert len(agent.memory.blocks) == len(request.memory_blocks) + len( - request.block_ids - ), f"Memory blocks count mismatch: {len(agent.memory.blocks)} != {len(request.memory_blocks) + len(request.block_ids)}" + assert len(agent.memory.blocks) == len(request.memory_blocks) + len(request.block_ids), ( + f"Memory blocks count mismatch: {len(agent.memory.blocks)} != {len(request.memory_blocks) + len(request.block_ids)}" + ) memory_block_values = {block.value for block in agent.memory.blocks} expected_block_values = {block.value for block in request.memory_blocks} - assert expected_block_values.issubset( - memory_block_values - ), f"Memory blocks mismatch: {expected_block_values} not in {memory_block_values}" + assert expected_block_values.issubset(memory_block_values), ( + f"Memory blocks mismatch: {expected_block_values} not in {memory_block_values}" + ) # Assert tools assert len(agent.tools) == len(request.tool_ids), f"Tools count mismatch: {len(agent.tools)} != {len(request.tool_ids)}" - assert {tool.id for tool in agent.tools} == set( - request.tool_ids - ), f"Tools mismatch: {set(tool.id for tool in agent.tools)} != {set(request.tool_ids)}" + assert {tool.id for tool in agent.tools} == set(request.tool_ids), ( + f"Tools mismatch: {set(tool.id for tool in agent.tools)} != {set(request.tool_ids)}" + ) # Assert sources assert len(agent.sources) == len(request.source_ids), f"Sources count mismatch: {len(agent.sources)} != {len(request.source_ids)}" - assert {source.id for source in agent.sources} == set( - request.source_ids - ), f"Sources mismatch: {set(source.id for source in agent.sources)} != {set(request.source_ids)}" + assert {source.id for source in agent.sources} == set(request.source_ids), ( + f"Sources mismatch: {set(source.id for source in agent.sources)} != {set(request.source_ids)}" + ) # Assert tags assert set(agent.tags) == set(request.tags), f"Tags mismatch: {set(agent.tags)} != {set(request.tags)}" @@ -158,15 +156,15 @@ def comprehensive_agent_checks(agent: AgentState, request: Union[CreateAgent, Up print("TOOLRULES", request.tool_rules) print("AGENTTOOLRULES", agent.tool_rules) if request.tool_rules: - assert len(agent.tool_rules) == len( - request.tool_rules - ), f"Tool rules count mismatch: {len(agent.tool_rules)} != {len(request.tool_rules)}" - assert all( - any(rule.tool_name == req_rule.tool_name for rule in agent.tool_rules) for req_rule in request.tool_rules - ), f"Tool rules mismatch: {agent.tool_rules} != {request.tool_rules}" + assert len(agent.tool_rules) == len(request.tool_rules), ( + f"Tool rules count mismatch: {len(agent.tool_rules)} != {len(request.tool_rules)}" + ) + assert all(any(rule.tool_name == req_rule.tool_name for rule in agent.tool_rules) for req_rule in request.tool_rules), ( + f"Tool rules mismatch: {agent.tool_rules} != {request.tool_rules}" + ) # Assert message_buffer_autoclear - if not request.message_buffer_autoclear is None: + if request.message_buffer_autoclear is not None: assert agent.message_buffer_autoclear == request.message_buffer_autoclear @@ -176,9 +174,9 @@ def validate_context_window_overview( """Validate common sense assertions for ContextWindowOverview""" # 1. Current context size should not exceed maximum - assert ( - overview.context_window_size_current <= overview.context_window_size_max - ), f"Current context size ({overview.context_window_size_current}) exceeds maximum ({overview.context_window_size_max})" + assert overview.context_window_size_current <= overview.context_window_size_max, ( + f"Current context size ({overview.context_window_size_current}) exceeds maximum ({overview.context_window_size_max})" + ) # 2. All token counts should be non-negative assert overview.num_tokens_system >= 0, "System token count cannot be negative" @@ -197,14 +195,14 @@ def validate_context_window_overview( + overview.num_tokens_messages + overview.num_tokens_functions_definitions ) - assert ( - overview.context_window_size_current == expected_total - ), f"Token sum ({expected_total}) doesn't match current size ({overview.context_window_size_current})" + assert overview.context_window_size_current == expected_total, ( + f"Token sum ({expected_total}) doesn't match current size ({overview.context_window_size_current})" + ) # 4. Message count should match messages list length - assert ( - len(overview.messages) == overview.num_messages - ), f"Messages list length ({len(overview.messages)}) doesn't match num_messages ({overview.num_messages})" + assert len(overview.messages) == overview.num_messages, ( + f"Messages list length ({len(overview.messages)}) doesn't match num_messages ({overview.num_messages})" + ) # 5. If summary_memory is None, its token count should be 0 if overview.summary_memory is None: diff --git a/tests/integration_test_batch_api_cron_jobs.py b/tests/integration_test_batch_api_cron_jobs.py index 95d98bf2..6d6fea28 100644 --- a/tests/integration_test_batch_api_cron_jobs.py +++ b/tests/integration_test_batch_api_cron_jobs.py @@ -141,7 +141,7 @@ def create_test_agent(name, actor, test_id: Optional[str] = None, model="anthrop model_endpoint_type="anthropic", model_endpoint="https://api.anthropic.com/v1", context_window=32000, - handle=f"anthropic/claude-3-7-sonnet-latest", + handle="anthropic/claude-3-7-sonnet-latest", put_inner_thoughts_in_kwargs=True, max_tokens=4096, ) @@ -193,7 +193,7 @@ async def create_test_batch_item(server, batch_id, agent_id, default_user): model_endpoint_type="anthropic", model_endpoint="https://api.anthropic.com/v1", context_window=32000, - handle=f"anthropic/claude-3-7-sonnet-latest", + handle="anthropic/claude-3-7-sonnet-latest", put_inner_thoughts_in_kwargs=True, max_tokens=4096, ) diff --git a/tests/integration_test_builtin_tools.py b/tests/integration_test_builtin_tools.py index 7257d7d2..367de6c3 100644 --- a/tests/integration_test_builtin_tools.py +++ b/tests/integration_test_builtin_tools.py @@ -219,7 +219,7 @@ def test_run_code( returns = [m.tool_return for m in tool_returns] assert any(expected in ret for ret in returns), ( - f"For language={language!r}, expected to find '{expected}' in tool_return, " f"but got {returns!r}" + f"For language={language!r}, expected to find '{expected}' in tool_return, but got {returns!r}" ) @@ -357,7 +357,6 @@ async def test_web_search_uses_agent_env_var_model(): patch.dict(os.environ, {WEB_SEARCH_MODEL_ENV_VAR_NAME: "gpt-4o"}), patch("firecrawl.AsyncFirecrawlApp") as mock_firecrawl_class, ): - # setup mocks mock_model_settings.openai_api_key = "test-key" diff --git a/tests/integration_test_chat_completions.py b/tests/integration_test_chat_completions.py index 1c17b4e4..d16be074 100644 --- a/tests/integration_test_chat_completions.py +++ b/tests/integration_test_chat_completions.py @@ -11,8 +11,7 @@ from openai.types.chat.chat_completion_chunk import ChatCompletionChunk from letta.schemas.embedding_config import EmbeddingConfig from letta.schemas.enums import MessageStreamStatus from letta.schemas.llm_config import LLMConfig -from letta.schemas.openai.chat_completion_request import ChatCompletionRequest -from letta.schemas.openai.chat_completion_request import UserMessage as OpenAIUserMessage +from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, UserMessage as OpenAIUserMessage from letta.schemas.tool import ToolCreate from letta.schemas.usage import LettaUsageStatistics from letta.services.tool_manager import ToolManager diff --git a/tests/integration_test_send_message.py b/tests/integration_test_send_message.py index 185f88f6..a63c6d43 100644 --- a/tests/integration_test_send_message.py +++ b/tests/integration_test_send_message.py @@ -92,7 +92,7 @@ USER_MESSAGE_FORCE_LONG_REPLY: List[MessageCreate] = [ USER_MESSAGE_GREETING: List[MessageCreate] = [ MessageCreate( role="user", - content=f"Hi!", + content="Hi!", otid=USER_MESSAGE_OTID, ) ] @@ -464,9 +464,9 @@ def validate_google_format_scrubbing(contents: List[Dict[str, Any]]) -> None: args = function_call.get("args", {}) # Assert that there is no 'thinking' field in the function call arguments - assert ( - "thinking" not in args - ), f"Found 'thinking' field in Google model functionCall args (inner thoughts not scrubbed): {args.get('thinking')}" + assert "thinking" not in args, ( + f"Found 'thinking' field in Google model functionCall args (inner thoughts not scrubbed): {args.get('thinking')}" + ) def assert_image_input_response( diff --git a/tests/integration_test_voice_agent.py b/tests/integration_test_voice_agent.py index 4390e978..4026a07d 100644 --- a/tests/integration_test_voice_agent.py +++ b/tests/integration_test_voice_agent.py @@ -20,8 +20,7 @@ from letta.schemas.letta_message import AssistantMessage, ReasoningMessage, Tool from letta.schemas.letta_message_content import TextContent from letta.schemas.llm_config import LLMConfig from letta.schemas.message import Message, MessageCreate -from letta.schemas.openai.chat_completion_request import ChatCompletionRequest -from letta.schemas.openai.chat_completion_request import UserMessage as OpenAIUserMessage +from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, UserMessage as OpenAIUserMessage from letta.schemas.usage import LettaUsageStatistics from letta.server.server import SyncServer from letta.services.agent_manager import AgentManager diff --git a/tests/mcp_tests/test_mcp.py b/tests/mcp_tests/test_mcp.py index 71eabbe5..54fa786c 100644 --- a/tests/mcp_tests/test_mcp.py +++ b/tests/mcp_tests/test_mcp.py @@ -63,7 +63,7 @@ def create_virtualenv_and_install_requirements(requirements_path: Path, name="ve except subprocess.CalledProcessError as exc: # On failure, try to clean up and recreate once more if not force_recreate: # Avoid infinite recursion - print(f"Initial pip install failed, attempting clean recreation...") + print("Initial pip install failed, attempting clean recreation...") return create_virtualenv_and_install_requirements(requirements_path, name, force_recreate=False) raise RuntimeError(f"pip install failed with exit code {exc.returncode}") diff --git a/tests/mcp_tests/weather/weather.py b/tests/mcp_tests/weather/weather.py index 599b8fd1..8079cd4a 100644 --- a/tests/mcp_tests/weather/weather.py +++ b/tests/mcp_tests/weather/weather.py @@ -27,11 +27,11 @@ def format_alert(feature: dict) -> str: """Format an alert feature into a readable string.""" props = feature["properties"] return f""" -Event: {props.get('event', 'Unknown')} -Area: {props.get('areaDesc', 'Unknown')} -Severity: {props.get('severity', 'Unknown')} -Description: {props.get('description', 'No description available')} -Instructions: {props.get('instruction', 'No specific instructions provided')} +Event: {props.get("event", "Unknown")} +Area: {props.get("areaDesc", "Unknown")} +Severity: {props.get("severity", "Unknown")} +Description: {props.get("description", "No description available")} +Instructions: {props.get("instruction", "No specific instructions provided")} """ @@ -82,10 +82,10 @@ async def get_forecast(latitude: float, longitude: float) -> str: forecasts = [] for period in periods[:5]: # Only show next 5 periods forecast = f""" -{period['name']}: -Temperature: {period['temperature']}°{period['temperatureUnit']} -Wind: {period['windSpeed']} {period['windDirection']} -Forecast: {period['detailedForecast']} +{period["name"]}: +Temperature: {period["temperature"]}°{period["temperatureUnit"]} +Wind: {period["windSpeed"]} {period["windDirection"]} +Forecast: {period["detailedForecast"]} """ forecasts.append(forecast) diff --git a/tests/test_agent_serialization.py b/tests/test_agent_serialization.py index c5272bcb..90588f0c 100644 --- a/tests/test_agent_serialization.py +++ b/tests/test_agent_serialization.py @@ -350,9 +350,9 @@ def compare_in_context_message_id_remapping(server, og_agent: AgentState, copy_a in_context_messages_copy = server.agent_manager.get_in_context_messages(agent_id=copy_agent.id, actor=copy_user) # 1. Check if the number of messages is the same - assert len(in_context_messages_og) == len( - in_context_messages_copy - ), f"Original message count ({len(in_context_messages_og)}) differs from copy ({len(in_context_messages_copy)})" + assert len(in_context_messages_og) == len(in_context_messages_copy), ( + f"Original message count ({len(in_context_messages_og)}) differs from copy ({len(in_context_messages_copy)})" + ) # 2. Iterate and compare messages by order, checking content equality and ID difference if not in_context_messages_og: diff --git a/tests/test_agent_serialization_v2.py b/tests/test_agent_serialization_v2.py index 3a7c004d..40cfb401 100644 --- a/tests/test_agent_serialization_v2.py +++ b/tests/test_agent_serialization_v2.py @@ -979,9 +979,9 @@ class TestAgentFileExport: exported_agent = agent_file.agents[0] for message in exported_agent.messages: - assert ( - message.agent_id == exported_agent.id - ), f"Message {message.id} has agent_id {message.agent_id}, expected {exported_agent.id}" + assert message.agent_id == exported_agent.id, ( + f"Message {message.id} has agent_id {message.agent_id}, expected {exported_agent.id}" + ) assert exported_agent.id == "agent-0" assert exported_agent.id != test_agent.id diff --git a/tests/test_cli.py b/tests/test_cli.py index f1052bd7..3b34cb80 100644 --- a/tests/test_cli.py +++ b/tests/test_cli.py @@ -71,10 +71,10 @@ def test_letta_run_create_new_agent(swap_letta_config): assert full_output is not None, "No output was captured." # Count occurrences of inner thoughts cloud_emoji_count = full_output.count(INNER_THOUGHTS_CLI_SYMBOL) - assert cloud_emoji_count == 1, f"It appears that there are multiple instances of inner thought outputted." + assert cloud_emoji_count == 1, "It appears that there are multiple instances of inner thought outputted." # Count occurrences of assistant messages robot = full_output.count(ASSISTANT_MESSAGE_CLI_SYMBOL) - assert robot == 1, f"It appears that there are multiple instances of assistant messages outputted." + assert robot == 1, "It appears that there are multiple instances of assistant messages outputted." def test_letta_version_prints_only_version(swap_letta_config): diff --git a/tests/test_client.py b/tests/test_client.py index d3de1bc1..caf37cd4 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -675,9 +675,9 @@ def test_timezone(client: Letta): pacific_tz_indicators = {"America/Los_Angeles", "PDT", "PST", "PT", "Pacific Daylight Time", "Pacific Standard Time", "Pacific Time"} content = response.messages[1].content - assert any( - tz in content for tz in pacific_tz_indicators - ), f"Response content: {response.messages[1].content} does not contain expected timezone" + assert any(tz in content for tz in pacific_tz_indicators), ( + f"Response content: {response.messages[1].content} does not contain expected timezone" + ) # test updating the timezone client.agents.modify(agent_id=agent.id, timezone="America/New_York") @@ -686,7 +686,6 @@ def test_timezone(client: Letta): def test_attach_sleeptime_block(client: Letta): - agent = client.agents.create( memory_blocks=[{"label": "human", "value": ""}, {"label": "persona", "value": ""}], model="letta/letta-free", diff --git a/tests/test_google_embeddings.py b/tests/test_google_embeddings.py index dcaad596..5f879933 100644 --- a/tests/test_google_embeddings.py +++ b/tests/test_google_embeddings.py @@ -10,9 +10,7 @@ import threading import time import pytest -from letta_client import CreateBlock -from letta_client import Letta as LettaSDKClient -from letta_client import MessageCreate +from letta_client import CreateBlock, Letta as LettaSDKClient, MessageCreate SERVER_PORT = 8283 @@ -71,7 +69,7 @@ def test_archival_insert_text_embedding_004(client: LettaSDKClient): """ # Create an agent with the specified model and embedding. agent = client.agents.create( - name=f"archival_insert_text_embedding_004", + name="archival_insert_text_embedding_004", memory_blocks=[ CreateBlock(label="human", value="name: archival_test"), CreateBlock(label="persona", value="You are a helpful assistant that loves helping out the user"), @@ -98,9 +96,9 @@ def test_archival_insert_text_embedding_004(client: LettaSDKClient): print(archived_messages.messages) # Assert that the archival message is present. - assert any( - message.status == "success" for message in archived_messages.messages if message.message_type == "tool_return_message" - ), f"Archival message '{archival_message}' not found. Archived messages: {archived_messages}" + assert any(message.status == "success" for message in archived_messages.messages if message.message_type == "tool_return_message"), ( + f"Archival message '{archival_message}' not found. Archived messages: {archived_messages}" + ) # Cleanup: Delete the agent. client.agents.delete(agent.id) @@ -119,7 +117,7 @@ def test_archival_insert_embedding_001(client: LettaSDKClient): """ # Create an agent with the specified model and embedding. agent = client.agents.create( - name=f"archival_insert_embedding_001", + name="archival_insert_embedding_001", memory_blocks=[ CreateBlock(label="human", value="name: archival_test"), CreateBlock(label="persona", value="You are a helpful assistant that loves helping out the user"), @@ -144,9 +142,9 @@ def test_archival_insert_embedding_001(client: LettaSDKClient): ) # Assert that the archival message is present. - assert any( - message.status == "success" for message in archived_messages.messages if message.message_type == "tool_return_message" - ), f"Archival message '{archival_message}' not found. Archived messages: {archived_messages}" + assert any(message.status == "success" for message in archived_messages.messages if message.message_type == "tool_return_message"), ( + f"Archival message '{archival_message}' not found. Archived messages: {archived_messages}" + ) # Cleanup: Delete the agent. client.agents.delete(agent.id) diff --git a/tests/test_letta_agent_batch.py b/tests/test_letta_agent_batch.py index 8f5241a0..afdb2f79 100644 --- a/tests/test_letta_agent_batch.py +++ b/tests/test_letta_agent_batch.py @@ -379,7 +379,7 @@ async def test_rethink_tool_modify_agent_state(disable_e2b_api_key, server, defa ) agents = [agent] batch_requests = [ - LettaBatchRequest(agent_id=agent.id, messages=[MessageCreate(role="user", content=[TextContent(text=f"Rethink memory.")])]) + LettaBatchRequest(agent_id=agent.id, messages=[MessageCreate(role="user", content=[TextContent(text="Rethink memory.")])]) for agent in agents ] @@ -520,12 +520,12 @@ async def test_partial_error_from_anthropic_batch( print("POST", post_resume_response) print("PRE", pre_resume_response) - assert ( - post_resume_response.letta_batch_id == pre_resume_response.letta_batch_id - ), "resume_step_after_request is expected to have the same letta_batch_id" - assert ( - post_resume_response.last_llm_batch_id != pre_resume_response.last_llm_batch_id - ), "resume_step_after_request is expected to have different llm_batch_id." + assert post_resume_response.letta_batch_id == pre_resume_response.letta_batch_id, ( + "resume_step_after_request is expected to have the same letta_batch_id" + ) + assert post_resume_response.last_llm_batch_id != pre_resume_response.last_llm_batch_id, ( + "resume_step_after_request is expected to have different llm_batch_id." + ) assert post_resume_response.status == JobStatus.running # NOTE: We only expect 2 agents to continue (succeeded ones) assert post_resume_response.agent_count == 2 @@ -542,13 +542,13 @@ async def test_partial_error_from_anthropic_batch( # Confirm that tool_rules_solver state was preserved correctly # Assert every new item's step_state's tool_rules_solver has "get_weather" in the tool_call_history - assert all( - "get_weather" in item.step_state.tool_rules_solver.tool_call_history for item in new_items - ), "Expected 'get_weather' in tool_call_history for all new_items" + assert all("get_weather" in item.step_state.tool_rules_solver.tool_call_history for item in new_items), ( + "Expected 'get_weather' in tool_call_history for all new_items" + ) # Assert that each new item's step_number was incremented to 1 - assert all( - item.step_state.step_number == 1 for item in new_items - ), "Expected step_number to be incremented to 1 for all new_items" + assert all(item.step_state.step_number == 1 for item in new_items), ( + "Expected step_number to be incremented to 1 for all new_items" + ) # Old items must have been flipped to completed / finished earlier # (sanity – we already asserted this above, but we keep it close for clarity) @@ -572,20 +572,20 @@ async def test_partial_error_from_anthropic_batch( assert after == before, f"Agent {agent.id} should not have extra messages persisted due to Anthropic failure" else: assert after - before >= 2, ( - f"Agent {agent.id} should have an assistant tool‑call " f"and tool‑response message persisted." + f"Agent {agent.id} should have an assistant tool‑call and tool‑response message persisted." ) # Check that agent states have been properly modified to have extended in-context messages for agent in agents: refreshed_agent = server.agent_manager.get_agent_by_id(agent_id=agent.id, actor=default_user) if refreshed_agent.id == agents_failed[0].id: - assert ( - len(refreshed_agent.message_ids) == 4 - ), f"Agent's in-context messages have not been extended, are length: {len(refreshed_agent.message_ids)}" + assert len(refreshed_agent.message_ids) == 4, ( + f"Agent's in-context messages have not been extended, are length: {len(refreshed_agent.message_ids)}" + ) else: - assert ( - len(refreshed_agent.message_ids) == 6 - ), f"Agent's in-context messages have been extended, are length: {len(refreshed_agent.message_ids)}" + assert len(refreshed_agent.message_ids) == 6, ( + f"Agent's in-context messages have been extended, are length: {len(refreshed_agent.message_ids)}" + ) # Check the total list of messages messages = await server.batch_manager.get_messages_for_letta_batch_async( @@ -688,12 +688,12 @@ async def test_resume_step_some_stop( assert len(new_batch_responses) == 1 post_resume_response = new_batch_responses[0] - assert ( - post_resume_response.letta_batch_id == pre_resume_response.letta_batch_id - ), "resume_step_after_request is expected to have the same letta_batch_id" - assert ( - post_resume_response.last_llm_batch_id != pre_resume_response.last_llm_batch_id - ), "resume_step_after_request is expected to have different llm_batch_id." + assert post_resume_response.letta_batch_id == pre_resume_response.letta_batch_id, ( + "resume_step_after_request is expected to have the same letta_batch_id" + ) + assert post_resume_response.last_llm_batch_id != pre_resume_response.last_llm_batch_id, ( + "resume_step_after_request is expected to have different llm_batch_id." + ) assert post_resume_response.status == JobStatus.running # NOTE: We only expect 1 agent to continue assert post_resume_response.agent_count == 1 @@ -710,13 +710,13 @@ async def test_resume_step_some_stop( # Confirm that tool_rules_solver state was preserved correctly # Assert every new item's step_state's tool_rules_solver has "get_weather" in the tool_call_history - assert all( - "get_weather" in item.step_state.tool_rules_solver.tool_call_history for item in new_items - ), "Expected 'get_weather' in tool_call_history for all new_items" + assert all("get_weather" in item.step_state.tool_rules_solver.tool_call_history for item in new_items), ( + "Expected 'get_weather' in tool_call_history for all new_items" + ) # Assert that each new item's step_number was incremented to 1 - assert all( - item.step_state.step_number == 1 for item in new_items - ), "Expected step_number to be incremented to 1 for all new_items" + assert all(item.step_state.step_number == 1 for item in new_items), ( + "Expected step_number to be incremented to 1 for all new_items" + ) # Old items must have been flipped to completed / finished earlier # (sanity – we already asserted this above, but we keep it close for clarity) @@ -730,16 +730,14 @@ async def test_resume_step_some_stop( for agent in agents: before = msg_counts_before[agent.id] # captured just before resume after = await server.message_manager.size_async(actor=default_user, agent_id=agent.id) - assert after - before >= 2, ( - f"Agent {agent.id} should have an assistant tool‑call " f"and tool‑response message persisted." - ) + assert after - before >= 2, f"Agent {agent.id} should have an assistant tool‑call and tool‑response message persisted." # Check that agent states have been properly modified to have extended in-context messages for agent in agents: refreshed_agent = server.agent_manager.get_agent_by_id(agent_id=agent.id, actor=default_user) - assert ( - len(refreshed_agent.message_ids) == 6 - ), f"Agent's in-context messages have been extended, are length: {len(refreshed_agent.message_ids)}" + assert len(refreshed_agent.message_ids) == 6, ( + f"Agent's in-context messages have been extended, are length: {len(refreshed_agent.message_ids)}" + ) # Check the total list of messages messages = await server.batch_manager.get_messages_for_letta_batch_async( @@ -770,9 +768,9 @@ def _assert_descending_order(messages): return True for prev, next in zip(messages[:-1], messages[1:]): - assert ( - prev.created_at >= next.created_at - ), f"Order violation: {prev.id} ({prev.created_at}) followed by {next.id} ({next.created_at})" + assert prev.created_at >= next.created_at, ( + f"Order violation: {prev.id} ({prev.created_at}) followed by {next.id} ({next.created_at})" + ) return True @@ -853,12 +851,12 @@ async def test_resume_step_after_request_all_continue( assert len(new_batch_responses) == 1 post_resume_response = new_batch_responses[0] - assert ( - post_resume_response.letta_batch_id == pre_resume_response.letta_batch_id - ), "resume_step_after_request is expected to have the same letta_batch_id" - assert ( - post_resume_response.last_llm_batch_id != pre_resume_response.last_llm_batch_id - ), "resume_step_after_request is expected to have different llm_batch_id." + assert post_resume_response.letta_batch_id == pre_resume_response.letta_batch_id, ( + "resume_step_after_request is expected to have the same letta_batch_id" + ) + assert post_resume_response.last_llm_batch_id != pre_resume_response.last_llm_batch_id, ( + "resume_step_after_request is expected to have different llm_batch_id." + ) assert post_resume_response.status == JobStatus.running assert post_resume_response.agent_count == 3 @@ -872,13 +870,13 @@ async def test_resume_step_after_request_all_continue( # Confirm that tool_rules_solver state was preserved correctly # Assert every new item's step_state's tool_rules_solver has "get_weather" in the tool_call_history - assert all( - "get_weather" in item.step_state.tool_rules_solver.tool_call_history for item in new_items - ), "Expected 'get_weather' in tool_call_history for all new_items" + assert all("get_weather" in item.step_state.tool_rules_solver.tool_call_history for item in new_items), ( + "Expected 'get_weather' in tool_call_history for all new_items" + ) # Assert that each new item's step_number was incremented to 1 - assert all( - item.step_state.step_number == 1 for item in new_items - ), "Expected step_number to be incremented to 1 for all new_items" + assert all(item.step_state.step_number == 1 for item in new_items), ( + "Expected step_number to be incremented to 1 for all new_items" + ) # Old items must have been flipped to completed / finished earlier # (sanity – we already asserted this above, but we keep it close for clarity) @@ -892,16 +890,14 @@ async def test_resume_step_after_request_all_continue( for agent in agents: before = msg_counts_before[agent.id] # captured just before resume after = await server.message_manager.size_async(actor=default_user, agent_id=agent.id) - assert after - before >= 2, ( - f"Agent {agent.id} should have an assistant tool‑call " f"and tool‑response message persisted." - ) + assert after - before >= 2, f"Agent {agent.id} should have an assistant tool‑call and tool‑response message persisted." # Check that agent states have been properly modified to have extended in-context messages for agent in agents: refreshed_agent = server.agent_manager.get_agent_by_id(agent_id=agent.id, actor=default_user) - assert ( - len(refreshed_agent.message_ids) == 6 - ), f"Agent's in-context messages have been extended, are length: {len(refreshed_agent.message_ids)}" + assert len(refreshed_agent.message_ids) == 6, ( + f"Agent's in-context messages have been extended, are length: {len(refreshed_agent.message_ids)}" + ) # Check the total list of messages messages = await server.batch_manager.get_messages_for_letta_batch_async( diff --git a/tests/test_managers.py b/tests/test_managers.py index 225e2c01..c79caf93 100644 --- a/tests/test_managers.py +++ b/tests/test_managers.py @@ -16,8 +16,7 @@ import pytest from _pytest.python_api import approx from anthropic.types.beta import BetaMessage from anthropic.types.beta.messages import BetaMessageBatchIndividualResponse, BetaMessageBatchSucceededResult -from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall -from openai.types.chat.chat_completion_message_tool_call import Function as OpenAIFunction +from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall, Function as OpenAIFunction from sqlalchemy import func, select from sqlalchemy.exc import IntegrityError, InvalidRequestError from sqlalchemy.orm.exc import StaleDataError @@ -48,11 +47,9 @@ from letta.jobs.types import ItemUpdateInfo, RequestStatusUpdateInfo, StepStatus from letta.orm import Base, Block from letta.orm.block_history import BlockHistory from letta.orm.errors import NoResultFound, UniqueConstraintViolationError -from letta.orm.file import FileContent as FileContentModel -from letta.orm.file import FileMetadata as FileMetadataModel +from letta.orm.file import FileContent as FileContentModel, FileMetadata as FileMetadataModel from letta.schemas.agent import CreateAgent, UpdateAgent -from letta.schemas.block import Block as PydanticBlock -from letta.schemas.block import BlockUpdate, CreateBlock +from letta.schemas.block import Block as PydanticBlock, BlockUpdate, CreateBlock from letta.schemas.embedding_config import EmbeddingConfig from letta.schemas.enums import ( ActorType, @@ -68,35 +65,25 @@ from letta.schemas.enums import ( ToolType, ) from letta.schemas.environment_variables import SandboxEnvironmentVariableCreate, SandboxEnvironmentVariableUpdate -from letta.schemas.file import FileMetadata -from letta.schemas.file import FileMetadata as PydanticFileMetadata +from letta.schemas.file import FileMetadata, FileMetadata as PydanticFileMetadata from letta.schemas.identity import IdentityCreate, IdentityProperty, IdentityPropertyType, IdentityType, IdentityUpdate, IdentityUpsert -from letta.schemas.job import BatchJob -from letta.schemas.job import Job -from letta.schemas.job import Job as PydanticJob -from letta.schemas.job import JobUpdate, LettaRequestConfig +from letta.schemas.job import BatchJob, Job, Job as PydanticJob, JobUpdate, LettaRequestConfig from letta.schemas.letta_message import UpdateAssistantMessage, UpdateReasoningMessage, UpdateSystemMessage, UpdateUserMessage from letta.schemas.letta_message_content import TextContent from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType from letta.schemas.llm_batch_job import AgentStepState, LLMBatchItem from letta.schemas.llm_config import LLMConfig -from letta.schemas.message import Message as PydanticMessage -from letta.schemas.message import MessageCreate, MessageUpdate +from letta.schemas.message import Message as PydanticMessage, MessageCreate, MessageUpdate from letta.schemas.openai.chat_completion_response import UsageStatistics -from letta.schemas.organization import Organization -from letta.schemas.organization import Organization as PydanticOrganization -from letta.schemas.organization import OrganizationUpdate +from letta.schemas.organization import Organization, Organization as PydanticOrganization, OrganizationUpdate from letta.schemas.passage import Passage as PydanticPassage from letta.schemas.pip_requirement import PipRequirement from letta.schemas.run import Run as PydanticRun from letta.schemas.sandbox_config import E2BSandboxConfig, LocalSandboxConfig, SandboxConfigCreate, SandboxConfigUpdate -from letta.schemas.source import Source as PydanticSource -from letta.schemas.source import SourceUpdate -from letta.schemas.tool import Tool as PydanticTool -from letta.schemas.tool import ToolCreate, ToolUpdate +from letta.schemas.source import Source as PydanticSource, SourceUpdate +from letta.schemas.tool import Tool as PydanticTool, ToolCreate, ToolUpdate from letta.schemas.tool_rule import InitToolRule -from letta.schemas.user import User as PydanticUser -from letta.schemas.user import UserUpdate +from letta.schemas.user import User as PydanticUser, UserUpdate from letta.server.db import db_registry from letta.server.server import SyncServer from letta.services.block_manager import BlockManager @@ -4062,7 +4049,7 @@ async def test_user_caching(server: SyncServer, default_user, performance_pct=0. actor_cached = await server.user_manager.get_actor_by_id_async(default_user.id) duration = timer.elapsed_ns durations.append(duration) - print(f"Call {i+2}: {duration:.2e}ns") + print(f"Call {i + 2}: {duration:.2e}ns") assert actor_cached == actor for d in durations: assert d < duration_first * performance_pct @@ -5306,7 +5293,7 @@ async def test_delete_block_detaches_from_agent(server: SyncServer, sarah_agent, # Check that block has been detached too agent_state = await server.agent_manager.get_agent_by_id_async(agent_id=sarah_agent.id, actor=default_user) - assert not (block.id in [b.id for b in agent_state.memory.blocks]) + assert block.id not in [b.id for b in agent_state.memory.blocks] @pytest.mark.asyncio @@ -5836,7 +5823,9 @@ def test_undo_concurrency_stale(server: SyncServer, default_user): # Session1 -> undo to seq=1 block_manager.undo_checkpoint_block( - block_id=block_v1.id, actor=default_user, use_preloaded_block=block_s1 # stale object from session1 + block_id=block_v1.id, + actor=default_user, + use_preloaded_block=block_s1, # stale object from session1 ) # This commits first => block now points to seq=1, version increments @@ -6133,7 +6122,7 @@ async def test_attach_detach_identity_from_agent(server: SyncServer, sarah_agent # Check that block has been detached too agent_state = await server.agent_manager.get_agent_by_id_async(agent_id=sarah_agent.id, actor=default_user) - assert not identity.id in agent_state.identity_ids + assert identity.id not in agent_state.identity_ids @pytest.mark.asyncio @@ -6172,7 +6161,7 @@ async def test_get_set_agents_for_identities(server: SyncServer, sarah_agent, ch assert sarah_agent.id in agent_state_ids assert charles_agent.id in agent_state_ids assert agent_with_identity.id in agent_state_ids - assert not agent_without_identity.id in agent_state_ids + assert agent_without_identity.id not in agent_state_ids # Get the agents for identifier key agent_states = await server.agent_manager.list_agents_async(identifier_keys=[identity.identifier_key], actor=default_user) @@ -6183,7 +6172,7 @@ async def test_get_set_agents_for_identities(server: SyncServer, sarah_agent, ch assert sarah_agent.id in agent_state_ids assert charles_agent.id in agent_state_ids assert agent_with_identity.id in agent_state_ids - assert not agent_without_identity.id in agent_state_ids + assert agent_without_identity.id not in agent_state_ids # Delete new agents server.agent_manager.delete_agent(agent_id=agent_with_identity.id, actor=default_user) @@ -6274,7 +6263,7 @@ async def test_get_set_blocks_for_identities(server: SyncServer, default_block, block_ids = [b.id for b in blocks] assert default_block.id in block_ids assert block_with_identity.id in block_ids - assert not block_without_identity.id in block_ids + assert block_without_identity.id not in block_ids # Get the blocks for identifier key blocks = await server.block_manager.get_blocks_async(identifier_keys=[identity.identifier_key], actor=default_user) @@ -6284,7 +6273,7 @@ async def test_get_set_blocks_for_identities(server: SyncServer, default_block, block_ids = [b.id for b in blocks] assert default_block.id in block_ids assert block_with_identity.id in block_ids - assert not block_without_identity.id in block_ids + assert block_without_identity.id not in block_ids # Delete new agents server.block_manager.delete_block(block_id=block_with_identity.id, actor=default_user) @@ -6297,8 +6286,8 @@ async def test_get_set_blocks_for_identities(server: SyncServer, default_block, # Check only initial block in the list block_ids = [b.id for b in blocks] assert default_block.id in block_ids - assert not block_with_identity.id in block_ids - assert not block_without_identity.id in block_ids + assert block_with_identity.id not in block_ids + assert block_without_identity.id not in block_ids await server.identity_manager.delete_identity_async(identity_id=identity.id, actor=default_user) @@ -8490,11 +8479,11 @@ def test_get_run_messages(server: SyncServer, default_user: PydanticUser, sarah_ role=MessageRole.tool if i % 2 == 0 else MessageRole.assistant, content=[TextContent(text=f"Test message {i}" if i % 2 == 1 else '{"status": "OK"}')], tool_calls=( - [{"type": "function", "id": f"call_{i//2}", "function": {"name": "custom_tool", "arguments": '{"custom_arg": "test"}'}}] + [{"type": "function", "id": f"call_{i // 2}", "function": {"name": "custom_tool", "arguments": '{"custom_arg": "test"}'}}] if i % 2 == 1 else None ), - tool_call_id=f"call_{i//2}" if i % 2 == 0 else None, + tool_call_id=f"call_{i // 2}" if i % 2 == 0 else None, ) for i in range(4) ] @@ -8540,11 +8529,11 @@ def test_get_run_messages_with_assistant_message(server: SyncServer, default_use role=MessageRole.tool if i % 2 == 0 else MessageRole.assistant, content=[TextContent(text=f"Test message {i}" if i % 2 == 1 else '{"status": "OK"}')], tool_calls=( - [{"type": "function", "id": f"call_{i//2}", "function": {"name": "custom_tool", "arguments": '{"custom_arg": "test"}'}}] + [{"type": "function", "id": f"call_{i // 2}", "function": {"name": "custom_tool", "arguments": '{"custom_arg": "test"}'}}] if i % 2 == 1 else None ), - tool_call_id=f"call_{i//2}" if i % 2 == 0 else None, + tool_call_id=f"call_{i // 2}" if i % 2 == 0 else None, ) for i in range(4) ] @@ -9549,9 +9538,9 @@ async def test_list_batch_items_pagination( llm_batch_id=batch.id, actor=default_user, after=cursor, limit=limit ) # If more than 'limit' items remain, we should only get exactly 'limit' items. - assert len(limited_page) == min( - limit, expected_remaining - ), f"Expected {min(limit, expected_remaining)} items with limit {limit}, got {len(limited_page)}" + assert len(limited_page) == min(limit, expected_remaining), ( + f"Expected {min(limit, expected_remaining)} items with limit {limit}, got {len(limited_page)}" + ) # Optional: Test with a cursor beyond the last item returns an empty list. last_cursor = sorted_ids[-1] @@ -9888,9 +9877,7 @@ async def test_get_mcp_servers_by_ids(server, default_user): async def test_mcp_server_deletion_cascades_oauth_sessions(server, default_organization, default_user): """Deleting an MCP server deletes associated OAuth sessions (same user + URL).""" - from letta.schemas.mcp import MCPOAuthSessionCreate - from letta.schemas.mcp import MCPServer as PydanticMCPServer - from letta.schemas.mcp import MCPServerType + from letta.schemas.mcp import MCPOAuthSessionCreate, MCPServer as PydanticMCPServer, MCPServerType test_server_url = "https://test.example.com/mcp" @@ -9932,9 +9919,7 @@ async def test_mcp_server_deletion_cascades_oauth_sessions(server, default_organ async def test_oauth_sessions_with_different_url_persist(server, default_organization, default_user): """Sessions with different URL should not be deleted when deleting the server for another URL.""" - from letta.schemas.mcp import MCPOAuthSessionCreate - from letta.schemas.mcp import MCPServer as PydanticMCPServer - from letta.schemas.mcp import MCPServerType + from letta.schemas.mcp import MCPOAuthSessionCreate, MCPServer as PydanticMCPServer, MCPServerType server_url = "https://test.example.com/mcp" other_url = "https://other.example.com/mcp" @@ -9973,9 +9958,7 @@ async def test_oauth_sessions_with_different_url_persist(server, default_organiz async def test_mcp_server_creation_links_orphaned_sessions(server, default_organization, default_user): """Creating a server should link any existing orphaned sessions (same user + URL).""" - from letta.schemas.mcp import MCPOAuthSessionCreate - from letta.schemas.mcp import MCPServer as PydanticMCPServer - from letta.schemas.mcp import MCPServerType + from letta.schemas.mcp import MCPOAuthSessionCreate, MCPServer as PydanticMCPServer, MCPServerType server_url = "https://test-atomic-create.example.com/mcp" @@ -10019,9 +10002,7 @@ async def test_mcp_server_creation_links_orphaned_sessions(server, default_organ async def test_mcp_server_delete_removes_all_sessions_for_url_and_user(server, default_organization, default_user): """Deleting a server removes both linked and orphaned sessions for same user+URL.""" - from letta.schemas.mcp import MCPOAuthSessionCreate - from letta.schemas.mcp import MCPServer as PydanticMCPServer - from letta.schemas.mcp import MCPServerType + from letta.schemas.mcp import MCPOAuthSessionCreate, MCPServer as PydanticMCPServer, MCPServerType server_url = "https://test-atomic-cleanup.example.com/mcp" @@ -10711,9 +10692,9 @@ async def test_lru_eviction_on_attach(server, default_user, sarah_agent, default # Should have closed exactly 2 files (e.g., 7 - 5 = 2 for max_files_open=5) expected_closed_count = len(files) - max_files_open - assert ( - len(all_closed_files) == expected_closed_count - ), f"Should have closed {expected_closed_count} files, but closed: {all_closed_files}" + assert len(all_closed_files) == expected_closed_count, ( + f"Should have closed {expected_closed_count} files, but closed: {all_closed_files}" + ) # Check that the oldest files were closed (first N files attached) expected_closed = [files[i].file_name for i in range(expected_closed_count)] diff --git a/tests/test_sdk_client.py b/tests/test_sdk_client.py index 1ac6fddd..480bf221 100644 --- a/tests/test_sdk_client.py +++ b/tests/test_sdk_client.py @@ -9,9 +9,16 @@ from typing import List, Type import pytest from dotenv import load_dotenv -from letta_client import ContinueToolRule, CreateBlock -from letta_client import Letta as LettaSDKClient -from letta_client import LettaRequest, MaxCountPerStepToolRule, MessageCreate, TerminalToolRule, TextContent +from letta_client import ( + ContinueToolRule, + CreateBlock, + Letta as LettaSDKClient, + LettaRequest, + MaxCountPerStepToolRule, + MessageCreate, + TerminalToolRule, + TextContent, +) from letta_client.client import BaseTool from letta_client.core import ApiError from letta_client.types import AgentState, ToolReturnMessage @@ -1019,7 +1026,6 @@ def test_pydantic_inventory_management_tool(e2b_sandbox_mode, client: LettaSDKCl @pytest.mark.parametrize("e2b_sandbox_mode", [False], indirect=True) def test_pydantic_task_planning_tool(e2b_sandbox_mode, client: LettaSDKClient): - class Step(BaseModel): name: str = Field(..., description="Name of the step.") description: str = Field(..., description="An exhaustive description of what this step is trying to achieve.") @@ -1642,7 +1648,9 @@ def test_import_agent_file_from_disk( # Now import from the file with open(file_path, "rb") as f: import_result = client.agents.import_file( - file=f, append_copy_suffix=True, override_existing_tools=True # Use suffix to avoid name conflict + file=f, + append_copy_suffix=True, + override_existing_tools=True, # Use suffix to avoid name conflict ) # Basic verification @@ -1716,9 +1724,9 @@ def test_agent_serialization_v2( assert imported_agent.name == name, f"Agent name mismatch: {imported_agent.name} != {name}" # LLM and embedding configs should be preserved - assert ( - imported_agent.llm_config.model == temp_agent.llm_config.model - ), f"LLM model mismatch: {imported_agent.llm_config.model} != {temp_agent.llm_config.model}" + assert imported_agent.llm_config.model == temp_agent.llm_config.model, ( + f"LLM model mismatch: {imported_agent.llm_config.model} != {temp_agent.llm_config.model}" + ) assert imported_agent.embedding_config.embedding_model == temp_agent.embedding_config.embedding_model, "Embedding model mismatch" # System prompt should be preserved @@ -1728,9 +1736,9 @@ def test_agent_serialization_v2( assert set(imported_agent.tags) == set(temp_agent.tags), f"Tags mismatch: {imported_agent.tags} != {temp_agent.tags}" # Agent type should be preserved - assert ( - imported_agent.agent_type == temp_agent.agent_type - ), f"Agent type mismatch: {imported_agent.agent_type} != {temp_agent.agent_type}" + assert imported_agent.agent_type == temp_agent.agent_type, ( + f"Agent type mismatch: {imported_agent.agent_type} != {temp_agent.agent_type}" + ) # ========== MEMORY BLOCKS ========== # Compare memory blocks directly from AgentState objects @@ -1757,9 +1765,9 @@ def test_agent_serialization_v2( # Check context block assert "project_context" in imported_blocks_by_label, "Context block missing in imported agent" assert "financial markets" in imported_blocks_by_label["project_context"].value, "Context block content not preserved" - assert ( - imported_blocks_by_label["project_context"].limit == original_blocks_by_label["project_context"].limit - ), "Context block limit mismatch" + assert imported_blocks_by_label["project_context"].limit == original_blocks_by_label["project_context"].limit, ( + "Context block limit mismatch" + ) # ========== TOOLS ========== # Compare tools directly from AgentState objects @@ -1799,9 +1807,9 @@ def test_agent_serialization_v2( imported_user_msgs = [msg for msg in imported_messages if msg.message_type == "user_message" and "Test message" in msg.content] # Should have the same number of test messages - assert len(imported_user_msgs) == len( - original_user_msgs - ), f"User message count mismatch: {len(imported_user_msgs)} != {len(original_user_msgs)}" + assert len(imported_user_msgs) == len(original_user_msgs), ( + f"User message count mismatch: {len(imported_user_msgs)} != {len(original_user_msgs)}" + ) # Verify test message content is preserved if len(original_user_msgs) > 0 and len(imported_user_msgs) > 0: @@ -1903,7 +1911,9 @@ def test_import_agent_with_files_from_disk(client: LettaSDKClient): # Now import from the file with open(file_path, "rb") as f: import_result = client.agents.import_file( - file=f, append_copy_suffix=True, override_existing_tools=True # Use suffix to avoid name conflict + file=f, + append_copy_suffix=True, + override_existing_tools=True, # Use suffix to avoid name conflict ) # Verify import was successful diff --git a/tests/test_server.py b/tests/test_server.py index f8e68df1..48da0d91 100644 --- a/tests/test_server.py +++ b/tests/test_server.py @@ -630,7 +630,6 @@ async def test_memory_rebuild_count(server, user, disable_e2b_api_key, base_tool ) def count_system_messages_in_recall() -> Tuple[int, List[LettaMessage]]: - # At this stage, there should only be 1 system message inside of recall storage letta_messages = server.get_agent_recall( user_id=user.id, diff --git a/tests/test_sonnet_nonnative_reasoning_buffering.py b/tests/test_sonnet_nonnative_reasoning_buffering.py index a61254ca..ed7628af 100755 --- a/tests/test_sonnet_nonnative_reasoning_buffering.py +++ b/tests/test_sonnet_nonnative_reasoning_buffering.py @@ -152,7 +152,9 @@ def test_streaming_buffering_behavior(client: Letta, agent_factory, model: str, # Create the stream response_stream = client.agents.messages.create_stream( - agent_id=agent.id, messages=[MessageCreate(role="user", content=user_message)], stream_tokens=True # Enable token streaming + agent_id=agent.id, + messages=[MessageCreate(role="user", content=user_message)], + stream_tokens=True, # Enable token streaming ) # Collect chunks with timestamps @@ -215,7 +217,7 @@ def test_streaming_buffering_behavior(client: Letta, agent_factory, model: str, traceback.print_exc() # Analyze results - print(f"\n=== Analysis ===") + print("\n=== Analysis ===") print(f"Total chunks: {len(chunks_with_time)}") print(f"Reasoning chunks: {len(reasoning_chunks)}") print(f"Assistant chunks: {len(assistant_chunks)}") @@ -227,24 +229,24 @@ def test_streaming_buffering_behavior(client: Letta, agent_factory, model: str, print(f"\nReasoning bursts detected: {len(reasoning_bursts)}") for i, burst in enumerate(reasoning_bursts): burst_times = [reasoning_chunks[idx][0] for idx in burst] - print(f" Burst {i+1}: {len(burst)} chunks from {burst_times[0]:.3f}s to {burst_times[-1]:.3f}s") + print(f" Burst {i + 1}: {len(burst)} chunks from {burst_times[0]:.3f}s to {burst_times[-1]:.3f}s") if assistant_chunks: assistant_bursts = detect_burst_chunks(assistant_chunks) print(f"\nAssistant bursts detected: {len(assistant_bursts)}") for i, burst in enumerate(assistant_bursts): burst_times = [assistant_chunks[idx][0] for idx in burst] - print(f" Burst {i+1}: {len(burst)} chunks from {burst_times[0]:.3f}s to {burst_times[-1]:.3f}s") + print(f" Burst {i + 1}: {len(burst)} chunks from {burst_times[0]:.3f}s to {burst_times[-1]:.3f}s") if tool_chunks: tool_bursts = detect_burst_chunks(tool_chunks) print(f"\nTool call bursts detected: {len(tool_bursts)}") for i, burst in enumerate(tool_bursts): burst_times = [tool_chunks[idx][0] for idx in burst] - print(f" Burst {i+1}: {len(burst)} chunks from {burst_times[0]:.3f}s to {burst_times[-1]:.3f}s") + print(f" Burst {i + 1}: {len(burst)} chunks from {burst_times[0]:.3f}s to {burst_times[-1]:.3f}s") # Analyze results based on expected behavior - print(f"\n=== Test Results ===") + print("\n=== Test Results ===") # Check if we detected large bursts has_significant_bursts = False diff --git a/tests/test_sources.py b/tests/test_sources.py index 55bb4434..497405f6 100644 --- a/tests/test_sources.py +++ b/tests/test_sources.py @@ -8,10 +8,7 @@ from datetime import datetime, timedelta import pytest from dotenv import load_dotenv -from letta_client import CreateBlock -from letta_client import Letta as LettaSDKClient -from letta_client import LettaRequest -from letta_client import MessageCreate as ClientMessageCreate +from letta_client import CreateBlock, Letta as LettaSDKClient, LettaRequest, MessageCreate as ClientMessageCreate from letta_client.types import AgentState from letta.constants import DEFAULT_ORG_ID, FILES_TOOLS @@ -453,7 +450,7 @@ def test_agent_uses_open_close_file_correctly(disable_pinecone, client: LettaSDK assert "6: " in new_value, f"Expected line 6 to be present, got: {new_value[:200]}..." assert "10: " in new_value, f"Expected line 10 to be present, got: {new_value}" - print(f"Comparing content ranges:") + print("Comparing content ranges:") print(f" First range (offset=0, length=5): '{old_value}'") print(f" Second range (offset=5, length=5): '{new_value}'") @@ -494,7 +491,7 @@ def test_agent_uses_search_files_correctly(disable_pinecone, client: LettaSDKCli agent_id=agent_state.id, messages=[ MessageCreate( - role="user", content=f"Use ONLY the semantic_search_files tool to search for details regarding the electoral history." + role="user", content="Use ONLY the semantic_search_files tool to search for details regarding the electoral history." ) ], ) @@ -538,7 +535,7 @@ def test_agent_uses_grep_correctly_basic(disable_pinecone, client: LettaSDKClien # Ask agent to use the semantic_search_files tool search_files_response = client.agents.messages.create( agent_id=agent_state.id, - messages=[MessageCreate(role="user", content=f"Use ONLY the grep_files tool to search for `Nunzia De Girolamo`.")], + messages=[MessageCreate(role="user", content="Use ONLY the grep_files tool to search for `Nunzia De Girolamo`.")], ) print(f"Grep request sent, got {len(search_files_response.messages)} message(s) in response") print(search_files_response.messages) @@ -581,7 +578,7 @@ def test_agent_uses_grep_correctly_advanced(disable_pinecone, client: LettaSDKCl search_files_response = client.agents.messages.create( agent_id=agent_state.id, messages=[ - MessageCreate(role="user", content=f"Use ONLY the grep_files tool to search for `tool-f5b80b08-5a45-4a0a-b2cd-dd8a0177b7ef`.") + MessageCreate(role="user", content="Use ONLY the grep_files tool to search for `tool-f5b80b08-5a45-4a0a-b2cd-dd8a0177b7ef`.") ], ) print(f"Grep request sent, got {len(search_files_response.messages)} message(s) in response") @@ -742,9 +739,9 @@ def test_duplicate_file_renaming(disable_pinecone, client: LettaSDKClient): for file in files: assert file.original_file_name == "test.txt", f"Expected original_file_name='test.txt', got '{file.original_file_name}'" - print(f"✓ Successfully tested duplicate file renaming:") + print("✓ Successfully tested duplicate file renaming:") for i, file in enumerate(files): - print(f" File {i+1}: original='{file.original_file_name}' → renamed='{file.file_name}'") + print(f" File {i + 1}: original='{file.original_file_name}' → renamed='{file.file_name}'") def test_duplicate_file_handling_replace(disable_pinecone, client: LettaSDKClient): @@ -817,9 +814,9 @@ def test_duplicate_file_handling_replace(disable_pinecone, client: LettaSDKClien replacement_block_content = updated_file_blocks[0].value assert replacement_content in replacement_block_content, f"Expected replacement content in block, got: {replacement_block_content}" - assert ( - original_content not in replacement_block_content - ), f"Original content should not be present after replacement: {replacement_block_content}" + assert original_content not in replacement_block_content, ( + f"Original content should not be present after replacement: {replacement_block_content}" + ) print("✓ Successfully tested DuplicateFileHandling.REPLACE functionality") @@ -948,17 +945,17 @@ def test_open_files_schema_descriptions(disable_pinecone, client: LettaSDKClient assert "file_requests" in properties file_requests_prop = properties["file_requests"] expected_file_requests_desc = "List of file open requests, each specifying file name and optional view range." - assert ( - file_requests_prop["description"] == expected_file_requests_desc - ), f"Expected file_requests description: '{expected_file_requests_desc}', got: '{file_requests_prop['description']}'" + assert file_requests_prop["description"] == expected_file_requests_desc, ( + f"Expected file_requests description: '{expected_file_requests_desc}', got: '{file_requests_prop['description']}'" + ) # Check close_all_others parameter assert "close_all_others" in properties close_all_others_prop = properties["close_all_others"] expected_close_all_others_desc = "If True, closes all other currently open files first. Defaults to False." - assert ( - close_all_others_prop["description"] == expected_close_all_others_desc - ), f"Expected close_all_others description: '{expected_close_all_others_desc}', got: '{close_all_others_prop['description']}'" + assert close_all_others_prop["description"] == expected_close_all_others_desc, ( + f"Expected close_all_others description: '{expected_close_all_others_desc}', got: '{close_all_others_prop['description']}'" + ) # Check that file_requests is an array type assert file_requests_prop["type"] == "array", f"Expected file_requests type to be 'array', got: '{file_requests_prop['type']}'" @@ -1031,29 +1028,29 @@ def test_grep_files_schema_descriptions(disable_pinecone, client: LettaSDKClient assert "pattern" in properties pattern_prop = properties["pattern"] expected_pattern_desc = "Keyword or regex pattern to search within file contents." - assert ( - pattern_prop["description"] == expected_pattern_desc - ), f"Expected pattern description: '{expected_pattern_desc}', got: '{pattern_prop['description']}'" + assert pattern_prop["description"] == expected_pattern_desc, ( + f"Expected pattern description: '{expected_pattern_desc}', got: '{pattern_prop['description']}'" + ) assert pattern_prop["type"] == "string" # Check include parameter assert "include" in properties include_prop = properties["include"] expected_include_desc = "Optional keyword or regex pattern to filter filenames to include in the search." - assert ( - include_prop["description"] == expected_include_desc - ), f"Expected include description: '{expected_include_desc}', got: '{include_prop['description']}'" + assert include_prop["description"] == expected_include_desc, ( + f"Expected include description: '{expected_include_desc}', got: '{include_prop['description']}'" + ) assert include_prop["type"] == "string" # Check context_lines parameter assert "context_lines" in properties context_lines_prop = properties["context_lines"] expected_context_lines_desc = ( - "Number of lines of context to show before and after each match.\n" "Equivalent to `-C` in grep_files. Defaults to 1." + "Number of lines of context to show before and after each match.\nEquivalent to `-C` in grep_files. Defaults to 1." + ) + assert context_lines_prop["description"] == expected_context_lines_desc, ( + f"Expected context_lines description: '{expected_context_lines_desc}', got: '{context_lines_prop['description']}'" ) - assert ( - context_lines_prop["description"] == expected_context_lines_desc - ), f"Expected context_lines description: '{expected_context_lines_desc}', got: '{context_lines_prop['description']}'" assert context_lines_prop["type"] == "integer" # Check offset parameter @@ -1066,9 +1063,9 @@ def test_grep_files_schema_descriptions(disable_pinecone, client: LettaSDKClient "offset=40 for third page, etc. The tool will tell you the exact\n" "offset to use for the next page." ) - assert ( - offset_prop["description"] == expected_offset_desc - ), f"Expected offset description: '{expected_offset_desc}', got: '{offset_prop['description']}'" + assert offset_prop["description"] == expected_offset_desc, ( + f"Expected offset description: '{expected_offset_desc}', got: '{offset_prop['description']}'" + ) assert offset_prop["type"] == "integer" # Check return description in main description @@ -1128,9 +1125,9 @@ def test_pinecone_search_files_tool(client: LettaSDKClient): # Check that results contain expected content search_results = tool_returns[0].tool_return print(search_results) - assert ( - "electoral" in search_results.lower() or "history" in search_results.lower() - ), f"Search results should contain relevant content: {search_results}" + assert "electoral" in search_results.lower() or "history" in search_results.lower(), ( + f"Search results should contain relevant content: {search_results}" + ) def test_pinecone_list_files_status(client: LettaSDKClient): @@ -1160,9 +1157,9 @@ def test_pinecone_list_files_status(client: LettaSDKClient): # verify embedding counts for files that have chunks if file_metadata.total_chunks and file_metadata.total_chunks > 0: - assert ( - file_metadata.chunks_embedded == file_metadata.total_chunks - ), f"File {file_metadata.file_name} should have all chunks embedded: {file_metadata.chunks_embedded}/{file_metadata.total_chunks}" + assert file_metadata.chunks_embedded == file_metadata.total_chunks, ( + f"File {file_metadata.file_name} should have all chunks embedded: {file_metadata.chunks_embedded}/{file_metadata.total_chunks}" + ) # cleanup client.sources.delete(source_id=source.id) @@ -1234,9 +1231,9 @@ def test_pinecone_lifecycle_file_and_source_deletion(client: LettaSDKClient): print(f"Found {len(records_after)} records for files after source deletion") - assert ( - len(records_after) == 0 - ), f"All source records should be removed from Pinecone after source deletion, but found {len(records_after)}" + assert len(records_after) == 0, ( + f"All source records should be removed from Pinecone after source deletion, but found {len(records_after)}" + ) def test_agent_open_file(disable_pinecone, client: LettaSDKClient, agent_state: AgentState): diff --git a/tests/test_stream_buffer_readers.py b/tests/test_stream_buffer_readers.py index 9a0bb5e8..cee0aeb2 100644 --- a/tests/test_stream_buffer_readers.py +++ b/tests/test_stream_buffer_readers.py @@ -75,12 +75,12 @@ def test_inner_thoughts_in_args_simple(wait_for_first_key): for idx, (fragment, expected) in enumerate(zip(fragments1, expected_updates1)): updates_main_json, updates_inner_thoughts = handler1.process_fragment(fragment) # Assertions - assert ( - updates_main_json == expected["main_json_update"] - ), f"Test Case 1, Fragment {idx+1}: Main JSON update mismatch.\nExpected: '{expected['main_json_update']}'\nGot: '{updates_main_json}'" - assert ( - updates_inner_thoughts == expected["inner_thoughts_update"] - ), f"Test Case 1, Fragment {idx+1}: Inner Thoughts update mismatch.\nExpected: '{expected['inner_thoughts_update']}'\nGot: '{updates_inner_thoughts}'" + assert updates_main_json == expected["main_json_update"], ( + f"Test Case 1, Fragment {idx + 1}: Main JSON update mismatch.\nExpected: '{expected['main_json_update']}'\nGot: '{updates_main_json}'" + ) + assert updates_inner_thoughts == expected["inner_thoughts_update"], ( + f"Test Case 1, Fragment {idx + 1}: Inner Thoughts update mismatch.\nExpected: '{expected['inner_thoughts_update']}'\nGot: '{updates_inner_thoughts}'" + ) @pytest.mark.parametrize("wait_for_first_key", [True, False]) @@ -182,12 +182,12 @@ def test_inner_thoughts_in_args_trailing_quote(wait_for_first_key): for idx, (fragment, expected) in enumerate(zip(fragments1, expected_updates1)): updates_main_json, updates_inner_thoughts = handler1.process_fragment(fragment) # Assertions - assert ( - updates_main_json == expected["main_json_update"] - ), f"Test Case 1, Fragment {idx+1}: Main JSON update mismatch.\nFragment: '{fragment}'\nExpected: '{expected['main_json_update']}'\nGot: '{updates_main_json}'\nCurrent JSON: '{current_main_json}'\nCurrent Inner Thoughts: '{current_inner_thoughts}'" - assert ( - updates_inner_thoughts == expected["inner_thoughts_update"] - ), f"Test Case 1, Fragment {idx+1}: Inner Thoughts update mismatch.\nExpected: '{expected['inner_thoughts_update']}'\nGot: '{updates_inner_thoughts}'\nCurrent JSON: '{current_main_json}'\nCurrent Inner Thoughts: '{current_inner_thoughts}'" + assert updates_main_json == expected["main_json_update"], ( + f"Test Case 1, Fragment {idx + 1}: Main JSON update mismatch.\nFragment: '{fragment}'\nExpected: '{expected['main_json_update']}'\nGot: '{updates_main_json}'\nCurrent JSON: '{current_main_json}'\nCurrent Inner Thoughts: '{current_inner_thoughts}'" + ) + assert updates_inner_thoughts == expected["inner_thoughts_update"], ( + f"Test Case 1, Fragment {idx + 1}: Inner Thoughts update mismatch.\nExpected: '{expected['inner_thoughts_update']}'\nGot: '{updates_inner_thoughts}'\nCurrent JSON: '{current_main_json}'\nCurrent Inner Thoughts: '{current_inner_thoughts}'" + ) current_main_json += updates_main_json current_inner_thoughts += updates_inner_thoughts @@ -227,20 +227,20 @@ def test_inner_thoughts_not_in_args(): for idx, (fragment, expected) in enumerate(zip(fragments2, expected_updates2)): updates_main_json, updates_inner_thoughts = handler2.process_fragment(fragment) # Assertions - assert ( - updates_main_json == expected["main_json_update"] - ), f"Test Case 2, Fragment {idx+1}: Main JSON update mismatch.\nExpected: '{expected['main_json_update']}'\nGot: '{updates_main_json}'" - assert ( - updates_inner_thoughts == expected["inner_thoughts_update"] - ), f"Test Case 2, Fragment {idx+1}: Inner Thoughts update mismatch.\nExpected: '{expected['inner_thoughts_update']}'\nGot: '{updates_inner_thoughts}'" + assert updates_main_json == expected["main_json_update"], ( + f"Test Case 2, Fragment {idx + 1}: Main JSON update mismatch.\nExpected: '{expected['main_json_update']}'\nGot: '{updates_main_json}'" + ) + assert updates_inner_thoughts == expected["inner_thoughts_update"], ( + f"Test Case 2, Fragment {idx + 1}: Inner Thoughts update mismatch.\nExpected: '{expected['inner_thoughts_update']}'\nGot: '{updates_inner_thoughts}'" + ) # Final assertions for Test Case 2 expected_final_main_json2 = '{"message":"Here we are again, with \'x2\'! 🎉 Let\'s take this chance: If you could swap lives with any fictional character for a day, who would it be?"}' expected_final_inner_thoughts2 = "" - assert ( - handler2.main_json == expected_final_main_json2 - ), f"Test Case 2: Final main_json mismatch.\nExpected: '{expected_final_main_json2}'\nGot: '{handler2.main_json}'" - assert ( - handler2.inner_thoughts == expected_final_inner_thoughts2 - ), f"Test Case 2: Final inner_thoughts mismatch.\nExpected: '{expected_final_inner_thoughts2}'\nGot: '{handler2.inner_thoughts}'" + assert handler2.main_json == expected_final_main_json2, ( + f"Test Case 2: Final main_json mismatch.\nExpected: '{expected_final_main_json2}'\nGot: '{handler2.main_json}'" + ) + assert handler2.inner_thoughts == expected_final_inner_thoughts2, ( + f"Test Case 2: Final inner_thoughts mismatch.\nExpected: '{expected_final_inner_thoughts2}'\nGot: '{handler2.inner_thoughts}'" + ) diff --git a/tests/test_timezone_formatting.py b/tests/test_timezone_formatting.py index 878799a1..b142b92a 100644 --- a/tests/test_timezone_formatting.py +++ b/tests/test_timezone_formatting.py @@ -68,9 +68,9 @@ class TestTimezoneFormatting: # Check that times are within tolerance time_diff = abs((parsed_time - current_time_in_tz).total_seconds()) - assert ( - time_diff <= tolerance_minutes * 60 - ), f"Time difference too large: {time_diff}s. Parsed: {parsed_time}, Expected timezone: {current_time_in_tz}" + assert time_diff <= tolerance_minutes * 60, ( + f"Time difference too large: {time_diff}s. Parsed: {parsed_time}, Expected timezone: {current_time_in_tz}" + ) # Verify timezone info exists and format looks reasonable assert parsed_time.tzinfo is not None, "Parsed time should have timezone info" diff --git a/tests/test_tool_rule_solver.py b/tests/test_tool_rule_solver.py index 54077563..932cb1ea 100644 --- a/tests/test_tool_rule_solver.py +++ b/tests/test_tool_rule_solver.py @@ -104,12 +104,12 @@ def test_conditional_tool_rule(): assert solver.get_allowed_tool_names({START_TOOL}) == [START_TOOL], "Initial allowed tool should be 'start_tool'" solver.register_tool_call(START_TOOL) - assert solver.get_allowed_tool_names({END_TOOL}, last_function_response='{"message": "true"}') == [ - END_TOOL - ], "After 'start_tool' returns true, should allow 'end_tool'" - assert solver.get_allowed_tool_names({START_TOOL}, last_function_response='{"message": "false"}') == [ - START_TOOL - ], "After 'start_tool' returns false, should allow 'start_tool'" + assert solver.get_allowed_tool_names({END_TOOL}, last_function_response='{"message": "true"}') == [END_TOOL], ( + "After 'start_tool' returns true, should allow 'end_tool'" + ) + assert solver.get_allowed_tool_names({START_TOOL}, last_function_response='{"message": "false"}') == [START_TOOL], ( + "After 'start_tool' returns false, should allow 'start_tool'" + ) assert solver.is_terminal_tool(END_TOOL) is True, "Should recognize 'end_tool' as terminal" @@ -148,9 +148,9 @@ def test_max_count_per_step_tool_rule(): assert solver.get_allowed_tool_names({START_TOOL}) == [START_TOOL], "After first use, should still allow 'start_tool'" solver.register_tool_call(START_TOOL) - assert ( - solver.get_allowed_tool_names({START_TOOL}, error_on_empty=False) == [] - ), "After reaching max count, 'start_tool' should no longer be allowed" + assert solver.get_allowed_tool_names({START_TOOL}, error_on_empty=False) == [], ( + "After reaching max count, 'start_tool' should no longer be allowed" + ) def test_max_count_per_step_tool_rule_allows_usage_up_to_limit(): @@ -179,9 +179,9 @@ def test_max_count_per_step_tool_rule_does_not_affect_other_tools(): solver.register_tool_call(START_TOOL) solver.register_tool_call(START_TOOL) - assert sorted(solver.get_allowed_tool_names({START_TOOL, NEXT_TOOL, HELPER_TOOL})) == sorted( - [NEXT_TOOL, HELPER_TOOL] - ), "Other tools should still be allowed even if 'start_tool' is over limit" + assert sorted(solver.get_allowed_tool_names({START_TOOL, NEXT_TOOL, HELPER_TOOL})) == sorted([NEXT_TOOL, HELPER_TOOL]), ( + "Other tools should still be allowed even if 'start_tool' is over limit" + ) def test_max_count_per_step_tool_rule_resets_on_clear(): @@ -507,31 +507,31 @@ def test_required_before_exit_tool_rule_multiple_required_tools(): required_rule_2 = RequiredBeforeExitToolRule(tool_name=REQUIRED_TOOL_2) solver = ToolRulesSolver(tool_rules=[required_rule_1, required_rule_2]) - assert ( - solver.has_required_tools_been_called({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) is False - ), "Should return False when no required tools have been called" + assert solver.has_required_tools_been_called({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) is False, ( + "Should return False when no required tools have been called" + ) uncalled_tools = solver.get_uncalled_required_tools({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) assert set(uncalled_tools) == {REQUIRED_TOOL_1, REQUIRED_TOOL_2}, "Should return both uncalled required tools" # Call first required tool solver.register_tool_call(REQUIRED_TOOL_1) - assert ( - solver.has_required_tools_been_called({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) is False - ), "Should return False when only one required tool has been called" - assert solver.get_uncalled_required_tools({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) == [ - REQUIRED_TOOL_2 - ], "Should return remaining uncalled required tool" + assert solver.has_required_tools_been_called({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) is False, ( + "Should return False when only one required tool has been called" + ) + assert solver.get_uncalled_required_tools({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) == [REQUIRED_TOOL_2], ( + "Should return remaining uncalled required tool" + ) # Call second required tool solver.register_tool_call(REQUIRED_TOOL_2) - assert ( - solver.has_required_tools_been_called({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) is True - ), "Should return True when all required tools have been called" - assert ( - solver.get_uncalled_required_tools({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) == [] - ), "Should return empty list when all required tools have been called" + assert solver.has_required_tools_been_called({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) is True, ( + "Should return True when all required tools have been called" + ) + assert solver.get_uncalled_required_tools({REQUIRED_TOOL_1, REQUIRED_TOOL_2}) == [], ( + "Should return empty list when all required tools have been called" + ) def test_required_before_exit_tool_rule_mixed_with_other_tools(): diff --git a/tests/test_tool_sandbox/restaurant_management_system/adjust_menu_prices.py b/tests/test_tool_sandbox/restaurant_management_system/adjust_menu_prices.py index 1d3d9d3e..ffe734b3 100644 --- a/tests/test_tool_sandbox/restaurant_management_system/adjust_menu_prices.py +++ b/tests/test_tool_sandbox/restaurant_management_system/adjust_menu_prices.py @@ -8,10 +8,9 @@ def adjust_menu_prices(percentage: float) -> str: str: A formatted string summarizing the price adjustments. """ import cowsay - from tqdm import tqdm - from core.menu import Menu, MenuItem # Import a class from the codebase from core.utils import format_currency # Use a utility function to test imports + from tqdm import tqdm if not isinstance(percentage, (int, float)): raise TypeError("percentage must be a number") diff --git a/tests/test_tool_sandbox/restaurant_management_system/test.py b/tests/test_tool_sandbox/restaurant_management_system/test.py index feefcc83..16c52a07 100644 --- a/tests/test_tool_sandbox/restaurant_management_system/test.py +++ b/tests/test_tool_sandbox/restaurant_management_system/test.py @@ -11,9 +11,9 @@ def generate_and_execute_tool(tool_name: str, args: dict): with open(script_path, "w") as script_file: script_file.write(f"from restaurant_management_system.tools.{tool_name} import {tool_name}\n\n") arg_str = ", ".join([f"{key}={repr(value)}" for key, value in args.items()]) - script_file.write(f"if __name__ == '__main__':\n") + script_file.write("if __name__ == '__main__':\n") script_file.write(f" result = {tool_name}({arg_str})\n") - script_file.write(f" print(result)\n") + script_file.write(" print(result)\n") # Execute the script runpy.run_path(script_path, run_name="__main__") diff --git a/uv.lock b/uv.lock index 6a814594..a405d816 100644 --- a/uv.lock +++ b/uv.lock @@ -1,5 +1,5 @@ version = 1 -revision = 2 +revision = 3 requires-python = ">=3.11, <3.14" resolution-markers = [ "python_full_version >= '3.13'", @@ -337,18 +337,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/77/06/bb80f5f86020c4551da315d78b3ab75e8228f89f0162f2c3a819e407941a/attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3", size = 63815, upload-time = "2025-03-13T11:10:21.14Z" }, ] -[[package]] -name = "autoflake" -version = "2.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyflakes" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/2a/cb/486f912d6171bc5748c311a2984a301f4e2d054833a1da78485866c71522/autoflake-2.3.1.tar.gz", hash = "sha256:c98b75dc5b0a86459c4f01a1d32ac7eb4338ec4317a4469515ff1e687ecd909e", size = 27642, upload-time = "2024-03-13T03:41:28.977Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a2/ee/3fd29bf416eb4f1c5579cf12bf393ae954099258abd7bde03c4f9716ef6b/autoflake-2.3.1-py3-none-any.whl", hash = "sha256:3ae7495db9084b7b32818b4140e6dc4fc280b712fb414f5b8fe57b0a8e85a840", size = 32483, upload-time = "2024-03-13T03:41:26.969Z" }, -] - [[package]] name = "banks" version = "2.2.0" @@ -2382,6 +2370,7 @@ dependencies = [ { name = "pyyaml" }, { name = "questionary" }, { name = "rich" }, + { name = "ruff" }, { name = "sentry-sdk", extra = ["fastapi"] }, { name = "setuptools" }, { name = "sqlalchemy", extra = ["asyncio"] }, @@ -2416,11 +2405,8 @@ desktop = [ { name = "wikipedia" }, ] dev = [ - { name = "autoflake" }, - { name = "black", extra = ["jupyter"] }, { name = "ipdb" }, { name = "ipykernel" }, - { name = "isort" }, { name = "pexpect" }, { name = "pre-commit" }, { name = "pyright" }, @@ -2482,9 +2468,7 @@ requires-dist = [ { name = "anthropic", specifier = ">=0.49.0" }, { name = "apscheduler", specifier = ">=3.11.0" }, { name = "asyncpg", marker = "extra == 'postgres'", specifier = ">=0.30.0" }, - { name = "autoflake", marker = "extra == 'dev'", specifier = ">=2.3.0" }, { name = "black", extras = ["jupyter"], specifier = ">=24.2.0" }, - { name = "black", extras = ["jupyter"], marker = "extra == 'dev'", specifier = ">=24.4.2" }, { name = "boto3", marker = "extra == 'bedrock'", specifier = ">=1.36.24" }, { name = "brotli", specifier = ">=1.1.0" }, { name = "certifi", specifier = ">=2025.6.15" }, @@ -2511,7 +2495,6 @@ requires-dist = [ { name = "httpx-sse", specifier = ">=0.4.0" }, { name = "ipdb", marker = "extra == 'dev'", specifier = ">=0.13.13" }, { name = "ipykernel", marker = "extra == 'dev'", specifier = ">=6.29.5" }, - { name = "isort", marker = "extra == 'dev'", specifier = ">=5.13.2" }, { name = "jinja2", specifier = ">=3.1.5" }, { name = "langchain", marker = "extra == 'desktop'", specifier = ">=0.3.7" }, { name = "langchain", marker = "extra == 'external-tools'", specifier = ">=0.3.7" }, @@ -2562,6 +2545,7 @@ requires-dist = [ { name = "questionary", specifier = ">=2.0.1" }, { name = "redis", marker = "extra == 'redis'", specifier = ">=6.2.0" }, { name = "rich", specifier = ">=13.9.4" }, + { name = "ruff", extras = ["dev"], specifier = ">=0.12.10" }, { name = "sentry-sdk", extras = ["fastapi"], specifier = "==2.19.1" }, { name = "setuptools", specifier = ">=70" }, { name = "sqlalchemy", extras = ["asyncio"], specifier = ">=2.0.41" }, @@ -4443,15 +4427,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/58/f0/427018098906416f580e3cf1366d3b1abfb408a0652e9f31600c24a1903c/pydantic_settings-2.10.1-py3-none-any.whl", hash = "sha256:a60952460b99cf661dc25c29c0ef171721f98bfcb52ef8d9ea4c943d7c8cc796", size = 45235, upload-time = "2025-06-24T13:26:45.485Z" }, ] -[[package]] -name = "pyflakes" -version = "3.4.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/45/dc/fd034dc20b4b264b3d015808458391acbf9df40b1e54750ef175d39180b1/pyflakes-3.4.0.tar.gz", hash = "sha256:b24f96fafb7d2ab0ec5075b7350b3d2d2218eab42003821c06344973d3ea2f58", size = 64669, upload-time = "2025-06-20T18:45:27.834Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c2/2f/81d580a0fb83baeb066698975cb14a618bdbed7720678566f1b046a95fe8/pyflakes-3.4.0-py2.py3-none-any.whl", hash = "sha256:f742a7dbd0d9cb9ea41e9a24a918996e8170c799fa528688d40dd582c8265f4f", size = 63551, upload-time = "2025-06-20T18:45:26.937Z" }, -] - [[package]] name = "pygments" version = "2.19.2" @@ -5044,6 +5019,32 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696, upload-time = "2025-04-16T09:51:17.142Z" }, ] +[[package]] +name = "ruff" +version = "0.12.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/eb/8c073deb376e46ae767f4961390d17545e8535921d2f65101720ed8bd434/ruff-0.12.10.tar.gz", hash = "sha256:189ab65149d11ea69a2d775343adf5f49bb2426fc4780f65ee33b423ad2e47f9", size = 5310076, upload-time = "2025-08-21T18:23:22.595Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/e7/560d049d15585d6c201f9eeacd2fd130def3741323e5ccf123786e0e3c95/ruff-0.12.10-py3-none-linux_armv6l.whl", hash = "sha256:8b593cb0fb55cc8692dac7b06deb29afda78c721c7ccfed22db941201b7b8f7b", size = 11935161, upload-time = "2025-08-21T18:22:26.965Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b0/ad2464922a1113c365d12b8f80ed70fcfb39764288ac77c995156080488d/ruff-0.12.10-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ebb7333a45d56efc7c110a46a69a1b32365d5c5161e7244aaf3aa20ce62399c1", size = 12660884, upload-time = "2025-08-21T18:22:30.925Z" }, + { url = "https://files.pythonhosted.org/packages/d7/f1/97f509b4108d7bae16c48389f54f005b62ce86712120fd8b2d8e88a7cb49/ruff-0.12.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d59e58586829f8e4a9920788f6efba97a13d1fa320b047814e8afede381c6839", size = 11872754, upload-time = "2025-08-21T18:22:34.035Z" }, + { url = "https://files.pythonhosted.org/packages/12/ad/44f606d243f744a75adc432275217296095101f83f966842063d78eee2d3/ruff-0.12.10-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:822d9677b560f1fdeab69b89d1f444bf5459da4aa04e06e766cf0121771ab844", size = 12092276, upload-time = "2025-08-21T18:22:36.764Z" }, + { url = "https://files.pythonhosted.org/packages/06/1f/ed6c265e199568010197909b25c896d66e4ef2c5e1c3808caf461f6f3579/ruff-0.12.10-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:37b4a64f4062a50c75019c61c7017ff598cb444984b638511f48539d3a1c98db", size = 11734700, upload-time = "2025-08-21T18:22:39.822Z" }, + { url = "https://files.pythonhosted.org/packages/63/c5/b21cde720f54a1d1db71538c0bc9b73dee4b563a7dd7d2e404914904d7f5/ruff-0.12.10-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2c6f4064c69d2542029b2a61d39920c85240c39837599d7f2e32e80d36401d6e", size = 13468783, upload-time = "2025-08-21T18:22:42.559Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/39369e6ac7f2a1848f22fb0b00b690492f20811a1ac5c1fd1d2798329263/ruff-0.12.10-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:059e863ea3a9ade41407ad71c1de2badfbe01539117f38f763ba42a1206f7559", size = 14436642, upload-time = "2025-08-21T18:22:45.612Z" }, + { url = "https://files.pythonhosted.org/packages/e3/03/5da8cad4b0d5242a936eb203b58318016db44f5c5d351b07e3f5e211bb89/ruff-0.12.10-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1bef6161e297c68908b7218fa6e0e93e99a286e5ed9653d4be71e687dff101cf", size = 13859107, upload-time = "2025-08-21T18:22:48.886Z" }, + { url = "https://files.pythonhosted.org/packages/19/19/dd7273b69bf7f93a070c9cec9494a94048325ad18fdcf50114f07e6bf417/ruff-0.12.10-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4f1345fbf8fb0531cd722285b5f15af49b2932742fc96b633e883da8d841896b", size = 12886521, upload-time = "2025-08-21T18:22:51.567Z" }, + { url = "https://files.pythonhosted.org/packages/c0/1d/b4207ec35e7babaee62c462769e77457e26eb853fbdc877af29417033333/ruff-0.12.10-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f68433c4fbc63efbfa3ba5db31727db229fa4e61000f452c540474b03de52a9", size = 13097528, upload-time = "2025-08-21T18:22:54.609Z" }, + { url = "https://files.pythonhosted.org/packages/ff/00/58f7b873b21114456e880b75176af3490d7a2836033779ca42f50de3b47a/ruff-0.12.10-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:141ce3d88803c625257b8a6debf4a0473eb6eed9643a6189b68838b43e78165a", size = 13080443, upload-time = "2025-08-21T18:22:57.413Z" }, + { url = "https://files.pythonhosted.org/packages/12/8c/9e6660007fb10189ccb78a02b41691288038e51e4788bf49b0a60f740604/ruff-0.12.10-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f3fc21178cd44c98142ae7590f42ddcb587b8e09a3b849cbc84edb62ee95de60", size = 11896759, upload-time = "2025-08-21T18:23:00.473Z" }, + { url = "https://files.pythonhosted.org/packages/67/4c/6d092bb99ea9ea6ebda817a0e7ad886f42a58b4501a7e27cd97371d0ba54/ruff-0.12.10-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:7d1a4e0bdfafcd2e3e235ecf50bf0176f74dd37902f241588ae1f6c827a36c56", size = 11701463, upload-time = "2025-08-21T18:23:03.211Z" }, + { url = "https://files.pythonhosted.org/packages/59/80/d982c55e91df981f3ab62559371380616c57ffd0172d96850280c2b04fa8/ruff-0.12.10-py3-none-musllinux_1_2_i686.whl", hash = "sha256:e67d96827854f50b9e3e8327b031647e7bcc090dbe7bb11101a81a3a2cbf1cc9", size = 12691603, upload-time = "2025-08-21T18:23:06.935Z" }, + { url = "https://files.pythonhosted.org/packages/ad/37/63a9c788bbe0b0850611669ec6b8589838faf2f4f959647f2d3e320383ae/ruff-0.12.10-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:ae479e1a18b439c59138f066ae79cc0f3ee250712a873d00dbafadaad9481e5b", size = 13164356, upload-time = "2025-08-21T18:23:10.225Z" }, + { url = "https://files.pythonhosted.org/packages/47/d4/1aaa7fb201a74181989970ebccd12f88c0fc074777027e2a21de5a90657e/ruff-0.12.10-py3-none-win32.whl", hash = "sha256:9de785e95dc2f09846c5e6e1d3a3d32ecd0b283a979898ad427a9be7be22b266", size = 11896089, upload-time = "2025-08-21T18:23:14.232Z" }, + { url = "https://files.pythonhosted.org/packages/ad/14/2ad38fd4037daab9e023456a4a40ed0154e9971f8d6aed41bdea390aabd9/ruff-0.12.10-py3-none-win_amd64.whl", hash = "sha256:7837eca8787f076f67aba2ca559cefd9c5cbc3a9852fd66186f4201b87c1563e", size = 13004616, upload-time = "2025-08-21T18:23:17.422Z" }, + { url = "https://files.pythonhosted.org/packages/24/3c/21cf283d67af33a8e6ed242396863af195a8a6134ec581524fd22b9811b6/ruff-0.12.10-py3-none-win_arm64.whl", hash = "sha256:cc138cc06ed9d4bfa9d667a65af7172b47840e1a98b02ce7011c391e54635ffc", size = 12074225, upload-time = "2025-08-21T18:23:20.137Z" }, +] + [[package]] name = "s3transfer" version = "0.13.1"