diff --git a/.devcontainer/dotnet/devcontainer.json b/.devcontainer/dotnet/devcontainer.json index 6ec44f9004..57bf3b4a11 100644 --- a/.devcontainer/dotnet/devcontainer.json +++ b/.devcontainer/dotnet/devcontainer.json @@ -1,10 +1,6 @@ { "name": "C# (.NET)", - //"image": "mcr.microsoft.com/devcontainers/dotnet", - // Workaround for https://github.com/devcontainers/images/issues/1752 - "build": { - "dockerfile": "dotnet.Dockerfile" - }, + "image": "mcr.microsoft.com/devcontainers/dotnet", "features": { "ghcr.io/devcontainers/features/azure-cli:1.2.9": {}, "ghcr.io/devcontainers/features/github-cli:1": { diff --git a/.devcontainer/dotnet/dotnet.Dockerfile b/.devcontainer/dotnet/dotnet.Dockerfile deleted file mode 100644 index 344e4ee813..0000000000 --- a/.devcontainer/dotnet/dotnet.Dockerfile +++ /dev/null @@ -1,5 +0,0 @@ -FROM mcr.microsoft.com/devcontainers/universal:latest - -# Remove Yarn repository with expired GPG key to prevent apt-get update failures -# Tracking issue: https://github.com/devcontainers/images/issues/1752 -RUN rm -f /etc/apt/sources.list.d/yarn.list \ No newline at end of file diff --git a/dotnet/agent-framework-dotnet.slnx b/dotnet/agent-framework-dotnet.slnx index 2db09a8b98..e0423ab908 100644 --- a/dotnet/agent-framework-dotnet.slnx +++ b/dotnet/agent-framework-dotnet.slnx @@ -183,6 +183,7 @@ + diff --git a/dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step21_BingCustomSearch/FoundryAgents_Step21_BingCustomSearch.csproj b/dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step21_BingCustomSearch/FoundryAgents_Step21_BingCustomSearch.csproj new file mode 100644 index 0000000000..730d284bd9 --- /dev/null +++ b/dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step21_BingCustomSearch/FoundryAgents_Step21_BingCustomSearch.csproj @@ -0,0 +1,22 @@ + + + + Exe + net10.0 + + enable + enable + $(NoWarn);CA1812;CS8321 + + + + + + + + + + + + + diff --git a/dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step21_BingCustomSearch/Program.cs b/dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step21_BingCustomSearch/Program.cs new file mode 100644 index 0000000000..33ee4ec511 --- /dev/null +++ b/dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step21_BingCustomSearch/Program.cs @@ -0,0 +1,76 @@ +// Copyright (c) Microsoft. All rights reserved. + +// This sample shows how to use Bing Custom Search Tool with AI Agents. + +using Azure.AI.Projects; +using Azure.AI.Projects.OpenAI; +using Azure.Identity; +using Microsoft.Agents.AI; +using OpenAI.Responses; + +string endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new InvalidOperationException("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set."); +string deploymentName = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME") ?? "gpt-4o-mini"; +string connectionId = Environment.GetEnvironmentVariable("BING_CUSTOM_SEARCH_PROJECT_CONNECTION_ID") ?? throw new InvalidOperationException("BING_CUSTOM_SEARCH_PROJECT_CONNECTION_ID is not set."); +string instanceName = Environment.GetEnvironmentVariable("BING_CUSTOM_SEARCH_INSTANCE_NAME") ?? throw new InvalidOperationException("BING_CUSTOM_SEARCH_INSTANCE_NAME is not set."); + +const string AgentInstructions = """ + You are a helpful agent that can use Bing Custom Search tools to assist users. + Use the available Bing Custom Search tools to answer questions and perform tasks. + """; + +// Get a client to create/retrieve/delete server side agents with Azure Foundry Agents. +// WARNING: DefaultAzureCredential is convenient for development but requires careful consideration in production. +// In production, consider using a specific credential (e.g., ManagedIdentityCredential) to avoid +// latency issues, unintended credential probing, and potential security risks from fallback mechanisms. +AIProjectClient aiProjectClient = new(new Uri(endpoint), new DefaultAzureCredential()); + +// Bing Custom Search tool parameters shared by both options +BingCustomSearchToolParameters bingCustomSearchToolParameters = new([ + new BingCustomSearchConfiguration(connectionId, instanceName) +]); + +AIAgent agent = await CreateAgentWithMEAIAsync(); +// AIAgent agent = await CreateAgentWithNativeSDKAsync(); + +Console.WriteLine($"Created agent: {agent.Name}"); + +// Run the agent with a search query +AgentResponse response = await agent.RunAsync("Search for the latest news about Microsoft AI"); + +Console.WriteLine("\n=== Agent Response ==="); +foreach (var message in response.Messages) +{ + Console.WriteLine(message.Text); +} + +// Cleanup by deleting the agent +await aiProjectClient.Agents.DeleteAgentAsync(agent.Name); +Console.WriteLine($"\nDeleted agent: {agent.Name}"); + +// --- Agent Creation Options --- + +// Option 1 - Using AsAITool wrapping for the ResponseTool returned by AgentTool.CreateBingCustomSearchTool (MEAI + AgentFramework) +async Task CreateAgentWithMEAIAsync() +{ + return await aiProjectClient.CreateAIAgentAsync( + model: deploymentName, + name: "BingCustomSearchAgent-MEAI", + instructions: AgentInstructions, + tools: [((ResponseTool)AgentTool.CreateBingCustomSearchTool(bingCustomSearchToolParameters)).AsAITool()]); +} + +// Option 2 - Using PromptAgentDefinition with AgentTool.CreateBingCustomSearchTool (Native SDK) +async Task CreateAgentWithNativeSDKAsync() +{ + return await aiProjectClient.CreateAIAgentAsync( + name: "BingCustomSearchAgent-NATIVE", + creationOptions: new AgentVersionCreationOptions( + new PromptAgentDefinition(model: deploymentName) + { + Instructions = AgentInstructions, + Tools = { + (ResponseTool)AgentTool.CreateBingCustomSearchTool(bingCustomSearchToolParameters), + } + }) + ); +} diff --git a/dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step21_BingCustomSearch/README.md b/dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step21_BingCustomSearch/README.md new file mode 100644 index 0000000000..86f12c71bd --- /dev/null +++ b/dotnet/samples/GettingStarted/FoundryAgents/FoundryAgents_Step21_BingCustomSearch/README.md @@ -0,0 +1,63 @@ +# Using Bing Custom Search with AI Agents + +This sample demonstrates how to use the Bing Custom Search tool with AI agents to perform customized web searches. + +## What this sample demonstrates + +- Creating agents with Bing Custom Search capabilities +- Configuring custom search instances via connection ID and instance name +- Two agent creation approaches: MEAI abstraction (Option 1) and Native SDK (Option 2) +- Running search queries through the agent +- Managing agent lifecycle (creation and deletion) + +## Agent creation options + +This sample provides two approaches for creating agents with Bing Custom Search: + +- **Option 1 - MEAI + AgentFramework**: Uses the Agent Framework `ResponseTool` wrapped with `AsAITool()` to call the `CreateAIAgentAsync` overload that accepts `tools:[]`, while still relying on the same underlying Azure AI Projects SDK types as Option 2. +- **Option 2 - Native SDK**: Uses `PromptAgentDefinition` with `AgentVersionCreationOptions` to create the agent directly with the Azure AI Projects SDK types. + +Both options produce the same result. Toggle between them by commenting/uncommenting the corresponding `CreateAgentWith*Async` call in `Program.cs`. + +## Prerequisites + +Before you begin, ensure you have the following prerequisites: + +- .NET 10 SDK or later +- Azure Foundry service endpoint and deployment configured +- Azure CLI installed and authenticated (for Azure credential authentication) +- A Bing Custom Search resource configured in Azure and connected to your Foundry project + +**Note**: This demo uses Azure Default credentials for authentication. Make sure you're logged in with `az login` and have access to the Azure Foundry resource. + +Set the following environment variables: + +```powershell +$env:AZURE_FOUNDRY_PROJECT_ENDPOINT="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project" +$env:AZURE_FOUNDRY_PROJECT_DEPLOYMENT_NAME="gpt-4o-mini" # Optional, defaults to gpt-4o-mini +$env:BING_CUSTOM_SEARCH_PROJECT_CONNECTION_ID="/subscriptions//resourceGroups//providers/Microsoft.CognitiveServices/accounts//projects//connections/" +$env:BING_CUSTOM_SEARCH_INSTANCE_NAME="your-configuration-name" +``` + +### Finding the connection ID and instance name + +- **Connection ID**: The full ARM resource path including the `/projects//connections/` segment. Find the connection name in your Foundry project under **Management center** → **Connected resources**. +- **Instance Name**: The **configuration name** from the Bing Custom Search resource (Azure portal → your Bing Custom Search resource → **Configurations**). This is _not_ the Azure resource name. + +## Run the sample + +Navigate to the FoundryAgents sample directory and run: + +```powershell +cd dotnet/samples/GettingStarted/FoundryAgents +dotnet run --project .\FoundryAgents_Step21_BingCustomSearch +``` + +## Expected behavior + +The sample will: + +1. Create an agent with Bing Custom Search tool capabilities +2. Run the agent with a search query about Microsoft AI +3. Display the search results returned by the agent +4. Clean up resources by deleting the agent diff --git a/dotnet/samples/GettingStarted/FoundryAgents/README.md b/dotnet/samples/GettingStarted/FoundryAgents/README.md index 702749b331..d8677ea58b 100644 --- a/dotnet/samples/GettingStarted/FoundryAgents/README.md +++ b/dotnet/samples/GettingStarted/FoundryAgents/README.md @@ -58,6 +58,7 @@ Before you begin, ensure you have the following prerequisites: |[Using plugins](./FoundryAgents_Step13_Plugins/)|This sample demonstrates how to use plugins with a Foundry agent| |[Code interpreter](./FoundryAgents_Step14_CodeInterpreter/)|This sample demonstrates how to use the code interpreter tool with a Foundry agent| |[Computer use](./FoundryAgents_Step15_ComputerUse/)|This sample demonstrates how to use computer use capabilities with a Foundry agent| +|[Bing Custom Search](./FoundryAgents_Step21_BingCustomSearch/)|This sample demonstrates how to use Bing Custom Search tool with a Foundry agent| |[Web search](./FoundryAgents_Step25_WebSearch/)|This sample demonstrates how to use the Responses API web search tool with a Foundry agent| |[Memory search](./FoundryAgents_Step26_MemorySearch/)|This sample demonstrates how to use memory search tool with a Foundry agent| |[File search](./FoundryAgents_Step18_FileSearch/)|This sample demonstrates how to use the file search tool with a Foundry agent| diff --git a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A.AspNetCore/EndpointRouteBuilderExtensions.cs b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A.AspNetCore/EndpointRouteBuilderExtensions.cs index 943b6e4a5c..af3ff093ee 100644 --- a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A.AspNetCore/EndpointRouteBuilderExtensions.cs +++ b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A.AspNetCore/EndpointRouteBuilderExtensions.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Diagnostics.CodeAnalysis; using A2A; using A2A.AspNetCore; using Microsoft.Agents.AI; @@ -10,12 +11,14 @@ using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Routing; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; +using Microsoft.Shared.DiagnosticIds; namespace Microsoft.AspNetCore.Builder; /// /// Provides extension methods for configuring A2A (Agent2Agent) communication in a host application builder. /// +[Experimental(DiagnosticIds.Experiments.AIResponseContinuations)] public static class MicrosoftAgentAIHostingA2AEndpointRouteBuilderExtensions { /// @@ -33,6 +36,20 @@ public static class MicrosoftAgentAIHostingA2AEndpointRouteBuilderExtensions public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, IHostedAgentBuilder agentBuilder, string path) => endpoints.MapA2A(agentBuilder, path, _ => { }); + /// + /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. + /// + /// The to add the A2A endpoints to. + /// The configuration builder for . + /// The route group to use for A2A endpoints. + /// Controls the response behavior of the agent run. + /// Configured for A2A integration. + public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, IHostedAgentBuilder agentBuilder, string path, AgentRunMode agentRunMode) + { + ArgumentNullException.ThrowIfNull(agentBuilder); + return endpoints.MapA2A(agentBuilder.Name, path, agentRunMode); + } + /// /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. /// @@ -43,6 +60,21 @@ public static class MicrosoftAgentAIHostingA2AEndpointRouteBuilderExtensions public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, string agentName, string path) => endpoints.MapA2A(agentName, path, _ => { }); + /// + /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. + /// + /// The to add the A2A endpoints to. + /// The name of the agent to use for A2A protocol integration. + /// The route group to use for A2A endpoints. + /// Controls the response behavior of the agent run. + /// Configured for A2A integration. + public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, string agentName, string path, AgentRunMode agentRunMode) + { + ArgumentNullException.ThrowIfNull(endpoints); + var agent = endpoints.ServiceProvider.GetRequiredKeyedService(agentName); + return endpoints.MapA2A(agent, path, _ => { }, agentRunMode); + } + /// /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. /// @@ -109,6 +141,37 @@ public static class MicrosoftAgentAIHostingA2AEndpointRouteBuilderExtensions public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, string agentName, string path, AgentCard agentCard) => endpoints.MapA2A(agentName, path, agentCard, _ => { }); + /// + /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. + /// + /// The to add the A2A endpoints to. + /// The configuration builder for . + /// The route group to use for A2A endpoints. + /// Agent card info to return on query. + /// Controls the response behavior of the agent run. + /// Configured for A2A integration. + public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, IHostedAgentBuilder agentBuilder, string path, AgentCard agentCard, AgentRunMode agentRunMode) + { + ArgumentNullException.ThrowIfNull(agentBuilder); + return endpoints.MapA2A(agentBuilder.Name, path, agentCard, agentRunMode); + } + + /// + /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. + /// + /// The to add the A2A endpoints to. + /// The name of the agent to use for A2A protocol integration. + /// The route group to use for A2A endpoints. + /// Agent card info to return on query. + /// Controls the response behavior of the agent run. + /// Configured for A2A integration. + public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, string agentName, string path, AgentCard agentCard, AgentRunMode agentRunMode) + { + ArgumentNullException.ThrowIfNull(endpoints); + var agent = endpoints.ServiceProvider.GetRequiredKeyedService(agentName); + return endpoints.MapA2A(agent, path, agentCard, agentRunMode); + } + /// /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. /// @@ -144,10 +207,28 @@ public static class MicrosoftAgentAIHostingA2AEndpointRouteBuilderExtensions /// discovery mechanism. /// public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, string agentName, string path, AgentCard agentCard, Action configureTaskManager) + => endpoints.MapA2A(agentName, path, agentCard, configureTaskManager, AgentRunMode.DisallowBackground); + + /// + /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. + /// + /// The to add the A2A endpoints to. + /// The name of the agent to use for A2A protocol integration. + /// The route group to use for A2A endpoints. + /// Agent card info to return on query. + /// The callback to configure . + /// Controls the response behavior of the agent run. + /// Configured for A2A integration. + /// + /// This method can be used to access A2A agents that support the + /// Curated Registries (Catalog-Based Discovery) + /// discovery mechanism. + /// + public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, string agentName, string path, AgentCard agentCard, Action configureTaskManager, AgentRunMode agentRunMode) { ArgumentNullException.ThrowIfNull(endpoints); var agent = endpoints.ServiceProvider.GetRequiredKeyedService(agentName); - return endpoints.MapA2A(agent, path, agentCard, configureTaskManager); + return endpoints.MapA2A(agent, path, agentCard, configureTaskManager, agentRunMode); } /// @@ -160,6 +241,17 @@ public static class MicrosoftAgentAIHostingA2AEndpointRouteBuilderExtensions public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, AIAgent agent, string path) => endpoints.MapA2A(agent, path, _ => { }); + /// + /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. + /// + /// The to add the A2A endpoints to. + /// The agent to use for A2A protocol integration. + /// The route group to use for A2A endpoints. + /// Controls the response behavior of the agent run. + /// Configured for A2A integration. + public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, AIAgent agent, string path, AgentRunMode agentRunMode) + => endpoints.MapA2A(agent, path, _ => { }, agentRunMode); + /// /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. /// @@ -169,13 +261,25 @@ public static class MicrosoftAgentAIHostingA2AEndpointRouteBuilderExtensions /// The callback to configure . /// Configured for A2A integration. public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, AIAgent agent, string path, Action configureTaskManager) + => endpoints.MapA2A(agent, path, configureTaskManager, AgentRunMode.DisallowBackground); + + /// + /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. + /// + /// The to add the A2A endpoints to. + /// The agent to use for A2A protocol integration. + /// The route group to use for A2A endpoints. + /// The callback to configure . + /// Controls the response behavior of the agent run. + /// Configured for A2A integration. + public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, AIAgent agent, string path, Action configureTaskManager, AgentRunMode agentRunMode) { ArgumentNullException.ThrowIfNull(endpoints); ArgumentNullException.ThrowIfNull(agent); var loggerFactory = endpoints.ServiceProvider.GetRequiredService(); var agentSessionStore = endpoints.ServiceProvider.GetKeyedService(agent.Name); - var taskManager = agent.MapA2A(loggerFactory: loggerFactory, agentSessionStore: agentSessionStore); + var taskManager = agent.MapA2A(loggerFactory: loggerFactory, agentSessionStore: agentSessionStore, runMode: agentRunMode); var endpointConventionBuilder = endpoints.MapA2A(taskManager, path); configureTaskManager(taskManager); @@ -198,6 +302,23 @@ public static class MicrosoftAgentAIHostingA2AEndpointRouteBuilderExtensions public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, AIAgent agent, string path, AgentCard agentCard) => endpoints.MapA2A(agent, path, agentCard, _ => { }); + /// + /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. + /// + /// The to add the A2A endpoints to. + /// The agent to use for A2A protocol integration. + /// The route group to use for A2A endpoints. + /// Agent card info to return on query. + /// Controls the response behavior of the agent run. + /// Configured for A2A integration. + /// + /// This method can be used to access A2A agents that support the + /// Curated Registries (Catalog-Based Discovery) + /// discovery mechanism. + /// + public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, AIAgent agent, string path, AgentCard agentCard, AgentRunMode agentRunMode) + => endpoints.MapA2A(agent, path, agentCard, _ => { }, agentRunMode); + /// /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. /// @@ -213,13 +334,31 @@ public static class MicrosoftAgentAIHostingA2AEndpointRouteBuilderExtensions /// discovery mechanism. /// public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, AIAgent agent, string path, AgentCard agentCard, Action configureTaskManager) + => endpoints.MapA2A(agent, path, agentCard, configureTaskManager, AgentRunMode.DisallowBackground); + + /// + /// Attaches A2A (Agent2Agent) communication capabilities via Message processing to the specified web application. + /// + /// The to add the A2A endpoints to. + /// The agent to use for A2A protocol integration. + /// The route group to use for A2A endpoints. + /// Agent card info to return on query. + /// The callback to configure . + /// Controls the response behavior of the agent run. + /// Configured for A2A integration. + /// + /// This method can be used to access A2A agents that support the + /// Curated Registries (Catalog-Based Discovery) + /// discovery mechanism. + /// + public static IEndpointConventionBuilder MapA2A(this IEndpointRouteBuilder endpoints, AIAgent agent, string path, AgentCard agentCard, Action configureTaskManager, AgentRunMode agentRunMode) { ArgumentNullException.ThrowIfNull(endpoints); ArgumentNullException.ThrowIfNull(agent); var loggerFactory = endpoints.ServiceProvider.GetRequiredService(); var agentSessionStore = endpoints.ServiceProvider.GetKeyedService(agent.Name); - var taskManager = agent.MapA2A(agentCard: agentCard, agentSessionStore: agentSessionStore, loggerFactory: loggerFactory); + var taskManager = agent.MapA2A(agentCard: agentCard, agentSessionStore: agentSessionStore, loggerFactory: loggerFactory, runMode: agentRunMode); var endpointConventionBuilder = endpoints.MapA2A(taskManager, path); configureTaskManager(taskManager); diff --git a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A.AspNetCore/Microsoft.Agents.AI.Hosting.A2A.AspNetCore.csproj b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A.AspNetCore/Microsoft.Agents.AI.Hosting.A2A.AspNetCore.csproj index 093c5e0cfb..4829b56b9e 100644 --- a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A.AspNetCore/Microsoft.Agents.AI.Hosting.A2A.AspNetCore.csproj +++ b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A.AspNetCore/Microsoft.Agents.AI.Hosting.A2A.AspNetCore.csproj @@ -8,6 +8,12 @@ + + true + true + true + + diff --git a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/A2AHostingJsonUtilities.cs b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/A2AHostingJsonUtilities.cs new file mode 100644 index 0000000000..0a4bd98c65 --- /dev/null +++ b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/A2AHostingJsonUtilities.cs @@ -0,0 +1,31 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Text.Json; + +namespace Microsoft.Agents.AI.Hosting.A2A; + +/// +/// Provides JSON serialization options for A2A Hosting APIs to support AOT and trimming. +/// +public static class A2AHostingJsonUtilities +{ + /// + /// Gets the default instance used for A2A Hosting serialization. + /// + public static JsonSerializerOptions DefaultOptions { get; } = CreateDefaultOptions(); + + private static JsonSerializerOptions CreateDefaultOptions() + { + JsonSerializerOptions options = new(global::A2A.A2AJsonUtilities.DefaultOptions); + + // Chain in the resolvers from both AgentAbstractionsJsonUtilities and the A2A SDK context. + // AgentAbstractionsJsonUtilities is first to ensure M.E.AI types (e.g. ResponseContinuationToken) + // are handled via its resolver, followed by the A2A SDK resolver for protocol types. + options.TypeInfoResolverChain.Clear(); + options.TypeInfoResolverChain.Add(AgentAbstractionsJsonUtilities.DefaultOptions.TypeInfoResolver!); + options.TypeInfoResolverChain.Add(global::A2A.A2AJsonUtilities.DefaultOptions.TypeInfoResolver!); + + options.MakeReadOnly(); + return options; + } +} diff --git a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/A2ARunDecisionContext.cs b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/A2ARunDecisionContext.cs new file mode 100644 index 0000000000..6ff49f6ecb --- /dev/null +++ b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/A2ARunDecisionContext.cs @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft. All rights reserved. + +using A2A; + +namespace Microsoft.Agents.AI.Hosting.A2A; + +/// +/// Provides context for a custom A2A run mode decision. +/// +public sealed class A2ARunDecisionContext +{ + internal A2ARunDecisionContext(MessageSendParams messageSendParams) + { + this.MessageSendParams = messageSendParams; + } + + /// + /// Gets the parameters of the incoming A2A message that triggered this run. + /// + public MessageSendParams MessageSendParams { get; } +} diff --git a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/AIAgentExtensions.cs b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/AIAgentExtensions.cs index da3fd782de..31c520755f 100644 --- a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/AIAgentExtensions.cs +++ b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/AIAgentExtensions.cs @@ -1,19 +1,29 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Text.Json; using System.Threading; using System.Threading.Tasks; using A2A; using Microsoft.Agents.AI.Hosting.A2A.Converters; +using Microsoft.Extensions.AI; using Microsoft.Extensions.Logging; +using Microsoft.Shared.DiagnosticIds; namespace Microsoft.Agents.AI.Hosting.A2A; /// /// Provides extension methods for attaching A2A (Agent2Agent) messaging capabilities to an . /// +[Experimental(DiagnosticIds.Experiments.AIResponseContinuations)] public static class AIAgentExtensions { + // Metadata key used to store continuation tokens for long-running background operations + // in the AgentTask.Metadata dictionary, persisted by the task store. + private const string ContinuationTokenMetadataKey = "__a2a__continuationToken"; + /// /// Attaches A2A (Agent2Agent) messaging capabilities via Message processing to the specified . /// @@ -21,49 +31,45 @@ public static class AIAgentExtensions /// Instance of to configure for A2A messaging. New instance will be created if not passed. /// The logger factory to use for creating instances. /// The store to store session contents and metadata. + /// Controls the response behavior of the agent run. + /// Optional for serializing and deserializing continuation tokens. Use this when the agent's continuation token contains custom types not registered in the default options. Falls back to if not provided. /// The configured . public static ITaskManager MapA2A( this AIAgent agent, ITaskManager? taskManager = null, ILoggerFactory? loggerFactory = null, - AgentSessionStore? agentSessionStore = null) + AgentSessionStore? agentSessionStore = null, + AgentRunMode? runMode = null, + JsonSerializerOptions? jsonSerializerOptions = null) { ArgumentNullException.ThrowIfNull(agent); ArgumentNullException.ThrowIfNull(agent.Name); + runMode ??= AgentRunMode.DisallowBackground; + var hostAgent = new AIHostAgent( innerAgent: agent, sessionStore: agentSessionStore ?? new NoopAgentSessionStore()); taskManager ??= new TaskManager(); - taskManager.OnMessageReceived += OnMessageReceivedAsync; + + // Resolve the JSON serializer options for continuation token serialization. May be custom for the user's agent. + JsonSerializerOptions continuationTokenJsonOptions = jsonSerializerOptions ?? A2AHostingJsonUtilities.DefaultOptions; + + // OnMessageReceived handles both message-only and task-based flows. + // The A2A SDK prioritizes OnMessageReceived over OnTaskCreated when both are set, + // so we consolidate all initial message handling here and return either + // an AgentMessage or AgentTask depending on the agent response. + // When the agent returns a ContinuationToken (long-running operation), a task is + // created for stateful tracking. Otherwise a lightweight AgentMessage is returned. + // See https://github.com/a2aproject/a2a-dotnet/issues/275 + taskManager.OnMessageReceived += (p, ct) => OnMessageReceivedAsync(p, hostAgent, runMode, taskManager, continuationTokenJsonOptions, ct); + + // Task flow for subsequent updates and cancellations + taskManager.OnTaskUpdated += (t, ct) => OnTaskUpdatedAsync(t, hostAgent, taskManager, continuationTokenJsonOptions, ct); + taskManager.OnTaskCancelled += OnTaskCancelledAsync; + return taskManager; - - async Task OnMessageReceivedAsync(MessageSendParams messageSendParams, CancellationToken cancellationToken) - { - var contextId = messageSendParams.Message.ContextId ?? Guid.NewGuid().ToString("N"); - var session = await hostAgent.GetOrCreateSessionAsync(contextId, cancellationToken).ConfigureAwait(false); - var options = messageSendParams.Metadata is not { Count: > 0 } - ? null - : new AgentRunOptions { AdditionalProperties = messageSendParams.Metadata.ToAdditionalProperties() }; - - var response = await hostAgent.RunAsync( - messageSendParams.ToChatMessages(), - session: session, - options: options, - cancellationToken: cancellationToken).ConfigureAwait(false); - - await hostAgent.SaveSessionAsync(contextId, session, cancellationToken).ConfigureAwait(false); - var parts = response.Messages.ToParts(); - return new AgentMessage - { - MessageId = response.ResponseId ?? Guid.NewGuid().ToString("N"), - ContextId = contextId, - Role = MessageRole.Agent, - Parts = parts, - Metadata = response.AdditionalProperties?.ToA2AMetadata() - }; - } } /// @@ -74,15 +80,19 @@ public static class AIAgentExtensions /// Instance of to configure for A2A messaging. New instance will be created if not passed. /// The logger factory to use for creating instances. /// The store to store session contents and metadata. + /// Controls the response behavior of the agent run. + /// Optional for serializing and deserializing continuation tokens. Use this when the agent's continuation token contains custom types not registered in the default options. Falls back to if not provided. /// The configured . public static ITaskManager MapA2A( this AIAgent agent, AgentCard agentCard, ITaskManager? taskManager = null, ILoggerFactory? loggerFactory = null, - AgentSessionStore? agentSessionStore = null) + AgentSessionStore? agentSessionStore = null, + AgentRunMode? runMode = null, + JsonSerializerOptions? jsonSerializerOptions = null) { - taskManager = agent.MapA2A(taskManager, loggerFactory, agentSessionStore); + taskManager = agent.MapA2A(taskManager, loggerFactory, agentSessionStore, runMode, jsonSerializerOptions); taskManager.OnAgentCardQuery += (context, query) => { @@ -97,4 +107,203 @@ public static class AIAgentExtensions }; return taskManager; } + + private static async Task OnMessageReceivedAsync( + MessageSendParams messageSendParams, + AIHostAgent hostAgent, + AgentRunMode runMode, + ITaskManager taskManager, + JsonSerializerOptions continuationTokenJsonOptions, + CancellationToken cancellationToken) + { + // AIAgent does not support resuming from arbitrary prior tasks. + // Throw explicitly so the client gets a clear error rather than a response + // that silently ignores the referenced task context. + // Follow-ups on the *same* task are handled via OnTaskUpdated instead. + if (messageSendParams.Message.ReferenceTaskIds is { Count: > 0 }) + { + throw new NotSupportedException("ReferenceTaskIds is not supported. AIAgent cannot resume from arbitrary prior task context. Use OnTaskUpdated for follow-ups on the same task."); + } + + var contextId = messageSendParams.Message.ContextId ?? Guid.NewGuid().ToString("N"); + var session = await hostAgent.GetOrCreateSessionAsync(contextId, cancellationToken).ConfigureAwait(false); + + // Decide whether to run in background based on user preferences and agent capabilities + var decisionContext = new A2ARunDecisionContext(messageSendParams); + var allowBackgroundResponses = await runMode.ShouldRunInBackgroundAsync(decisionContext, cancellationToken).ConfigureAwait(false); + + var options = messageSendParams.Metadata is not { Count: > 0 } + ? new AgentRunOptions { AllowBackgroundResponses = allowBackgroundResponses } + : new AgentRunOptions { AllowBackgroundResponses = allowBackgroundResponses, AdditionalProperties = messageSendParams.Metadata.ToAdditionalProperties() }; + + var response = await hostAgent.RunAsync( + messageSendParams.ToChatMessages(), + session: session, + options: options, + cancellationToken: cancellationToken).ConfigureAwait(false); + + await hostAgent.SaveSessionAsync(contextId, session, cancellationToken).ConfigureAwait(false); + + if (response.ContinuationToken is null) + { + return CreateMessageFromResponse(contextId, response); + } + + var agentTask = await InitializeTaskAsync(contextId, messageSendParams.Message, taskManager, cancellationToken).ConfigureAwait(false); + StoreContinuationToken(agentTask, response.ContinuationToken, continuationTokenJsonOptions); + await TransitionToWorkingAsync(agentTask.Id, contextId, response, taskManager, cancellationToken).ConfigureAwait(false); + return agentTask; + } + + private static async Task OnTaskUpdatedAsync( + AgentTask agentTask, + AIHostAgent hostAgent, + ITaskManager taskManager, + JsonSerializerOptions continuationTokenJsonOptions, + CancellationToken cancellationToken) + { + var contextId = agentTask.ContextId ?? Guid.NewGuid().ToString("N"); + var session = await hostAgent.GetOrCreateSessionAsync(contextId, cancellationToken).ConfigureAwait(false); + + try + { + // Discard any stale continuation token — the incoming user message supersedes + // any previous background operation. AF agents don't support updating existing + // background responses (long-running operations); we start a fresh run from the + // existing session using the full chat history (which includes the new message). + agentTask.Metadata?.Remove(ContinuationTokenMetadataKey); + + await taskManager.UpdateStatusAsync(agentTask.Id, TaskState.Working, cancellationToken: cancellationToken).ConfigureAwait(false); + + var response = await hostAgent.RunAsync( + ExtractChatMessagesFromTaskHistory(agentTask), + session: session, + options: new AgentRunOptions { AllowBackgroundResponses = true }, + cancellationToken: cancellationToken).ConfigureAwait(false); + + await hostAgent.SaveSessionAsync(contextId, session, cancellationToken).ConfigureAwait(false); + + if (response.ContinuationToken is not null) + { + StoreContinuationToken(agentTask, response.ContinuationToken, continuationTokenJsonOptions); + await TransitionToWorkingAsync(agentTask.Id, contextId, response, taskManager, cancellationToken).ConfigureAwait(false); + } + else + { + await CompleteWithArtifactAsync(agentTask.Id, response, taskManager, cancellationToken).ConfigureAwait(false); + } + } + catch (OperationCanceledException) + { + throw; + } + catch (Exception) + { + await taskManager.UpdateStatusAsync( + agentTask.Id, + TaskState.Failed, + final: true, + cancellationToken: cancellationToken).ConfigureAwait(false); + throw; + } + } + + private static Task OnTaskCancelledAsync(AgentTask agentTask, CancellationToken cancellationToken) + { + // Remove the continuation token from metadata if present. + // The task has already been marked as cancelled by the TaskManager. + agentTask.Metadata?.Remove(ContinuationTokenMetadataKey); + return Task.CompletedTask; + } + + private static AgentMessage CreateMessageFromResponse(string contextId, AgentResponse response) => + new() + { + MessageId = response.ResponseId ?? Guid.NewGuid().ToString("N"), + ContextId = contextId, + Role = MessageRole.Agent, + Parts = response.Messages.ToParts(), + Metadata = response.AdditionalProperties?.ToA2AMetadata() + }; + + // Task outputs should be returned as artifacts rather than messages: + // https://a2a-protocol.org/latest/specification/#37-messages-and-artifacts + private static Artifact CreateArtifactFromResponse(AgentResponse response) => + new() + { + ArtifactId = response.ResponseId ?? Guid.NewGuid().ToString("N"), + Parts = response.Messages.ToParts(), + Metadata = response.AdditionalProperties?.ToA2AMetadata() + }; + + private static async Task InitializeTaskAsync( + string contextId, + AgentMessage originalMessage, + ITaskManager taskManager, + CancellationToken cancellationToken) + { + AgentTask agentTask = await taskManager.CreateTaskAsync(contextId, cancellationToken: cancellationToken).ConfigureAwait(false); + + // Add the original user message to the task history. + // The A2A SDK does this internally when it creates tasks via OnTaskCreated. + agentTask.History ??= []; + agentTask.History.Add(originalMessage); + + // Notify subscribers of the Submitted state per the A2A spec: https://a2a-protocol.org/latest/specification/#413-taskstate + await taskManager.UpdateStatusAsync(agentTask.Id, TaskState.Submitted, cancellationToken: cancellationToken).ConfigureAwait(false); + + return agentTask; + } + + private static void StoreContinuationToken( + AgentTask agentTask, + ResponseContinuationToken token, + JsonSerializerOptions continuationTokenJsonOptions) + { + // Serialize the continuation token into the task's metadata so it survives + // across requests and is cleaned up with the task itself. + agentTask.Metadata ??= []; + agentTask.Metadata[ContinuationTokenMetadataKey] = JsonSerializer.SerializeToElement( + token, + continuationTokenJsonOptions.GetTypeInfo(typeof(ResponseContinuationToken))); + } + + private static async Task TransitionToWorkingAsync( + string taskId, + string contextId, + AgentResponse response, + ITaskManager taskManager, + CancellationToken cancellationToken) + { + // Include any intermediate progress messages from the response as a status message. + AgentMessage? progressMessage = response.Messages.Count > 0 ? CreateMessageFromResponse(contextId, response) : null; + await taskManager.UpdateStatusAsync(taskId, TaskState.Working, message: progressMessage, cancellationToken: cancellationToken).ConfigureAwait(false); + } + + private static async Task CompleteWithArtifactAsync( + string taskId, + AgentResponse response, + ITaskManager taskManager, + CancellationToken cancellationToken) + { + var artifact = CreateArtifactFromResponse(response); + await taskManager.ReturnArtifactAsync(taskId, artifact, cancellationToken).ConfigureAwait(false); + await taskManager.UpdateStatusAsync(taskId, TaskState.Completed, final: true, cancellationToken: cancellationToken).ConfigureAwait(false); + } + + private static List ExtractChatMessagesFromTaskHistory(AgentTask agentTask) + { + if (agentTask.History is not { Count: > 0 }) + { + return []; + } + + var chatMessages = new List(agentTask.History.Count); + foreach (var message in agentTask.History) + { + chatMessages.Add(message.ToChatMessage()); + } + + return chatMessages; + } } diff --git a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/AgentRunMode.cs b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/AgentRunMode.cs new file mode 100644 index 0000000000..087df96aae --- /dev/null +++ b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/AgentRunMode.cs @@ -0,0 +1,105 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Diagnostics.CodeAnalysis; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Shared.DiagnosticIds; + +namespace Microsoft.Agents.AI.Hosting.A2A; + +/// +/// Specifies how the A2A hosting layer determines whether to run in background or not. +/// +[Experimental(DiagnosticIds.Experiments.AIResponseContinuations)] +public sealed class AgentRunMode : IEquatable +{ + private const string MessageValue = "message"; + private const string TaskValue = "task"; + private const string DynamicValue = "dynamic"; + + private readonly string _value; + private readonly Func>? _runInBackground; + + private AgentRunMode(string value, Func>? runInBackground = null) + { + this._value = value; + this._runInBackground = runInBackground; + } + + /// + /// Dissallows the background responses from the agent. Is equivalent to configuring as false. + /// In the A2A protocol terminology will make responses be returned as AgentMessage. + /// + public static AgentRunMode DisallowBackground => new(MessageValue); + + /// + /// Allows the background responses from the agent. Is equivalent to configuring as true. + /// In the A2A protocol terminology will make responses be returned as AgentTask if the agent supports background responses, and as AgentMessage otherwise. + /// + public static AgentRunMode AllowBackgroundIfSupported => new(TaskValue); + + /// + /// The agent run mode is decided by the supplied delegate. + /// The delegate receives an with the incoming + /// message and returns a boolean specifying whether to run the agent in background mode. + /// indicates that the agent should run in background mode and return an + /// AgentTask if the agent supports background mode; otherwise, it returns an AgentMessage + /// if the mode is not supported. indicates that the agent should run in + /// non-background mode and return an AgentMessage. + /// + /// + /// An async delegate that decides whether the response should be wrapped in an AgentTask. + /// + public static AgentRunMode AllowBackgroundWhen(Func> runInBackground) + { + ArgumentNullException.ThrowIfNull(runInBackground); + return new(DynamicValue, runInBackground); + } + + /// + /// Determines whether the agent response should be returned as an AgentTask. + /// + internal ValueTask ShouldRunInBackgroundAsync(A2ARunDecisionContext context, CancellationToken cancellationToken) + { + if (string.Equals(this._value, MessageValue, StringComparison.OrdinalIgnoreCase)) + { + return ValueTask.FromResult(false); + } + + if (string.Equals(this._value, TaskValue, StringComparison.OrdinalIgnoreCase)) + { + return ValueTask.FromResult(true); + } + + // Dynamic: delegate to custom callback. + if (this._runInBackground is not null) + { + return this._runInBackground(context, cancellationToken); + } + + // No delegate provided — fall back to "message" behavior. + return ValueTask.FromResult(true); + } + + /// + public bool Equals(AgentRunMode? other) => + other is not null && string.Equals(this._value, other._value, StringComparison.OrdinalIgnoreCase); + + /// + public override bool Equals(object? obj) => this.Equals(obj as AgentRunMode); + + /// + public override int GetHashCode() => StringComparer.OrdinalIgnoreCase.GetHashCode(this._value); + + /// + public override string ToString() => this._value; + + /// Determines whether two instances are equal. + public static bool operator ==(AgentRunMode? left, AgentRunMode? right) => + left?.Equals(right) ?? right is null; + + /// Determines whether two instances are not equal. + public static bool operator !=(AgentRunMode? left, AgentRunMode? right) => + !(left == right); +} diff --git a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Converters/AdditionalPropertiesDictionaryExtensions.cs b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Converters/AdditionalPropertiesDictionaryExtensions.cs index d46ef72d1f..e557ff4e07 100644 --- a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Converters/AdditionalPropertiesDictionaryExtensions.cs +++ b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Converters/AdditionalPropertiesDictionaryExtensions.cs @@ -2,7 +2,6 @@ using System.Collections.Generic; using System.Text.Json; -using A2A; using Microsoft.Extensions.AI; namespace Microsoft.Agents.AI.Hosting.A2A.Converters; @@ -37,7 +36,7 @@ internal static class AdditionalPropertiesDictionaryExtensions continue; } - metadata[kvp.Key] = JsonSerializer.SerializeToElement(kvp.Value, A2AJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))); + metadata[kvp.Key] = JsonSerializer.SerializeToElement(kvp.Value, A2AHostingJsonUtilities.DefaultOptions.GetTypeInfo(typeof(object))); } return metadata; diff --git a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Microsoft.Agents.AI.Hosting.A2A.csproj b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Microsoft.Agents.AI.Hosting.A2A.csproj index a0d66cc1d5..3c805ee7a4 100644 --- a/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Microsoft.Agents.AI.Hosting.A2A.csproj +++ b/dotnet/src/Microsoft.Agents.AI.Hosting.A2A/Microsoft.Agents.AI.Hosting.A2A.csproj @@ -10,6 +10,8 @@ true + true + true diff --git a/dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/Extensions/JsonDocumentExtensions.cs b/dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/Extensions/JsonDocumentExtensions.cs index 9d3c5e335d..e2b038bbd7 100644 --- a/dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/Extensions/JsonDocumentExtensions.cs +++ b/dotnet/src/Microsoft.Agents.AI.Workflows.Declarative/Extensions/JsonDocumentExtensions.cs @@ -111,7 +111,9 @@ internal static class JsonDocumentExtensions VariableType? currentType = element.ValueKind switch { - JsonValueKind.Object => VariableType.Record(targetType.Schema?.Select(kvp => (kvp.Key, kvp.Value)) ?? []), + JsonValueKind.Object => targetType.HasSchema + ? VariableType.Record(targetType.Schema!.Select(kvp => (kvp.Key, kvp.Value))) + : VariableType.RecordType, JsonValueKind.String => typeof(string), JsonValueKind.True => typeof(bool), JsonValueKind.False => typeof(bool), diff --git a/dotnet/tests/Microsoft.Agents.AI.Hosting.A2A.UnitTests/AIAgentExtensionsTests.cs b/dotnet/tests/Microsoft.Agents.AI.Hosting.A2A.UnitTests/AIAgentExtensionsTests.cs index 15a83ccd50..87de6e52cd 100644 --- a/dotnet/tests/Microsoft.Agents.AI.Hosting.A2A.UnitTests/AIAgentExtensionsTests.cs +++ b/dotnet/tests/Microsoft.Agents.AI.Hosting.A2A.UnitTests/AIAgentExtensionsTests.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Generic; +using System.Runtime.CompilerServices; using System.Text.Json; using System.Threading; using System.Threading.Tasks; @@ -18,10 +19,11 @@ namespace Microsoft.Agents.AI.Hosting.A2A.UnitTests; public sealed class AIAgentExtensionsTests { /// - /// Verifies that when messageSendParams.Metadata is null, the options passed to RunAsync are null. + /// Verifies that when messageSendParams.Metadata is null, the options passed to RunAsync have + /// AllowBackgroundResponses enabled and no AdditionalProperties. /// [Fact] - public async Task MapA2A_WhenMetadataIsNull_PassesNullOptionsToRunAsync() + public async Task MapA2A_WhenMetadataIsNull_PassesOptionsWithNoAdditionalPropertiesToRunAsync() { // Arrange AgentRunOptions? capturedOptions = null; @@ -35,7 +37,9 @@ public sealed class AIAgentExtensionsTests }); // Assert - Assert.Null(capturedOptions); + Assert.NotNull(capturedOptions); + Assert.False(capturedOptions.AllowBackgroundResponses); + Assert.Null(capturedOptions.AdditionalProperties); } /// @@ -68,11 +72,11 @@ public sealed class AIAgentExtensionsTests } /// - /// Verifies that when messageSendParams.Metadata is an empty dictionary, the options passed to RunAsync is null - /// because the ToAdditionalProperties extension method returns null for empty dictionaries. + /// Verifies that when messageSendParams.Metadata is an empty dictionary, the options passed to RunAsync have + /// AllowBackgroundResponses enabled and no AdditionalProperties. /// [Fact] - public async Task MapA2A_WhenMetadataIsEmptyDictionary_PassesNullOptionsToRunAsync() + public async Task MapA2A_WhenMetadataIsEmptyDictionary_PassesOptionsWithNoAdditionalPropertiesToRunAsync() { // Arrange AgentRunOptions? capturedOptions = null; @@ -86,7 +90,9 @@ public sealed class AIAgentExtensionsTests }); // Assert - Assert.Null(capturedOptions); + Assert.NotNull(capturedOptions); + Assert.False(capturedOptions.AllowBackgroundResponses); + Assert.Null(capturedOptions.AdditionalProperties); } /// @@ -171,6 +177,590 @@ public sealed class AIAgentExtensionsTests Assert.Null(agentMessage.Metadata); } + /// + /// Verifies that when runMode is Message, the result is always an AgentMessage even when + /// the agent would otherwise support background responses. + /// + [Fact] + public async Task MapA2A_MessageMode_AlwaysReturnsAgentMessageAsync() + { + // Arrange + AgentRunOptions? capturedOptions = null; + ITaskManager taskManager = CreateAgentMock(options => capturedOptions = options) + .Object.MapA2A(runMode: AgentRunMode.DisallowBackground); + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + + // Assert + Assert.IsType(a2aResponse); + Assert.NotNull(capturedOptions); + Assert.False(capturedOptions.AllowBackgroundResponses); + } + + /// + /// Verifies that in BackgroundIfSupported mode when the agent completes immediately (no ContinuationToken), + /// the result is an AgentMessage because the response type is determined solely by ContinuationToken presence. + /// + [Fact] + public async Task MapA2A_BackgroundIfSupportedMode_WhenNoContinuationToken_ReturnsAgentMessageAsync() + { + // Arrange + AgentRunOptions? capturedOptions = null; + ITaskManager taskManager = CreateAgentMock(options => capturedOptions = options) + .Object.MapA2A(runMode: AgentRunMode.AllowBackgroundIfSupported); + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + + // Assert + Assert.IsType(a2aResponse); + Assert.NotNull(capturedOptions); + Assert.True(capturedOptions.AllowBackgroundResponses); + } + + /// + /// Verifies that a custom Dynamic delegate returning false produces an AgentMessage + /// even when the agent completes immediately (no ContinuationToken). + /// + [Fact] + public async Task MapA2A_DynamicMode_WithFalseCallback_ReturnsAgentMessageAsync() + { + // Arrange + AgentResponse response = new([new ChatMessage(ChatRole.Assistant, "Quick reply")]); + ITaskManager taskManager = CreateAgentMockWithResponse(response) + .Object.MapA2A(runMode: AgentRunMode.AllowBackgroundWhen((_, _) => ValueTask.FromResult(false))); + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + + // Assert + Assert.IsType(a2aResponse); + } + +#pragma warning disable MEAI001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed. + + /// + /// Verifies that when the agent returns a ContinuationToken, an AgentTask in Working state is returned. + /// + [Fact] + public async Task MapA2A_WhenResponseHasContinuationToken_ReturnsAgentTaskInWorkingStateAsync() + { + // Arrange + AgentResponse response = new([new ChatMessage(ChatRole.Assistant, "Starting work...")]) + { + ContinuationToken = CreateTestContinuationToken() + }; + ITaskManager taskManager = CreateAgentMockWithResponse(response).Object.MapA2A(); + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + + // Assert + AgentTask agentTask = Assert.IsType(a2aResponse); + Assert.Equal(TaskState.Working, agentTask.Status.State); + } + + /// + /// Verifies that when the agent returns a ContinuationToken, the returned task includes + /// intermediate messages from the initial response in its status message. + /// + [Fact] + public async Task MapA2A_WhenResponseHasContinuationToken_TaskStatusHasIntermediateMessageAsync() + { + // Arrange + AgentResponse response = new([new ChatMessage(ChatRole.Assistant, "Starting work...")]) + { + ContinuationToken = CreateTestContinuationToken() + }; + ITaskManager taskManager = CreateAgentMockWithResponse(response).Object.MapA2A(); + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + + // Assert + AgentTask agentTask = Assert.IsType(a2aResponse); + Assert.NotNull(agentTask.Status.Message); + TextPart textPart = Assert.IsType(Assert.Single(agentTask.Status.Message.Parts)); + Assert.Equal("Starting work...", textPart.Text); + } + + /// + /// Verifies that when the agent returns a ContinuationToken, the continuation token + /// is serialized into the AgentTask.Metadata for persistence. + /// + [Fact] + public async Task MapA2A_WhenResponseHasContinuationToken_StoresTokenInTaskMetadataAsync() + { + // Arrange + AgentResponse response = new([new ChatMessage(ChatRole.Assistant, "Starting work...")]) + { + ContinuationToken = CreateTestContinuationToken() + }; + ITaskManager taskManager = CreateAgentMockWithResponse(response).Object.MapA2A(); + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + + // Assert + AgentTask agentTask = Assert.IsType(a2aResponse); + Assert.NotNull(agentTask.Metadata); + Assert.True(agentTask.Metadata.ContainsKey("__a2a__continuationToken")); + } + + /// + /// Verifies that when a task is created (Working or Completed), the original user message + /// is added to the task history, matching the A2A SDK's behavior when it creates tasks internally. + /// + [Fact] + public async Task MapA2A_WhenTaskIsCreated_OriginalMessageIsInHistoryAsync() + { + // Arrange + AgentResponse response = new([new ChatMessage(ChatRole.Assistant, "Starting work...")]) + { + ContinuationToken = CreateTestContinuationToken() + }; + ITaskManager taskManager = CreateAgentMockWithResponse(response).Object.MapA2A(); + AgentMessage originalMessage = new() { MessageId = "user-msg-1", Role = MessageRole.User, Parts = [new TextPart { Text = "Do something" }] }; + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = originalMessage + }); + + // Assert + AgentTask agentTask = Assert.IsType(a2aResponse); + Assert.NotNull(agentTask.History); + Assert.Contains(agentTask.History, m => m.MessageId == "user-msg-1" && m.Role == MessageRole.User); + } + + /// + /// Verifies that in BackgroundIfSupported mode when the agent completes immediately (no ContinuationToken), + /// the returned AgentMessage preserves the original context ID. + /// + [Fact] + public async Task MapA2A_BackgroundIfSupportedMode_WhenNoContinuationToken_ReturnsAgentMessageWithContextIdAsync() + { + // Arrange + AgentResponse response = new([new ChatMessage(ChatRole.Assistant, "Done!")]); + ITaskManager taskManager = CreateAgentMockWithResponse(response) + .Object.MapA2A(runMode: AgentRunMode.AllowBackgroundIfSupported); + AgentMessage originalMessage = new() { MessageId = "user-msg-2", ContextId = "ctx-123", Role = MessageRole.User, Parts = [new TextPart { Text = "Quick task" }] }; + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = originalMessage + }); + + // Assert + AgentMessage agentMessage = Assert.IsType(a2aResponse); + Assert.Equal("ctx-123", agentMessage.ContextId); + } + + /// + /// Verifies that when OnTaskUpdated is invoked on a task with a pending continuation token + /// and the agent returns a completed response (null ContinuationToken), the task is updated to Completed. + /// + [Fact] + public async Task MapA2A_OnTaskUpdated_WhenBackgroundOperationCompletes_TaskIsCompletedAsync() + { + // Arrange + int callCount = 0; + Mock agentMock = CreateAgentMockWithSequentialResponses( + // First call: return response with ContinuationToken (long-running) + new AgentResponse([new ChatMessage(ChatRole.Assistant, "Starting...")]) + { + ContinuationToken = CreateTestContinuationToken() + }, + // Second call (via OnTaskUpdated): return completed response + new AgentResponse([new ChatMessage(ChatRole.Assistant, "Done!")]), + ref callCount); + ITaskManager taskManager = agentMock.Object.MapA2A(); + + // Act — trigger OnMessageReceived to create the task + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + AgentTask agentTask = Assert.IsType(a2aResponse); + Assert.Equal(TaskState.Working, agentTask.Status.State); + + // Act — invoke OnTaskUpdated to check on the background operation + await InvokeOnTaskUpdatedAsync(taskManager, agentTask); + + // Assert — task should now be completed + AgentTask? updatedTask = await taskManager.GetTaskAsync(new TaskQueryParams { Id = agentTask.Id }, CancellationToken.None); + Assert.NotNull(updatedTask); + Assert.Equal(TaskState.Completed, updatedTask.Status.State); + Assert.NotNull(updatedTask.Artifacts); + Artifact artifact = Assert.Single(updatedTask.Artifacts); + TextPart textPart = Assert.IsType(Assert.Single(artifact.Parts)); + Assert.Equal("Done!", textPart.Text); + } + + /// + /// Verifies that when OnTaskUpdated is invoked on a task with a pending continuation token + /// and the agent returns another ContinuationToken, the task stays in Working state. + /// + [Fact] + public async Task MapA2A_OnTaskUpdated_WhenBackgroundOperationStillWorking_TaskRemainsWorkingAsync() + { + // Arrange + int callCount = 0; + Mock agentMock = CreateAgentMockWithSequentialResponses( + // First call: return response with ContinuationToken + new AgentResponse([new ChatMessage(ChatRole.Assistant, "Starting...")]) + { + ContinuationToken = CreateTestContinuationToken() + }, + // Second call (via OnTaskUpdated): still working, return another token + new AgentResponse([new ChatMessage(ChatRole.Assistant, "Still working...")]) + { + ContinuationToken = CreateTestContinuationToken() + }, + ref callCount); + ITaskManager taskManager = agentMock.Object.MapA2A(); + + // Act — trigger OnMessageReceived to create the task + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + AgentTask agentTask = Assert.IsType(a2aResponse); + + // Act — invoke OnTaskUpdated; agent still working + await InvokeOnTaskUpdatedAsync(taskManager, agentTask); + + // Assert — task should still be in Working state + AgentTask? updatedTask = await taskManager.GetTaskAsync(new TaskQueryParams { Id = agentTask.Id }, CancellationToken.None); + Assert.NotNull(updatedTask); + Assert.Equal(TaskState.Working, updatedTask.Status.State); + } + + /// + /// Verifies the full lifecycle: agent starts background work, first poll returns still working, + /// second poll returns completed. + /// + [Fact] + public async Task MapA2A_OnTaskUpdated_MultiplePolls_EventuallyCompletesAsync() + { + // Arrange + int callCount = 0; + Mock agentMock = CreateAgentMockWithCallCount(ref callCount, invocation => + { + return invocation switch + { + // First call: start background work + 1 => new AgentResponse([new ChatMessage(ChatRole.Assistant, "Starting...")]) + { + ContinuationToken = CreateTestContinuationToken() + }, + // Second call: still working + 2 => new AgentResponse([new ChatMessage(ChatRole.Assistant, "Still working...")]) + { + ContinuationToken = CreateTestContinuationToken() + }, + // Third call: done + _ => new AgentResponse([new ChatMessage(ChatRole.Assistant, "All done!")]) + }; + }); + ITaskManager taskManager = agentMock.Object.MapA2A(); + + // Act — create the task + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Do work" }] } + }); + AgentTask agentTask = Assert.IsType(a2aResponse); + Assert.Equal(TaskState.Working, agentTask.Status.State); + + // Act — first poll: still working + AgentTask? currentTask = await taskManager.GetTaskAsync(new TaskQueryParams { Id = agentTask.Id }, CancellationToken.None); + Assert.NotNull(currentTask); + await InvokeOnTaskUpdatedAsync(taskManager, currentTask); + currentTask = await taskManager.GetTaskAsync(new TaskQueryParams { Id = agentTask.Id }, CancellationToken.None); + Assert.NotNull(currentTask); + Assert.Equal(TaskState.Working, currentTask.Status.State); + + // Act — second poll: completed + await InvokeOnTaskUpdatedAsync(taskManager, currentTask); + currentTask = await taskManager.GetTaskAsync(new TaskQueryParams { Id = agentTask.Id }, CancellationToken.None); + Assert.NotNull(currentTask); + Assert.Equal(TaskState.Completed, currentTask.Status.State); + + // Assert — final output as artifact + Assert.NotNull(currentTask.Artifacts); + Artifact artifact = Assert.Single(currentTask.Artifacts); + TextPart textPart = Assert.IsType(Assert.Single(artifact.Parts)); + Assert.Equal("All done!", textPart.Text); + } + + /// + /// Verifies that when the agent throws during a background operation poll, + /// the task is updated to Failed state. + /// + [Fact] + public async Task MapA2A_OnTaskUpdated_WhenAgentThrows_TaskIsFailedAsync() + { + // Arrange + int callCount = 0; + Mock agentMock = CreateAgentMockWithCallCount(ref callCount, invocation => + { + if (invocation == 1) + { + return new AgentResponse([new ChatMessage(ChatRole.Assistant, "Starting...")]) + { + ContinuationToken = CreateTestContinuationToken() + }; + } + + throw new InvalidOperationException("Agent failed"); + }); + ITaskManager taskManager = agentMock.Object.MapA2A(); + + // Act — create the task + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + AgentTask agentTask = Assert.IsType(a2aResponse); + + // Act — poll the task; agent throws + await Assert.ThrowsAsync(() => InvokeOnTaskUpdatedAsync(taskManager, agentTask)); + + // Assert — task should be Failed + AgentTask? updatedTask = await taskManager.GetTaskAsync(new TaskQueryParams { Id = agentTask.Id }, CancellationToken.None); + Assert.NotNull(updatedTask); + Assert.Equal(TaskState.Failed, updatedTask.Status.State); + } + + /// + /// Verifies that in Task mode with a ContinuationToken, the result is an AgentTask in Working state. + /// + [Fact] + public async Task MapA2A_TaskMode_WhenContinuationToken_ReturnsWorkingAgentTaskAsync() + { + // Arrange + AgentResponse response = new([new ChatMessage(ChatRole.Assistant, "Working on it...")]) + { + ContinuationToken = CreateTestContinuationToken() + }; + ITaskManager taskManager = CreateAgentMockWithResponse(response) + .Object.MapA2A(runMode: AgentRunMode.AllowBackgroundIfSupported); + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + + // Assert + AgentTask agentTask = Assert.IsType(a2aResponse); + Assert.Equal(TaskState.Working, agentTask.Status.State); + Assert.NotNull(agentTask.Metadata); + Assert.True(agentTask.Metadata.ContainsKey("__a2a__continuationToken")); + } + + /// + /// Verifies that when the agent returns a ContinuationToken with no progress messages, + /// the task transitions to Working state with a null status message. + /// + [Fact] + public async Task MapA2A_WhenContinuationTokenWithNoMessages_TaskStatusHasNullMessageAsync() + { + // Arrange + AgentResponse response = new([]) + { + ContinuationToken = CreateTestContinuationToken() + }; + ITaskManager taskManager = CreateAgentMockWithResponse(response).Object.MapA2A(); + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + + // Assert + AgentTask agentTask = Assert.IsType(a2aResponse); + Assert.Equal(TaskState.Working, agentTask.Status.State); + Assert.Null(agentTask.Status.Message); + } + + /// + /// Verifies that when OnTaskUpdated is invoked on a completed task with a follow-up message + /// and no continuation token in metadata, the task processes history and completes with a new artifact. + /// + [Fact] + public async Task MapA2A_OnTaskUpdated_WhenNoContinuationToken_ProcessesHistoryAndCompletesAsync() + { + // Arrange + int callCount = 0; + Mock agentMock = CreateAgentMockWithCallCount(ref callCount, invocation => + { + return invocation switch + { + // First call: create a task with ContinuationToken + 1 => new AgentResponse([new ChatMessage(ChatRole.Assistant, "Starting...")]) + { + ContinuationToken = CreateTestContinuationToken() + }, + // Second call (via OnTaskUpdated): complete the background operation + 2 => new AgentResponse([new ChatMessage(ChatRole.Assistant, "Done!")]), + // Third call (follow-up via OnTaskUpdated): complete follow-up + _ => new AgentResponse([new ChatMessage(ChatRole.Assistant, "Follow-up done!")]) + }; + }); + ITaskManager taskManager = agentMock.Object.MapA2A(); + + // Act — create a working task (with continuation token) + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + AgentTask agentTask = Assert.IsType(a2aResponse); + + // Act — first OnTaskUpdated: completes the background operation + await InvokeOnTaskUpdatedAsync(taskManager, agentTask); + agentTask = (await taskManager.GetTaskAsync(new TaskQueryParams { Id = agentTask.Id }, CancellationToken.None))!; + Assert.Equal(TaskState.Completed, agentTask.Status.State); + + // Simulate a follow-up message by adding it to history and re-submitting via OnTaskUpdated + agentTask.History ??= []; + agentTask.History.Add(new AgentMessage { MessageId = "follow-up", Role = MessageRole.User, Parts = [new TextPart { Text = "Follow up" }] }); + + // Act — invoke OnTaskUpdated without a continuation token in metadata + await InvokeOnTaskUpdatedAsync(taskManager, agentTask); + + // Assert + AgentTask? updatedTask = await taskManager.GetTaskAsync(new TaskQueryParams { Id = agentTask.Id }, CancellationToken.None); + Assert.NotNull(updatedTask); + Assert.Equal(TaskState.Completed, updatedTask.Status.State); + Assert.NotNull(updatedTask.Artifacts); + Assert.Equal(2, updatedTask.Artifacts.Count); + Artifact artifact = updatedTask.Artifacts[1]; + TextPart textPart = Assert.IsType(Assert.Single(artifact.Parts)); + Assert.Equal("Follow-up done!", textPart.Text); + } + + /// + /// Verifies that when a task is cancelled, the continuation token is removed from metadata. + /// + [Fact] + public async Task MapA2A_OnTaskCancelled_RemovesContinuationTokenFromMetadataAsync() + { + // Arrange + AgentResponse response = new([new ChatMessage(ChatRole.Assistant, "Starting...")]) + { + ContinuationToken = CreateTestContinuationToken() + }; + ITaskManager taskManager = CreateAgentMockWithResponse(response).Object.MapA2A(); + + // Act — create a working task with a continuation token + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + AgentTask agentTask = Assert.IsType(a2aResponse); + Assert.NotNull(agentTask.Metadata); + Assert.True(agentTask.Metadata.ContainsKey("__a2a__continuationToken")); + + // Act — cancel the task + await taskManager.CancelTaskAsync(new TaskIdParams { Id = agentTask.Id }, CancellationToken.None); + + // Assert — continuation token should be removed from metadata + Assert.False(agentTask.Metadata.ContainsKey("__a2a__continuationToken")); + } + + /// + /// Verifies that when the agent throws an OperationCanceledException during a poll, + /// it is re-thrown without marking the task as Failed. + /// + [Fact] + public async Task MapA2A_OnTaskUpdated_WhenOperationCancelled_DoesNotMarkFailedAsync() + { + // Arrange + int callCount = 0; + Mock agentMock = CreateAgentMockWithCallCount(ref callCount, invocation => + { + if (invocation == 1) + { + return new AgentResponse([new ChatMessage(ChatRole.Assistant, "Starting...")]) + { + ContinuationToken = CreateTestContinuationToken() + }; + } + + throw new OperationCanceledException("Cancelled"); + }); + ITaskManager taskManager = agentMock.Object.MapA2A(); + + // Act — create the task + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage { MessageId = "test-id", Role = MessageRole.User, Parts = [new TextPart { Text = "Hello" }] } + }); + AgentTask agentTask = Assert.IsType(a2aResponse); + + // Act — poll the task; agent throws OperationCanceledException + await Assert.ThrowsAsync(() => InvokeOnTaskUpdatedAsync(taskManager, agentTask)); + + // Assert — task should still be Working, not Failed + AgentTask? updatedTask = await taskManager.GetTaskAsync(new TaskQueryParams { Id = agentTask.Id }, CancellationToken.None); + Assert.NotNull(updatedTask); + Assert.Equal(TaskState.Working, updatedTask.Status.State); + } + + /// + /// Verifies that when the incoming message has a ContextId, it is used for the task + /// rather than generating a new one. + /// + [Fact] + public async Task MapA2A_WhenMessageHasContextId_UsesProvidedContextIdAsync() + { + // Arrange + AgentResponse response = new([new ChatMessage(ChatRole.Assistant, "Reply")]); + ITaskManager taskManager = CreateAgentMockWithResponse(response).Object.MapA2A(); + + // Act + A2AResponse a2aResponse = await InvokeOnMessageReceivedAsync(taskManager, new MessageSendParams + { + Message = new AgentMessage + { + MessageId = "test-id", + ContextId = "my-context-123", + Role = MessageRole.User, + Parts = [new TextPart { Text = "Hello" }] + } + }); + + // Assert + AgentMessage agentMessage = Assert.IsType(a2aResponse); + Assert.Equal("my-context-123", agentMessage.ContextId); + } + +#pragma warning restore MEAI001 + private static Mock CreateAgentMock(Action optionsCallback) { Mock agentMock = new() { CallBase = true }; @@ -220,5 +810,57 @@ public sealed class AIAgentExtensionsTests return await handler.Invoke(messageSendParams, CancellationToken.None); } + private static async Task InvokeOnTaskUpdatedAsync(ITaskManager taskManager, AgentTask agentTask) + { + Func? handler = taskManager.OnTaskUpdated; + Assert.NotNull(handler); + await handler.Invoke(agentTask, CancellationToken.None); + } + +#pragma warning disable MEAI001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed. + private static ResponseContinuationToken CreateTestContinuationToken() + { + return ResponseContinuationToken.FromBytes(new byte[] { 0x01, 0x02, 0x03 }); + } +#pragma warning restore MEAI001 + + private static Mock CreateAgentMockWithSequentialResponses( + AgentResponse firstResponse, + AgentResponse secondResponse, + ref int callCount) + { + return CreateAgentMockWithCallCount(ref callCount, invocation => + invocation == 1 ? firstResponse : secondResponse); + } + + private static Mock CreateAgentMockWithCallCount( + ref int callCount, + Func responseFactory) + { + // Use a StrongBox to allow the lambda to capture a mutable reference + StrongBox callCountBox = new(callCount); + + Mock agentMock = new() { CallBase = true }; + agentMock.SetupGet(x => x.Name).Returns("TestAgent"); + agentMock + .Protected() + .Setup>("CreateSessionCoreAsync", ItExpr.IsAny()) + .ReturnsAsync(new TestAgentSession()); + agentMock + .Protected() + .Setup>("RunCoreAsync", + ItExpr.IsAny>(), + ItExpr.IsAny(), + ItExpr.IsAny(), + ItExpr.IsAny()) + .ReturnsAsync(() => + { + int currentCall = Interlocked.Increment(ref callCountBox.Value); + return responseFactory(currentCall); + }); + + return agentMock; + } + private sealed class TestAgentSession : AgentSession; } diff --git a/dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Extensions/JsonDocumentExtensionsTests.cs b/dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Extensions/JsonDocumentExtensionsTests.cs index bd86aa1958..fc03d17142 100644 --- a/dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Extensions/JsonDocumentExtensionsTests.cs +++ b/dotnet/tests/Microsoft.Agents.AI.Workflows.Declarative.UnitTests/Extensions/JsonDocumentExtensionsTests.cs @@ -384,4 +384,79 @@ public sealed class JsonDocumentExtensionsTests // Act / Assert Assert.Throws(() => document.ParseList(typeof(int[]))); } + + /// + /// Regression test for #4195: When a JSON object contains an array of objects + /// and is parsed with VariableType.RecordType (no schema), the nested + /// object properties must be preserved. Before the fix, DetermineElementType() + /// created an empty-schema VariableType, causing ParseRecord to take the + /// ParseSchema path (zero fields) and return empty dictionaries. + /// + [Fact] + public void ParseRecord_ObjectWithArrayOfObjects_NoSchema_PreservesNestedProperties() + { + // Arrange + JsonDocument document = JsonDocument.Parse( + """ + { + "items": [ + { "name": "Alice", "role": "Engineer" }, + { "name": "Bob", "role": "Designer" }, + { "name": "Carol", "role": "PM" } + ] + } + """); + + // Act + Dictionary result = document.ParseRecord(VariableType.RecordType); + + // Assert + Assert.True(result.ContainsKey("items")); + List items = Assert.IsType>(result["items"]); + Assert.Equal(3, items.Count); + + Dictionary first = Assert.IsType>(items[0]); + Assert.Equal("Alice", first["name"]); + Assert.Equal("Engineer", first["role"]); + + Dictionary second = Assert.IsType>(items[1]); + Assert.Equal("Bob", second["name"]); + Assert.Equal("Designer", second["role"]); + + Dictionary third = Assert.IsType>(items[2]); + Assert.Equal("Carol", third["name"]); + Assert.Equal("PM", third["role"]); + } + + /// + /// Regression test for #4195: When a JSON array of objects is parsed directly + /// via ParseList with VariableType.ListType (no schema), all + /// object properties must be preserved in each element. + /// + [Fact] + public void ParseList_ArrayOfObjects_NoSchema_PreservesProperties() + { + // Arrange + JsonDocument document = JsonDocument.Parse( + """ + [ + { "name": "Alice", "role": "Engineer" }, + { "name": "Bob", "role": "Designer" } + ] + """); + + // Act + List result = document.ParseList(VariableType.ListType); + + // Assert + Assert.Equal(2, result.Count); + + Dictionary first = Assert.IsType>(result[0]); + Assert.Equal("Alice", first["name"]); + Assert.Equal("Engineer", first["role"]); + + Dictionary second = Assert.IsType>(result[1]); + Assert.Equal("Bob", second["name"]); + Assert.Equal("Designer", second["role"]); + } } diff --git a/python/packages/azure-ai-search/agent_framework_azure_ai_search/_context_provider.py b/python/packages/azure-ai-search/agent_framework_azure_ai_search/_context_provider.py index 4445de8015..ff245817b7 100644 --- a/python/packages/azure-ai-search/agent_framework_azure_ai_search/_context_provider.py +++ b/python/packages/azure-ai-search/agent_framework_azure_ai_search/_context_provider.py @@ -13,7 +13,7 @@ import sys from collections.abc import Awaitable, Callable from typing import TYPE_CHECKING, Any, ClassVar, Literal, TypedDict -from agent_framework import AGENT_FRAMEWORK_USER_AGENT, Message +from agent_framework import AGENT_FRAMEWORK_USER_AGENT, Annotation, Content, Message, SupportsGetEmbeddings from agent_framework._sessions import AgentSession, BaseContextProvider, SessionContext from agent_framework._settings import SecretString, load_settings from agent_framework.azure._entra_id_authentication import AzureCredentialTypes @@ -47,8 +47,12 @@ if TYPE_CHECKING: from azure.search.documents.knowledgebases.aio import KnowledgeBaseRetrievalClient from azure.search.documents.knowledgebases.models import ( KnowledgeBaseMessage, + KnowledgeBaseMessageImageContent, + KnowledgeBaseMessageImageContentImage, KnowledgeBaseMessageTextContent, + KnowledgeBaseReference, KnowledgeBaseRetrievalRequest, + KnowledgeBaseRetrievalResponse, KnowledgeRetrievalIntent, KnowledgeRetrievalSemanticIntent, ) @@ -78,8 +82,12 @@ try: from azure.search.documents.knowledgebases.aio import KnowledgeBaseRetrievalClient from azure.search.documents.knowledgebases.models import ( KnowledgeBaseMessage, + KnowledgeBaseMessageImageContent, + KnowledgeBaseMessageImageContentImage, KnowledgeBaseMessageTextContent, + KnowledgeBaseReference, KnowledgeBaseRetrievalRequest, + KnowledgeBaseRetrievalResponse, KnowledgeRetrievalIntent, KnowledgeRetrievalSemanticIntent, ) @@ -154,7 +162,9 @@ class AzureAISearchContextProvider(BaseContextProvider): top_k: int = 5, semantic_configuration_name: str | None = None, vector_field_name: str | None = None, - embedding_function: Callable[[str], Awaitable[list[float]]] | None = None, + embedding_function: Callable[[str], Awaitable[list[float]]] + | SupportsGetEmbeddings[str, list[float], Any] + | None = None, context_prompt: str | None = None, azure_openai_resource_url: str | None = None, model_deployment_name: str | None = None, @@ -181,7 +191,7 @@ class AzureAISearchContextProvider(BaseContextProvider): top_k: Maximum number of documents to retrieve. Default: 5. semantic_configuration_name: Name of semantic configuration in the index. vector_field_name: Name of the vector field in the index. - embedding_function: Async function to generate embeddings. + embedding_function: Async function to generate embeddings or a SupportsGetEmbeddings instance. context_prompt: Custom prompt to prepend to retrieved context. azure_openai_resource_url: Azure OpenAI resource URL for Knowledge Base. model_deployment_name: Model deployment name in Azure OpenAI. @@ -309,9 +319,20 @@ class AzureAISearchContextProvider(BaseContextProvider): exc_tb: Any, ) -> None: """Async context manager exit - cleanup clients.""" + await self.close() + + async def close(self) -> None: + """Close all the open clients.""" if self._retrieval_client is not None: await self._retrieval_client.close() self._retrieval_client = None + self._knowledge_base_initialized = False + if self._search_client is not None: + await self._search_client.close() + self._search_client = None + if self._index_client is not None: + await self._index_client.close() + self._index_client = None # -- Hooks pattern --------------------------------------------------------- @@ -326,32 +347,23 @@ class AzureAISearchContextProvider(BaseContextProvider): """Retrieve relevant context from Azure AI Search and add to session context.""" messages_list = list(context.input_messages) - def get_role_value(role: str | Any) -> str: - return role.value if hasattr(role, "value") else str(role) - filtered_messages = [ - msg - for msg in messages_list - if msg and msg.text and msg.text.strip() and get_role_value(msg.role) in ["user", "assistant"] + msg for msg in messages_list if msg and msg.text and msg.text.strip() and msg.role in ["user", "assistant"] ] if not filtered_messages: return if self.mode == "semantic": query = "\n".join(msg.text for msg in filtered_messages) - search_result_parts = await self._semantic_search(query) + result_messages = await self._semantic_search(query) else: recent_messages = filtered_messages[-self.agentic_message_history_count :] - search_result_parts = await self._agentic_search(recent_messages) + result_messages = await self._agentic_search(recent_messages) - if not search_result_parts: + if not result_messages: return - context_messages = [Message(role="user", text=self.context_prompt)] - context_messages.extend([Message(role="user", text=part) for part in search_result_parts]) - context.extend_messages(self.source_id, context_messages) - - # -- Internal methods (ported from AzureAISearchContextProvider) ----------- + context.extend_messages(self.source_id, [Message(role="user", text=self.context_prompt), *result_messages]) def _find_vector_fields(self, index: Any) -> list[str]: """Find all fields that can store vectors.""" @@ -432,7 +444,7 @@ class AzureAISearchContextProvider(BaseContextProvider): self._auto_discovered_vector_field = True - async def _semantic_search(self, query: str) -> list[str]: + async def _semantic_search(self, query: str) -> list[Message]: """Perform semantic hybrid search.""" await self._auto_discover_vector_field() @@ -440,14 +452,14 @@ class AzureAISearchContextProvider(BaseContextProvider): if self.vector_field_name: vector_k = max(self.top_k, 50) if self.semantic_configuration_name else self.top_k if self._use_vectorizable_query: - vector_queries = [ - VectorizableTextQuery(text=query, k_nearest_neighbors=vector_k, fields=self.vector_field_name) - ] + vector_queries = [VectorizableTextQuery(text=query, k=vector_k, fields=self.vector_field_name)] elif self.embedding_function: - query_vector = await self.embedding_function(query) - vector_queries = [ - VectorizedQuery(vector=query_vector, k_nearest_neighbors=vector_k, fields=self.vector_field_name) - ] + if isinstance(self.embedding_function, SupportsGetEmbeddings): + embeddings = await self.embedding_function.get_embeddings([query]) # type: ignore[reportUnknownVariableType] + query_vector: list[float] = embeddings[0].vector # type: ignore[reportUnknownVariableType] + else: + query_vector = await self.embedding_function(query) + vector_queries = [VectorizedQuery(vector=query_vector, k=vector_k, fields=self.vector_field_name)] search_params: dict[str, Any] = {"search_text": query, "top": self.top_k} if vector_queries: @@ -461,13 +473,13 @@ class AzureAISearchContextProvider(BaseContextProvider): raise RuntimeError("Search client is not initialized.") results = await self._search_client.search(**search_params) # type: ignore[reportUnknownVariableType] - formatted_results: list[str] = [] + result_messages: list[Message] = [] async for doc in results: # type: ignore[reportUnknownVariableType] doc_id = doc.get("id") or doc.get("@search.id") # type: ignore[reportUnknownVariableType] doc_text: str = self._extract_document_text(doc, doc_id=doc_id) # type: ignore[reportUnknownArgumentType] if doc_text: - formatted_results.append(doc_text) # type: ignore[reportUnknownArgumentType] - return formatted_results + result_messages.append(Message(role="user", text=doc_text)) # type: ignore[reportUnknownArgumentType] + return result_messages async def _ensure_knowledge_base(self) -> None: """Ensure Knowledge Base and knowledge source are created or use existing KB.""" @@ -550,7 +562,7 @@ class AzureAISearchContextProvider(BaseContextProvider): user_agent=AGENT_FRAMEWORK_USER_AGENT, ) - async def _agentic_search(self, messages: list[Message]) -> list[str]: + async def _agentic_search(self, messages: list[Message]) -> list[Message]: """Perform agentic retrieval with multi-hop reasoning.""" await self._ensure_knowledge_base() @@ -577,14 +589,7 @@ class AzureAISearchContextProvider(BaseContextProvider): include_activity=True, ) else: - kb_messages = [ - KnowledgeBaseMessage( - role=msg.role if hasattr(msg.role, "value") else str(msg.role), - content=[KnowledgeBaseMessageTextContent(text=msg.text)], - ) - for msg in messages - if msg.text - ] + kb_messages = self._prepare_messages_for_kb_search(messages) retrieval_request = KnowledgeBaseRetrievalRequest( messages=kb_messages, retrieval_reasoning_effort=reasoning_effort, @@ -596,17 +601,136 @@ class AzureAISearchContextProvider(BaseContextProvider): raise RuntimeError("Retrieval client not initialized.") retrieval_result = await self._retrieval_client.retrieve(retrieval_request=retrieval_request) - if retrieval_result.response and len(retrieval_result.response) > 0: - assistant_message = retrieval_result.response[-1] - if assistant_message.content: - answer_parts: list[str] = [] - for content_item in assistant_message.content: - if isinstance(content_item, KnowledgeBaseMessageTextContent) and content_item.text: - answer_parts.append(content_item.text) - if answer_parts: - return answer_parts + return self._parse_messages_from_kb_response(retrieval_result) - return ["No results found from Knowledge Base."] + @staticmethod + def _prepare_messages_for_kb_search(messages: list[Message]) -> list[KnowledgeBaseMessage]: + """Convert framework Messages to KnowledgeBaseMessages for agentic retrieval. + + Handles text and image content types. Other content types (function calls, + errors, etc.) are skipped. + + Args: + messages: Framework messages to convert. + + Returns: + List of KnowledgeBaseMessage objects suitable for retrieval requests. + """ + kb_messages: list[KnowledgeBaseMessage] = [] + for msg in messages: + kb_content: list[KnowledgeBaseMessageTextContent | KnowledgeBaseMessageImageContent] = [] + if msg.contents: + for content in msg.contents: + match content.type: + case "text" if content.text: + kb_content.append(KnowledgeBaseMessageTextContent(text=content.text)) + case "uri" | "data" if ( + content.uri and content.media_type and content.media_type.startswith("image/") + ): + kb_content.append( + KnowledgeBaseMessageImageContent( + image=KnowledgeBaseMessageImageContentImage(url=content.uri), + ) + ) + elif msg.text: + kb_content.append(KnowledgeBaseMessageTextContent(text=msg.text)) + if kb_content: + kb_messages.append(KnowledgeBaseMessage(role=msg.role, content=kb_content)) # type: ignore[arg-type] + return kb_messages + + @staticmethod + def _parse_references_to_annotations(references: list[KnowledgeBaseReference] | None) -> list[Annotation]: + """Convert Knowledge Base references to framework Annotations. + + Captures all available fields from each reference subtype: URLs, doc keys, + reranker scores, source data, and the raw reference object itself. + + Args: + references: The references from a Knowledge Base retrieval response. + + Returns: + List of citation Annotations. + """ + if not references: + return [] + annotations: list[Annotation] = [] + for ref in references: + url: str | None = None + for attr in ("url", "blob_url", "doc_url", "web_url"): + url = getattr(ref, attr, None) + if url: + break + + annotation = Annotation( + type="citation", + url=url or "", + title=getattr(ref, "title", None) or ref.id, + ) + + extra: dict[str, Any] = { + "reference_id": ref.id, + "reference_type": getattr(ref, "type", None), + "activity_source": ref.activity_source, + } + if ref.reranker_score is not None: + extra["reranker_score"] = ref.reranker_score + if ref.source_data: + extra["source_data"] = ref.source_data + doc_key = getattr(ref, "doc_key", None) + if doc_key: + extra["doc_key"] = doc_key + if ref.additional_properties: + extra["sdk_additional_properties"] = ref.additional_properties + sensitivity_info = getattr(ref, "search_sensitivity_label_info", None) + if sensitivity_info: + extra["sensitivity_label"] = { + "display_name": sensitivity_info.display_name, + "sensitivity_label_id": sensitivity_info.sensitivity_label_id, + "is_encrypted": sensitivity_info.is_encrypted, + } + + annotation["additional_properties"] = extra + annotation["raw_representation"] = ref + annotations.append(annotation) + return annotations + + @staticmethod + def _parse_messages_from_kb_response(retrieval_result: KnowledgeBaseRetrievalResponse) -> list[Message]: + """Convert a Knowledge Base retrieval response to framework Messages. + + Each KnowledgeBaseMessage becomes a Message. References from the response + are converted to Annotations and attached to content items. + + Args: + retrieval_result: The full retrieval response including messages and references. + + Returns: + List of Messages, or a single default Message if no results found. + """ + if not retrieval_result.response: + return [Message(role="assistant", text="No results found from Knowledge Base.")] + + annotations = AzureAISearchContextProvider._parse_references_to_annotations(retrieval_result.references) + + result_messages: list[Message] = [] + for kb_msg in retrieval_result.response: + if not kb_msg.content: + continue + contents: list[Content] = [] + for item in kb_msg.content: + if isinstance(item, KnowledgeBaseMessageTextContent) and item.text: + contents.append(Content.from_text(item.text)) + elif isinstance(item, KnowledgeBaseMessageImageContent) and item.image and item.image.url: + contents.append(Content.from_uri(uri=item.image.url, media_type="image/png")) + if contents: + if annotations: + for c in contents: + c.annotations = annotations + result_messages.append(Message(role=kb_msg.role or "assistant", contents=contents)) + + if not result_messages: + return [Message(role="assistant", text="No results found from Knowledge Base.")] + return result_messages def _extract_document_text(self, doc: dict[str, Any], doc_id: str | None = None) -> str: """Extract readable text from a search document with optional citation.""" diff --git a/python/packages/azure-ai-search/tests/test_aisearch_context_provider.py b/python/packages/azure-ai-search/tests/test_aisearch_context_provider.py index 3a83015872..7cc51e4930 100644 --- a/python/packages/azure-ai-search/tests/test_aisearch_context_provider.py +++ b/python/packages/azure-ai-search/tests/test_aisearch_context_provider.py @@ -6,7 +6,7 @@ from types import SimpleNamespace from unittest.mock import AsyncMock, Mock, patch import pytest -from agent_framework import Message +from agent_framework import Content, Message from agent_framework._sessions import AgentSession, SessionContext from agent_framework.exceptions import SettingNotFoundError from azure.core.credentials import AzureKeyCredential @@ -720,7 +720,7 @@ class TestSemanticSearch: results = await provider._semantic_search("test query") assert len(results) == 1 - assert "result text" in results[0] + assert "result text" in results[0].text call_kwargs = mock_client.search.call_args[1] assert call_kwargs["search_text"] == "test query" @@ -746,7 +746,11 @@ class TestSemanticSearch: provider = _make_provider() provider._use_vectorizable_query = False provider.vector_field_name = "embedding" - provider.embedding_function = AsyncMock(return_value=[0.1, 0.2, 0.3]) + + async def _embed(query: str) -> list[float]: + return [0.1, 0.2, 0.3] + + provider.embedding_function = _embed mock_client = AsyncMock() async def _search(**kwargs): @@ -757,7 +761,6 @@ class TestSemanticSearch: results = await provider._semantic_search("embed query") assert len(results) == 1 - provider.embedding_function.assert_awaited_once_with("embed query") call_kwargs = mock_client.search.call_args[1] assert "vector_queries" in call_kwargs @@ -1100,9 +1103,11 @@ class TestAgenticSearch: mock_content = Mock() mock_content.text = "Answer text" mock_message = Mock() + mock_message.role = "assistant" mock_message.content = [mock_content] mock_result = Mock() mock_result.response = [mock_message] + mock_result.references = None mock_retrieval = AsyncMock() mock_retrieval.retrieve = AsyncMock(return_value=mock_result) @@ -1115,7 +1120,9 @@ class TestAgenticSearch: ): results = await provider._agentic_search([Message(role="user", contents=["test query"])]) - assert results == ["Answer text"] + assert len(results) == 1 + assert results[0].text == "Answer text" + assert results[0].role == "assistant" async def test_non_minimal_reasoning_uses_messages(self) -> None: provider = _make_provider() @@ -1126,9 +1133,11 @@ class TestAgenticSearch: mock_content = Mock() mock_content.text = "Medium answer" mock_message = Mock() + mock_message.role = "assistant" mock_message.content = [mock_content] mock_result = Mock() mock_result.response = [mock_message] + mock_result.references = None mock_retrieval = AsyncMock() mock_retrieval.retrieve = AsyncMock(return_value=mock_result) @@ -1143,7 +1152,8 @@ class TestAgenticSearch: Message(role="assistant", contents=["answer"]), ]) - assert results == ["Medium answer"] + assert len(results) == 1 + assert results[0].text == "Medium answer" mock_retrieval.retrieve.assert_awaited_once() async def test_no_response_returns_default_message(self) -> None: @@ -1154,13 +1164,15 @@ class TestAgenticSearch: mock_result = Mock() mock_result.response = [] + mock_result.references = None mock_retrieval = AsyncMock() mock_retrieval.retrieve = AsyncMock(return_value=mock_result) provider._retrieval_client = mock_retrieval results = await provider._agentic_search([Message(role="user", contents=["query"])]) - assert results == ["No results found from Knowledge Base."] + assert len(results) == 1 + assert results[0].text == "No results found from Knowledge Base." async def test_empty_content_returns_default_message(self) -> None: provider = _make_provider() @@ -1172,13 +1184,15 @@ class TestAgenticSearch: mock_message.content = None mock_result = Mock() mock_result.response = [mock_message] + mock_result.references = None mock_retrieval = AsyncMock() mock_retrieval.retrieve = AsyncMock(return_value=mock_result) provider._retrieval_client = mock_retrieval results = await provider._agentic_search([Message(role="user", contents=["query"])]) - assert results == ["No results found from Knowledge Base."] + assert len(results) == 1 + assert results[0].text == "No results found from Knowledge Base." async def test_answer_synthesis_output_mode(self) -> None: provider = _make_provider() @@ -1190,9 +1204,11 @@ class TestAgenticSearch: mock_content = Mock() mock_content.text = "Synthesized answer" mock_message = Mock() + mock_message.role = "assistant" mock_message.content = [mock_content] mock_result = Mock() mock_result.response = [mock_message] + mock_result.references = None mock_retrieval = AsyncMock() mock_retrieval.retrieve = AsyncMock(return_value=mock_result) @@ -1204,7 +1220,8 @@ class TestAgenticSearch: ): results = await provider._agentic_search([Message(role="user", contents=["query"])]) - assert results == ["Synthesized answer"] + assert len(results) == 1 + assert results[0].text == "Synthesized answer" async def test_content_without_text_excluded(self) -> None: provider = _make_provider() @@ -1217,9 +1234,11 @@ class TestAgenticSearch: mock_content_no_text = Mock() mock_content_no_text.text = None mock_message = Mock() + mock_message.role = "assistant" mock_message.content = [mock_content_no_text, mock_content_with_text] mock_result = Mock() mock_result.response = [mock_message] + mock_result.references = None mock_retrieval = AsyncMock() mock_retrieval.retrieve = AsyncMock(return_value=mock_result) @@ -1231,7 +1250,8 @@ class TestAgenticSearch: ): results = await provider._agentic_search([Message(role="user", contents=["query"])]) - assert results == ["Good content"] + assert len(results) == 1 + assert results[0].text == "Good content" async def test_none_response_returns_default_message(self) -> None: provider = _make_provider() @@ -1241,13 +1261,355 @@ class TestAgenticSearch: mock_result = Mock() mock_result.response = None + mock_result.references = None mock_retrieval = AsyncMock() mock_retrieval.retrieve = AsyncMock(return_value=mock_result) provider._retrieval_client = mock_retrieval results = await provider._agentic_search([Message(role="user", contents=["query"])]) - assert results == ["No results found from Knowledge Base."] + assert len(results) == 1 + assert results[0].text == "No results found from Knowledge Base." + + +# -- before_run: agentic mode -------------------------------------------------- + + +# -- _prepare_messages_for_kb_search / _parse_content_from_kb_response -------- + + +class TestPrepareMessagesForKbSearch: + """Tests for _prepare_messages_for_kb_search.""" + + def test_text_only_messages(self) -> None: + messages = [ + Message(role="user", contents=["hello"]), + Message(role="assistant", contents=["world"]), + ] + result = AzureAISearchContextProvider._prepare_messages_for_kb_search(messages) + assert len(result) == 2 + assert result[0].role == "user" + assert result[1].role == "assistant" + # Verify content is KnowledgeBaseMessageTextContent + from azure.search.documents.knowledgebases.models import KnowledgeBaseMessageTextContent + + assert isinstance(result[0].content[0], KnowledgeBaseMessageTextContent) + assert result[0].content[0].text == "hello" + + def test_image_uri_content(self) -> None: + from agent_framework import Content + + img = Content.from_uri(uri="https://example.com/photo.png", media_type="image/png") + messages = [Message(role="user", contents=[img])] + result = AzureAISearchContextProvider._prepare_messages_for_kb_search(messages) + assert len(result) == 1 + from azure.search.documents.knowledgebases.models import KnowledgeBaseMessageImageContent + + assert isinstance(result[0].content[0], KnowledgeBaseMessageImageContent) + assert result[0].content[0].image.url == "https://example.com/photo.png" + + def test_mixed_text_and_image_content(self) -> None: + from agent_framework import Content + + text = Content.from_text("describe this image") + img = Content.from_uri(uri="https://example.com/img.jpg", media_type="image/jpeg") + messages = [Message(role="user", contents=[text, img])] + result = AzureAISearchContextProvider._prepare_messages_for_kb_search(messages) + assert len(result) == 1 + assert len(result[0].content) == 2 + + def test_skips_non_text_non_image_content(self) -> None: + from agent_framework import Content + + error = Content.from_error(message="oops") + messages = [Message(role="user", contents=[error])] + result = AzureAISearchContextProvider._prepare_messages_for_kb_search(messages) + assert len(result) == 0 # message had no usable content + + def test_skips_empty_text(self) -> None: + from agent_framework import Content + + empty = Content.from_text("") + messages = [Message(role="user", contents=[empty])] + result = AzureAISearchContextProvider._prepare_messages_for_kb_search(messages) + assert len(result) == 0 + + def test_fallback_to_msg_text_when_no_contents(self) -> None: + msg = Message(role="user", text="fallback text") + result = AzureAISearchContextProvider._prepare_messages_for_kb_search([msg]) + assert len(result) == 1 + assert result[0].content[0].text == "fallback text" + + def test_data_uri_image(self) -> None: + from agent_framework import Content + + img = Content.from_data(data=b"\x89PNG", media_type="image/png") + messages = [Message(role="user", contents=[img])] + result = AzureAISearchContextProvider._prepare_messages_for_kb_search(messages) + assert len(result) == 1 + from azure.search.documents.knowledgebases.models import KnowledgeBaseMessageImageContent + + assert isinstance(result[0].content[0], KnowledgeBaseMessageImageContent) + + def test_non_image_uri_skipped(self) -> None: + from agent_framework import Content + + pdf = Content.from_uri(uri="https://example.com/doc.pdf", media_type="application/pdf") + messages = [Message(role="user", contents=[pdf])] + result = AzureAISearchContextProvider._prepare_messages_for_kb_search(messages) + assert len(result) == 0 + + +class TestParseReferencesToAnnotations: + """Tests for _parse_references_to_annotations.""" + + def test_none_references(self) -> None: + result = AzureAISearchContextProvider._parse_references_to_annotations(None) + assert result == [] + + def test_empty_references(self) -> None: + result = AzureAISearchContextProvider._parse_references_to_annotations([]) + assert result == [] + + def test_search_index_reference_captures_doc_key(self) -> None: + from azure.search.documents.knowledgebases.models import KnowledgeBaseSearchIndexReference + + ref = KnowledgeBaseSearchIndexReference(id="ref-1", activity_source=0, doc_key="doc-1") + result = AzureAISearchContextProvider._parse_references_to_annotations([ref]) + assert len(result) == 1 + assert result[0]["type"] == "citation" + assert result[0]["title"] == "ref-1" + extra = result[0]["additional_properties"] + assert extra["reference_id"] == "ref-1" + assert extra["reference_type"] == "searchIndex" + assert extra["activity_source"] == 0 + assert extra["doc_key"] == "doc-1" + + def test_web_reference_with_url_and_title(self) -> None: + from azure.search.documents.knowledgebases.models import KnowledgeBaseWebReference + + ref = KnowledgeBaseWebReference( + id="ref-2", activity_source=0, url="https://example.com/page", title="Example Page" + ) + result = AzureAISearchContextProvider._parse_references_to_annotations([ref]) + assert len(result) == 1 + assert result[0]["url"] == "https://example.com/page" + assert result[0]["title"] == "Example Page" + assert result[0]["additional_properties"]["reference_type"] == "web" + + def test_blob_reference_extracts_blob_url(self) -> None: + from azure.search.documents.knowledgebases.models import KnowledgeBaseAzureBlobReference + + ref = KnowledgeBaseAzureBlobReference( + id="ref-3", activity_source=0, blob_url="https://storage.blob.core.windows.net/doc.pdf" + ) + result = AzureAISearchContextProvider._parse_references_to_annotations([ref]) + assert result[0]["url"] == "https://storage.blob.core.windows.net/doc.pdf" + assert result[0]["additional_properties"]["reference_type"] == "azureBlob" + + def test_source_data_and_reranker_score(self) -> None: + from azure.search.documents.knowledgebases.models import KnowledgeBaseSearchIndexReference + + ref = KnowledgeBaseSearchIndexReference( + id="ref-4", activity_source=0, source_data={"chunk": "some text"}, reranker_score=0.95 + ) + result = AzureAISearchContextProvider._parse_references_to_annotations([ref]) + extra = result[0]["additional_properties"] + assert extra["source_data"] == {"chunk": "some text"} + assert extra["reranker_score"] == 0.95 + + def test_raw_representation_stores_original_ref(self) -> None: + from azure.search.documents.knowledgebases.models import KnowledgeBaseSearchIndexReference + + ref = KnowledgeBaseSearchIndexReference(id="ref-5", activity_source=0) + result = AzureAISearchContextProvider._parse_references_to_annotations([ref]) + assert result[0]["raw_representation"] is ref + + def test_remote_sharepoint_captures_sensitivity_label(self) -> None: + from azure.search.documents.knowledgebases.models import ( + KnowledgeBaseRemoteSharePointReference, + SharePointSensitivityLabelInfo, + ) + + label = SharePointSensitivityLabelInfo( + display_name="Confidential", sensitivity_label_id="lbl-1", is_encrypted=True + ) + ref = KnowledgeBaseRemoteSharePointReference( + id="ref-6", activity_source=0, web_url="https://sp.example.com/doc", search_sensitivity_label_info=label + ) + result = AzureAISearchContextProvider._parse_references_to_annotations([ref]) + assert result[0]["url"] == "https://sp.example.com/doc" + sl = result[0]["additional_properties"]["sensitivity_label"] + assert sl["display_name"] == "Confidential" + assert sl["sensitivity_label_id"] == "lbl-1" + assert sl["is_encrypted"] is True + + def test_multiple_references(self) -> None: + from azure.search.documents.knowledgebases.models import ( + KnowledgeBaseSearchIndexReference, + KnowledgeBaseWebReference, + ) + + refs = [ + KnowledgeBaseSearchIndexReference(id="ref-a", activity_source=0), + KnowledgeBaseWebReference(id="ref-b", activity_source=1, url="https://example.com"), + ] + result = AzureAISearchContextProvider._parse_references_to_annotations(refs) + assert len(result) == 2 + assert result[0]["additional_properties"]["activity_source"] == 0 + assert result[1]["additional_properties"]["activity_source"] == 1 + + +class TestParseMessagesFromKbResponse: + """Tests for _parse_messages_from_kb_response.""" + + def test_converts_all_messages(self) -> None: + from azure.search.documents.knowledgebases.models import ( + KnowledgeBaseMessage, + KnowledgeBaseMessageTextContent, + KnowledgeBaseRetrievalResponse, + ) + + response = KnowledgeBaseRetrievalResponse( + response=[ + KnowledgeBaseMessage(role="user", content=[KnowledgeBaseMessageTextContent(text="q")]), + KnowledgeBaseMessage(role="assistant", content=[KnowledgeBaseMessageTextContent(text="answer")]), + ], + references=None, + ) + result = AzureAISearchContextProvider._parse_messages_from_kb_response(response) + assert len(result) == 2 + assert result[0].role == "user" + assert result[0].text == "q" + assert result[1].role == "assistant" + assert result[1].text == "answer" + + def test_none_response_returns_default(self) -> None: + from azure.search.documents.knowledgebases.models import KnowledgeBaseRetrievalResponse + + response = KnowledgeBaseRetrievalResponse(response=None, references=None) + result = AzureAISearchContextProvider._parse_messages_from_kb_response(response) + assert len(result) == 1 + assert result[0].text == "No results found from Knowledge Base." + + def test_empty_response_returns_default(self) -> None: + from azure.search.documents.knowledgebases.models import KnowledgeBaseRetrievalResponse + + response = KnowledgeBaseRetrievalResponse(response=[], references=None) + result = AzureAISearchContextProvider._parse_messages_from_kb_response(response) + assert len(result) == 1 + assert result[0].text == "No results found from Knowledge Base." + + def test_image_content(self) -> None: + from azure.search.documents.knowledgebases.models import ( + KnowledgeBaseMessage, + KnowledgeBaseMessageImageContent, + KnowledgeBaseMessageImageContentImage, + KnowledgeBaseRetrievalResponse, + ) + + response = KnowledgeBaseRetrievalResponse( + response=[ + KnowledgeBaseMessage( + role="assistant", + content=[ + KnowledgeBaseMessageImageContent( + image=KnowledgeBaseMessageImageContentImage(url="https://img.example.com/a.png") + ) + ], + ), + ], + references=None, + ) + result = AzureAISearchContextProvider._parse_messages_from_kb_response(response) + assert len(result) == 1 + assert result[0].contents[0].type == "uri" + assert result[0].contents[0].uri == "https://img.example.com/a.png" + + def test_mixed_text_and_image_content(self) -> None: + from azure.search.documents.knowledgebases.models import ( + KnowledgeBaseMessage, + KnowledgeBaseMessageImageContent, + KnowledgeBaseMessageImageContentImage, + KnowledgeBaseMessageTextContent, + KnowledgeBaseRetrievalResponse, + ) + + response = KnowledgeBaseRetrievalResponse( + response=[ + KnowledgeBaseMessage( + role="assistant", + content=[ + KnowledgeBaseMessageTextContent(text="description"), + KnowledgeBaseMessageImageContent( + image=KnowledgeBaseMessageImageContentImage(url="https://img.example.com/b.png") + ), + ], + ), + ], + references=None, + ) + result = AzureAISearchContextProvider._parse_messages_from_kb_response(response) + assert len(result) == 1 + assert len(result[0].contents) == 2 + assert result[0].contents[0].type == "text" + assert result[0].contents[1].type == "uri" + + def test_references_become_annotations(self) -> None: + from azure.search.documents.knowledgebases.models import ( + KnowledgeBaseMessage, + KnowledgeBaseMessageTextContent, + KnowledgeBaseRetrievalResponse, + KnowledgeBaseWebReference, + ) + + response = KnowledgeBaseRetrievalResponse( + response=[ + KnowledgeBaseMessage(role="assistant", content=[KnowledgeBaseMessageTextContent(text="answer")]), + ], + references=[ + KnowledgeBaseWebReference( + id="ref-1", activity_source=0, url="https://example.com", title="Example" + ), + ], + ) + result = AzureAISearchContextProvider._parse_messages_from_kb_response(response) + assert len(result) == 1 + annotations = result[0].contents[0].annotations + assert annotations is not None + assert len(annotations) == 1 + assert annotations[0]["type"] == "citation" + assert annotations[0]["url"] == "https://example.com" + assert annotations[0]["title"] == "Example" + + def test_multiple_messages_with_references(self) -> None: + from azure.search.documents.knowledgebases.models import ( + KnowledgeBaseMessage, + KnowledgeBaseMessageTextContent, + KnowledgeBaseRetrievalResponse, + KnowledgeBaseSearchIndexReference, + ) + + response = KnowledgeBaseRetrievalResponse( + response=[ + KnowledgeBaseMessage(role="user", content=[KnowledgeBaseMessageTextContent(text="q")]), + KnowledgeBaseMessage( + role="assistant", + content=[ + KnowledgeBaseMessageTextContent(text="part1"), + KnowledgeBaseMessageTextContent(text="part2"), + ], + ), + ], + references=[KnowledgeBaseSearchIndexReference(id="doc-1", activity_source=0)], + ) + result = AzureAISearchContextProvider._parse_messages_from_kb_response(response) + assert len(result) == 2 + # All content items get annotations + for msg in result: + for c in msg.contents: + assert c.annotations is not None + assert len(c.annotations) == 1 # -- before_run: agentic mode -------------------------------------------------- @@ -1266,9 +1628,11 @@ class TestBeforeRunAgentic: mock_content = Mock() mock_content.text = "agentic result" mock_message = Mock() + mock_message.role = "assistant" mock_message.content = [mock_content] mock_result = Mock() mock_result.response = [mock_message] + mock_result.references = None mock_retrieval = AsyncMock() mock_retrieval.retrieve = AsyncMock(return_value=mock_result) diff --git a/python/packages/core/agent_framework/__init__.py b/python/packages/core/agent_framework/__init__.py index bfa684b469..32746cbe1c 100644 --- a/python/packages/core/agent_framework/__init__.py +++ b/python/packages/core/agent_framework/__init__.py @@ -59,6 +59,7 @@ from ._sessions import ( register_state_type, ) from ._settings import SecretString, load_settings +from ._skills import FileAgentSkillsProvider from ._telemetry import ( AGENT_FRAMEWORK_USER_AGENT, APP_INFO, @@ -233,6 +234,7 @@ __all__ = [ "Executor", "FanInEdgeGroup", "FanOutEdgeGroup", + "FileAgentSkillsProvider", "FileCheckpointStorage", "FinalT", "FinishReason", diff --git a/python/packages/core/agent_framework/_skills.py b/python/packages/core/agent_framework/_skills.py new file mode 100644 index 0000000000..0e132a9336 --- /dev/null +++ b/python/packages/core/agent_framework/_skills.py @@ -0,0 +1,597 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""File-based Agent Skills provider for the agent framework. + +This module implements the progressive disclosure pattern from the +`Agent Skills specification `_: + +1. **Advertise** — skill names and descriptions are injected into the system prompt. +2. **Load** — the full SKILL.md body is returned via the ``load_skill`` tool. +3. **Read resources** — supplementary files are read from disk on demand via + the ``read_skill_resource`` tool. + +Skills are discovered by searching configured directories for ``SKILL.md`` files. +Referenced resources are validated at initialization; invalid skills are excluded +and logged. + +**Security:** this provider only reads static content. Skill metadata is XML-escaped +before prompt embedding, and resource reads are guarded against path traversal and +symlink escape. Only use skills from trusted sources. +""" + +from __future__ import annotations + +import logging +import os +import re +from collections.abc import Sequence +from dataclasses import dataclass, field +from html import escape as xml_escape +from pathlib import Path, PurePosixPath +from typing import TYPE_CHECKING, Any, ClassVar, Final + +from ._sessions import BaseContextProvider +from ._tools import FunctionTool + +if TYPE_CHECKING: + from ._agents import SupportsAgentRun + from ._sessions import AgentSession, SessionContext + +logger = logging.getLogger(__name__) + +# region Constants + +SKILL_FILE_NAME: Final[str] = "SKILL.md" +MAX_SEARCH_DEPTH: Final[int] = 2 +MAX_NAME_LENGTH: Final[int] = 64 +MAX_DESCRIPTION_LENGTH: Final[int] = 1024 + +# endregion + +# region Compiled regex patterns (ported from .NET FileAgentSkillLoader) + +# Matches YAML frontmatter delimited by "---" lines. +# The \uFEFF? prefix allows an optional UTF-8 BOM. +_FRONTMATTER_RE = re.compile( + r"\A\uFEFF?---\s*$(.+?)^---\s*$", + re.MULTILINE | re.DOTALL, +) + +# Matches resource file references in skill markdown. Group 1 = relative file path. +# Supports two forms: +# 1. Markdown links: [text](path/file.ext) +# 2. Backtick-quoted paths: `path/file.ext` +# Supports optional ./ or ../ prefixes; excludes URLs (no ":" in the path character class). +_RESOURCE_LINK_RE = re.compile( + r"(?:\[.*?\]\(|`)(\.?\.?/?[\w][\w\-./]*\.\w+)(?:\)|`)", +) + +# Matches YAML "key: value" lines. Group 1 = key, Group 2 = quoted value, +# Group 3 = unquoted value. +_YAML_KV_RE = re.compile( + r"^\s*(\w+)\s*:\s*(?:[\"'](.+?)[\"']|(.+?))\s*$", + re.MULTILINE, +) + +# Validates skill names: lowercase letters, numbers, hyphens only; +# must not start or end with a hyphen. +_VALID_NAME_RE = re.compile(r"^[a-z0-9]([a-z0-9\-]*[a-z0-9])?$") + +_DEFAULT_SKILLS_INSTRUCTION_PROMPT = """\ +You have access to skills containing domain-specific knowledge and capabilities. +Each skill provides specialized instructions, reference documents, and assets for specific tasks. + + +{0} + + +When a task aligns with a skill's domain: +1. Use `load_skill` to retrieve the skill's instructions +2. Follow the provided guidance +3. Use `read_skill_resource` to read any references or other files mentioned by the skill, + always using the full path as written (e.g. `references/FAQ.md`, not just `FAQ.md`) + +Only load what is needed, when it is needed.""" + +# endregion + +# region Private data classes + + +@dataclass +class _SkillFrontmatter: + """Parsed YAML frontmatter from a SKILL.md file.""" + + name: str + description: str + + +@dataclass +class _FileAgentSkill: + """Represents a loaded Agent Skill discovered from a filesystem directory.""" + + frontmatter: _SkillFrontmatter + body: str + source_path: str + resource_names: list[str] = field(default_factory=list) + +# endregion + +# region Private module-level functions (skill discovery, parsing, security) + + +def _normalize_resource_path(path: str) -> str: + """Normalize a relative resource path. + + Replaces backslashes with forward slashes and removes leading ``./`` prefixes + so that ``./refs/doc.md`` and ``refs/doc.md`` are treated as the same resource. + """ + return PurePosixPath(path.replace("\\", "/")).as_posix() + + +def _extract_resource_paths(content: str) -> list[str]: + """Extract deduplicated resource paths from markdown link syntax.""" + seen: set[str] = set() + paths: list[str] = [] + for match in _RESOURCE_LINK_RE.finditer(content): + normalized = _normalize_resource_path(match.group(1)) + lower = normalized.lower() + if lower not in seen: + seen.add(lower) + paths.append(normalized) + return paths + + +def _is_path_within_directory(full_path: str, directory_path: str) -> bool: + """Check that *full_path* is under *directory_path*. + + Uses :meth:`pathlib.Path.is_relative_to` for cross-platform comparison, + which handles case sensitivity correctly per platform. + """ + try: + return Path(full_path).is_relative_to(directory_path) + except (ValueError, OSError): + return False + + +def _has_symlink_in_path(full_path: str, directory_path: str) -> bool: + """Check whether any segment in *full_path* below *directory_path* is a symlink. + + Precondition: *full_path* must start with *directory_path*. Callers are + expected to verify containment via :func:`_is_path_within_directory` before + invoking this function. + """ + dir_path = Path(directory_path) + try: + relative = Path(full_path).relative_to(dir_path) + except ValueError as exc: + raise ValueError( + f"full_path {full_path!r} does not start with directory_path {directory_path!r}" + ) from exc + + current = dir_path + for part in relative.parts: + current = current / part + if current.is_symlink(): + return True + return False + + +def _try_parse_skill_document( + content: str, + skill_file_path: str, +) -> tuple[_SkillFrontmatter, str] | None: + """Parse a SKILL.md file into frontmatter and body. + + Returns: + A ``(frontmatter, body)`` tuple on success, or ``None`` if parsing fails. + """ + match = _FRONTMATTER_RE.search(content) + if not match: + logger.error("SKILL.md at '%s' does not contain valid YAML frontmatter delimited by '---'", skill_file_path) + return None + + yaml_content = match.group(1).strip() + name: str | None = None + description: str | None = None + + for kv_match in _YAML_KV_RE.finditer(yaml_content): + key = kv_match.group(1) + value = kv_match.group(2) if kv_match.group(2) is not None else kv_match.group(3) + + if key.lower() == "name": + name = value + elif key.lower() == "description": + description = value + + if not name or not name.strip(): + logger.error("SKILL.md at '%s' is missing a 'name' field in frontmatter", skill_file_path) + return None + + if len(name) > MAX_NAME_LENGTH or not _VALID_NAME_RE.match(name): + logger.error( + "SKILL.md at '%s' has an invalid 'name' value: Must be %d characters or fewer, " + "using only lowercase letters, numbers, and hyphens, and must not start or end with a hyphen.", + skill_file_path, + MAX_NAME_LENGTH, + ) + return None + + if not description or not description.strip(): + logger.error("SKILL.md at '%s' is missing a 'description' field in frontmatter", skill_file_path) + return None + + if len(description) > MAX_DESCRIPTION_LENGTH: + logger.error( + "SKILL.md at '%s' has an invalid 'description' value: Must be %d characters or fewer.", + skill_file_path, + MAX_DESCRIPTION_LENGTH, + ) + return None + + body = content[match.end() :].lstrip() + return _SkillFrontmatter(name, description), body + + +def _validate_resources( + skill_dir_path: str, + resource_names: list[str], + skill_name: str, +) -> bool: + """Validate that all resource paths exist and are safe.""" + skill_dir = Path(skill_dir_path).absolute() + + for resource_name in resource_names: + resource_path = Path(os.path.normpath(skill_dir / resource_name)) + + if not _is_path_within_directory(str(resource_path), str(skill_dir)): + logger.warning( + "Excluding skill '%s': resource '%s' references a path outside the skill directory", + skill_name, + resource_name, + ) + return False + + if not resource_path.is_file(): + logger.warning( + "Excluding skill '%s': referenced resource '%s' does not exist", + skill_name, + resource_name, + ) + return False + + if _has_symlink_in_path(str(resource_path), str(skill_dir)): + logger.warning( + "Excluding skill '%s': resource '%s' is a symlink that resolves outside the skill directory", + skill_name, + resource_name, + ) + return False + + return True + + +def _parse_skill_file(skill_dir_path: str) -> _FileAgentSkill | None: + """Parse a SKILL.md file from the given directory.""" + skill_file = Path(skill_dir_path) / SKILL_FILE_NAME + + try: + content = skill_file.read_text(encoding="utf-8") + except OSError: + logger.error("Failed to read SKILL.md at '%s'", skill_file) + return None + + result = _try_parse_skill_document(content, str(skill_file)) + if result is None: + return None + + frontmatter, body = result + resource_names = _extract_resource_paths(body) + + if not _validate_resources(skill_dir_path, resource_names, frontmatter.name): + return None + + return _FileAgentSkill( + frontmatter=frontmatter, + body=body, + source_path=skill_dir_path, + resource_names=resource_names, + ) + + +def _search_directories_for_skills( + directory: str, + results: list[str], + current_depth: int, +) -> None: + """Recursively search for SKILL.md files up to *MAX_SEARCH_DEPTH*.""" + dir_path = Path(directory) + if (dir_path / SKILL_FILE_NAME).is_file(): + results.append(str(dir_path.absolute())) + + if current_depth >= MAX_SEARCH_DEPTH: + return + + try: + entries = list(dir_path.iterdir()) + except OSError: + return + + for entry in entries: + if entry.is_dir(): + _search_directories_for_skills(str(entry), results, current_depth + 1) + + +def _discover_skill_directories(skill_paths: Sequence[str]) -> list[str]: + """Discover all directories containing SKILL.md files.""" + discovered: list[str] = [] + for root_dir in skill_paths: + if not root_dir or not root_dir.strip() or not Path(root_dir).is_dir(): + continue + _search_directories_for_skills(root_dir, discovered, current_depth=0) + return discovered + + +def _discover_and_load_skills(skill_paths: Sequence[str]) -> dict[str, _FileAgentSkill]: + """Discover and load all valid skills from the given paths.""" + skills: dict[str, _FileAgentSkill] = {} + + discovered = _discover_skill_directories(skill_paths) + logger.info("Discovered %d potential skills", len(discovered)) + + for skill_path in discovered: + skill = _parse_skill_file(skill_path) + if skill is None: + continue + + if skill.frontmatter.name in skills: + existing = skills[skill.frontmatter.name] + logger.warning( + "Duplicate skill name '%s': skill from '%s' skipped in favor of existing skill from '%s'", + skill.frontmatter.name, + skill_path, + existing.source_path, + ) + continue + + skills[skill.frontmatter.name] = skill + logger.info("Loaded skill: %s", skill.frontmatter.name) + + logger.info("Successfully loaded %d skills", len(skills)) + return skills + + +def _read_skill_resource(skill: _FileAgentSkill, resource_name: str) -> str: + """Read a resource file from disk with path traversal and symlink guards. + + Args: + skill: The skill that owns the resource. + resource_name: Relative path of the resource within the skill directory. + + Returns: + The UTF-8 text content of the resource file. + + Raises: + ValueError: The resource is not registered, resolves outside the skill + directory, or does not exist. + """ + resource_name = _normalize_resource_path(resource_name) + + # Find the registered resource name with the original casing so the + # file path is correct on case-sensitive filesystems. + registered_name: str | None = None + for r in skill.resource_names: + if r.lower() == resource_name.lower(): + registered_name = r + break + + if registered_name is None: + raise ValueError(f"Resource '{resource_name}' not found in skill '{skill.frontmatter.name}'.") + + full_path = os.path.normpath(Path(skill.source_path) / registered_name) + source_dir = str(Path(skill.source_path).absolute()) + + if not _is_path_within_directory(full_path, source_dir): + raise ValueError(f"Resource file '{resource_name}' references a path outside the skill directory.") + + if not Path(full_path).is_file(): + raise ValueError(f"Resource file '{resource_name}' not found in skill '{skill.frontmatter.name}'.") + + if _has_symlink_in_path(full_path, source_dir): + raise ValueError(f"Resource file '{resource_name}' is a symlink that resolves outside the skill directory.") + + logger.info("Reading resource '%s' from skill '%s'", resource_name, skill.frontmatter.name) + return Path(full_path).read_text(encoding="utf-8") + + +def _build_skills_instruction_prompt( + prompt_template: str | None, + skills: dict[str, _FileAgentSkill], +) -> str | None: + """Build the system prompt advertising available skills.""" + template = _DEFAULT_SKILLS_INSTRUCTION_PROMPT + + if prompt_template is not None: + # Validate that the custom template contains a valid {0} placeholder + try: + prompt_template.format("") + template = prompt_template + except (KeyError, IndexError) as exc: + raise ValueError( + "The provided skills_instruction_prompt is not a valid format string. " + "It must contain a '{0}' placeholder and escape any literal '{' or '}' " + "by doubling them ('{{' or '}}')." + ) from exc + + if not skills: + return None + + lines: list[str] = [] + # Sort by name for deterministic output + for skill in sorted(skills.values(), key=lambda s: s.frontmatter.name): + lines.append(" ") + lines.append(f" {xml_escape(skill.frontmatter.name)}") + lines.append(f" {xml_escape(skill.frontmatter.description)}") + lines.append(" ") + + return template.format("\n".join(lines)) + +# endregion + +# region Public API + + +class FileAgentSkillsProvider(BaseContextProvider): + """A context provider that discovers and exposes Agent Skills from filesystem directories. + + This provider implements the progressive disclosure pattern from the + `Agent Skills specification `_: + + 1. **Advertise** — skill names and descriptions are injected into the system prompt + (~100 tokens per skill). + 2. **Load** — the full SKILL.md body is returned via the ``load_skill`` tool. + 3. **Read resources** — supplementary files are read on demand via the + ``read_skill_resource`` tool. + + Skills are discovered by searching the configured directories for ``SKILL.md`` files. + Referenced resources are validated at initialization; invalid skills are excluded and + logged. + + **Security:** this provider only reads static content. Skill metadata is XML-escaped + before prompt embedding, and resource reads are guarded against path traversal and + symlink escape. Only use skills from trusted sources. + + Args: + skill_paths: A single path or sequence of paths to search. Each can be an + individual skill folder (containing a SKILL.md file) or a parent folder + with skill subdirectories. + + Keyword Args: + skills_instruction_prompt: A custom system prompt template for advertising + skills. Use ``{0}`` as the placeholder for the generated skills list. + When ``None``, a default template is used. + source_id: Unique identifier for this provider instance. + logger: Optional logger instance. When ``None``, uses the module logger. + """ + + DEFAULT_SOURCE_ID: ClassVar[str] = "file_agent_skills" + + def __init__( + self, + skill_paths: str | Path | Sequence[str | Path], + *, + skills_instruction_prompt: str | None = None, + source_id: str | None = None, + ) -> None: + """Initialize the FileAgentSkillsProvider. + + Args: + skill_paths: A single path or sequence of paths to search for skills. + + Keyword Args: + skills_instruction_prompt: Custom system prompt template with ``{0}`` placeholder. + source_id: Unique identifier for this provider instance. + """ + super().__init__(source_id or self.DEFAULT_SOURCE_ID) + + resolved_paths: Sequence[str] = [str(skill_paths)] if isinstance(skill_paths, (str, Path)) else [str(p) for p in skill_paths] + + self._skills = _discover_and_load_skills(resolved_paths) + self._skills_instruction_prompt = _build_skills_instruction_prompt(skills_instruction_prompt, self._skills) + self._tools = [ + FunctionTool( + name="load_skill", + description="Loads the full instructions for a specific skill.", + func=self._load_skill, + input_model={ + "type": "object", + "properties": { + "skill_name": {"type": "string", "description": "The name of the skill to load."}, + }, + "required": ["skill_name"], + }, + ), + FunctionTool( + name="read_skill_resource", + description="Reads a file associated with a skill, such as references or assets.", + func=self._read_skill_resource, + input_model={ + "type": "object", + "properties": { + "skill_name": {"type": "string", "description": "The name of the skill."}, + "resource_name": { + "type": "string", + "description": "The relative path of the resource file.", + }, + }, + "required": ["skill_name", "resource_name"], + }, + ), + ] + + async def before_run( + self, + *, + agent: SupportsAgentRun, + session: AgentSession, + context: SessionContext, + state: dict[str, Any], + ) -> None: + """Inject skill instructions and tools into the session context. + + When skills are available, adds the skills instruction prompt and + ``load_skill`` / ``read_skill_resource`` tools. + """ + if not self._skills: + return + + if self._skills_instruction_prompt: + context.extend_instructions(self.source_id, self._skills_instruction_prompt) + context.extend_tools(self.source_id, self._tools) + + def _load_skill(self, skill_name: str) -> str: + """Load the full instructions for a specific skill. + + Args: + skill_name: The name of the skill to load. + + Returns: + The skill body text, or an error message if not found. + """ + if not skill_name or not skill_name.strip(): + return "Error: Skill name cannot be empty." + + skill = self._skills.get(skill_name) + if skill is None: + return f"Error: Skill '{skill_name}' not found." + + logger.info("Loading skill: %s", skill_name) + return skill.body + + def _read_skill_resource(self, skill_name: str, resource_name: str) -> str: + """Read a file associated with a skill. + + Args: + skill_name: The name of the skill. + resource_name: The relative path of the resource file. + + Returns: + The resource file content, or an error message if not found. + """ + if not skill_name or not skill_name.strip(): + return "Error: Skill name cannot be empty." + + if not resource_name or not resource_name.strip(): + return "Error: Resource name cannot be empty." + + skill = self._skills.get(skill_name) + if skill is None: + return f"Error: Skill '{skill_name}' not found." + + try: + return _read_skill_resource(skill, resource_name) + except Exception: + logger.exception("Failed to read resource '%s' from skill '%s'", resource_name, skill_name) + return f"Error: Failed to read resource '{resource_name}' from skill '{skill_name}'." + +# endregion diff --git a/python/packages/core/agent_framework/_tools.py b/python/packages/core/agent_framework/_tools.py index df0608e614..3ec167d4f7 100644 --- a/python/packages/core/agent_framework/_tools.py +++ b/python/packages/core/agent_framework/_tools.py @@ -2164,15 +2164,11 @@ class FunctionInvocationLayer(Generic[OptionsCoT]): # Error threshold reached: force a final non-tool turn so # function_call_output items are submitted before exit. mutable_options["tool_choice"] = "none" - elif ( - max_function_calls is not None - and total_function_calls >= max_function_calls - ): + elif max_function_calls is not None and total_function_calls >= max_function_calls: # Best-effort limit: checked after each batch of parallel calls completes, # so the current batch always runs to completion even if it overshoots. logger.info( - "Maximum function calls reached (%d/%d). " - "Stopping further function calls for this request.", + "Maximum function calls reached (%d/%d). Stopping further function calls for this request.", total_function_calls, max_function_calls, ) @@ -2196,9 +2192,15 @@ class FunctionInvocationLayer(Generic[OptionsCoT]): prepped_messages.extend(response.messages) continue - if response is not None: - return response - + # Loop exhausted all iterations (or function invocation disabled). + # Make a final model call with tool_choice="none" so the model + # produces a plain text answer instead of leaving orphaned + # function_call items without matching results. + if response is not None and self.function_invocation_configuration["enabled"]: + logger.info( + "Maximum iterations reached (%d). Requesting final response without tools.", + self.function_invocation_configuration["max_iterations"], + ) mutable_options["tool_choice"] = "none" response = await super_get_response( messages=prepped_messages, @@ -2302,15 +2304,11 @@ class FunctionInvocationLayer(Generic[OptionsCoT]): mutable_options["tool_choice"] = "none" elif result["action"] != "continue": return - elif ( - max_function_calls is not None - and total_function_calls >= max_function_calls - ): + elif max_function_calls is not None and total_function_calls >= max_function_calls: # Best-effort limit: checked after each batch of parallel calls completes, # so the current batch always runs to completion even if it overshoots. logger.info( - "Maximum function calls reached (%d/%d). " - "Stopping further function calls for this request.", + "Maximum function calls reached (%d/%d). Stopping further function calls for this request.", total_function_calls, max_function_calls, ) @@ -2333,9 +2331,15 @@ class FunctionInvocationLayer(Generic[OptionsCoT]): prepped_messages.extend(response.messages) continue - if response is not None: - return - + # Loop exhausted all iterations (or function invocation disabled). + # Make a final model call with tool_choice="none" so the model + # produces a plain text answer instead of leaving orphaned + # function_call items without matching results. + if response is not None and self.function_invocation_configuration["enabled"]: + logger.info( + "Maximum iterations reached (%d). Requesting final response without tools.", + self.function_invocation_configuration["max_iterations"], + ) mutable_options["tool_choice"] = "none" inner_stream = await _ensure_response_stream( super_get_response( diff --git a/python/packages/core/agent_framework/_workflows/_runner.py b/python/packages/core/agent_framework/_workflows/_runner.py index ce1661cc7f..c548e76e53 100644 --- a/python/packages/core/agent_framework/_workflows/_runner.py +++ b/python/packages/core/agent_framework/_workflows/_runner.py @@ -158,7 +158,28 @@ class Runner: self._running = False async def _run_iteration(self) -> None: - async def _deliver_messages(source_executor_id: str, messages: list[WorkflowMessage]) -> None: + """Run a single iteration of the workflow. + + Messages are delivered through edge runners. A source executor may have multiple outgoing edge + runners. All edge runners run concurrently, but messages sent through the same edge runner are + delivered in the order they were sent to preserve message ordering guarantees per edge. + + What this means in practice: + - A message from a source to multiple target is delivered to all targets concurrently. + - Multiple messages from a source to the same target are delivered in the order they were sent. + - Multiple messages from different sources to the same target can be delivered to the target one + at a time in any order, because true parallelism is not realized in Python. + - Multiple message from different sources to different targets are delivered concurrently to all + targets, assuming each message is targeting a unique target, or it falls back to the previous + rules if there are multiple messages targeting the same target. + - Special case: if using a fan-out edge runner (or derived edge runner that replicates messages + to multiple targets such as multi-selection or switch-case) to send messages to targets from + a source by specifying the target, the messages will be delivered to the specified targets + in the order they were sent. This is because all messages go through the same edge runner instance + which preserves message order. + """ + + async def _deliver_messages(source_executor_id: str, source_messages: list[WorkflowMessage]) -> None: """Outer loop to concurrently deliver messages from all sources to their targets.""" async def _deliver_message_inner(edge_runner: EdgeRunner, message: WorkflowMessage) -> bool: @@ -172,13 +193,20 @@ class Runner: logger.debug(f"No outgoing edges found for executor {source_executor_id}; dropping messages.") return - for message in messages: - # Deliver a message through all edge runners associated with the source executor concurrently. - tasks = [_deliver_message_inner(edge_runner, message) for edge_runner in associated_edge_runners] - await asyncio.gather(*tasks) + async def _deliver_messages_for_edge_runner(edge_runner: EdgeRunner) -> None: + # Preserve message order per edge runner (and therefore per routed target path) + # while still allowing parallelism across different edge runners. + for message in source_messages: + await _deliver_message_inner(edge_runner, message) - messages = await self._ctx.drain_messages() - tasks = [_deliver_messages(source_executor_id, messages) for source_executor_id, messages in messages.items()] + tasks = [_deliver_messages_for_edge_runner(edge_runner) for edge_runner in associated_edge_runners] + await asyncio.gather(*tasks) + + message_batches = await self._ctx.drain_messages() + tasks = [ + _deliver_messages(source_executor_id, source_messages) + for source_executor_id, source_messages in message_batches.items() + ] await asyncio.gather(*tasks) async def _create_checkpoint_if_enabled(self, previous_checkpoint_id: CheckpointID | None) -> CheckpointID | None: diff --git a/python/packages/core/pyproject.toml b/python/packages/core/pyproject.toml index 9b0c9e60a8..09ccda3c18 100644 --- a/python/packages/core/pyproject.toml +++ b/python/packages/core/pyproject.toml @@ -34,7 +34,8 @@ dependencies = [ # connectors and functions "openai>=1.99.0", "azure-identity>=1,<2", - "azure-ai-projects >= 2.0.0b3", + # Pinned to 2.0.0b3 - breaking changes in 2.0.0b4, unpin once upgrades complete + "azure-ai-projects == 2.0.0b3", "mcp[ws]>=1.24.0,<2", "packaging>=24.1", ] diff --git a/python/packages/core/tests/core/test_function_invocation_logic.py b/python/packages/core/tests/core/test_function_invocation_logic.py index b4213d6029..f278afaeac 100644 --- a/python/packages/core/tests/core/test_function_invocation_logic.py +++ b/python/packages/core/tests/core/test_function_invocation_logic.py @@ -831,8 +831,6 @@ async def test_rejection_result_uses_function_call_id(chat_client_base: Supports assert "rejected" in rejection_result.result.lower() -@pytest.mark.skip(reason="Failsafe behavior with max_iterations needs investigation in unified API") -@pytest.mark.skip(reason="Failsafe behavior with max_iterations needs investigation in unified API") async def test_max_iterations_limit(chat_client_base: SupportsChatGetResponse): """Test that MAX_ITERATIONS in additional_properties limits function call loops.""" exec_counter = 0 @@ -880,6 +878,256 @@ async def test_max_iterations_limit(chat_client_base: SupportsChatGetResponse): assert response.messages[-1].text == "I broke out of the function invocation loop..." # Failsafe response +async def test_max_iterations_no_orphaned_function_calls(chat_client_base: SupportsChatGetResponse): + """When max_iterations is reached, verify the returned response has no orphaned + FunctionCallContent (i.e., every function_call has a matching function_result). + """ + exec_counter = 0 + + @tool(name="test_function", approval_mode="never_require") + def ai_func(arg1: str) -> str: + nonlocal exec_counter + exec_counter += 1 + return f"Processed {arg1}" + + # Model keeps requesting tool calls on every iteration + chat_client_base.run_responses = [ + ChatResponse( + messages=Message( + role="assistant", + contents=[ + Content.from_function_call(call_id="call_1", name="test_function", arguments='{"arg1": "v1"}') + ], + ) + ), + ChatResponse( + messages=Message( + role="assistant", + contents=[ + Content.from_function_call(call_id="call_2", name="test_function", arguments='{"arg1": "v2"}') + ], + ) + ), + ChatResponse( + messages=Message( + role="assistant", + contents=[ + Content.from_function_call(call_id="call_3", name="test_function", arguments='{"arg1": "v3"}') + ], + ) + ), + ] + + chat_client_base.function_invocation_configuration["max_iterations"] = 2 + + response = await chat_client_base.get_response( + [Message(role="user", text="hello")], + options={"tool_choice": "auto", "tools": [ai_func]}, + ) + + # Collect all function_call and function_result call_ids from response + all_call_ids = set() + all_result_ids = set() + for msg in response.messages: + for content in msg.contents: + if content.type == "function_call": + all_call_ids.add(content.call_id) + elif content.type == "function_result": + all_result_ids.add(content.call_id) + + orphaned_calls = all_call_ids - all_result_ids + assert not orphaned_calls, ( + f"Response contains orphaned FunctionCallContent without matching " + f"FunctionResultContent: {orphaned_calls}." + ) + + +async def test_max_iterations_makes_final_toolchoice_none_call(chat_client_base: SupportsChatGetResponse): + """When max_iterations is reached, verify a final model call is made with + tool_choice='none' to produce a clean text response. + """ + exec_counter = 0 + + @tool(name="test_function", approval_mode="never_require") + def ai_func(arg1: str) -> str: + nonlocal exec_counter + exec_counter += 1 + return f"Processed {arg1}" + + chat_client_base.run_responses = [ + ChatResponse( + messages=Message( + role="assistant", + contents=[ + Content.from_function_call(call_id="call_1", name="test_function", arguments='{"arg1": "v1"}') + ], + ) + ), + ChatResponse( + messages=Message( + role="assistant", + contents=[ + Content.from_function_call(call_id="call_2", name="test_function", arguments='{"arg1": "v2"}') + ], + ) + ), + # This response should be reached via failsafe (tool_choice="none") + ChatResponse(messages=Message(role="assistant", text="Final answer after giving up on tools.")), + ] + + chat_client_base.function_invocation_configuration["max_iterations"] = 1 + + response = await chat_client_base.get_response( + [Message(role="user", text="hello")], + options={"tool_choice": "auto", "tools": [ai_func]}, + ) + + assert exec_counter == 1, f"Expected 1 function execution, got {exec_counter}" + + # The response should end with a plain text message (from the failsafe call) + last_msg = response.messages[-1] + has_function_calls = any(c.type == "function_call" for c in last_msg.contents) + + assert not has_function_calls, ( + f"Last message in response still contains function_call items. " + f"Expected a clean text response after max_iterations failsafe. " + f"Got message with role={last_msg.role}, contents={[c.type for c in last_msg.contents]}" + ) + + # The mock client returns "I broke out of the function invocation loop..." + # when tool_choice="none" + assert last_msg.text == "I broke out of the function invocation loop...", ( + f"Expected failsafe text response, got: {last_msg.text!r}" + ) + + +async def test_max_iterations_preserves_all_fcc_messages(chat_client_base: SupportsChatGetResponse): + """When max_iterations is reached and a final response is produced, all + intermediate function call/result messages should be included. + """ + exec_counter = 0 + + @tool(name="test_function", approval_mode="never_require") + def ai_func(arg1: str) -> str: + nonlocal exec_counter + exec_counter += 1 + return f"Result {exec_counter}" + + # Two iterations of function calls, then failsafe + chat_client_base.run_responses = [ + ChatResponse( + messages=Message( + role="assistant", + contents=[ + Content.from_function_call(call_id="call_1", name="test_function", arguments='{"arg1": "v1"}') + ], + ) + ), + ChatResponse( + messages=Message( + role="assistant", + contents=[ + Content.from_function_call(call_id="call_2", name="test_function", arguments='{"arg1": "v2"}') + ], + ) + ), + ChatResponse(messages=Message(role="assistant", text="Done")), + ] + + chat_client_base.function_invocation_configuration["max_iterations"] = 2 + + response = await chat_client_base.get_response( + [Message(role="user", text="hello")], + options={"tool_choice": "auto", "tools": [ai_func]}, + ) + + assert exec_counter == 2, f"Expected 2 function executions, got {exec_counter}" + + # All function calls from both iterations should be present in the response + all_call_ids = set() + all_result_ids = set() + for msg in response.messages: + for content in msg.contents: + if content.type == "function_call": + all_call_ids.add(content.call_id) + elif content.type == "function_result": + all_result_ids.add(content.call_id) + + assert "call_1" in all_call_ids, "First iteration's function call missing from response" + assert "call_2" in all_call_ids, "Second iteration's function call missing from response" + + assert all_call_ids == all_result_ids, ( + f"Mismatched function calls and results. Calls: {all_call_ids}, Results: {all_result_ids}" + ) + + +async def test_max_iterations_thread_integrity_with_agent(chat_client_base: SupportsChatGetResponse): + """Verify that agent.run() does not produce orphaned function calls after + max_iterations, which would corrupt the thread and cause API errors on the + next call. + """ + + @tool(name="browser_snapshot", approval_mode="never_require") + def browser_snapshot(url: str) -> str: + return f"Screenshot of {url}" + + # Model keeps requesting tool calls on every iteration. + # The failsafe call (with tool_choice="none") after the loop is handled + # automatically by the mock client, which returns a hardcoded text response + # when tool_choice="none" (see conftest.py ChatClientBase.get_response). + chat_client_base.run_responses = [ + ChatResponse( + messages=Message( + role="assistant", + contents=[ + Content.from_function_call( + call_id="call_abc", name="browser_snapshot", arguments='{"url": "https://example.com"}' + ) + ], + ) + ), + ChatResponse( + messages=Message( + role="assistant", + contents=[ + Content.from_function_call( + call_id="call_xyz", name="browser_snapshot", arguments='{"url": "https://test.com"}' + ) + ], + ) + ), + ] + + chat_client_base.function_invocation_configuration["max_iterations"] = 2 + + agent = Agent( + client=chat_client_base, + name="test-agent", + tools=[browser_snapshot], + ) + + response = await agent.run( + "Take screenshots", + options={"tool_choice": "auto"}, + ) + + # Check for orphaned function calls in the response messages + all_call_ids = set() + all_result_ids = set() + for msg in response.messages: + for content in msg.contents: + if content.type == "function_call": + all_call_ids.add(content.call_id) + elif content.type == "function_result": + all_result_ids.add(content.call_id) + + orphaned_calls = all_call_ids - all_result_ids + assert not orphaned_calls, ( + f"Response contains orphaned function calls {orphaned_calls}. " + f"This would cause API errors on the next call." + ) + + @pytest.mark.parametrize("max_iterations", [10]) async def test_max_function_calls_limits_parallel_invocations(chat_client_base: SupportsChatGetResponse): """Test that max_function_calls caps total function invocations across iterations with parallel calls.""" @@ -2248,7 +2496,6 @@ async def test_streaming_approval_request_generated(chat_client_base: SupportsCh assert exec_counter == 0 # Function not executed yet due to approval requirement -@pytest.mark.skip(reason="Failsafe behavior with max_iterations needs investigation in unified API") async def test_streaming_max_iterations_limit(chat_client_base: SupportsChatGetResponse): """Test that MAX_ITERATIONS in streaming mode limits function call loops.""" exec_counter = 0 diff --git a/python/packages/core/tests/core/test_skills.py b/python/packages/core/tests/core/test_skills.py new file mode 100644 index 0000000000..571abeaa21 --- /dev/null +++ b/python/packages/core/tests/core/test_skills.py @@ -0,0 +1,697 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""Tests for file-based Agent Skills provider.""" + +from __future__ import annotations + +import os +from pathlib import Path +from unittest.mock import AsyncMock + +import pytest + +from agent_framework import FileAgentSkillsProvider, SessionContext +from agent_framework._skills import ( + _build_skills_instruction_prompt, + _discover_and_load_skills, + _extract_resource_paths, + _FileAgentSkill, + _has_symlink_in_path, + _normalize_resource_path, + _read_skill_resource, + _SkillFrontmatter, + _try_parse_skill_document, +) + + +def _symlinks_supported(tmp: Path) -> bool: + """Return True if the current platform/environment supports symlinks.""" + test_target = tmp / "_symlink_test_target" + test_link = tmp / "_symlink_test_link" + try: + test_target.write_text("test", encoding="utf-8") + test_link.symlink_to(test_target) + return True + except (OSError, NotImplementedError): + return False + finally: + test_link.unlink(missing_ok=True) + test_target.unlink(missing_ok=True) + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + + +def _write_skill( + base: Path, + name: str, + description: str = "A test skill.", + body: str = "# Instructions\nDo the thing.", + *, + extra_frontmatter: str = "", + resources: dict[str, str] | None = None, +) -> Path: + """Create a skill directory with SKILL.md and optional resource files.""" + skill_dir = base / name + skill_dir.mkdir(parents=True, exist_ok=True) + + frontmatter = f"---\nname: {name}\ndescription: {description}\n{extra_frontmatter}---\n" + skill_md = skill_dir / "SKILL.md" + skill_md.write_text(frontmatter + body, encoding="utf-8") + + if resources: + for rel_path, content in resources.items(): + res_file = skill_dir / rel_path + res_file.parent.mkdir(parents=True, exist_ok=True) + res_file.write_text(content, encoding="utf-8") + + return skill_dir + + +# --------------------------------------------------------------------------- +# Tests: module-level helper functions +# --------------------------------------------------------------------------- + + +class TestNormalizeResourcePath: + """Tests for _normalize_resource_path.""" + + def test_strips_dot_slash_prefix(self) -> None: + assert _normalize_resource_path("./refs/doc.md") == "refs/doc.md" + + def test_replaces_backslashes(self) -> None: + assert _normalize_resource_path("refs\\doc.md") == "refs/doc.md" + + def test_strips_dot_slash_and_replaces_backslashes(self) -> None: + assert _normalize_resource_path(".\\refs\\doc.md") == "refs/doc.md" + + def test_no_change_for_clean_path(self) -> None: + assert _normalize_resource_path("refs/doc.md") == "refs/doc.md" + + +class TestExtractResourcePaths: + """Tests for _extract_resource_paths.""" + + def test_extracts_markdown_links(self) -> None: + content = "See [doc](refs/FAQ.md) and [template](assets/template.md)." + paths = _extract_resource_paths(content) + assert paths == ["refs/FAQ.md", "assets/template.md"] + + def test_deduplicates_case_insensitive(self) -> None: + content = "See [a](refs/FAQ.md) and [b](refs/faq.md)." + paths = _extract_resource_paths(content) + assert len(paths) == 1 + + def test_normalizes_dot_slash_prefix(self) -> None: + content = "See [doc](./refs/FAQ.md)." + paths = _extract_resource_paths(content) + assert paths == ["refs/FAQ.md"] + + def test_ignores_urls(self) -> None: + content = "See [link](https://example.com/doc.md)." + paths = _extract_resource_paths(content) + assert paths == [] + + def test_empty_content(self) -> None: + assert _extract_resource_paths("") == [] + + def test_extracts_backtick_quoted_paths(self) -> None: + content = "Use the template at `assets/template.md` and the script `./scripts/run.py`." + paths = _extract_resource_paths(content) + assert paths == ["assets/template.md", "scripts/run.py"] + + def test_deduplicates_across_link_and_backtick(self) -> None: + content = "See [doc](refs/FAQ.md) and also `refs/FAQ.md`." + paths = _extract_resource_paths(content) + assert len(paths) == 1 + + +class TestTryParseSkillDocument: + """Tests for _try_parse_skill_document.""" + + def test_valid_skill(self) -> None: + content = "---\nname: test-skill\ndescription: A test skill.\n---\n# Body\nInstructions here." + result = _try_parse_skill_document(content, "test.md") + assert result is not None + frontmatter, body = result + assert frontmatter.name == "test-skill" + assert frontmatter.description == "A test skill." + assert "Instructions here." in body + + def test_quoted_values(self) -> None: + content = "---\nname: \"test-skill\"\ndescription: 'A test skill.'\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is not None + assert result[0].name == "test-skill" + assert result[0].description == "A test skill." + + def test_utf8_bom(self) -> None: + content = "\ufeff---\nname: test-skill\ndescription: A test skill.\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is not None + assert result[0].name == "test-skill" + + def test_missing_frontmatter(self) -> None: + content = "# Just a markdown file\nNo frontmatter here." + result = _try_parse_skill_document(content, "test.md") + assert result is None + + def test_missing_name(self) -> None: + content = "---\ndescription: A test skill.\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is None + + def test_missing_description(self) -> None: + content = "---\nname: test-skill\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is None + + def test_invalid_name_uppercase(self) -> None: + content = "---\nname: Test-Skill\ndescription: A test skill.\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is None + + def test_invalid_name_starts_with_hyphen(self) -> None: + content = "---\nname: -test-skill\ndescription: A test skill.\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is None + + def test_invalid_name_ends_with_hyphen(self) -> None: + content = "---\nname: test-skill-\ndescription: A test skill.\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is None + + def test_name_too_long(self) -> None: + long_name = "a" * 65 + content = f"---\nname: {long_name}\ndescription: A test skill.\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is None + + def test_description_too_long(self) -> None: + long_desc = "a" * 1025 + content = f"---\nname: test-skill\ndescription: {long_desc}\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is None + + def test_extra_metadata_ignored(self) -> None: + content = "---\nname: test-skill\ndescription: A test skill.\nauthor: someone\nversion: 1.0\n---\nBody." + result = _try_parse_skill_document(content, "test.md") + assert result is not None + assert result[0].name == "test-skill" + + +# --------------------------------------------------------------------------- +# Tests: skill discovery and loading +# --------------------------------------------------------------------------- + + +class TestDiscoverAndLoadSkills: + """Tests for _discover_and_load_skills.""" + + def test_discovers_valid_skill(self, tmp_path: Path) -> None: + _write_skill(tmp_path, "my-skill") + skills = _discover_and_load_skills([str(tmp_path)]) + assert "my-skill" in skills + assert skills["my-skill"].frontmatter.name == "my-skill" + + def test_discovers_nested_skills(self, tmp_path: Path) -> None: + skills_dir = tmp_path / "skills" + _write_skill(skills_dir, "skill-a") + _write_skill(skills_dir, "skill-b") + skills = _discover_and_load_skills([str(skills_dir)]) + assert len(skills) == 2 + assert "skill-a" in skills + assert "skill-b" in skills + + def test_skips_invalid_skill(self, tmp_path: Path) -> None: + skill_dir = tmp_path / "bad-skill" + skill_dir.mkdir() + (skill_dir / "SKILL.md").write_text("No frontmatter here.", encoding="utf-8") + skills = _discover_and_load_skills([str(tmp_path)]) + assert len(skills) == 0 + + def test_deduplicates_skill_names(self, tmp_path: Path) -> None: + dir1 = tmp_path / "dir1" + dir2 = tmp_path / "dir2" + _write_skill(dir1, "my-skill", body="First") + _write_skill(dir2, "my-skill", body="Second") + skills = _discover_and_load_skills([str(dir1), str(dir2)]) + assert len(skills) == 1 + assert skills["my-skill"].body == "First" + + def test_empty_directory(self, tmp_path: Path) -> None: + skills = _discover_and_load_skills([str(tmp_path)]) + assert len(skills) == 0 + + def test_nonexistent_directory(self) -> None: + skills = _discover_and_load_skills(["/nonexistent/path"]) + assert len(skills) == 0 + + def test_multiple_paths(self, tmp_path: Path) -> None: + dir1 = tmp_path / "dir1" + dir2 = tmp_path / "dir2" + _write_skill(dir1, "skill-a") + _write_skill(dir2, "skill-b") + skills = _discover_and_load_skills([str(dir1), str(dir2)]) + assert len(skills) == 2 + + def test_depth_limit(self, tmp_path: Path) -> None: + # Depth 0: tmp_path itself + # Depth 1: tmp_path/level1 + # Depth 2: tmp_path/level1/level2 (should be found) + # Depth 3: tmp_path/level1/level2/level3 (should NOT be found) + deep = tmp_path / "level1" / "level2" / "level3" + deep.mkdir(parents=True) + (deep / "SKILL.md").write_text("---\nname: deep-skill\ndescription: Too deep.\n---\nBody.", encoding="utf-8") + skills = _discover_and_load_skills([str(tmp_path)]) + assert "deep-skill" not in skills + + def test_skill_with_resources(self, tmp_path: Path) -> None: + _write_skill( + tmp_path, + "my-skill", + body="See [doc](refs/FAQ.md).", + resources={"refs/FAQ.md": "FAQ content"}, + ) + skills = _discover_and_load_skills([str(tmp_path)]) + assert "my-skill" in skills + assert skills["my-skill"].resource_names == ["refs/FAQ.md"] + + def test_excludes_skill_with_missing_resource(self, tmp_path: Path) -> None: + _write_skill( + tmp_path, + "my-skill", + body="See [doc](refs/MISSING.md).", + ) + skills = _discover_and_load_skills([str(tmp_path)]) + assert len(skills) == 0 + + def test_excludes_skill_with_path_traversal_resource(self, tmp_path: Path) -> None: + _write_skill( + tmp_path, + "my-skill", + body="See [doc](../secret.md).", + resources={}, # resource points outside + ) + # Create the file outside the skill directory + (tmp_path / "secret.md").write_text("secret", encoding="utf-8") + skills = _discover_and_load_skills([str(tmp_path)]) + assert len(skills) == 0 + + +# --------------------------------------------------------------------------- +# Tests: read_skill_resource +# --------------------------------------------------------------------------- + + +class TestReadSkillResource: + """Tests for _read_skill_resource.""" + + def test_reads_valid_resource(self, tmp_path: Path) -> None: + _write_skill( + tmp_path, + "my-skill", + body="See [doc](refs/FAQ.md).", + resources={"refs/FAQ.md": "FAQ content here"}, + ) + skills = _discover_and_load_skills([str(tmp_path)]) + content = _read_skill_resource(skills["my-skill"], "refs/FAQ.md") + assert content == "FAQ content here" + + def test_normalizes_dot_slash(self, tmp_path: Path) -> None: + _write_skill( + tmp_path, + "my-skill", + body="See [doc](refs/FAQ.md).", + resources={"refs/FAQ.md": "FAQ content"}, + ) + skills = _discover_and_load_skills([str(tmp_path)]) + content = _read_skill_resource(skills["my-skill"], "./refs/FAQ.md") + assert content == "FAQ content" + + def test_unregistered_resource_raises(self, tmp_path: Path) -> None: + _write_skill(tmp_path, "my-skill") + skills = _discover_and_load_skills([str(tmp_path)]) + with pytest.raises(ValueError, match="not found in skill"): + _read_skill_resource(skills["my-skill"], "nonexistent.md") + + def test_case_insensitive_lookup_uses_registered_casing(self, tmp_path: Path) -> None: + _write_skill( + tmp_path, + "my-skill", + body="See [doc](refs/FAQ.md).", + resources={"refs/FAQ.md": "FAQ content"}, + ) + skills = _discover_and_load_skills([str(tmp_path)]) + # Request with different casing; the registered name should be used for the file path + content = _read_skill_resource(skills["my-skill"], "REFS/faq.md") + assert content == "FAQ content" + + def test_path_traversal_raises(self, tmp_path: Path) -> None: + skill = _FileAgentSkill( + frontmatter=_SkillFrontmatter("test", "Test skill"), + body="Body", + source_path=str(tmp_path / "skill"), + resource_names=["../secret.md"], + ) + (tmp_path / "secret.md").write_text("secret", encoding="utf-8") + with pytest.raises(ValueError, match="outside the skill directory"): + _read_skill_resource(skill, "../secret.md") + + def test_similar_prefix_directory_does_not_match(self, tmp_path: Path) -> None: + """A skill directory named 'skill-a-evil' must not access resources from 'skill-a'.""" + skill = _FileAgentSkill( + frontmatter=_SkillFrontmatter("test", "Test skill"), + body="Body", + source_path=str(tmp_path / "skill-a"), + resource_names=["../skill-a-evil/secret.md"], + ) + evil_dir = tmp_path / "skill-a-evil" + evil_dir.mkdir() + (evil_dir / "secret.md").write_text("evil", encoding="utf-8") + with pytest.raises(ValueError, match="outside the skill directory"): + _read_skill_resource(skill, "../skill-a-evil/secret.md") + + +# --------------------------------------------------------------------------- +# Tests: _build_skills_instruction_prompt +# --------------------------------------------------------------------------- + + +class TestBuildSkillsInstructionPrompt: + """Tests for _build_skills_instruction_prompt.""" + + def test_returns_none_for_empty_skills(self) -> None: + assert _build_skills_instruction_prompt(None, {}) is None + + def test_default_prompt_contains_skills(self) -> None: + skills = { + "my-skill": _FileAgentSkill( + frontmatter=_SkillFrontmatter("my-skill", "Does stuff."), + body="Body", + source_path="/tmp/skill", + ), + } + prompt = _build_skills_instruction_prompt(None, skills) + assert prompt is not None + assert "my-skill" in prompt + assert "Does stuff." in prompt + assert "load_skill" in prompt + + def test_skills_sorted_alphabetically(self) -> None: + skills = { + "zebra": _FileAgentSkill( + frontmatter=_SkillFrontmatter("zebra", "Z skill."), + body="Body", + source_path="/tmp/z", + ), + "alpha": _FileAgentSkill( + frontmatter=_SkillFrontmatter("alpha", "A skill."), + body="Body", + source_path="/tmp/a", + ), + } + prompt = _build_skills_instruction_prompt(None, skills) + assert prompt is not None + alpha_pos = prompt.index("alpha") + zebra_pos = prompt.index("zebra") + assert alpha_pos < zebra_pos + + def test_xml_escapes_metadata(self) -> None: + skills = { + "my-skill": _FileAgentSkill( + frontmatter=_SkillFrontmatter("my-skill", 'Uses & "quotes"'), + body="Body", + source_path="/tmp/skill", + ), + } + prompt = _build_skills_instruction_prompt(None, skills) + assert prompt is not None + assert "<tags>" in prompt + assert "&" in prompt + + def test_custom_prompt_template(self) -> None: + skills = { + "my-skill": _FileAgentSkill( + frontmatter=_SkillFrontmatter("my-skill", "Does stuff."), + body="Body", + source_path="/tmp/skill", + ), + } + custom = "Custom header:\n{0}\nCustom footer." + prompt = _build_skills_instruction_prompt(custom, skills) + assert prompt is not None + assert prompt.startswith("Custom header:") + assert prompt.endswith("Custom footer.") + + def test_invalid_prompt_template_raises(self) -> None: + skills = { + "my-skill": _FileAgentSkill( + frontmatter=_SkillFrontmatter("my-skill", "Does stuff."), + body="Body", + source_path="/tmp/skill", + ), + } + with pytest.raises(ValueError, match="valid format string"): + _build_skills_instruction_prompt("{invalid}", skills) + + +# --------------------------------------------------------------------------- +# Tests: FileAgentSkillsProvider +# --------------------------------------------------------------------------- + + +class TestFileAgentSkillsProvider: + """Tests for the public FileAgentSkillsProvider class.""" + + def test_default_source_id(self, tmp_path: Path) -> None: + provider = FileAgentSkillsProvider(str(tmp_path)) + assert provider.source_id == "file_agent_skills" + + def test_custom_source_id(self, tmp_path: Path) -> None: + provider = FileAgentSkillsProvider(str(tmp_path), source_id="custom") + assert provider.source_id == "custom" + + def test_accepts_single_path_string(self, tmp_path: Path) -> None: + _write_skill(tmp_path, "my-skill") + provider = FileAgentSkillsProvider(str(tmp_path)) + assert len(provider._skills) == 1 + + def test_accepts_sequence_of_paths(self, tmp_path: Path) -> None: + dir1 = tmp_path / "dir1" + dir2 = tmp_path / "dir2" + _write_skill(dir1, "skill-a") + _write_skill(dir2, "skill-b") + provider = FileAgentSkillsProvider([str(dir1), str(dir2)]) + assert len(provider._skills) == 2 + + async def test_before_run_with_skills(self, tmp_path: Path) -> None: + _write_skill(tmp_path, "my-skill") + provider = FileAgentSkillsProvider(str(tmp_path)) + context = SessionContext(input_messages=[]) + + await provider.before_run( + agent=AsyncMock(), + session=AsyncMock(), + context=context, + state={}, + ) + + assert len(context.instructions) == 1 + assert "my-skill" in context.instructions[0] + assert len(context.tools) == 2 + tool_names = {t.name for t in context.tools} + assert tool_names == {"load_skill", "read_skill_resource"} + + async def test_before_run_without_skills(self, tmp_path: Path) -> None: + provider = FileAgentSkillsProvider(str(tmp_path)) + context = SessionContext(input_messages=[]) + + await provider.before_run( + agent=AsyncMock(), + session=AsyncMock(), + context=context, + state={}, + ) + + assert len(context.instructions) == 0 + assert len(context.tools) == 0 + + def test_load_skill_returns_body(self, tmp_path: Path) -> None: + _write_skill(tmp_path, "my-skill", body="Skill body content.") + provider = FileAgentSkillsProvider(str(tmp_path)) + result = provider._load_skill("my-skill") + assert result == "Skill body content." + + def test_load_skill_unknown_returns_error(self, tmp_path: Path) -> None: + provider = FileAgentSkillsProvider(str(tmp_path)) + result = provider._load_skill("nonexistent") + assert result.startswith("Error:") + + def test_load_skill_empty_name_returns_error(self, tmp_path: Path) -> None: + provider = FileAgentSkillsProvider(str(tmp_path)) + result = provider._load_skill("") + assert result.startswith("Error:") + + def test_read_skill_resource_returns_content(self, tmp_path: Path) -> None: + _write_skill( + tmp_path, + "my-skill", + body="See [doc](refs/FAQ.md).", + resources={"refs/FAQ.md": "FAQ content"}, + ) + provider = FileAgentSkillsProvider(str(tmp_path)) + result = provider._read_skill_resource("my-skill", "refs/FAQ.md") + assert result == "FAQ content" + + def test_read_skill_resource_unknown_skill_returns_error(self, tmp_path: Path) -> None: + provider = FileAgentSkillsProvider(str(tmp_path)) + result = provider._read_skill_resource("nonexistent", "file.md") + assert result.startswith("Error:") + + def test_read_skill_resource_empty_name_returns_error(self, tmp_path: Path) -> None: + _write_skill(tmp_path, "my-skill") + provider = FileAgentSkillsProvider(str(tmp_path)) + result = provider._read_skill_resource("my-skill", "") + assert result.startswith("Error:") + + def test_read_skill_resource_unknown_resource_returns_error(self, tmp_path: Path) -> None: + _write_skill(tmp_path, "my-skill") + provider = FileAgentSkillsProvider(str(tmp_path)) + result = provider._read_skill_resource("my-skill", "nonexistent.md") + assert result.startswith("Error:") + + async def test_skills_sorted_in_prompt(self, tmp_path: Path) -> None: + skills_dir = tmp_path / "skills" + _write_skill(skills_dir, "zebra", description="Z skill.") + _write_skill(skills_dir, "alpha", description="A skill.") + provider = FileAgentSkillsProvider(str(skills_dir)) + context = SessionContext(input_messages=[]) + + await provider.before_run( + agent=AsyncMock(), + session=AsyncMock(), + context=context, + state={}, + ) + + prompt = context.instructions[0] + assert prompt.index("alpha") < prompt.index("zebra") + + async def test_xml_escaping_in_prompt(self, tmp_path: Path) -> None: + _write_skill(tmp_path, "my-skill", description="Uses & stuff") + provider = FileAgentSkillsProvider(str(tmp_path)) + context = SessionContext(input_messages=[]) + + await provider.before_run( + agent=AsyncMock(), + session=AsyncMock(), + context=context, + state={}, + ) + + prompt = context.instructions[0] + assert "<tags>" in prompt + assert "&" in prompt + + +# --------------------------------------------------------------------------- +# Tests: symlink detection (_has_symlink_in_path and end-to-end guards) +# --------------------------------------------------------------------------- + + +@pytest.fixture() +def _requires_symlinks(tmp_path: Path) -> None: + """Skip the test if the platform does not support symlinks.""" + if not _symlinks_supported(tmp_path): + pytest.skip("Symlinks not supported on this platform/environment") + + +@pytest.mark.usefixtures("_requires_symlinks") +class TestSymlinkDetection: + """Tests for _has_symlink_in_path and the symlink guards in validation/read.""" + + def test_detects_symlinked_file(self, tmp_path: Path) -> None: + """A symlink to a file outside the directory should be detected.""" + skill_dir = tmp_path / "skill" + skill_dir.mkdir() + + outside_file = tmp_path / "secret.txt" + outside_file.write_text("secret", encoding="utf-8") + + symlink_path = skill_dir / "link.txt" + symlink_path.symlink_to(outside_file) + + full_path = str(symlink_path) + directory_path = str(skill_dir) + os.sep + assert _has_symlink_in_path(full_path, directory_path) is True + + def test_detects_symlinked_directory(self, tmp_path: Path) -> None: + """A symlink to a directory outside should be detected for paths through it.""" + skill_dir = tmp_path / "skill" + skill_dir.mkdir() + + outside_dir = tmp_path / "outside" + outside_dir.mkdir() + (outside_dir / "data.txt").write_text("data", encoding="utf-8") + + symlink_dir = skill_dir / "linked-dir" + symlink_dir.symlink_to(outside_dir) + + full_path = str(skill_dir / "linked-dir" / "data.txt") + directory_path = str(skill_dir) + os.sep + assert _has_symlink_in_path(full_path, directory_path) is True + + def test_returns_false_for_regular_files(self, tmp_path: Path) -> None: + """Regular (non-symlinked) files should not be flagged.""" + skill_dir = tmp_path / "skill" + skill_dir.mkdir() + + regular_file = skill_dir / "doc.txt" + regular_file.write_text("content", encoding="utf-8") + + full_path = str(regular_file) + directory_path = str(skill_dir) + os.sep + assert _has_symlink_in_path(full_path, directory_path) is False + + def test_validate_resources_rejects_symlinked_resource(self, tmp_path: Path) -> None: + """_discover_and_load_skills should exclude a skill whose resource is a symlink.""" + skill_dir = tmp_path / "my-skill" + skill_dir.mkdir() + + outside_file = tmp_path / "secret.md" + outside_file.write_text("secret content", encoding="utf-8") + + # Create SKILL.md referencing a resource + (skill_dir / "SKILL.md").write_text( + "---\nname: my-skill\ndescription: A test skill.\n---\nSee [doc](refs/leak.md).\n", + encoding="utf-8", + ) + refs_dir = skill_dir / "refs" + refs_dir.mkdir() + (refs_dir / "leak.md").symlink_to(outside_file) + + skills = _discover_and_load_skills([str(tmp_path)]) + assert "my-skill" not in skills + + def test_read_skill_resource_rejects_symlinked_resource(self, tmp_path: Path) -> None: + """_read_skill_resource should raise ValueError for a symlinked resource.""" + skill_dir = tmp_path / "skill" + skill_dir.mkdir() + + outside_file = tmp_path / "secret.md" + outside_file.write_text("secret content", encoding="utf-8") + + refs_dir = skill_dir / "refs" + refs_dir.mkdir() + (refs_dir / "leak.md").symlink_to(outside_file) + + skill = _FileAgentSkill( + frontmatter=_SkillFrontmatter("test", "Test skill"), + body="See [doc](refs/leak.md).", + source_path=str(skill_dir), + resource_names=["refs/leak.md"], + ) + with pytest.raises(ValueError, match="symlink"): + _read_skill_resource(skill, "refs/leak.md") diff --git a/python/packages/core/tests/workflow/test_runner.py b/python/packages/core/tests/workflow/test_runner.py index 039c61b07d..eaf69f90b0 100644 --- a/python/packages/core/tests/workflow/test_runner.py +++ b/python/packages/core/tests/workflow/test_runner.py @@ -21,7 +21,7 @@ from agent_framework import ( handler, ) from agent_framework._workflows._const import EXECUTOR_STATE_KEY -from agent_framework._workflows._edge import SingleEdgeGroup +from agent_framework._workflows._edge import FanOutEdgeGroup, SingleEdgeGroup from agent_framework._workflows._runner import Runner from agent_framework._workflows._runner_context import ( InProcRunnerContext, @@ -150,6 +150,154 @@ async def test_runner_run_until_convergence_not_completed(): assert event.type != "status" or event.state != WorkflowRunState.IDLE +async def test_runner_run_iteration_preserves_message_order_per_edge_runner() -> None: + """Test that _run_iteration preserves message order to the same target path.""" + + class RecordingEdgeRunner: + def __init__(self) -> None: + self.received: list[int] = [] + + async def send_message(self, message: WorkflowMessage, state: State, ctx: RunnerContext) -> bool: + message_data = message.data + assert isinstance(message_data, MockMessage) + self.received.append(message_data.data) + return True + + ctx = InProcRunnerContext() + state = State() + runner = Runner([], {}, state, ctx, "test_name", graph_signature_hash="test_hash") + + edge_runner = RecordingEdgeRunner() + runner._edge_runner_map = {"source": [edge_runner]} # type: ignore[assignment] + + for index in range(5): + await ctx.send_message(WorkflowMessage(data=MockMessage(data=index), source_id="source")) + + await runner._run_iteration() + + assert edge_runner.received == [0, 1, 2, 3, 4] + + +async def test_runner_run_iteration_delivers_different_edge_runners_concurrently() -> None: + """Test that different edge runners for the same source are executed concurrently.""" + + class BlockingEdgeRunner: + def __init__(self) -> None: + self.started = asyncio.Event() + self.release = asyncio.Event() + self.call_count = 0 + + async def send_message(self, message: WorkflowMessage, state: State, ctx: RunnerContext) -> bool: + self.call_count += 1 + self.started.set() + await self.release.wait() + return True + + class ProbeEdgeRunner: + def __init__(self) -> None: + self.probe_completed = asyncio.Event() + self.call_count = 0 + + async def send_message(self, message: WorkflowMessage, state: State, ctx: RunnerContext) -> bool: + self.call_count += 1 + self.probe_completed.set() + return True + + ctx = InProcRunnerContext() + state = State() + runner = Runner([], {}, state, ctx, "test_name", graph_signature_hash="test_hash") + + blocking_edge_runner = BlockingEdgeRunner() + probe_edge_runner = ProbeEdgeRunner() + runner._edge_runner_map = {"source": [blocking_edge_runner, probe_edge_runner]} # type: ignore[assignment] + + await ctx.send_message(WorkflowMessage(data=MockMessage(data=1), source_id="source")) + + iteration_task = asyncio.create_task(runner._run_iteration()) + + await blocking_edge_runner.started.wait() + await asyncio.wait_for(probe_edge_runner.probe_completed.wait(), timeout=2.0) + + blocking_edge_runner.release.set() + await iteration_task + + assert blocking_edge_runner.call_count == 1 + assert probe_edge_runner.call_count == 1 + + +async def test_fanout_edge_runner_delivers_to_multiple_targets_concurrently() -> None: + """Test that FanOutEdgeRunner delivers messages to multiple targets concurrently. + + This verifies that when a message is broadcast through a FanOutEdgeGroup (no target_id), + the runner delivers to all targets concurrently rather than sequentially. + """ + + class BlockingExecutor(Executor): + """An executor that blocks until released, used to detect concurrent execution.""" + + def __init__(self, id: str) -> None: + super().__init__(id=id) + self.started = asyncio.Event() + self.release = asyncio.Event() + self.call_count = 0 + + @handler + async def handle(self, message: MockMessage, ctx: WorkflowContext[MockMessage, int]) -> None: + self.call_count += 1 + self.started.set() + await self.release.wait() + + class ProbeExecutor(Executor): + """An executor that completes immediately, used to probe concurrent execution.""" + + def __init__(self, id: str) -> None: + super().__init__(id=id) + self.probe_completed = asyncio.Event() + self.call_count = 0 + + @handler + async def handle(self, message: MockMessage, ctx: WorkflowContext[MockMessage, int]) -> None: + self.call_count += 1 + self.probe_completed.set() + + source = MockExecutor(id="source") + blocking_target = BlockingExecutor(id="blocking_target") + probe_target = ProbeExecutor(id="probe_target") + + # FanOutEdgeGroup broadcasts messages to multiple targets + edge_group = FanOutEdgeGroup(source_id=source.id, target_ids=[blocking_target.id, probe_target.id]) + + executors: dict[str, Executor] = { + source.id: source, + blocking_target.id: blocking_target, + probe_target.id: probe_target, + } + + ctx = InProcRunnerContext() + state = State() + runner = Runner([edge_group], executors, state, ctx, "test_name", graph_signature_hash="test_hash") + + # Queue a message from source (will be delivered to both targets via FanOut) + await ctx.send_message(WorkflowMessage(data=MockMessage(data=1), source_id=source.id)) + + iteration_task = asyncio.create_task(runner._run_iteration()) + + # Wait for the blocking executor to start + await blocking_target.started.wait() + + # If FanOut delivers concurrently, the probe should complete while blocking is still waiting + # If sequential, this would timeout because probe wouldn't start until blocking finishes + await asyncio.wait_for(probe_target.probe_completed.wait(), timeout=2.0) + + # Release the blocking executor to allow iteration to complete + blocking_target.release.set() + await iteration_task + + # Both executors should have been called exactly once + assert blocking_target.call_count == 1 + assert probe_target.call_count == 1 + + async def test_runner_already_running(): """Test that running the runner while it is already running raises an error.""" executor_a = MockExecutor(id="executor_a") diff --git a/python/packages/declarative/agent_framework_declarative/_workflows/__init__.py b/python/packages/declarative/agent_framework_declarative/_workflows/__init__.py index af3e196e3a..2968f2b3f9 100644 --- a/python/packages/declarative/agent_framework_declarative/_workflows/__init__.py +++ b/python/packages/declarative/agent_framework_declarative/_workflows/__init__.py @@ -34,7 +34,6 @@ from ._executors_agents import ( AgentResult, ExternalLoopState, InvokeAzureAgentExecutor, - InvokeToolExecutor, ) from ._executors_basic import ( BASIC_ACTION_EXECUTORS, @@ -68,6 +67,17 @@ from ._executors_external_input import ( RequestExternalInputExecutor, WaitForInputExecutor, ) +from ._executors_tools import ( + FUNCTION_TOOL_REGISTRY_KEY, + TOOL_ACTION_EXECUTORS, + TOOL_APPROVAL_STATE_KEY, + BaseToolExecutor, + InvokeFunctionToolExecutor, + ToolApprovalRequest, + ToolApprovalResponse, + ToolApprovalState, + ToolInvocationResult, +) from ._factory import DeclarativeWorkflowError, WorkflowFactory from ._state import WorkflowState @@ -79,6 +89,9 @@ __all__ = [ "CONTROL_FLOW_EXECUTORS", "DECLARATIVE_STATE_KEY", "EXTERNAL_INPUT_EXECUTORS", + "FUNCTION_TOOL_REGISTRY_KEY", + "TOOL_ACTION_EXECUTORS", + "TOOL_APPROVAL_STATE_KEY", "TOOL_REGISTRY_KEY", "ActionComplete", "ActionTrigger", @@ -86,6 +99,7 @@ __all__ = [ "AgentExternalInputResponse", "AgentResult", "AppendValueExecutor", + "BaseToolExecutor", "BreakLoopExecutor", "ClearAllVariablesExecutor", "ConfirmationExecutor", @@ -107,7 +121,7 @@ __all__ = [ "ForeachInitExecutor", "ForeachNextExecutor", "InvokeAzureAgentExecutor", - "InvokeToolExecutor", + "InvokeFunctionToolExecutor", "JoinExecutor", "LoopControl", "LoopIterationResult", @@ -119,6 +133,10 @@ __all__ = [ "SetTextVariableExecutor", "SetValueExecutor", "SetVariableExecutor", + "ToolApprovalRequest", + "ToolApprovalResponse", + "ToolApprovalState", + "ToolInvocationResult", "WaitForInputExecutor", "WorkflowFactory", "WorkflowState", diff --git a/python/packages/declarative/agent_framework_declarative/_workflows/_declarative_builder.py b/python/packages/declarative/agent_framework_declarative/_workflows/_declarative_builder.py index c5552c0e85..65e129d921 100644 --- a/python/packages/declarative/agent_framework_declarative/_workflows/_declarative_builder.py +++ b/python/packages/declarative/agent_framework_declarative/_workflows/_declarative_builder.py @@ -13,6 +13,7 @@ action definitions and creates a proper workflow graph with: from __future__ import annotations +import logging from typing import Any from agent_framework import ( @@ -38,6 +39,10 @@ from ._executors_control_flow import ( SwitchEvaluatorExecutor, ) from ._executors_external_input import EXTERNAL_INPUT_EXECUTORS +from ._executors_tools import TOOL_ACTION_EXECUTORS, InvokeFunctionToolExecutor + +logger = logging.getLogger(__name__) + # Combined mapping of all action kinds to executor classes ALL_ACTION_EXECUTORS = { @@ -45,6 +50,7 @@ ALL_ACTION_EXECUTORS = { **CONTROL_FLOW_EXECUTORS, **AGENT_ACTION_EXECUTORS, **EXTERNAL_INPUT_EXECUTORS, + **TOOL_ACTION_EXECUTORS, } # Action kinds that terminate control flow (no fall-through to successor) @@ -78,6 +84,7 @@ ACTION_REQUIRED_FIELDS: dict[str, list[str]] = { "RequestHumanInput": ["variable"], "WaitForHumanInput": ["variable"], "EmitEvent": ["event"], + "InvokeFunctionTool": ["functionName"], } # Alternate field names that satisfy required field requirements @@ -118,6 +125,7 @@ class DeclarativeWorkflowBuilder: yaml_definition: dict[str, Any], workflow_id: str | None = None, agents: dict[str, Any] | None = None, + tools: dict[str, Any] | None = None, checkpoint_storage: Any | None = None, validate: bool = True, max_iterations: int | None = None, @@ -128,6 +136,7 @@ class DeclarativeWorkflowBuilder: yaml_definition: The parsed YAML workflow definition workflow_id: Optional ID for the workflow (defaults to name from YAML) agents: Registry of agent instances by name (for InvokeAzureAgent actions) + tools: Registry of tool/function instances by name (for InvokeFunctionTool actions) checkpoint_storage: Optional checkpoint storage for pause/resume support validate: Whether to validate the workflow definition before building (default: True) max_iterations: Maximum runner supersteps. Falls back to the YAML ``maxTurns`` @@ -138,6 +147,7 @@ class DeclarativeWorkflowBuilder: self._executors: dict[str, Any] = {} # id -> executor self._action_index = 0 # Counter for generating unique IDs self._agents = agents or {} # Agent registry for agent executors + self._tools = tools or {} # Tool registry for tool executors self._checkpoint_storage = checkpoint_storage self._pending_gotos: list[tuple[Any, str]] = [] # (goto_executor, target_id) self._validate = validate @@ -423,8 +433,13 @@ class DeclarativeWorkflowBuilder: executor_class = ALL_ACTION_EXECUTORS.get(kind) if executor_class is None: - # Unknown action type - skip with warning - # In production, might want to log this + # Unknown action type - log warning and skip + logger.warning( + "Unknown action kind '%s' encountered at index %d - action will be skipped. Available action kinds: %s", + kind, + self._action_index, + list(ALL_ACTION_EXECUTORS.keys()), + ) return None # Create the executor with ID @@ -437,10 +452,12 @@ class DeclarativeWorkflowBuilder: action_id = f"{parent_id}_{kind}_{self._action_index}" if parent_id else f"{kind}_{self._action_index}" self._action_index += 1 - # Pass agents to agent-related executors + # Pass agents/tools to specialized executors executor: Any if kind in ("InvokeAzureAgent",): executor = InvokeAzureAgentExecutor(action_def, id=action_id, agents=self._agents) + elif kind == "InvokeFunctionTool": + executor = InvokeFunctionToolExecutor(action_def, id=action_id, tools=self._tools) else: executor = executor_class(action_def, id=action_id) self._executors[action_id] = executor diff --git a/python/packages/declarative/agent_framework_declarative/_workflows/_executors_agents.py b/python/packages/declarative/agent_framework_declarative/_workflows/_executors_agents.py index 96f8991d17..c2fded5fb8 100644 --- a/python/packages/declarative/agent_framework_declarative/_workflows/_executors_agents.py +++ b/python/packages/declarative/agent_framework_declarative/_workflows/_executors_agents.py @@ -1019,75 +1019,7 @@ class InvokeAzureAgentExecutor(DeclarativeActionExecutor): await ctx.send_message(ActionComplete()) -class InvokeToolExecutor(DeclarativeActionExecutor): - """Executor that invokes a registered tool/function. - - Tools are simpler than agents - they take input, perform an action, - and return a result synchronously (or with a simple async call). - """ - - @handler - async def handle_action( - self, - trigger: Any, - ctx: WorkflowContext[ActionComplete], - ) -> None: - """Handle the tool invocation.""" - state = await self._ensure_state_initialized(ctx, trigger) - - tool_name = self._action_def.get("tool") or self._action_def.get("toolName", "") - input_expr = self._action_def.get("input") - output_property = self._action_def.get("output", {}).get("property") or self._action_def.get("resultProperty") - parameters = self._action_def.get("parameters", {}) - - # Get tools registry - try: - tool_registry: dict[str, Any] | None = ctx.state.get(TOOL_REGISTRY_KEY) - except KeyError: - tool_registry = {} - - tool: Any = tool_registry.get(tool_name) if tool_registry else None - - if tool is None: - error_msg = f"Tool '{tool_name}' not found in registry" - if output_property: - state.set(output_property, {"error": error_msg}) - await ctx.send_message(ActionComplete()) - return - - # Build parameters - params: dict[str, Any] = {} - for param_name, param_expression in parameters.items(): - params[param_name] = state.eval_if_expression(param_expression) - - # Add main input if specified - if input_expr: - params["input"] = state.eval_if_expression(input_expr) - - try: - # Invoke the tool - if callable(tool): - from inspect import isawaitable - - result = tool(**params) - if isawaitable(result): - result = await result - - # Store result - if output_property: - state.set(output_property, result) - - except Exception as e: - if output_property: - state.set(output_property, {"error": str(e)}) - await ctx.send_message(ActionComplete()) - return - - await ctx.send_message(ActionComplete()) - - # Mapping of agent action kinds to executor classes AGENT_ACTION_EXECUTORS: dict[str, type[DeclarativeActionExecutor]] = { "InvokeAzureAgent": InvokeAzureAgentExecutor, - "InvokeTool": InvokeToolExecutor, } diff --git a/python/packages/declarative/agent_framework_declarative/_workflows/_executors_tools.py b/python/packages/declarative/agent_framework_declarative/_workflows/_executors_tools.py new file mode 100644 index 0000000000..829d48103f --- /dev/null +++ b/python/packages/declarative/agent_framework_declarative/_workflows/_executors_tools.py @@ -0,0 +1,711 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""Tool invocation executors for declarative workflows. + +Provides base abstractions and concrete executors for invoking various tool types +(functions, APIs, MCP servers, etc.) with support for approval flows and structured output. + +This module is designed for extensibility: +- BaseToolExecutor provides common patterns (registry lookup, approval flow, output formatting) +- Concrete executors (InvokeFunctionToolExecutor) implement tool-specific invocation logic +- New tool types can be added by subclassing BaseToolExecutor +""" + +import json +import logging +import uuid +from abc import abstractmethod +from dataclasses import dataclass, field +from inspect import isawaitable +from typing import Any + +from agent_framework import ( + Content, + Message, + WorkflowContext, + handler, + response_handler, +) + +from ._declarative_base import ( + ActionComplete, + DeclarativeActionExecutor, + DeclarativeWorkflowState, +) +from ._executors_agents import TOOL_REGISTRY_KEY + +logger = logging.getLogger(__name__) + +# Registry key for function tools in State - reuse existing key so functions registered +# at runtime are discoverable by both agent-based and function-based tool executors. +FUNCTION_TOOL_REGISTRY_KEY = TOOL_REGISTRY_KEY + +# State key prefix for storing approval state during yield/resume. +# The executor's ID is appended to create a per-executor key. +TOOL_APPROVAL_STATE_KEY = "_tool_approval_state" + + +# ============================================================================ +# Request/Response Types for Approval Flow +# ============================================================================ + + +@dataclass +class ToolApprovalRequest: + """Request for approval before invoking a tool. + + Emitted when requireApproval=true, signaling that the workflow should yield + and wait for user approval before invoking the tool. + + This follows the same pattern as AgentExternalInputRequest from _executors_agents.py, + allowing consistent handling of human-in-loop scenarios across agents and tools. + + Attributes: + request_id: Unique identifier for this approval request. + function_name: Evaluated function name to be invoked. + arguments: Evaluated arguments to be passed to the function. + """ + + request_id: str + function_name: str + arguments: dict[str, Any] + + +@dataclass +class ToolApprovalResponse: + """Response to a ToolApprovalRequest. + + Provided by the caller to approve or reject tool invocation. + + Attributes: + approved: Whether the tool invocation was approved. + reason: Optional reason for rejection. + """ + + approved: bool + reason: str | None = None + + +# ============================================================================ +# State Types for Approval Flow +# ============================================================================ + + +@dataclass +class ToolApprovalState: + """State saved during approval yield for resumption. + + Stored in State under a per-executor key when requireApproval=true. + Retrieved by handle_approval_response() to continue execution. + """ + + function_name: str + arguments: dict[str, Any] + output_messages_var: str | None + output_result_var: str | None + auto_send: bool + + +# ============================================================================ +# Result Types +# ============================================================================ + + +@dataclass +class ToolInvocationResult: + """Result from a tool invocation. + + Attributes: + success: Whether the invocation succeeded. + result: The return value from the tool (if successful). + error: Error message (if failed). + messages: Message list format for conversation history. + rejected: Whether the invocation was rejected during approval. + rejection_reason: Reason for rejection. + """ + + success: bool + result: Any = None + error: str | None = None + messages: list[Message] = field(default_factory=list) + rejected: bool = False + rejection_reason: str | None = None + + +# ============================================================================ +# Helper Functions +# ============================================================================ + + +def _normalize_variable_path(variable: str) -> str: + """Normalize variable names to ensure they have a scope prefix. + + Args: + variable: Variable name like 'Local.X' or 'weatherResult' + + Returns: + The variable path with a scope prefix (defaults to Local if none provided) + """ + if variable.startswith(("Local.", "System.", "Workflow.", "Agent.", "Conversation.")): + return variable + if "." in variable: + return variable + return "Local." + variable + + +# ============================================================================ +# Base Tool Executor (Abstract) +# ============================================================================ + + +class BaseToolExecutor(DeclarativeActionExecutor): + """Base class for tool invocation executors. + + Provides common functionality for all tool-like executors: + - Tool registry lookup (State + WorkflowFactory registration) + - Approval flow (request_info pattern with yield/resume) + - Output formatting (messages as Message list + result variable) + - Error handling (stores error in output, doesn't raise) + + Subclasses must implement: + - _invoke_tool(): Perform the actual tool invocation + + YAML Schema (common fields): + kind: + id: unique_id + functionName: function_to_call # required, supports =expression syntax + requireApproval: true # optional, default=false + arguments: # optional dictionary + param1: value1 + param2: =Local.dynamicValue + output: + messages: Local.toolCallMessages # Message list + result: Local.toolResult + autoSend: true # optional, default=true + """ + + def __init__( + self, + action_def: dict[str, Any], + *, + id: str | None = None, + tools: dict[str, Any] | None = None, + ): + """Initialize the tool executor. + + Args: + action_def: The action definition from YAML + id: Optional executor ID + tools: Registry of tool instances by name (from WorkflowFactory) + """ + super().__init__(action_def, id=id) + self._tools = tools or {} + + @abstractmethod + async def _invoke_tool( + self, + tool: Any, + function_name: str, + arguments: dict[str, Any], + state: DeclarativeWorkflowState, + ) -> Any: + """Invoke the tool with the given arguments. + + Args: + tool: The tool instance to invoke + function_name: Function/method name to call + arguments: Arguments to pass + state: Workflow state + + Returns: + The result from the tool invocation + + Raises: + Any exception from the tool invocation + """ + pass + + def _get_tool( + self, + function_name: str, + ctx: WorkflowContext[Any, Any], + ) -> Any | None: + """Get tool from registry. + + Checks both WorkflowFactory registry (self._tools) and State registry. + + Args: + function_name: Name of the function + ctx: Workflow context + + Returns: + The tool/function, or None if not found + """ + # Check WorkflowFactory registry first (passed in constructor) + tool = self._tools.get(function_name) + if tool is not None: + return tool + + # Check State registry (for runtime registration) + try: + tool_registry: dict[str, Any] | None = ctx.state.get(FUNCTION_TOOL_REGISTRY_KEY) + if tool_registry: + return tool_registry.get(function_name) + except KeyError: + logger.debug( + "%s: tool registry key '%s' not found in state " + "(this is normal if tools are only registered via WorkflowFactory)", + self.__class__.__name__, + FUNCTION_TOOL_REGISTRY_KEY, + ) + + return None + + def _get_output_config(self) -> tuple[str | None, str | None, bool]: + """Parse output configuration from action definition. + + Returns: + Tuple of (messages_var, result_var, auto_send) + """ + output_config = self._action_def.get("output", {}) + + if not isinstance(output_config, dict): + return None, None, True + + messages_var = output_config.get("messages") + result_var = output_config.get("result") + auto_send = bool(output_config.get("autoSend", True)) + + return ( + str(messages_var) if messages_var else None, + str(result_var) if result_var else None, + auto_send, + ) + + def _store_result( + self, + result: ToolInvocationResult, + state: DeclarativeWorkflowState, + messages_var: str | None, + result_var: str | None, + ) -> None: + """Store tool invocation result in workflow state. + + Args: + result: The tool invocation result + state: Workflow state + messages_var: Variable path for messages output + result_var: Variable path for result output + """ + # Store messages if variable specified + if messages_var: + path = _normalize_variable_path(messages_var) + state.set(path, result.messages) + + # Store result if variable specified + if result_var: + path = _normalize_variable_path(result_var) + if result.rejected: + state.set( + path, + { + "approved": False, + "rejected": True, + "reason": result.rejection_reason, + }, + ) + elif result.success: + state.set(path, result.result) + else: + state.set( + path, + { + "error": result.error, + }, + ) + + async def _format_messages( + self, + function_name: str, + arguments: dict[str, Any], + result: Any, + ) -> list[Message]: + """Format tool invocation as Message list. + + Creates tool call + tool result message pair for conversation history, + following the same format as agent tool calls. + + Args: + function_name: Function name invoked + arguments: Arguments passed + result: Result from invocation + + Returns: + List of Message objects [tool_call_message, tool_result_message] + """ + call_id = str(uuid.uuid4()) + + # Safely serialize arguments to JSON + try: + arguments_str = json.dumps(arguments) if isinstance(arguments, dict) else str(arguments) + except (TypeError, ValueError) as e: + logger.warning(f"Failed to serialize arguments to JSON: {e}") + arguments_str = str(arguments) + + # Tool call message (from assistant) + tool_call_content = Content.from_function_call( + call_id=call_id, + name=function_name, + arguments=arguments_str, + ) + tool_call_message = Message( + role="assistant", + contents=[tool_call_content], + ) + + # Safely serialize result to JSON + try: + result_str = json.dumps(result) if not isinstance(result, str) else result + except (TypeError, ValueError) as e: + logger.warning(f"Failed to serialize result to JSON: {e}") + result_str = str(result) + + tool_result_content = Content.from_function_result( + call_id=call_id, + result=result_str, + ) + tool_result_message = Message( + role="tool", + contents=[tool_result_content], + ) + + return [tool_call_message, tool_result_message] + + async def _execute_tool_invocation( + self, + function_name: str, + arguments: dict[str, Any], + state: DeclarativeWorkflowState, + ctx: WorkflowContext[Any, Any], + ) -> ToolInvocationResult: + """Execute the tool invocation. + + Args: + function_name: Function to invoke + arguments: Arguments to pass + state: Workflow state + ctx: Workflow context + + Returns: + ToolInvocationResult with outcome + """ + # Get tool from registry + tool = self._get_tool(function_name, ctx) + if tool is None: + error_msg = f"Function '{function_name}' not found in registry" + logger.error(f"{self.__class__.__name__}: {error_msg}") + return ToolInvocationResult( + success=False, + error=error_msg, + ) + + try: + # Invoke the tool (subclass implements this) + result_value = await self._invoke_tool( + tool=tool, + function_name=function_name, + arguments=arguments, + state=state, + ) + + # Format as messages for conversation history + messages = await self._format_messages( + function_name=function_name, + arguments=arguments, + result=result_value, + ) + + return ToolInvocationResult( + success=True, + result=result_value, + messages=messages, + ) + + except Exception as e: + logger.error( + "%s: error invoking function '%s': %s: %s", + self.__class__.__name__, + function_name, + type(e).__name__, + e, + exc_info=True, + ) + return ToolInvocationResult( + success=False, + error=f"{type(e).__name__}: {e}", + ) + + @handler + async def handle_action( + self, + trigger: Any, + ctx: WorkflowContext[ActionComplete, str], + ) -> None: + """Handle the tool invocation with optional approval flow. + + When requireApproval=true: + 1. Saves invocation state to State (keyed by executor ID) + 2. Emits ToolApprovalRequest via ctx.request_info() + 3. Workflow yields (returns without ActionComplete) + 4. Resumes in handle_approval_response() when user responds + """ + state = await self._ensure_state_initialized(ctx, trigger) + + # Parse output configuration early so we can store errors + messages_var, result_var, auto_send = self._get_output_config() + + # Get and evaluate function name (required) + function_name_expr = self._action_def.get("functionName") + if not function_name_expr: + error_msg = f"Action '{self.id}' is missing required 'functionName' field" + logger.error(f"{self.__class__.__name__}: {error_msg}") + if result_var: + state.set(_normalize_variable_path(result_var), {"error": error_msg}) + await ctx.send_message(ActionComplete()) + return + + function_name = state.eval_if_expression(function_name_expr) + if not function_name: + error_msg = f"Action '{self.id}': functionName expression evaluated to empty" + logger.error(f"{self.__class__.__name__}: {error_msg}") + if result_var: + state.set(_normalize_variable_path(result_var), {"error": error_msg}) + await ctx.send_message(ActionComplete()) + return + function_name = str(function_name) + + # Evaluate arguments + arguments_def = self._action_def.get("arguments", {}) + arguments: dict[str, Any] = {} + if arguments_def is not None and not isinstance(arguments_def, dict): + logger.warning( + "%s: 'arguments' must be a dictionary, got %s - ignoring", + self.__class__.__name__, + type(arguments_def).__name__, + ) + elif isinstance(arguments_def, dict): + for key, value in arguments_def.items(): + arguments[key] = state.eval_if_expression(value) + + # Check if approval is required + require_approval = self._action_def.get("requireApproval", False) + + if require_approval: + # Save state for resumption (keyed by executor ID to avoid collisions) + approval_state = ToolApprovalState( + function_name=function_name, + arguments=arguments, + output_messages_var=messages_var, + output_result_var=result_var, + auto_send=auto_send, + ) + approval_key = f"{TOOL_APPROVAL_STATE_KEY}_{self.id}" + ctx.state.set(approval_key, approval_state) + + # Emit approval request - workflow yields here + request = ToolApprovalRequest( + request_id=str(uuid.uuid4()), + function_name=function_name, + arguments=arguments, + ) + logger.info(f"{self.__class__.__name__}: requesting approval for '{function_name}'") + await ctx.request_info(request, ToolApprovalResponse) + # Workflow yields - will resume in handle_approval_response + return + + # No approval required - invoke directly + result = await self._execute_tool_invocation( + function_name=function_name, + arguments=arguments, + state=state, + ctx=ctx, + ) + + self._store_result(result, state, messages_var, result_var) + if auto_send and result.success and result.result is not None: + await ctx.yield_output(str(result.result)) + await ctx.send_message(ActionComplete()) + + @response_handler + async def handle_approval_response( + self, + original_request: ToolApprovalRequest, + response: ToolApprovalResponse, + ctx: WorkflowContext[ActionComplete, str], + ) -> None: + """Handle response to a ToolApprovalRequest. + + Called when the workflow resumes after yielding for approval. + Either executes the tool (if approved) or stores rejection status. + """ + state = self._get_state(ctx.state) + approval_key = f"{TOOL_APPROVAL_STATE_KEY}_{self.id}" + + # Retrieve saved invocation state + try: + approval_state: ToolApprovalState = ctx.state.get(approval_key) + except KeyError: + error_msg = "Approval state not found, cannot resume tool invocation" + logger.error(f"{self.__class__.__name__}: {error_msg}") + # Try to store error - get output config from action def as fallback + _, result_var, _ = self._get_output_config() + if result_var and state: + state.set(_normalize_variable_path(result_var), {"error": error_msg}) + await ctx.send_message(ActionComplete()) + return + + # Clean up approval state + try: + ctx.state.delete(approval_key) + except KeyError: + logger.warning(f"{self.__class__.__name__}: approval state already deleted") + + function_name = approval_state.function_name + arguments = approval_state.arguments + messages_var = approval_state.output_messages_var + result_var = approval_state.output_result_var + auto_send = approval_state.auto_send + + # Check if approved + if not response.approved: + logger.info(f"{self.__class__.__name__}: tool invocation rejected: {response.reason}") + + # Store rejection status (don't raise error) + result = ToolInvocationResult( + success=False, + rejected=True, + rejection_reason=response.reason, + messages=[ + Message( + role="assistant", + text=f"Function '{function_name}' was rejected: {response.reason or 'No reason provided'}", + ) + ], + ) + self._store_result(result, state, messages_var, result_var) + await ctx.send_message(ActionComplete()) + return + + # Approved - execute the invocation + result = await self._execute_tool_invocation( + function_name=function_name, + arguments=arguments, + state=state, + ctx=ctx, + ) + + self._store_result(result, state, messages_var, result_var) + if auto_send and result.success and result.result is not None: + await ctx.yield_output(str(result.result)) + await ctx.send_message(ActionComplete()) + + +# ============================================================================ +# Function Tool Executor (Concrete) +# ============================================================================ + + +class InvokeFunctionToolExecutor(BaseToolExecutor): + """Executor that invokes a Python function as a tool. + + This executor supports invoking registered Python functions with: + - Expression evaluation for functionName and arguments + - Optional approval flow (yield/resume pattern) + - Async function support + - Message list output for conversation history + + YAML Schema: + kind: InvokeFunctionTool + id: invoke_function_example + functionName: get_weather # required, supports =expression syntax + requireApproval: true # optional, default=false + arguments: # optional dictionary + location: =Local.location + unit: F + output: + messages: Local.weatherToolCallItems # Message list + result: Local.WeatherInfo + autoSend: true # optional, default=true + + Tool Registration: + Tools can be registered via: + 1. WorkflowFactory.register_tool("name", func) - preferred + 2. Setting FUNCTION_TOOL_REGISTRY_KEY in State at runtime + + Examples: + .. code-block:: python + + from agent_framework_declarative import WorkflowFactory + + + def get_weather(location: str, unit: str = "F") -> dict: + return {"temp": 72, "unit": unit, "location": location} + + + async def fetch_data(url: str) -> dict: + # async function example + return {"data": "..."} + + + factory = ( + WorkflowFactory().register_tool("get_weather", get_weather).register_tool("fetch_data", fetch_data) + ) + + workflow = factory.create_workflow_from_yaml_path("workflow.yaml") + """ + + async def _invoke_tool( + self, + tool: Any, + function_name: str, + arguments: dict[str, Any], + state: DeclarativeWorkflowState, + ) -> Any: + """Invoke the function tool. + + Supports: + - Direct callable functions + - Async functions (via inspect.isawaitable) + + Args: + tool: The tool/function to invoke + function_name: Name of the function (for error messages) + arguments: Arguments to pass to the function + state: Workflow state (not used for function tools) + + Returns: + The result from the function invocation + + Raises: + ValueError: If the tool is not callable + """ + if not callable(tool): + raise ValueError(f"Function '{function_name}' is not callable") + + # Invoke the function + result = tool(**arguments) + + # Handle async functions + if isawaitable(result): + result = await result + + return result + + +# ============================================================================ +# Executor Registry Export +# ============================================================================ + +TOOL_ACTION_EXECUTORS: dict[str, type[DeclarativeActionExecutor]] = { + "InvokeFunctionTool": InvokeFunctionToolExecutor, +} diff --git a/python/packages/declarative/agent_framework_declarative/_workflows/_factory.py b/python/packages/declarative/agent_framework_declarative/_workflows/_factory.py index 1b22a9679d..4d6f3fa35b 100644 --- a/python/packages/declarative/agent_framework_declarative/_workflows/_factory.py +++ b/python/packages/declarative/agent_framework_declarative/_workflows/_factory.py @@ -141,6 +141,7 @@ class WorkflowFactory: self._agent_factory = agent_factory or AgentFactory(env_file_path=env_file) self._agents: dict[str, SupportsAgentRun | AgentExecutor] = dict(agents) if agents else {} self._bindings: dict[str, Any] = dict(bindings) if bindings else {} + self._tools: dict[str, Any] = {} # Tool registry for InvokeFunctionTool actions self._checkpoint_storage = checkpoint_storage self._max_iterations = max_iterations @@ -377,12 +378,13 @@ class WorkflowFactory: if description: normalized_def["description"] = description - # Build the graph-based workflow, passing agents for InvokeAzureAgent executors + # Build the graph-based workflow, passing agents and tools for specialized executors try: graph_builder = DeclarativeWorkflowBuilder( normalized_def, workflow_id=name, agents=agents, + tools=self._tools, checkpoint_storage=self._checkpoint_storage, max_iterations=self._max_iterations, ) @@ -390,9 +392,10 @@ class WorkflowFactory: except ValueError as e: raise DeclarativeWorkflowError(f"Failed to build graph-based workflow: {e}") from e - # Store agents and bindings for reference (executors already have them) + # Store agents, bindings, and tools for reference (executors already have them) workflow._declarative_agents = agents # type: ignore[attr-defined] workflow._declarative_bindings = self._bindings # type: ignore[attr-defined] + workflow._declarative_tools = self._tools # type: ignore[attr-defined] # Store input schema if defined in workflow definition # This allows DevUI to generate proper input forms @@ -598,9 +601,66 @@ class WorkflowFactory: workflow = factory.create_workflow_from_yaml_path("workflow.yaml") """ + if not callable(func): + raise TypeError(f"Expected a callable for binding '{name}', got {type(func).__name__}") self._bindings[name] = func return self + def register_tool(self, name: str, func: Any) -> WorkflowFactory: + """Register a function with the factory for use in InvokeFunctionTool actions. + + Registered functions are available to InvokeFunctionTool actions by name via the functionName field. + This method supports fluent chaining. + + Args: + name: The name to register the function under. Must match the functionName + referenced in InvokeFunctionTool actions. + func: The function to register (can be sync or async). + + Returns: + Self for method chaining. + + Examples: + .. code-block:: python + + from agent_framework_declarative import WorkflowFactory + + + def get_weather(location: str, unit: str = "F") -> dict: + return {"temp": 72, "unit": unit, "location": location} + + + async def fetch_data(url: str) -> dict: + # Async function example + return {"data": "..."} + + + # Register functions for use in InvokeFunctionTool workflow actions + factory = ( + WorkflowFactory().register_tool("get_weather", get_weather).register_tool("fetch_data", fetch_data) + ) + + workflow = factory.create_workflow_from_yaml_path("workflow.yaml") + + The workflow YAML can then reference these tools: + + .. code-block:: yaml + + actions: + - kind: InvokeFunctionTool + id: call_weather + functionName: get_weather + arguments: + location: =Local.city + unit: F + output: + result: Local.weatherData + """ + if not callable(func): + raise TypeError(f"Expected a callable for tool '{name}', got {type(func).__name__}") + self._tools[name] = func + return self + def _convert_inputs_to_json_schema(self, inputs_def: dict[str, Any]) -> dict[str, Any]: """Convert a declarative inputs definition to JSON Schema. diff --git a/python/packages/declarative/tests/test_declarative_loader.py b/python/packages/declarative/tests/test_declarative_loader.py index bd58e0044a..aee0d762d9 100644 --- a/python/packages/declarative/tests/test_declarative_loader.py +++ b/python/packages/declarative/tests/test_declarative_loader.py @@ -961,6 +961,423 @@ tools: assert mcp_tool.get("project_connection_id") == "my-oauth-connection" +class TestAgentFactoryFilePath: + """Tests for AgentFactory file path operations.""" + + def test_create_agent_from_yaml_path_file_not_found(self, tmp_path): + """Test that nonexistent file raises DeclarativeLoaderError.""" + from agent_framework_declarative import AgentFactory + from agent_framework_declarative._loader import DeclarativeLoaderError + + factory = AgentFactory() + with pytest.raises(DeclarativeLoaderError, match="YAML file not found"): + factory.create_agent_from_yaml_path(tmp_path / "nonexistent.yaml") + + def test_create_agent_from_yaml_path_with_string_path(self, tmp_path): + """Test create_agent_from_yaml_path accepts string path.""" + from unittest.mock import MagicMock + + from agent_framework_declarative import AgentFactory + + yaml_file = tmp_path / "agent.yaml" + yaml_file.write_text(""" +kind: Prompt +name: FileAgent +instructions: Test agent from file +""") + + mock_client = MagicMock() + factory = AgentFactory(client=mock_client) + agent = factory.create_agent_from_yaml_path(str(yaml_file)) + + assert agent.name == "FileAgent" + + def test_create_agent_from_yaml_path_with_path_object(self, tmp_path): + """Test create_agent_from_yaml_path accepts Path object.""" + from unittest.mock import MagicMock + + from agent_framework_declarative import AgentFactory + + yaml_file = tmp_path / "agent.yaml" + yaml_file.write_text(""" +kind: Prompt +name: PathAgent +instructions: Test agent from Path +""") + + mock_client = MagicMock() + factory = AgentFactory(client=mock_client) + agent = factory.create_agent_from_yaml_path(yaml_file) + + assert agent.name == "PathAgent" + + +class TestAgentFactoryAsyncMethods: + """Tests for AgentFactory async methods.""" + + @pytest.mark.asyncio + async def test_create_agent_from_yaml_path_async_file_not_found(self, tmp_path): + """Test async version raises DeclarativeLoaderError for nonexistent file.""" + from agent_framework_declarative import AgentFactory + from agent_framework_declarative._loader import DeclarativeLoaderError + + factory = AgentFactory() + with pytest.raises(DeclarativeLoaderError, match="YAML file not found"): + await factory.create_agent_from_yaml_path_async(tmp_path / "nonexistent.yaml") + + @pytest.mark.asyncio + async def test_create_agent_from_yaml_async_with_client(self): + """Test async creation with pre-configured client.""" + from unittest.mock import MagicMock + + from agent_framework_declarative import AgentFactory + + yaml_content = """ +kind: Prompt +name: AsyncAgent +instructions: Test async agent +""" + + mock_client = MagicMock() + factory = AgentFactory(client=mock_client) + agent = await factory.create_agent_from_yaml_async(yaml_content) + + assert agent.name == "AsyncAgent" + + @pytest.mark.asyncio + async def test_create_agent_from_dict_async_with_client(self): + """Test async dict creation with pre-configured client.""" + from unittest.mock import MagicMock + + from agent_framework_declarative import AgentFactory + + agent_def = { + "kind": "Prompt", + "name": "AsyncDictAgent", + "instructions": "Test async dict agent", + } + + mock_client = MagicMock() + factory = AgentFactory(client=mock_client) + agent = await factory.create_agent_from_dict_async(agent_def) + + assert agent.name == "AsyncDictAgent" + + @pytest.mark.asyncio + async def test_create_agent_from_dict_async_invalid_kind_raises(self): + """Test that async version also raises for non-PromptAgent.""" + from agent_framework_declarative import AgentFactory + from agent_framework_declarative._loader import DeclarativeLoaderError + + agent_def = { + "kind": "Resource", + "name": "NotAnAgent", + } + + factory = AgentFactory() + with pytest.raises(DeclarativeLoaderError, match="Only definitions for a PromptAgent are supported"): + await factory.create_agent_from_dict_async(agent_def) + + @pytest.mark.asyncio + async def test_create_agent_from_yaml_path_async_with_string_path(self, tmp_path): + """Test async version accepts string path.""" + from unittest.mock import MagicMock + + from agent_framework_declarative import AgentFactory + + yaml_file = tmp_path / "async_agent.yaml" + yaml_file.write_text(""" +kind: Prompt +name: AsyncPathAgent +instructions: Test async path agent +""") + + mock_client = MagicMock() + factory = AgentFactory(client=mock_client) + agent = await factory.create_agent_from_yaml_path_async(str(yaml_file)) + + assert agent.name == "AsyncPathAgent" + + +class TestAgentFactoryProviderLookup: + """Tests for provider configuration lookup.""" + + def test_provider_lookup_error_for_unknown_provider(self): + """Test that unknown provider raises ProviderLookupError.""" + + from agent_framework_declarative import AgentFactory + from agent_framework_declarative._loader import ProviderLookupError + + yaml_content = """ +kind: Prompt +name: TestAgent +instructions: Test agent +model: + id: test-model + provider: UnknownProvider + apiType: UnknownApiType +""" + + factory = AgentFactory() + with pytest.raises(ProviderLookupError, match="Unsupported provider type"): + factory.create_agent_from_yaml(yaml_content) + + def test_additional_mappings_override_default(self): + """Test that additional_mappings can extend provider configurations.""" + from agent_framework_declarative import AgentFactory + + # Define a custom provider mapping + custom_mappings = { + "CustomProvider.Chat": { + "package": "agent_framework.openai", + "name": "OpenAIChatClient", + "model_id_field": "model_id", + }, + } + + factory = AgentFactory(additional_mappings=custom_mappings) + + # The custom mapping should be available + assert "CustomProvider.Chat" in factory.additional_mappings + + +class TestAgentFactoryConnectionHandling: + """Tests for connection handling in AgentFactory.""" + + def test_reference_connection_requires_connections_dict(self): + """Test that ReferenceConnection without connections dict raises.""" + from agent_framework_declarative import AgentFactory + + yaml_content = """ +kind: Prompt +name: TestAgent +instructions: Test agent +model: + id: gpt-4 + provider: OpenAI + apiType: Chat + connection: + kind: reference + name: my-connection +""" + + factory = AgentFactory() # No connections provided + with pytest.raises(ValueError, match="Connections must be provided to resolve ReferenceConnection"): + factory.create_agent_from_yaml(yaml_content) + + def test_reference_connection_not_found_raises(self): + """Test that missing ReferenceConnection raises.""" + from agent_framework_declarative import AgentFactory + + yaml_content = """ +kind: Prompt +name: TestAgent +instructions: Test agent +model: + id: gpt-4 + provider: OpenAI + apiType: Chat + connection: + kind: reference + name: missing-connection +""" + + factory = AgentFactory(connections={"other-connection": "value"}) + with pytest.raises(ValueError, match="not found in provided connections"): + factory.create_agent_from_yaml(yaml_content) + + def test_model_without_id_uses_provided_client(self): + """Test that model without id uses the provided chat_client.""" + from unittest.mock import MagicMock + + from agent_framework_declarative import AgentFactory + + yaml_content = """ +kind: Prompt +name: TestAgent +instructions: Test agent +model: + provider: OpenAI +""" + + mock_client = MagicMock() + factory = AgentFactory(client=mock_client) + agent = factory.create_agent_from_yaml(yaml_content) + + assert agent is not None + + def test_model_without_id_and_no_client_raises(self): + """Test that model without id and no client raises.""" + from agent_framework_declarative import AgentFactory + from agent_framework_declarative._loader import DeclarativeLoaderError + + yaml_content = """ +kind: Prompt +name: TestAgent +instructions: Test agent +model: + provider: OpenAI +""" + + factory = AgentFactory() # No chat_client + with pytest.raises(DeclarativeLoaderError, match="ChatClient must be provided"): + factory.create_agent_from_yaml(yaml_content) + + +class TestAgentFactoryChatOptions: + """Tests for chat options parsing.""" + + def test_parse_chat_options_with_all_fields(self): + """Test parsing all ModelOptions fields into chat options dict.""" + from agent_framework_declarative._loader import AgentFactory + from agent_framework_declarative._models import Model, ModelOptions + + factory = AgentFactory() + + # Create a Model with all options set + options = ModelOptions( + temperature=0.7, + maxOutputTokens=1000, + topP=0.9, + frequencyPenalty=0.5, + presencePenalty=0.3, + seed=42, + stopSequences=["STOP", "END"], + allowMultipleToolCalls=True, + ) + options.additionalProperties["chatToolMode"] = "auto" + + model = Model(id="gpt-4", options=options) + + # Parse the options + chat_options = factory._parse_chat_options(model) + + # Verify all options are parsed correctly + assert chat_options.get("temperature") == 0.7 + assert chat_options.get("max_tokens") == 1000 + assert chat_options.get("top_p") == 0.9 + assert chat_options.get("frequency_penalty") == 0.5 + assert chat_options.get("presence_penalty") == 0.3 + assert chat_options.get("seed") == 42 + assert chat_options.get("stop") == ["STOP", "END"] + assert chat_options.get("allow_multiple_tool_calls") is True + assert chat_options.get("tool_choice") == "auto" + + def test_parse_chat_options_empty_model(self): + """Test that missing model options returns empty dict.""" + from agent_framework_declarative._loader import AgentFactory + + factory = AgentFactory() + result = factory._parse_chat_options(None) + assert result == {} + + def test_parse_chat_options_with_additional_properties(self): + """Test that additional properties are passed through.""" + from agent_framework_declarative._loader import AgentFactory + from agent_framework_declarative._models import Model, ModelOptions + + factory = AgentFactory() + + # Create a Model with additional properties + options = ModelOptions(temperature=0.5) + options.additionalProperties["customOption"] = "customValue" + + model = Model(id="gpt-4", options=options) + + # Parse the options + chat_options = factory._parse_chat_options(model) + + # Verify additional properties are preserved + assert "additional_chat_options" in chat_options + assert chat_options["additional_chat_options"].get("customOption") == "customValue" + + +class TestAgentFactoryToolParsing: + """Tests for tool parsing edge cases.""" + + def test_parse_tools_returns_none_for_empty_list(self): + """Test that empty tools list returns None.""" + from agent_framework_declarative._loader import AgentFactory + + factory = AgentFactory() + result = factory._parse_tools(None) + assert result is None + + result = factory._parse_tools([]) + assert result is None + + def test_parse_function_tool_with_bindings(self): + """Test parsing FunctionTool with bindings.""" + from unittest.mock import MagicMock + + from agent_framework_declarative import AgentFactory + + yaml_content = """ +kind: Prompt +name: TestAgent +instructions: Test agent +tools: + - kind: function + name: my_function + description: A test function + bindings: + - name: my_binding +""" + + def my_function(): + return "result" + + mock_client = MagicMock() + factory = AgentFactory(client=mock_client, bindings={"my_binding": my_function}) + agent = factory.create_agent_from_yaml(yaml_content) + + # Should have parsed the tool with binding + tools = agent.default_options.get("tools", []) + assert len(tools) == 1 + + def test_parse_file_search_tool_with_all_options(self): + """Test parsing FileSearchTool with ranker and filters.""" + from unittest.mock import MagicMock + + from agent_framework_declarative import AgentFactory + + yaml_content = """ +kind: Prompt +name: TestAgent +instructions: Test agent +tools: + - kind: file_search + name: search + description: Search files + vectorStoreIds: + - vs_123 + ranker: semantic + scoreThreshold: 0.8 + maximumResultCount: 10 + filters: + type: document +""" + + mock_client = MagicMock() + factory = AgentFactory(client=mock_client) + agent = factory.create_agent_from_yaml(yaml_content) + + # Verify a file search tool was parsed + tools = agent.default_options.get("tools", []) + assert len(tools) == 1 + + def test_parse_unsupported_tool_kind_raises(self): + """Test that unsupported tool kind raises ValueError.""" + from agent_framework_declarative._loader import AgentFactory + from agent_framework_declarative._models import CustomTool + + factory = AgentFactory() + custom_tool = CustomTool(kind="custom", name="test") + + with pytest.raises(ValueError, match="Unsupported tool kind"): + factory._parse_tool(custom_tool) + + class TestProviderResponseFormat: """response_format from outputSchema must be passed inside default_options.""" diff --git a/python/packages/declarative/tests/test_function_tool_executor.py b/python/packages/declarative/tests/test_function_tool_executor.py new file mode 100644 index 0000000000..f11b356865 --- /dev/null +++ b/python/packages/declarative/tests/test_function_tool_executor.py @@ -0,0 +1,1378 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""Tests for InvokeFunctionTool executor. + +These tests verify: +- Basic function invocation (sync and async) +- Expression evaluation for functionName and arguments +- Output formatting (messages and result) +- Error handling (function not found, execution errors) +- WorkflowFactory registration +- Approval flow (requireApproval=true with yield/resume) +- Variable path normalization +- Non-callable tool error handling +- JSON serialization fallbacks +""" + +import sys +from typing import Any +from unittest.mock import AsyncMock, MagicMock + +import pytest + +try: + import powerfx # noqa: F401 + + _powerfx_available = True +except (ImportError, RuntimeError): + _powerfx_available = False + +pytestmark = pytest.mark.skipif( + not _powerfx_available or sys.version_info >= (3, 14), + reason="PowerFx engine not available (requires dotnet runtime)", +) + +from agent_framework_declarative._workflows import ( # noqa: E402 + DECLARATIVE_STATE_KEY, + FUNCTION_TOOL_REGISTRY_KEY, + TOOL_APPROVAL_STATE_KEY, + ActionComplete, + ActionTrigger, + DeclarativeWorkflowBuilder, + InvokeFunctionToolExecutor, + ToolApprovalRequest, + ToolApprovalResponse, + ToolApprovalState, + ToolInvocationResult, + WorkflowFactory, +) +from agent_framework_declarative._workflows._executors_tools import ( # noqa: E402 + _normalize_variable_path, +) + + +class TestInvokeFunctionToolExecutor: + """Tests for InvokeFunctionToolExecutor.""" + + @pytest.mark.asyncio + async def test_basic_sync_function_invocation(self): + """Test invoking a simple synchronous function.""" + + def get_weather(location: str, unit: str = "F") -> dict: + return {"temp": 72, "unit": unit, "location": location} + + yaml_def = { + "name": "function_tool_test", + "actions": [ + {"kind": "SetValue", "id": "set_location", "path": "Local.city", "value": "Seattle"}, + { + "kind": "InvokeFunctionTool", + "id": "call_weather", + "functionName": "get_weather", + "arguments": {"location": "=Local.city", "unit": "C"}, + "output": {"result": "Local.weatherData"}, + }, + # Use SendActivity to output the result so we can check it + {"kind": "SendActivity", "id": "output_location", "activity": {"text": "=Local.weatherData.location"}}, + {"kind": "SendActivity", "id": "output_unit", "activity": {"text": "=Local.weatherData.unit"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"get_weather": get_weather}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + # Verify the function was called with correct arguments + assert "Seattle" in outputs # location + assert "C" in outputs # unit + + @pytest.mark.asyncio + async def test_async_function_invocation(self): + """Test invoking an async function.""" + + async def fetch_data(url: str) -> dict: + return {"url": url, "status": "success"} + + yaml_def = { + "name": "async_function_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "fetch", + "functionName": "fetch_data", + "arguments": {"url": "https://example.com/api"}, + "output": {"result": "Local.response"}, + }, + {"kind": "SendActivity", "id": "output_url", "activity": {"text": "=Local.response.url"}}, + {"kind": "SendActivity", "id": "output_status", "activity": {"text": "=Local.response.status"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"fetch_data": fetch_data}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert "https://example.com/api" in outputs + assert "success" in outputs + + @pytest.mark.asyncio + async def test_expression_function_name(self): + """Test dynamic function name via expression.""" + + def tool_a() -> str: + return "result_a" + + def tool_b() -> str: + return "result_b" + + yaml_def = { + "name": "dynamic_function_name_test", + "actions": [ + {"kind": "SetValue", "id": "set_tool", "path": "Local.toolName", "value": "tool_b"}, + { + "kind": "InvokeFunctionTool", + "id": "dynamic_call", + "functionName": "=Local.toolName", + "arguments": {}, + "output": {"result": "Local.result"}, + }, + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.result"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"tool_a": tool_a, "tool_b": tool_b}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert "result_b" in outputs + + @pytest.mark.asyncio + async def test_function_not_found(self): + """Test error handling when function is not in registry.""" + yaml_def = { + "name": "function_not_found_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_missing", + "functionName": "nonexistent_function", + "arguments": {}, + "output": {"result": "Local.result"}, + }, + # Check if error is stored + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.result.error"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={}) # Empty registry + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + # Result should contain error info + assert "not found" in outputs[0].lower() + + @pytest.mark.asyncio + async def test_function_execution_error(self): + """Test error handling when function raises exception.""" + + def failing_function() -> str: + raise ValueError("Intentional test error") + + yaml_def = { + "name": "function_error_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_failing", + "functionName": "failing_function", + "arguments": {}, + "output": {"result": "Local.result"}, + }, + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.result.error"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"failing_function": failing_function}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + # Result should contain error info + assert "Intentional test error" in outputs[0] + + @pytest.mark.asyncio + async def test_function_with_no_output_config(self): + """Test that function works even without output configuration.""" + + counter = {"value": 0} + + def increment() -> int: + counter["value"] += 1 + return counter["value"] + + yaml_def = { + "name": "no_output_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "increment_call", + "functionName": "increment", + "arguments": {}, + # No output configuration + }, + {"kind": "SendActivity", "id": "done", "activity": {"text": "Done"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"increment": increment}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + # Workflow should complete + assert "Done" in outputs + # Function should have been called + assert counter["value"] == 1 + + +class TestInvokeFunctionToolWithWorkflowFactory: + """Tests for InvokeFunctionTool with WorkflowFactory registration.""" + + @pytest.mark.asyncio + async def test_register_tool_method(self): + """Test registering tools via WorkflowFactory.register_tool().""" + + def multiply(a: int, b: int) -> int: + return a * b + + yaml_content = """ +name: factory_tool_test +actions: + - kind: InvokeFunctionTool + id: multiply_call + functionName: multiply + arguments: + a: 6 + b: 7 + output: + result: Local.product + - kind: SendActivity + id: output + activity: + text: =Local.product +""" + factory = WorkflowFactory().register_tool("multiply", multiply) + workflow = factory.create_workflow_from_yaml(yaml_content) + + events = await workflow.run({}) + outputs = events.get_outputs() + + # PowerFx outputs integers as floats, so we check for 42 or 42.0 + assert any("42" in out for out in outputs) + + @pytest.mark.asyncio + async def test_fluent_registration(self): + """Test fluent chaining for tool registration.""" + + def add(a: int, b: int) -> int: + return a + b + + def subtract(a: int, b: int) -> int: + return a - b + + yaml_content = """ +name: fluent_test +actions: + - kind: InvokeFunctionTool + id: add_call + functionName: add + arguments: + a: 10 + b: 5 + output: + result: Local.sum + - kind: InvokeFunctionTool + id: subtract_call + functionName: subtract + arguments: + a: 10 + b: 5 + output: + result: Local.diff + - kind: SendActivity + id: output_sum + activity: + text: =Local.sum + - kind: SendActivity + id: output_diff + activity: + text: =Local.diff +""" + factory = WorkflowFactory().register_tool("add", add).register_tool("subtract", subtract) + + workflow = factory.create_workflow_from_yaml(yaml_content) + + events = await workflow.run({}) + outputs = events.get_outputs() + + # PowerFx outputs integers as floats, so we check for 15 or 15.0 + assert any("15" in out for out in outputs) # sum + assert any("5" in out for out in outputs) # diff + + +class TestToolInvocationResult: + """Tests for ToolInvocationResult dataclass.""" + + def test_success_result(self): + """Test creating a successful result.""" + result = ToolInvocationResult( + success=True, + result={"data": "value"}, + messages=[], + ) + assert result.success is True + assert result.result == {"data": "value"} + assert result.rejected is False + assert result.error is None + + def test_error_result(self): + """Test creating an error result.""" + result = ToolInvocationResult( + success=False, + error="Function failed", + ) + assert result.success is False + assert result.error == "Function failed" + assert result.result is None + + def test_rejected_result(self): + """Test creating a rejected result.""" + result = ToolInvocationResult( + success=False, + rejected=True, + rejection_reason="User denied approval", + ) + assert result.success is False + assert result.rejected is True + assert result.rejection_reason == "User denied approval" + + +class TestToolApprovalTypes: + """Tests for approval-related dataclasses.""" + + def test_approval_request(self): + """Test creating an approval request.""" + request = ToolApprovalRequest( + request_id="test-123", + function_name="dangerous_operation", + arguments={"target": "production"}, + ) + assert request.request_id == "test-123" + assert request.function_name == "dangerous_operation" + assert request.arguments == {"target": "production"} + + def test_approval_response_approved(self): + """Test creating an approved response.""" + response = ToolApprovalResponse(approved=True) + assert response.approved is True + assert response.reason is None + + def test_approval_response_rejected(self): + """Test creating a rejected response.""" + response = ToolApprovalResponse(approved=False, reason="Not authorized") + assert response.approved is False + assert response.reason == "Not authorized" + + def test_approval_state(self): + """Test creating approval state for yield/resume.""" + state = ToolApprovalState( + function_name="delete_user", + arguments={"user_id": "123"}, + output_messages_var="Local.messages", + output_result_var="Local.result", + auto_send=True, + ) + assert state.function_name == "delete_user" + assert state.arguments == {"user_id": "123"} + assert state.output_messages_var == "Local.messages" + assert state.output_result_var == "Local.result" + assert state.auto_send is True + + +class TestInvokeFunctionToolEdgeCases: + """Tests for edge cases and error handling.""" + + def test_missing_function_name_field_raises_validation_error(self): + """Test that missing functionName raises validation error at build time.""" + yaml_def = { + "name": "missing_function_name_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "no_name", + # Missing functionName field + "arguments": {}, + }, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={}) + + # Should raise validation error + with pytest.raises(ValueError, match="missing required field 'functionName'"): + builder.build() + + @pytest.mark.asyncio + async def test_empty_function_name_expression(self): + """Test handling when functionName expression evaluates to empty.""" + yaml_def = { + "name": "empty_function_name_test", + "actions": [ + {"kind": "SetValue", "id": "set_empty", "path": "Local.toolName", "value": ""}, + { + "kind": "InvokeFunctionTool", + "id": "empty_name", + "functionName": "=Local.toolName", + "arguments": {}, + }, + {"kind": "SendActivity", "id": "done", "activity": {"text": "Completed"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + # Should complete without crashing + assert "Completed" in outputs + + @pytest.mark.asyncio + async def test_messages_output_configuration(self): + """Test that messages output stores Message list.""" + + def simple_func(x: int) -> int: + return x * 2 + + yaml_def = { + "name": "messages_output_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_func", + "functionName": "simple_func", + "arguments": {"x": 5}, + "output": { + "messages": "Local.toolMessages", + "result": "Local.result", + }, + }, + {"kind": "SendActivity", "id": "output_result", "activity": {"text": "=Local.result"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"simple_func": simple_func}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + # Result should be doubled + assert any("10" in out for out in outputs) + + @pytest.mark.asyncio + async def test_function_returning_none(self): + """Test handling function that returns None.""" + + def returns_none() -> None: + pass + + yaml_def = { + "name": "returns_none_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_none", + "functionName": "returns_none", + "arguments": {}, + "output": {"result": "Local.result"}, + }, + {"kind": "SendActivity", "id": "done", "activity": {"text": "Completed"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"returns_none": returns_none}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert "Completed" in outputs + + @pytest.mark.asyncio + async def test_function_with_complex_return_type(self): + """Test function returning complex nested data.""" + + def complex_return() -> dict: + return { + "nested": { + "array": [1, 2, 3], + "string": "test", + }, + "boolean": True, + "number": 42.5, + } + + yaml_def = { + "name": "complex_return_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_complex", + "functionName": "complex_return", + "arguments": {}, + "output": {"result": "Local.data"}, + }, + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.data.nested.string"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"complex_return": complex_return}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert "test" in outputs + + @pytest.mark.asyncio + async def test_function_with_list_argument(self): + """Test passing list as argument.""" + + def sum_list(numbers: list) -> int: + return sum(numbers) + + yaml_def = { + "name": "list_argument_test", + "actions": [ + {"kind": "SetValue", "id": "set_list", "path": "Local.numbers", "value": [1, 2, 3, 4, 5]}, + { + "kind": "InvokeFunctionTool", + "id": "call_sum", + "functionName": "sum_list", + "arguments": {"numbers": "=Local.numbers"}, + "output": {"result": "Local.total"}, + }, + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.total"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"sum_list": sum_list}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert any("15" in out for out in outputs) + + @pytest.mark.asyncio + async def test_auto_send_disabled(self): + """Test autoSend=false prevents automatic output yielding.""" + + def echo_id(msg: str) -> str: + return msg + + yaml_def = { + "name": "auto_send_disabled_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_no_auto_send", + "functionName": "echo_id", + "arguments": {"msg": "hello"}, + "output": {"result": "Local.result", "autoSend": False}, + }, + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.result"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"echo_id": echo_id}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + # Result should still be available via explicit SendActivity + assert "hello" in outputs + + @pytest.mark.asyncio + async def test_function_with_only_result_output(self): + """Test output config with only result, no messages.""" + + def double(x: int) -> int: + return x * 2 + + yaml_def = { + "name": "result_only_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_double", + "functionName": "double", + "arguments": {"x": 21}, + "output": {"result": "Local.doubled"}, + }, + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.doubled"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"double": double}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert any("42" in out for out in outputs) + + @pytest.mark.asyncio + async def test_function_with_only_messages_output(self): + """Test output config with only messages, no result.""" + + def simple() -> str: + return "done" + + yaml_def = { + "name": "messages_only_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_simple", + "functionName": "simple", + "arguments": {}, + "output": {"messages": "Local.msgs"}, + }, + {"kind": "SendActivity", "id": "done", "activity": {"text": "Completed"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"simple": simple}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert "Completed" in outputs + + @pytest.mark.asyncio + async def test_function_string_return(self): + """Test function that returns a simple string.""" + + def greet(name: str) -> str: + return f"Hello, {name}!" + + yaml_def = { + "name": "string_return_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_greet", + "functionName": "greet", + "arguments": {"name": "World"}, + "output": {"result": "Local.greeting"}, + }, + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.greeting"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"greet": greet}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert "Hello, World!" in outputs + + +class TestInvokeFunctionToolBuilder: + """Tests for InvokeFunctionTool executor registration in builder.""" + + def test_executor_registered_in_all_executors(self): + """Test that InvokeFunctionTool is registered in ALL_ACTION_EXECUTORS.""" + from agent_framework_declarative._workflows import ALL_ACTION_EXECUTORS + + assert "InvokeFunctionTool" in ALL_ACTION_EXECUTORS + assert ALL_ACTION_EXECUTORS["InvokeFunctionTool"] == InvokeFunctionToolExecutor + + def test_builder_creates_tool_executor(self): + """Test that builder creates InvokeFunctionToolExecutor for InvokeFunctionTool actions.""" + + def dummy() -> str: + return "test" + + yaml_def = { + "name": "builder_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "my_tool", + "functionName": "dummy", + "arguments": {}, + }, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"dummy": dummy}) + _ = builder.build() + + # Verify the executor was created + assert "my_tool" in builder._executors + executor = builder._executors["my_tool"] + assert isinstance(executor, InvokeFunctionToolExecutor) + + +# ============================================================================ +# Helper: Mock State and Context +# ============================================================================ + + +@pytest.fixture +def mock_state() -> MagicMock: + """Create a mock state with sync get/set/delete methods.""" + mock_state = MagicMock() + mock_state._data = {} + + def mock_get(key: str, default: Any = None) -> Any: + if key not in mock_state._data: + if default is not None: + return default + raise KeyError(key) + return mock_state._data[key] + + def mock_set(key: str, value: Any) -> None: + mock_state._data[key] = value + + def mock_has(key: str) -> bool: + return key in mock_state._data + + def mock_delete(key: str) -> None: + if key in mock_state._data: + del mock_state._data[key] + else: + raise KeyError(key) + + mock_state.get = MagicMock(side_effect=mock_get) + mock_state.set = MagicMock(side_effect=mock_set) + mock_state.has = MagicMock(side_effect=mock_has) + mock_state.delete = MagicMock(side_effect=mock_delete) + + return mock_state + + +@pytest.fixture +def mock_context(mock_state: MagicMock) -> MagicMock: + """Create a mock workflow context.""" + ctx = MagicMock() + ctx.state = mock_state + ctx.send_message = AsyncMock() + ctx.yield_output = AsyncMock() + ctx.request_info = AsyncMock() + return ctx + + +# ============================================================================ +# _normalize_variable_path unit tests (lines 153-155) +# ============================================================================ + + +class TestNormalizeVariablePath: + """Tests for _normalize_variable_path helper.""" + + def test_known_prefix_local(self): + assert _normalize_variable_path("Local.myVar") == "Local.myVar" + + def test_known_prefix_system(self): + assert _normalize_variable_path("System.ConversationId") == "System.ConversationId" + + def test_known_prefix_workflow(self): + assert _normalize_variable_path("Workflow.Inputs.x") == "Workflow.Inputs.x" + + def test_known_prefix_agent(self): + assert _normalize_variable_path("Agent.LastResponse") == "Agent.LastResponse" + + def test_known_prefix_conversation(self): + assert _normalize_variable_path("Conversation.messages") == "Conversation.messages" + + def test_dotted_unknown_prefix(self): + """Dotted path without a known prefix is returned as-is.""" + assert _normalize_variable_path("Custom.myVar") == "Custom.myVar" + + def test_bare_name_gets_local_prefix(self): + """Bare name without any dots defaults to Local. prefix.""" + assert _normalize_variable_path("weatherResult") == "Local.weatherResult" + + def test_bare_name_with_underscore(self): + assert _normalize_variable_path("my_var") == "Local.my_var" + + +# ============================================================================ +# Non-dict output config (line 275) +# ============================================================================ + + +class TestNonDictOutputConfig: + """Tests for non-dict output config handling.""" + + @pytest.mark.asyncio + async def test_output_as_string_is_ignored(self): + """When output is a string instead of dict, both vars should be None.""" + + def noop() -> str: + return "done" + + action_def = { + "kind": "InvokeFunctionTool", + "id": "test_nondictoutput", + "functionName": "noop", + "arguments": {}, + "output": "Local.result", # wrong: should be dict + } + + executor = InvokeFunctionToolExecutor(action_def, tools={"noop": noop}) + messages_var, result_var, auto_send = executor._get_output_config() + assert messages_var is None + assert result_var is None + assert auto_send is True + + @pytest.mark.asyncio + async def test_output_as_list_is_ignored(self): + """When output is a list instead of dict, both vars should be None.""" + + def noop() -> str: + return "done" + + action_def = { + "kind": "InvokeFunctionTool", + "id": "test_listoutput", + "functionName": "noop", + "arguments": {}, + "output": ["Local.result"], + } + + executor = InvokeFunctionToolExecutor(action_def, tools={"noop": noop}) + messages_var, result_var, auto_send = executor._get_output_config() + assert messages_var is None + assert result_var is None + assert auto_send is True + + +# ============================================================================ +# Non-callable tool error (line 696) +# ============================================================================ + + +class TestNonCallableTool: + """Tests for non-callable tool invocation.""" + + @pytest.mark.asyncio + async def test_non_callable_stores_error(self): + """Non-callable tool should produce an error result.""" + yaml_def = { + "name": "non_callable_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_noncallable", + "functionName": "not_a_func", + "arguments": {}, + "output": {"result": "Local.result"}, + }, + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.result.error"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"not_a_func": "i_am_a_string"}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert any("not callable" in out.lower() for out in outputs) + + +# ============================================================================ +# Non-dict arguments warning (line 491) +# ============================================================================ + + +class TestNonDictArguments: + """Tests for non-dict arguments handling.""" + + @pytest.mark.asyncio + async def test_non_dict_arguments_ignored(self): + """When arguments is not a dict, it should be ignored with a warning.""" + + def no_args_needed() -> str: + return "ok" + + yaml_def = { + "name": "nondict_args_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_with_bad_args", + "functionName": "no_args_needed", + "arguments": "invalid_string_args", + "output": {"result": "Local.result"}, + }, + {"kind": "SendActivity", "id": "output", "activity": {"text": "=Local.result"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"no_args_needed": no_args_needed}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + assert "ok" in outputs + + +# ============================================================================ +# JSON serialization fallbacks (lines 351-353, 369-371) +# ============================================================================ + + +class TestFormatMessagesSerialization: + """Tests for JSON serialization fallbacks in _format_messages.""" + + @pytest.mark.asyncio + async def test_non_serializable_result_uses_str_fallback(self): + """When the function returns a non-JSON-serializable object, str() is used.""" + + class CustomObj: + def __str__(self): + return "custom_string_repr" + + def returns_custom() -> object: + return CustomObj() + + yaml_def = { + "name": "nonserializable_result_test", + "actions": [ + { + "kind": "InvokeFunctionTool", + "id": "call_custom", + "functionName": "returns_custom", + "arguments": {}, + "output": {"messages": "Local.msgs", "result": "Local.result"}, + }, + {"kind": "SendActivity", "id": "done", "activity": {"text": "Done"}}, + ], + } + + builder = DeclarativeWorkflowBuilder(yaml_def, tools={"returns_custom": returns_custom}) + workflow = builder.build() + + events = await workflow.run({}) + outputs = events.get_outputs() + + # Should complete without crashing + assert "Done" in outputs + + @pytest.mark.asyncio + async def test_format_messages_directly_with_non_serializable(self): + """Directly test _format_messages with non-serializable arguments and result.""" + + class Unserializable: + def __str__(self): + return "unserializable_obj" + + action_def = { + "kind": "InvokeFunctionTool", + "id": "test_serialize", + "functionName": "dummy", + } + executor = InvokeFunctionToolExecutor(action_def, tools={}) + + # Non-serializable arguments + messages = await executor._format_messages( + function_name="test_func", + arguments={"obj": Unserializable()}, + result=Unserializable(), + ) + + # Should produce 2 messages (tool_call + tool_result) without crashing + assert len(messages) == 2 + assert messages[0].role == "assistant" + assert messages[1].role == "tool" + + +# ============================================================================ +# Approval flow tests (lines 512-532, 557-613) +# ============================================================================ + + +class TestApprovalFlow: + """Tests for the requireApproval=true flow with yield/resume pattern.""" + + def _init_state(self, mock_state: MagicMock) -> None: + """Pre-populate the state with declarative workflow data so _ensure_state_initialized works.""" + from agent_framework_declarative._workflows import DECLARATIVE_STATE_KEY + + mock_state._data[DECLARATIVE_STATE_KEY] = { + "Inputs": {}, + "Outputs": {}, + "Local": {}, + "System": { + "ConversationId": "test-conv", + "LastMessage": {"Text": "", "Id": ""}, + "LastMessageText": "", + "LastMessageId": "", + }, + "Agent": {}, + "Conversation": {"messages": [], "history": []}, + } + + @pytest.mark.asyncio + async def test_approval_required_emits_request(self, mock_state, mock_context): + """When requireApproval=true, handle_action should emit ToolApprovalRequest and return.""" + self._init_state(mock_state) + + def my_tool(x: int) -> int: + return x * 2 + + action_def = { + "kind": "InvokeFunctionTool", + "id": "approval_test", + "functionName": "my_tool", + "requireApproval": True, + "arguments": {"x": 5}, + "output": {"result": "Local.result"}, + } + + executor = InvokeFunctionToolExecutor(action_def, tools={"my_tool": my_tool}) + + await executor.handle_action(ActionTrigger(), mock_context) + + # Should have called request_info with ToolApprovalRequest + mock_context.request_info.assert_called_once() + request = mock_context.request_info.call_args[0][0] + assert isinstance(request, ToolApprovalRequest) + assert request.function_name == "my_tool" + assert request.arguments == {"x": 5} + + # Should NOT have sent ActionComplete (workflow yields) + mock_context.send_message.assert_not_called() + + # Approval state should be saved in state + approval_key = f"{TOOL_APPROVAL_STATE_KEY}_approval_test" + saved_state = mock_state._data[approval_key] + assert isinstance(saved_state, ToolApprovalState) + assert saved_state.function_name == "my_tool" + assert saved_state.arguments == {"x": 5} + + @pytest.mark.asyncio + async def test_approval_response_approved(self, mock_state, mock_context): + """When approval response is approved, the tool should be invoked.""" + self._init_state(mock_state) + + call_log = [] + + def my_tool(x: int) -> int: + call_log.append(x) + return x * 2 + + action_def = { + "kind": "InvokeFunctionTool", + "id": "approval_approved", + "functionName": "my_tool", + "requireApproval": True, + "arguments": {"x": 7}, + "output": {"result": "Local.result"}, + } + + executor = InvokeFunctionToolExecutor(action_def, tools={"my_tool": my_tool}) + + # Pre-populate approval state (simulating what handle_action stores) + approval_key = f"{TOOL_APPROVAL_STATE_KEY}_approval_approved" + mock_state._data[approval_key] = ToolApprovalState( + function_name="my_tool", + arguments={"x": 7}, + output_messages_var=None, + output_result_var="Local.result", + auto_send=True, + ) + + # Simulate the response + original_request = ToolApprovalRequest( + request_id="req-123", + function_name="my_tool", + arguments={"x": 7}, + ) + response = ToolApprovalResponse(approved=True) + + await executor.handle_approval_response(original_request, response, mock_context) + + # Tool should have been called + assert call_log == [7] + + # ActionComplete should have been sent + mock_context.send_message.assert_called_once() + sent = mock_context.send_message.call_args[0][0] + assert isinstance(sent, ActionComplete) + + # Approval state should be cleaned up + assert approval_key not in mock_state._data + + @pytest.mark.asyncio + async def test_approval_response_rejected(self, mock_state, mock_context): + """When approval response is rejected, rejection status should be stored.""" + self._init_state(mock_state) + + def my_tool(x: int) -> int: + raise AssertionError("Should not be called when rejected") + + action_def = { + "kind": "InvokeFunctionTool", + "id": "approval_rejected", + "functionName": "my_tool", + "requireApproval": True, + "arguments": {"x": 5}, + "output": {"result": "Local.result"}, + } + + executor = InvokeFunctionToolExecutor(action_def, tools={"my_tool": my_tool}) + + # Pre-populate approval state + approval_key = f"{TOOL_APPROVAL_STATE_KEY}_approval_rejected" + mock_state._data[approval_key] = ToolApprovalState( + function_name="my_tool", + arguments={"x": 5}, + output_messages_var=None, + output_result_var="Local.result", + auto_send=True, + ) + + original_request = ToolApprovalRequest( + request_id="req-456", + function_name="my_tool", + arguments={"x": 5}, + ) + response = ToolApprovalResponse(approved=False, reason="Not authorized") + + await executor.handle_approval_response(original_request, response, mock_context) + + # ActionComplete should have been sent + mock_context.send_message.assert_called_once() + + # Result var should contain rejection info + state_data = mock_state._data.get(DECLARATIVE_STATE_KEY, {}) + local_data = state_data.get("Local", {}) + result = local_data.get("result") + assert result is not None + assert result["rejected"] is True + assert result["reason"] == "Not authorized" + assert result["approved"] is False + + @pytest.mark.asyncio + async def test_approval_response_missing_state(self, mock_state, mock_context): + """When approval state is missing on resume, should log error and complete.""" + self._init_state(mock_state) + + action_def = { + "kind": "InvokeFunctionTool", + "id": "missing_state_test", + "functionName": "my_tool", + "requireApproval": True, + "output": {"result": "Local.result"}, + } + + executor = InvokeFunctionToolExecutor(action_def, tools={}) + + # Don't populate approval state - simulate missing state + original_request = ToolApprovalRequest( + request_id="req-789", + function_name="my_tool", + arguments={}, + ) + response = ToolApprovalResponse(approved=True) + + await executor.handle_approval_response(original_request, response, mock_context) + + # Should still send ActionComplete + mock_context.send_message.assert_called_once() + sent = mock_context.send_message.call_args[0][0] + assert isinstance(sent, ActionComplete) + + +# ============================================================================ +# State registry tool lookup (lines 255-257) +# ============================================================================ + + +class TestStateRegistryLookup: + """Tests for tool lookup from State registry.""" + + @pytest.mark.asyncio + async def test_tool_found_in_state_registry(self, mock_state, mock_context): + """Tool should be found from State registry when not in constructor tools.""" + self._init_state(mock_state) + + def state_registered_tool() -> str: + return "from_state" + + # Register tool in State registry + mock_state._data[FUNCTION_TOOL_REGISTRY_KEY] = {"state_tool": state_registered_tool} + + action_def = { + "kind": "InvokeFunctionTool", + "id": "state_lookup", + "functionName": "state_tool", + "arguments": {}, + "output": {"result": "Local.result"}, + } + + # Empty constructor tools - should fall back to State registry + executor = InvokeFunctionToolExecutor(action_def, tools={}) + + tool = executor._get_tool("state_tool", mock_context) + assert tool is state_registered_tool + + def _init_state(self, mock_state: MagicMock) -> None: + from agent_framework_declarative._workflows import DECLARATIVE_STATE_KEY + + mock_state._data[DECLARATIVE_STATE_KEY] = { + "Inputs": {}, + "Outputs": {}, + "Local": {}, + "System": { + "ConversationId": "test-conv", + "LastMessage": {"Text": "", "Id": ""}, + "LastMessageText": "", + "LastMessageId": "", + }, + "Agent": {}, + "Conversation": {"messages": [], "history": []}, + } + + @pytest.mark.asyncio + async def test_tool_not_found_in_state_registry_key_error(self, mock_state, mock_context): + """When State registry key doesn't exist, should return None.""" + # Don't populate FUNCTION_TOOL_REGISTRY_KEY - will raise KeyError + + action_def = { + "kind": "InvokeFunctionTool", + "id": "missing_registry", + "functionName": "missing", + } + + executor = InvokeFunctionToolExecutor(action_def, tools={}) + + tool = executor._get_tool("missing", mock_context) + assert tool is None + + @pytest.mark.asyncio + async def test_tool_not_in_registry_returns_none(self, mock_state, mock_context): + """When State registry exists but tool isn't in it, should return None.""" + mock_state._data[FUNCTION_TOOL_REGISTRY_KEY] = {"other_tool": lambda: None} + + action_def = { + "kind": "InvokeFunctionTool", + "id": "wrong_name", + "functionName": "missing", + } + + executor = InvokeFunctionToolExecutor(action_def, tools={}) + + tool = executor._get_tool("missing", mock_context) + assert tool is None + + +# ============================================================================ +# Missing/empty functionName at runtime (lines 470-475, 482) +# ============================================================================ + + +class TestMissingFunctionNameRuntime: + """Tests for missing/empty functionName at runtime with result_var.""" + + def _init_state(self, mock_state: MagicMock) -> None: + from agent_framework_declarative._workflows import DECLARATIVE_STATE_KEY + + mock_state._data[DECLARATIVE_STATE_KEY] = { + "Inputs": {}, + "Outputs": {}, + "Local": {}, + "System": { + "ConversationId": "test-conv", + "LastMessage": {"Text": "", "Id": ""}, + "LastMessageText": "", + "LastMessageId": "", + }, + "Agent": {}, + "Conversation": {"messages": [], "history": []}, + } + + @pytest.mark.asyncio + async def test_missing_function_name_stores_error_in_result_var(self, mock_state, mock_context): + """Missing functionName should store error in result_var and complete.""" + self._init_state(mock_state) + + action_def = { + "kind": "InvokeFunctionTool", + "id": "no_name", + # No functionName field + "output": {"result": "Local.errorResult"}, + } + + executor = InvokeFunctionToolExecutor(action_def, tools={}) + + await executor.handle_action(ActionTrigger(), mock_context) + + # Should send ActionComplete + mock_context.send_message.assert_called_once() + sent = mock_context.send_message.call_args[0][0] + assert isinstance(sent, ActionComplete) + + # Error should be stored in result_var + state_data = mock_state._data.get("_declarative_workflow_state", {}) + local_data = state_data.get("Local", {}) + assert "error" in local_data.get("errorResult", {}) + + @pytest.mark.asyncio + async def test_empty_function_name_with_result_var(self, mock_state, mock_context): + """Empty functionName expression should store error in result_var.""" + self._init_state(mock_state) + + # Pre-set an empty value for toolName + mock_state._data["_declarative_workflow_state"]["Local"]["toolName"] = "" + + action_def = { + "kind": "InvokeFunctionTool", + "id": "empty_name", + "functionName": "=Local.toolName", + "output": {"result": "Local.errorResult"}, + } + + executor = InvokeFunctionToolExecutor(action_def, tools={}) + + await executor.handle_action(ActionTrigger(), mock_context) + + # Should send ActionComplete + mock_context.send_message.assert_called_once() + + # Error should be stored in result_var + state_data = mock_state._data.get("_declarative_workflow_state", {}) + local_data = state_data.get("Local", {}) + assert "error" in local_data.get("errorResult", {}) diff --git a/python/packages/declarative/tests/test_graph_coverage.py b/python/packages/declarative/tests/test_graph_coverage.py index a8115e832d..2088162a28 100644 --- a/python/packages/declarative/tests/test_graph_coverage.py +++ b/python/packages/declarative/tests/test_graph_coverage.py @@ -21,6 +21,15 @@ from agent_framework_declarative._workflows._declarative_base import ( LoopIterationResult, ) +try: + import powerfx # noqa: F401 + + _powerfx_available = True +except (ImportError, RuntimeError): + _powerfx_available = False + +_requires_powerfx = pytest.mark.skipif(not _powerfx_available, reason="PowerFx engine not available") + # --------------------------------------------------------------------------- # Fixtures # --------------------------------------------------------------------------- @@ -250,6 +259,7 @@ class TestDeclarativeWorkflowStateExtended: result = state.eval([1, 2, 3]) # type: ignore[arg-type] assert result == [1, 2, 3] + @_requires_powerfx async def test_eval_simple_and_operator(self, mock_state): """Test simple And operator evaluation.""" state = DeclarativeWorkflowState(mock_state) @@ -264,6 +274,7 @@ class TestDeclarativeWorkflowStateExtended: result = state.eval("=Local.a And Local.b") assert result is True + @_requires_powerfx async def test_eval_simple_or_operator(self, mock_state): """Test simple Or operator evaluation.""" state = DeclarativeWorkflowState(mock_state) @@ -278,6 +289,7 @@ class TestDeclarativeWorkflowStateExtended: result = state.eval("=Local.a Or Local.b") assert result is False + @_requires_powerfx async def test_eval_negation(self, mock_state): """Test negation (!) evaluation.""" state = DeclarativeWorkflowState(mock_state) @@ -287,6 +299,7 @@ class TestDeclarativeWorkflowStateExtended: result = state.eval("=!Local.flag") assert result is False + @_requires_powerfx async def test_eval_not_function(self, mock_state): """Test Not() function evaluation.""" state = DeclarativeWorkflowState(mock_state) @@ -296,6 +309,7 @@ class TestDeclarativeWorkflowStateExtended: result = state.eval("=Not(Local.flag)") assert result is False + @_requires_powerfx async def test_eval_comparison_operators(self, mock_state): """Test comparison operators.""" state = DeclarativeWorkflowState(mock_state) @@ -310,6 +324,7 @@ class TestDeclarativeWorkflowStateExtended: assert state.eval("=Local.x <> Local.y") is True assert state.eval("=Local.x = 5") is True + @_requires_powerfx async def test_eval_arithmetic_operators(self, mock_state): """Test arithmetic operators.""" state = DeclarativeWorkflowState(mock_state) @@ -322,6 +337,7 @@ class TestDeclarativeWorkflowStateExtended: assert state.eval("=Local.x * Local.y") == 30 assert state.eval("=Local.x / Local.y") == pytest.approx(3.333, rel=0.01) + @_requires_powerfx async def test_eval_string_literal(self, mock_state): """Test string literal evaluation.""" state = DeclarativeWorkflowState(mock_state) @@ -330,6 +346,7 @@ class TestDeclarativeWorkflowStateExtended: result = state.eval('="hello world"') assert result == "hello world" + @_requires_powerfx async def test_eval_float_literal(self, mock_state): """Test float literal evaluation.""" from decimal import Decimal @@ -341,6 +358,7 @@ class TestDeclarativeWorkflowStateExtended: # Accepts both float (Python fallback) and Decimal (pythonnet/PowerFx) assert result == 3.14 or result == Decimal("3.14") + @_requires_powerfx async def test_eval_variable_reference_with_namespace_mappings(self, mock_state): """Test variable reference with PowerFx symbols.""" state = DeclarativeWorkflowState(mock_state) @@ -355,6 +373,7 @@ class TestDeclarativeWorkflowStateExtended: result = state.eval("=Workflow.Inputs.query") assert result == "test" + @_requires_powerfx async def test_eval_if_expression_with_dict(self, mock_state): """Test eval_if_expression recursively evaluates dicts.""" state = DeclarativeWorkflowState(mock_state) @@ -364,6 +383,7 @@ class TestDeclarativeWorkflowStateExtended: result = state.eval_if_expression({"greeting": "=Local.name", "static": "hello"}) assert result == {"greeting": "Alice", "static": "hello"} + @_requires_powerfx async def test_eval_if_expression_with_list(self, mock_state): """Test eval_if_expression recursively evaluates lists.""" state = DeclarativeWorkflowState(mock_state) @@ -449,6 +469,7 @@ class TestBasicExecutorsCoverage: result = state.get("Local.nested") assert result == 42 + @_requires_powerfx async def test_set_text_variable_executor(self, mock_context, mock_state): """Test SetTextVariableExecutor.""" from agent_framework_declarative._workflows._executors_basic import ( @@ -591,6 +612,7 @@ class TestBasicExecutorsCoverage: mock_context.yield_output.assert_called_once_with("Plain text message") + @_requires_powerfx async def test_send_activity_with_expression(self, mock_context, mock_state): """Test SendActivityExecutor evaluates expressions.""" from agent_framework_declarative._workflows._executors_basic import ( @@ -909,6 +931,7 @@ class TestAgentExecutorsCoverage: assert result_prop == "Local.result" assert auto_send is False + @_requires_powerfx async def test_agent_executor_build_input_text_from_string_messages(self, mock_context, mock_state): """Test _build_input_text with string messages expression.""" from agent_framework_declarative._workflows._executors_agents import ( @@ -925,6 +948,7 @@ class TestAgentExecutorsCoverage: input_text = await executor._build_input_text(state, {}, "=Local.userInput") assert input_text == "Hello agent!" + @_requires_powerfx async def test_agent_executor_build_input_text_from_message_list(self, mock_context, mock_state): """Test _build_input_text extracts text from message list.""" from agent_framework_declarative._workflows._executors_agents import ( @@ -948,6 +972,7 @@ class TestAgentExecutorsCoverage: input_text = await executor._build_input_text(state, {}, "=Conversation.messages") assert input_text == "Last message" + @_requires_powerfx async def test_agent_executor_build_input_text_from_message_with_text_attr(self, mock_context, mock_state): """Test _build_input_text extracts text from message with text attribute.""" from agent_framework_declarative._workflows._executors_agents import ( @@ -1120,83 +1145,6 @@ class TestAgentExecutorsCoverage: parsed = state.get("Local.Parsed") assert parsed == {"status": "ok", "count": 42} - async def test_invoke_tool_executor_not_found(self, mock_context, mock_state): - """Test InvokeToolExecutor when tool not found.""" - from agent_framework_declarative._workflows._executors_agents import ( - InvokeToolExecutor, - ) - - state = DeclarativeWorkflowState(mock_state) - state.initialize() - - action_def = { - "kind": "InvokeTool", - "tool": "MissingTool", - "resultProperty": "Local.result", - } - executor = InvokeToolExecutor(action_def) - - await executor.handle_action(ActionTrigger(), mock_context) - - result = state.get("Local.result") - assert result == {"error": "Tool 'MissingTool' not found in registry"} - - async def test_invoke_tool_executor_sync_tool(self, mock_context, mock_state): - """Test InvokeToolExecutor with synchronous tool.""" - from agent_framework_declarative._workflows._executors_agents import ( - TOOL_REGISTRY_KEY, - InvokeToolExecutor, - ) - - def my_tool(x: int, y: int) -> int: - return x + y - - mock_state._data[TOOL_REGISTRY_KEY] = {"add": my_tool} - - state = DeclarativeWorkflowState(mock_state) - state.initialize() - - action_def = { - "kind": "InvokeTool", - "tool": "add", - "parameters": {"x": 5, "y": 3}, - "resultProperty": "Local.result", - } - executor = InvokeToolExecutor(action_def) - - await executor.handle_action(ActionTrigger(), mock_context) - - result = state.get("Local.result") - assert result == 8 - - async def test_invoke_tool_executor_async_tool(self, mock_context, mock_state): - """Test InvokeToolExecutor with asynchronous tool.""" - from agent_framework_declarative._workflows._executors_agents import ( - TOOL_REGISTRY_KEY, - InvokeToolExecutor, - ) - - async def my_async_tool(input: str) -> str: - return f"Processed: {input}" - - mock_state._data[TOOL_REGISTRY_KEY] = {"process": my_async_tool} - - state = DeclarativeWorkflowState(mock_state) - state.initialize() - - action_def = { - "kind": "InvokeTool", - "tool": "process", - "input": "test data", - "resultProperty": "Local.result", - } - executor = InvokeToolExecutor(action_def) - - await executor.handle_action(ActionTrigger(), mock_context) - - result = state.get("Local.result") - assert result == "Processed: test data" - # --------------------------------------------------------------------------- # Control Flow Executors Tests - Additional coverage @@ -1206,6 +1154,7 @@ class TestAgentExecutorsCoverage: class TestControlFlowCoverage: """Tests for control flow executors covering uncovered code paths.""" + @_requires_powerfx async def test_foreach_with_source_alias(self, mock_context, mock_state): """Test ForeachInitExecutor with 'source' alias (interpreter mode).""" from agent_framework_declarative._workflows._executors_control_flow import ( @@ -1268,6 +1217,7 @@ class TestControlFlowCoverage: assert msg.current_index == 1 assert msg.current_item == "b" + @_requires_powerfx async def test_switch_evaluator_with_value_cases(self, mock_context, mock_state): """Test SwitchEvaluatorExecutor with value/cases schema.""" from agent_framework_declarative._workflows._executors_control_flow import ( @@ -1295,6 +1245,7 @@ class TestControlFlowCoverage: assert msg.matched is True assert msg.branch_index == 1 # Second case matched + @_requires_powerfx async def test_switch_evaluator_default_case(self, mock_context, mock_state): """Test SwitchEvaluatorExecutor falls through to default.""" from agent_framework_declarative._workflows._executors_control_flow import ( @@ -1554,6 +1505,7 @@ class TestControlFlowCoverage: # Should NOT send any message mock_context.send_message.assert_not_called() + @_requires_powerfx async def test_condition_group_evaluator_first_match(self, mock_context, mock_state): """Test ConditionGroupEvaluatorExecutor returns first match.""" from agent_framework_declarative._workflows._executors_control_flow import ( @@ -1579,6 +1531,7 @@ class TestControlFlowCoverage: assert msg.matched is True assert msg.branch_index == 1 # Second condition (x > 5) is first match + @_requires_powerfx async def test_condition_group_evaluator_no_match(self, mock_context, mock_state): """Test ConditionGroupEvaluatorExecutor with no matches.""" from agent_framework_declarative._workflows._executors_control_flow import ( @@ -1603,6 +1556,7 @@ class TestControlFlowCoverage: assert msg.matched is False assert msg.branch_index == -1 + @_requires_powerfx async def test_condition_group_evaluator_boolean_true_condition(self, mock_context, mock_state): """Test ConditionGroupEvaluatorExecutor with boolean True condition.""" from agent_framework_declarative._workflows._executors_control_flow import ( @@ -1626,6 +1580,7 @@ class TestControlFlowCoverage: assert msg.matched is True assert msg.branch_index == 1 + @_requires_powerfx async def test_if_condition_evaluator_true(self, mock_context, mock_state): """Test IfConditionEvaluatorExecutor with true condition.""" from agent_framework_declarative._workflows._executors_control_flow import ( @@ -1646,6 +1601,7 @@ class TestControlFlowCoverage: assert msg.matched is True assert msg.branch_index == 0 # Then branch + @_requires_powerfx async def test_if_condition_evaluator_false(self, mock_context, mock_state): """Test IfConditionEvaluatorExecutor with false condition.""" from agent_framework_declarative._workflows._executors_control_flow import ( @@ -1894,6 +1850,7 @@ class TestHumanInputExecutorsCoverage: class TestAgentExternalLoopCoverage: """Tests for agent executor external loop handling.""" + @_requires_powerfx async def test_agent_executor_with_external_loop(self, mock_context, mock_state): """Test agent executor with external loop that triggers.""" from unittest.mock import patch @@ -1996,39 +1953,13 @@ class TestAgentExternalLoopCoverage: result = state.get("Local.result") assert result == "Direct string response" - async def test_invoke_tool_with_error(self, mock_context, mock_state): - """Test InvokeToolExecutor handles tool errors.""" - from agent_framework_declarative._workflows._executors_agents import ( - TOOL_REGISTRY_KEY, - InvokeToolExecutor, - ) - - def failing_tool(**kwargs): - raise ValueError("Tool error") - - mock_state._data[TOOL_REGISTRY_KEY] = {"bad_tool": failing_tool} - - state = DeclarativeWorkflowState(mock_state) - state.initialize() - - action_def = { - "kind": "InvokeTool", - "tool": "bad_tool", - "resultProperty": "Local.result", - } - executor = InvokeToolExecutor(action_def) - - await executor.handle_action(ActionTrigger(), mock_context) - - result = state.get("Local.result") - assert result == {"error": "Tool error"} - # --------------------------------------------------------------------------- # PowerFx Functions Coverage # --------------------------------------------------------------------------- +@_requires_powerfx class TestPowerFxFunctionsCoverage: """Tests for PowerFx function evaluation coverage.""" @@ -2784,6 +2715,7 @@ class TestBuilderValidation: assert "activity" in str(exc_info.value) +@_requires_powerfx class TestExpressionEdgeCases: """Tests for expression evaluation edge cases.""" @@ -2808,6 +2740,7 @@ class TestExpressionEdgeCases: assert result == 42 +@_requires_powerfx class TestLongMessageTextHandling: """Tests for handling long MessageText results that exceed PowerFx limits.""" diff --git a/python/packages/declarative/tests/test_graph_executors.py b/python/packages/declarative/tests/test_graph_executors.py index 412ef12f76..14ed33db51 100644 --- a/python/packages/declarative/tests/test_graph_executors.py +++ b/python/packages/declarative/tests/test_graph_executors.py @@ -7,7 +7,16 @@ from unittest.mock import AsyncMock, MagicMock import pytest -from agent_framework_declarative._workflows import ( +try: + import powerfx # noqa: F401 + + _powerfx_available = True +except (ImportError, RuntimeError): + _powerfx_available = False + +_requires_powerfx = pytest.mark.skipif(not _powerfx_available, reason="PowerFx engine not available") + +from agent_framework_declarative._workflows import ( # noqa: E402 ALL_ACTION_EXECUTORS, DECLARATIVE_STATE_KEY, ActionComplete, @@ -99,6 +108,7 @@ class TestDeclarativeWorkflowState: result = state.get("Local.items") assert result == ["first", "second"] + @_requires_powerfx @pytest.mark.asyncio async def test_eval_expression(self, mock_state): """Test evaluating expressions.""" @@ -196,6 +206,7 @@ class TestDeclarativeActionExecutor: # Note: ConditionEvaluatorExecutor tests removed - conditions are now evaluated on edges + @_requires_powerfx async def test_foreach_init_with_items(self, mock_context, mock_state): """Test ForeachInitExecutor with items.""" state = DeclarativeWorkflowState(mock_state) @@ -529,6 +540,7 @@ class TestHumanInputExecutors: assert "continue" in request.message.lower() +@_requires_powerfx class TestParseValueExecutor: """Tests for the ParseValue action executor.""" diff --git a/python/packages/declarative/tests/test_graph_workflow_integration.py b/python/packages/declarative/tests/test_graph_workflow_integration.py index b7bd08e60a..d0cba5148b 100644 --- a/python/packages/declarative/tests/test_graph_workflow_integration.py +++ b/python/packages/declarative/tests/test_graph_workflow_integration.py @@ -9,13 +9,27 @@ These tests verify: - Pause/resume capabilities """ +import sys + import pytest -from agent_framework_declarative._workflows import ( +try: + import powerfx # noqa: F401 + + _powerfx_available = True +except (ImportError, RuntimeError): + _powerfx_available = False + +pytestmark = pytest.mark.skipif( + not _powerfx_available or sys.version_info >= (3, 14), + reason="PowerFx engine not available (requires dotnet runtime)", +) + +from agent_framework_declarative._workflows import ( # noqa: E402 ActionTrigger, DeclarativeWorkflowBuilder, ) -from agent_framework_declarative._workflows._factory import WorkflowFactory +from agent_framework_declarative._workflows._factory import WorkflowFactory # noqa: E402 class TestGraphBasedWorkflowExecution: diff --git a/python/packages/declarative/tests/test_powerfx_functions.py b/python/packages/declarative/tests/test_powerfx_functions.py index 050fa96786..6c9752f79c 100644 --- a/python/packages/declarative/tests/test_powerfx_functions.py +++ b/python/packages/declarative/tests/test_powerfx_functions.py @@ -237,6 +237,444 @@ class TestCustomFunctionsRegistry: "Lower", "Concat", "Search", + "If", + "Or", + "And", + "Not", + "AgentMessage", + "ForAll", ] for name in expected: assert name in CUSTOM_FUNCTIONS + + +class TestMessageTextEdgeCases: + """Additional tests for message_text edge cases.""" + + def test_message_text_dict_with_text_attr_content(self): + """Test message with content that has text attribute.""" + + class ContentWithText: # noqa: B903 + def __init__(self, text: str): + self.text = text + + msg = {"role": "assistant", "content": ContentWithText("Hello from text attr")} + assert message_text(msg) == "Hello from text attr" + + def test_message_text_dict_content_non_string(self): + """Test message with non-string content.""" + msg = {"role": "assistant", "content": 42} + assert message_text(msg) == "42" + + def test_message_text_list_with_string_items(self): + """Test message_text with list of strings.""" + result = message_text(["Hello", "World"]) + assert result == "Hello World" + + def test_message_text_list_with_content_objects(self): + """Test message_text with list items having content attribute.""" + + class MessageObj: # noqa: B903 + def __init__(self, content: str): + self.content = content + + msgs = [MessageObj("Hello"), MessageObj("World")] + result = message_text(msgs) + assert result == "Hello World" + + def test_message_text_list_with_content_text_attr(self): + """Test message_text with content having text attribute.""" + + class ContentWithText: # noqa: B903 + def __init__(self, text: str): + self.text = text + + class MessageObj: + def __init__(self, content): + self.content = content + + msgs = [MessageObj(ContentWithText("Part1")), MessageObj(ContentWithText("Part2"))] + result = message_text(msgs) + assert result == "Part1 Part2" + + def test_message_text_list_with_non_string_content(self): + """Test message_text with non-string content in dicts.""" + msgs = [{"content": 123}, {"content": 456}] + result = message_text(msgs) + assert result == "123 456" + + def test_message_text_object_with_text_attr(self): + """Test message_text with object having text attribute.""" + + class ObjWithText: + text = "Direct text" + + result = message_text(ObjWithText()) + assert result == "Direct text" + + def test_message_text_object_with_content_attr(self): + """Test message_text with object having content attribute.""" + + class ObjWithContent: + content = "Direct content" + + result = message_text(ObjWithContent()) + assert result == "Direct content" + + def test_message_text_object_with_non_string_content(self): + """Test message_text with object having non-string content.""" + + class ObjWithContent: + content = None + + result = message_text(ObjWithContent()) + assert result == "" + + def test_message_text_list_with_empty_content_object(self): + """Test message with content object that evaluates to empty.""" + + class MessageObj: + content = None + + result = message_text([MessageObj()]) + assert result == "" + + +class TestAgentMessage: + """Tests for agent_message function.""" + + def test_agent_message_creates_dict(self): + """Test that AgentMessage creates correct dict.""" + from agent_framework_declarative._workflows._powerfx_functions import agent_message + + msg = agent_message("Hello") + assert msg == {"role": "assistant", "content": "Hello"} + + def test_agent_message_with_none(self): + """Test AgentMessage with None.""" + from agent_framework_declarative._workflows._powerfx_functions import agent_message + + msg = agent_message(None) + assert msg == {"role": "assistant", "content": ""} + + +class TestIfFunc: + """Tests for if_func conditional function.""" + + def test_if_true_condition(self): + """Test If with true condition.""" + from agent_framework_declarative._workflows._powerfx_functions import if_func + + assert if_func(True, "yes", "no") == "yes" + + def test_if_false_condition(self): + """Test If with false condition.""" + from agent_framework_declarative._workflows._powerfx_functions import if_func + + assert if_func(False, "yes", "no") == "no" + + def test_if_truthy_value(self): + """Test If with truthy value.""" + from agent_framework_declarative._workflows._powerfx_functions import if_func + + assert if_func(1, "yes", "no") == "yes" + assert if_func("non-empty", "yes", "no") == "yes" + + def test_if_falsy_value(self): + """Test If with falsy value.""" + from agent_framework_declarative._workflows._powerfx_functions import if_func + + assert if_func(0, "yes", "no") == "no" + assert if_func("", "yes", "no") == "no" + assert if_func(None, "yes", "no") == "no" + + def test_if_no_false_value(self): + """Test If with no false value defaults to None.""" + from agent_framework_declarative._workflows._powerfx_functions import if_func + + assert if_func(False, "yes") is None + + +class TestOrFunc: + """Tests for or_func function.""" + + def test_or_all_false(self): + """Test Or with all false values.""" + from agent_framework_declarative._workflows._powerfx_functions import or_func + + assert or_func(False, False, False) is False + + def test_or_one_true(self): + """Test Or with one true value.""" + from agent_framework_declarative._workflows._powerfx_functions import or_func + + assert or_func(False, True, False) is True + + def test_or_all_true(self): + """Test Or with all true values.""" + from agent_framework_declarative._workflows._powerfx_functions import or_func + + assert or_func(True, True, True) is True + + def test_or_empty(self): + """Test Or with no arguments.""" + from agent_framework_declarative._workflows._powerfx_functions import or_func + + assert or_func() is False + + +class TestAndFunc: + """Tests for and_func function.""" + + def test_and_all_true(self): + """Test And with all true values.""" + from agent_framework_declarative._workflows._powerfx_functions import and_func + + assert and_func(True, True, True) is True + + def test_and_one_false(self): + """Test And with one false value.""" + from agent_framework_declarative._workflows._powerfx_functions import and_func + + assert and_func(True, False, True) is False + + def test_and_all_false(self): + """Test And with all false values.""" + from agent_framework_declarative._workflows._powerfx_functions import and_func + + assert and_func(False, False, False) is False + + def test_and_empty(self): + """Test And with no arguments.""" + from agent_framework_declarative._workflows._powerfx_functions import and_func + + assert and_func() is True + + +class TestNotFunc: + """Tests for not_func function.""" + + def test_not_true(self): + """Test Not with true.""" + from agent_framework_declarative._workflows._powerfx_functions import not_func + + assert not_func(True) is False + + def test_not_false(self): + """Test Not with false.""" + from agent_framework_declarative._workflows._powerfx_functions import not_func + + assert not_func(False) is True + + def test_not_truthy(self): + """Test Not with truthy values.""" + from agent_framework_declarative._workflows._powerfx_functions import not_func + + assert not_func(1) is False + assert not_func("text") is False + + def test_not_falsy(self): + """Test Not with falsy values.""" + from agent_framework_declarative._workflows._powerfx_functions import not_func + + assert not_func(0) is True + assert not_func("") is True + assert not_func(None) is True + + +class TestIsBlankEdgeCases: + """Additional tests for is_blank edge cases.""" + + def test_is_blank_empty_dict(self): + """Test that empty dict is blank.""" + assert is_blank({}) is True + + def test_is_blank_non_empty_dict(self): + """Test that non-empty dict is not blank.""" + assert is_blank({"key": "value"}) is False + + +class TestCountRowsEdgeCases: + """Additional tests for count_rows edge cases.""" + + def test_count_rows_dict(self): + """Test counting dict items.""" + assert count_rows({"a": 1, "b": 2, "c": 3}) == 3 + + def test_count_rows_tuple(self): + """Test counting tuple items.""" + assert count_rows((1, 2, 3, 4)) == 4 + + def test_count_rows_non_iterable(self): + """Test counting non-iterable returns 0.""" + assert count_rows(42) == 0 + assert count_rows("string") == 0 + + +class TestFirstLastEdgeCases: + """Additional tests for first/last edge cases.""" + + def test_first_none(self): + """Test first with None.""" + assert first(None) is None + + def test_last_none(self): + """Test last with None.""" + assert last(None) is None + + def test_first_tuple(self): + """Test first with tuple.""" + assert first((1, 2, 3)) == 1 + + def test_last_tuple(self): + """Test last with tuple.""" + assert last((1, 2, 3)) == 3 + + +class TestFindEdgeCases: + """Additional tests for find edge cases.""" + + def test_find_none_substring(self): + """Test find with None substring.""" + assert find(None, "text") is None + + def test_find_none_text(self): + """Test find with None text.""" + assert find("sub", None) is None + + def test_find_both_none(self): + """Test find with both None.""" + assert find(None, None) is None + + +class TestLowerEdgeCases: + """Additional tests for lower edge cases.""" + + def test_lower_none(self): + """Test lower with None.""" + assert lower(None) == "" + + +class TestConcatStrings: + """Tests for concat_strings function.""" + + def test_concat_strings_basic(self): + """Test basic string concatenation.""" + from agent_framework_declarative._workflows._powerfx_functions import concat_strings + + assert concat_strings("Hello", " ", "World") == "Hello World" + + def test_concat_strings_with_none(self): + """Test concat with None values.""" + from agent_framework_declarative._workflows._powerfx_functions import concat_strings + + assert concat_strings("Hello", None, "World") == "HelloWorld" + + def test_concat_strings_empty(self): + """Test concat with no arguments.""" + from agent_framework_declarative._workflows._powerfx_functions import concat_strings + + assert concat_strings() == "" + + +class TestConcatTextEdgeCases: + """Additional tests for concat_text edge cases.""" + + def test_concat_text_none(self): + """Test concat_text with None.""" + assert concat_text(None) == "" + + def test_concat_text_non_list(self): + """Test concat_text with non-list.""" + assert concat_text("single value") == "single value" + + def test_concat_text_with_field_attr(self): + """Test concat_text with field as object attribute.""" + + class Item: # noqa: B903 + def __init__(self, name: str): + self.name = name + + items = [Item("Alice"), Item("Bob")] + assert concat_text(items, field="name", separator=", ") == "Alice, Bob" + + def test_concat_text_with_none_values(self): + """Test concat_text with None values in list.""" + items = [{"name": "Alice"}, {"name": None}, {"name": "Bob"}] + result = concat_text(items, field="name", separator=", ") + assert result == "Alice, , Bob" + + +class TestForAll: + """Tests for for_all function.""" + + def test_for_all_with_list_of_dicts(self): + """Test ForAll with list of dictionaries.""" + from agent_framework_declarative._workflows._powerfx_functions import for_all + + items = [{"name": "Alice"}, {"name": "Bob"}] + result = for_all(items, "expression") + assert result == items + + def test_for_all_with_non_dict_items(self): + """Test ForAll with non-dict items.""" + from agent_framework_declarative._workflows._powerfx_functions import for_all + + items = [1, 2, 3] + result = for_all(items, "expression") + assert result == [1, 2, 3] + + def test_for_all_with_none(self): + """Test ForAll with None.""" + from agent_framework_declarative._workflows._powerfx_functions import for_all + + assert for_all(None, "expression") == [] + + def test_for_all_with_non_list(self): + """Test ForAll with non-list.""" + from agent_framework_declarative._workflows._powerfx_functions import for_all + + assert for_all("not a list", "expression") == [] + + def test_for_all_empty_list(self): + """Test ForAll with empty list.""" + from agent_framework_declarative._workflows._powerfx_functions import for_all + + assert for_all([], "expression") == [] + + +class TestSearchTableEdgeCases: + """Additional tests for search_table edge cases.""" + + def test_search_table_none(self): + """Test search_table with None.""" + assert search_table(None, "value", "column") == [] + + def test_search_table_non_list(self): + """Test search_table with non-list.""" + assert search_table("not a list", "value", "column") == [] + + def test_search_table_with_object_attr(self): + """Test search_table with object attributes.""" + + class Item: # noqa: B903 + def __init__(self, name: str): + self.name = name + + items = [Item("Alice"), Item("Bob"), Item("Charlie")] + result = search_table(items, "Bob", "name") + assert len(result) == 1 + assert result[0].name == "Bob" + + def test_search_table_no_matching_column(self): + """Test search_table when items don't have the column.""" + items = [{"other": "value"}] + result = search_table(items, "value", "name") + assert result == [] + + def test_search_table_empty_value(self): + """Test search_table with empty search value.""" + items = [{"name": "Alice"}, {"name": "Bob"}] + result = search_table(items, "", "name") + # Empty string matches everything + assert len(result) == 2 diff --git a/python/packages/declarative/tests/test_powerfx_yaml_compatibility.py b/python/packages/declarative/tests/test_powerfx_yaml_compatibility.py index 72b2d398c5..9591dc05cb 100644 --- a/python/packages/declarative/tests/test_powerfx_yaml_compatibility.py +++ b/python/packages/declarative/tests/test_powerfx_yaml_compatibility.py @@ -20,7 +20,16 @@ from unittest.mock import MagicMock import pytest -from agent_framework_declarative._workflows._declarative_base import ( +try: + import powerfx # noqa: F401 + + _powerfx_available = True +except (ImportError, RuntimeError): + _powerfx_available = False + +pytestmark = pytest.mark.skipif(not _powerfx_available, reason="PowerFx engine not available") + +from agent_framework_declarative._workflows._declarative_base import ( # noqa: E402 DeclarativeWorkflowState, ) diff --git a/python/packages/declarative/tests/test_workflow_factory.py b/python/packages/declarative/tests/test_workflow_factory.py index abdd56e6f8..25c1249a50 100644 --- a/python/packages/declarative/tests/test_workflow_factory.py +++ b/python/packages/declarative/tests/test_workflow_factory.py @@ -9,6 +9,15 @@ from agent_framework_declarative._workflows._factory import ( WorkflowFactory, ) +try: + import powerfx # noqa: F401 + + _powerfx_available = True +except (ImportError, RuntimeError): + _powerfx_available = False + +_requires_powerfx = pytest.mark.skipif(not _powerfx_available, reason="PowerFx engine not available") + class TestWorkflowFactoryValidation: """Tests for workflow definition validation.""" @@ -58,6 +67,7 @@ actions: assert workflow.name == "minimal-workflow" +@_requires_powerfx class TestWorkflowFactoryExecution: """Tests for workflow execution.""" @@ -204,6 +214,7 @@ actions: assert workflow.name == "file-workflow" +@_requires_powerfx class TestDisplayNameMetadata: """Tests for displayName metadata support.""" @@ -231,3 +242,662 @@ actions: # Should execute successfully with displayName metadata assert len(outputs) >= 1 + + +class TestWorkflowFactoryToolRegistration: + """Tests for tool registration.""" + + def test_register_tool_basic(self): + """Test registering a tool.""" + + def my_tool(x: int) -> int: + return x * 2 + + factory = WorkflowFactory() + result = factory.register_tool("my_tool", my_tool) + + # Should return self for fluent chaining + assert result is factory + assert "my_tool" in factory._tools + assert factory._tools["my_tool"](5) == 10 + + def test_register_multiple_tools(self): + """Test registering multiple tools with fluent chaining.""" + + def add(a: int, b: int) -> int: + return a + b + + def multiply(a: int, b: int) -> int: + return a * b + + factory = WorkflowFactory().register_tool("add", add).register_tool("multiply", multiply) + + assert "add" in factory._tools + assert "multiply" in factory._tools + assert factory._tools["add"](2, 3) == 5 + assert factory._tools["multiply"](2, 3) == 6 + + def test_register_tool_non_callable_raises(self): + """Test that register_tool raises TypeError for non-callable.""" + factory = WorkflowFactory() + + with pytest.raises(TypeError, match="Expected a callable for tool"): + factory.register_tool("bad_tool", "not_a_function") + + def test_register_binding_non_callable_raises(self): + """Test that register_binding raises TypeError for non-callable.""" + factory = WorkflowFactory() + + with pytest.raises(TypeError, match="Expected a callable for binding"): + factory.register_binding("bad_binding", 42) + + +class TestWorkflowFactoryEdgeCases: + """Tests for edge cases in workflow factory.""" + + def test_empty_actions_list(self): + """Test workflow with empty actions list.""" + factory = WorkflowFactory() + with pytest.raises(DeclarativeWorkflowError, match="actions"): + factory.create_workflow_from_yaml(""" +name: empty-actions +actions: [] +""") + + def test_unknown_action_kind(self): + """Test workflow with unknown action kind.""" + factory = WorkflowFactory() + with pytest.raises((DeclarativeWorkflowError, ValueError)): + factory.create_workflow_from_yaml(""" +name: unknown-action +actions: + - kind: UnknownActionType + value: test +""") + + def test_workflow_with_description(self): + """Test workflow with description field.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: described-workflow +description: This is a test workflow +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + assert workflow is not None + assert workflow.name == "described-workflow" + + @_requires_powerfx + @pytest.mark.asyncio + async def test_workflow_with_expression_value(self): + """Test workflow with expression-based value.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: expression-test +actions: + - kind: SetValue + path: Local.x + value: 5 + - kind: SetValue + path: Local.y + value: =Local.x + - kind: SendActivity + activity: + text: =Local.y +""") + + result = await workflow.run({}) + outputs = result.get_outputs() + + assert any("5" in str(o) for o in outputs) + + @_requires_powerfx + @pytest.mark.asyncio + async def test_workflow_with_nested_if(self): + """Test workflow with nested If statements.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: nested-if-test +actions: + - kind: SetValue + path: Local.level + value: 2 + - kind: If + condition: true + then: + - kind: If + condition: true + then: + - kind: SendActivity + activity: + text: Nested condition passed +""") + + result = await workflow.run({}) + outputs = result.get_outputs() + + assert any("Nested condition passed" in str(o) for o in outputs) + + def test_load_from_string_path(self, tmp_path): + """Test loading a workflow from a string file path.""" + workflow_file = tmp_path / "workflow.yaml" + workflow_file.write_text(""" +name: string-path-workflow +actions: + - kind: SetValue + path: Local.loaded + value: true +""") + + factory = WorkflowFactory() + # Pass as string instead of Path object + workflow = factory.create_workflow_from_yaml_path(str(workflow_file)) + + assert workflow is not None + assert workflow.name == "string-path-workflow" + + +@_requires_powerfx +class TestWorkflowFactorySwitch: + """Tests for Switch/Case action.""" + + @pytest.mark.asyncio + async def test_switch_with_matching_case(self): + """Test Switch with a matching case.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: switch-test +actions: + - kind: SetValue + path: Local.color + value: red + - kind: Switch + value: =Local.color + cases: + - match: red + actions: + - kind: SendActivity + activity: + text: Color is red + - match: blue + actions: + - kind: SendActivity + activity: + text: Color is blue +""") + + result = await workflow.run({}) + outputs = result.get_outputs() + + assert any("Color is red" in str(o) for o in outputs) + + @pytest.mark.asyncio + async def test_switch_with_default(self): + """Test Switch falling through to default.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: switch-default-test +actions: + - kind: SetValue + path: Local.color + value: green + - kind: Switch + value: =Local.color + cases: + - match: red + actions: + - kind: SendActivity + activity: + text: Red + - match: blue + actions: + - kind: SendActivity + activity: + text: Blue + default: + - kind: SendActivity + activity: + text: Unknown color +""") + + result = await workflow.run({}) + outputs = result.get_outputs() + + assert any("Unknown color" in str(o) for o in outputs) + + +@_requires_powerfx +class TestWorkflowFactoryMultipleActionTypes: + """Tests for workflows with multiple action types.""" + + @pytest.mark.asyncio + async def test_set_multiple_variables(self): + """Test SetMultipleVariables action.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: multi-set-test +actions: + - kind: SetMultipleVariables + variables: + - path: Local.a + value: 1 + - path: Local.b + value: 2 + - path: Local.c + value: 3 + - kind: SendActivity + activity: + text: Done +""") + + result = await workflow.run({}) + outputs = result.get_outputs() + + assert any("Done" in str(o) for o in outputs) + + @pytest.mark.asyncio + async def test_append_value(self): + """Test AppendValue action.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: append-test +actions: + - kind: SetValue + path: Local.list + value: [] + - kind: AppendValue + path: Local.list + value: first + - kind: AppendValue + path: Local.list + value: second + - kind: SendActivity + activity: + text: Done +""") + + result = await workflow.run({}) + outputs = result.get_outputs() + + assert any("Done" in str(o) for o in outputs) + + @pytest.mark.asyncio + async def test_emit_event(self): + """Test EmitEvent action.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: emit-event-test +actions: + - kind: EmitEvent + event: + name: test_event + data: + message: Hello + - kind: SendActivity + activity: + text: Event emitted +""") + + result = await workflow.run({}) + outputs = result.get_outputs() + + # Workflow should complete + assert any("Event emitted" in str(o) for o in outputs) + + +class TestWorkflowFactoryYamlErrors: + """Tests for YAML parsing error handling.""" + + def test_invalid_yaml_raises(self): + """Test that invalid YAML raises DeclarativeWorkflowError.""" + factory = WorkflowFactory() + with pytest.raises(DeclarativeWorkflowError, match="Invalid YAML"): + factory.create_workflow_from_yaml(""" +name: broken-yaml +actions: + - kind: SetValue + path: Local.x + value: [unclosed bracket +""") + + def test_non_dict_workflow_raises(self): + """Test that non-dict workflow definition raises error.""" + factory = WorkflowFactory() + with pytest.raises(DeclarativeWorkflowError, match="must be a dictionary"): + factory.create_workflow_from_yaml("- just a list item") + + +class TestWorkflowFactoryTriggerFormat: + """Tests for trigger-based workflow format.""" + + def test_trigger_based_workflow(self): + """Test workflow with trigger-based format.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +kind: Workflow +trigger: + kind: OnConversationStart + id: my_trigger + actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + assert workflow is not None + assert workflow.name == "my_trigger" + + def test_trigger_workflow_without_id(self): + """Test trigger workflow without id uses default name.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +kind: Workflow +trigger: + kind: OnConversationStart + actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + assert workflow is not None + assert workflow.name == "declarative_workflow" + + +class TestWorkflowFactoryAgentCreation: + """Tests for agent creation from definitions.""" + + def test_agent_creation_with_file_reference(self, tmp_path): + """Test creating agent from file reference.""" + from unittest.mock import MagicMock + + from agent_framework_declarative import AgentFactory + + # Create a minimal agent YAML file (using Prompt kind) + agent_file = tmp_path / "test_agent.yaml" + agent_file.write_text(""" +kind: Prompt +name: TestAgent +description: A test agent +instructions: You are a test agent. +""") + + # Create a mock client and agent factory + mock_client = MagicMock() + mock_agent = MagicMock() + mock_agent.name = "TestAgent" + mock_client.create_agent.return_value = mock_agent + + agent_factory = AgentFactory(client=mock_client) + + # Create workflow that references the agent + workflow_file = tmp_path / "workflow.yaml" + workflow_file.write_text(f""" +kind: Workflow +agents: + TestAgent: + file: {agent_file.name} +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + factory = WorkflowFactory(agent_factory=agent_factory) + workflow = factory.create_workflow_from_yaml_path(workflow_file) + + assert workflow is not None + assert "TestAgent" in workflow._declarative_agents + + def test_agent_connection_definition_raises(self): + """Test that connection-based agent definition raises error.""" + factory = WorkflowFactory() + with pytest.raises(DeclarativeWorkflowError, match="Connection-based agents"): + factory.create_workflow_from_yaml(""" +kind: Workflow +agents: + MyAgent: + connection: azure-connection +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + def test_invalid_agent_definition_raises(self): + """Test that invalid agent definition raises error.""" + factory = WorkflowFactory() + with pytest.raises(DeclarativeWorkflowError, match="Invalid agent definition"): + factory.create_workflow_from_yaml(""" +kind: Workflow +agents: + MyAgent: + unknown_field: value +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + def test_preregistered_agent_not_overwritten(self): + """Test that pre-registered agents are not overwritten by definitions.""" + + class MockAgent: + name = "PreregisteredAgent" + + factory = WorkflowFactory(agents={"TestAgent": MockAgent()}) + workflow = factory.create_workflow_from_yaml(""" +kind: Workflow +agents: + TestAgent: + kind: Agent + name: OverrideAttempt +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + assert workflow._declarative_agents["TestAgent"].name == "PreregisteredAgent" + + +class TestWorkflowFactoryInputSchema: + """Tests for input schema conversion.""" + + def test_inputs_to_json_schema_basic(self): + """Test basic input schema conversion.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: input-schema-test +inputs: + name: + type: string + description: The user's name + age: + type: integer + description: The user's age +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + schema = workflow.input_schema + assert schema["type"] == "object" + assert "name" in schema["properties"] + assert "age" in schema["properties"] + assert schema["properties"]["name"]["type"] == "string" + assert schema["properties"]["age"]["type"] == "integer" + assert "name" in schema["required"] + assert "age" in schema["required"] + + def test_inputs_schema_with_optional_field(self): + """Test input schema with optional field.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: optional-input-test +inputs: + required_field: + type: string + required: true + optional_field: + type: string + required: false +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + schema = workflow.input_schema + assert "required_field" in schema["required"] + assert "optional_field" not in schema["required"] + + def test_inputs_schema_with_default_value(self): + """Test input schema with default value.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: default-input-test +inputs: + greeting: + type: string + default: Hello +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + schema = workflow.input_schema + assert schema["properties"]["greeting"]["default"] == "Hello" + + def test_inputs_schema_with_enum(self): + """Test input schema with enum values.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: enum-input-test +inputs: + color: + type: string + enum: + - red + - green + - blue +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + schema = workflow.input_schema + assert schema["properties"]["color"]["enum"] == ["red", "green", "blue"] + + def test_inputs_schema_type_mappings(self): + """Test various type mappings in input schema.""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: type-mapping-test +inputs: + str_field: + type: str + int_field: + type: int + float_field: + type: float + bool_field: + type: bool + list_field: + type: list + dict_field: + type: dict +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + schema = workflow.input_schema + assert schema["properties"]["str_field"]["type"] == "string" + assert schema["properties"]["int_field"]["type"] == "integer" + assert schema["properties"]["float_field"]["type"] == "number" + assert schema["properties"]["bool_field"]["type"] == "boolean" + assert schema["properties"]["list_field"]["type"] == "array" + assert schema["properties"]["dict_field"]["type"] == "object" + + def test_inputs_schema_simple_format(self): + """Test simple input format (field: type).""" + factory = WorkflowFactory() + workflow = factory.create_workflow_from_yaml(""" +name: simple-input-test +inputs: + name: string + count: integer +actions: + - kind: SetValue + path: Local.x + value: 1 +""") + + schema = workflow.input_schema + assert schema["properties"]["name"]["type"] == "string" + assert schema["properties"]["count"]["type"] == "integer" + assert "name" in schema["required"] + assert "count" in schema["required"] + + +class TestWorkflowFactoryChaining: + """Tests for fluent method chaining.""" + + def test_fluent_agent_registration(self): + """Test fluent agent registration.""" + + class MockAgent1: + name = "Agent1" + + class MockAgent2: + name = "Agent2" + + factory = WorkflowFactory().register_agent("agent1", MockAgent1()).register_agent("agent2", MockAgent2()) + + assert "agent1" in factory._agents + assert "agent2" in factory._agents + + def test_fluent_binding_registration(self): + """Test fluent binding registration.""" + + def func1(): + return 1 + + def func2(): + return 2 + + factory = WorkflowFactory().register_binding("func1", func1).register_binding("func2", func2) + + assert "func1" in factory._bindings + assert "func2" in factory._bindings + + def test_fluent_mixed_registration(self): + """Test mixed fluent registration.""" + + class MockAgent: + name = "Agent" + + def my_tool(): + return "tool" + + def my_binding(): + return "binding" + + factory = ( + WorkflowFactory() + .register_agent("agent", MockAgent()) + .register_tool("tool", my_tool) + .register_binding("binding", my_binding) + ) + + assert "agent" in factory._agents + assert "tool" in factory._tools + assert "binding" in factory._bindings diff --git a/python/packages/declarative/tests/test_workflow_state.py b/python/packages/declarative/tests/test_workflow_state.py index d1b6002381..c72d85d1ab 100644 --- a/python/packages/declarative/tests/test_workflow_state.py +++ b/python/packages/declarative/tests/test_workflow_state.py @@ -225,6 +225,335 @@ class TestWorkflowStateResetTurn: assert state.get("Workflow.Outputs.result") == "done" +class TestWorkflowStateEvalSimple: + """Tests for _eval_simple fallback PowerFx evaluation.""" + + def test_negation_prefix(self): + """Test negation with ! prefix.""" + state = WorkflowState() + state.set("Local.value", True) + assert state._eval_simple("!Local.value") is False + state.set("Local.value", False) + assert state._eval_simple("!Local.value") is True + + def test_not_function(self): + """Test Not() function.""" + state = WorkflowState() + state.set("Local.flag", True) + assert state._eval_simple("Not(Local.flag)") is False + state.set("Local.flag", False) + assert state._eval_simple("Not(Local.flag)") is True + + def test_and_operator(self): + """Test And operator.""" + state = WorkflowState() + state.set("Local.a", True) + state.set("Local.b", True) + assert state._eval_simple("Local.a And Local.b") is True + state.set("Local.b", False) + assert state._eval_simple("Local.a And Local.b") is False + + def test_or_operator(self): + """Test Or operator.""" + state = WorkflowState() + state.set("Local.a", False) + state.set("Local.b", False) + assert state._eval_simple("Local.a Or Local.b") is False + state.set("Local.b", True) + assert state._eval_simple("Local.a Or Local.b") is True + + def test_or_operator_double_pipe(self): + """Test || operator.""" + state = WorkflowState() + state.set("Local.x", False) + state.set("Local.y", True) + assert state._eval_simple("Local.x || Local.y") is True + + def test_less_than(self): + """Test < comparison.""" + state = WorkflowState() + state.set("Local.num", 5) + assert state._eval_simple("Local.num < 10") is True + assert state._eval_simple("Local.num < 3") is False + + def test_greater_than(self): + """Test > comparison.""" + state = WorkflowState() + state.set("Local.num", 5) + assert state._eval_simple("Local.num > 3") is True + assert state._eval_simple("Local.num > 10") is False + + def test_less_than_or_equal(self): + """Test <= comparison.""" + state = WorkflowState() + state.set("Local.num", 5) + assert state._eval_simple("Local.num <= 5") is True + assert state._eval_simple("Local.num <= 4") is False + + def test_greater_than_or_equal(self): + """Test >= comparison.""" + state = WorkflowState() + state.set("Local.num", 5) + assert state._eval_simple("Local.num >= 5") is True + assert state._eval_simple("Local.num >= 6") is False + + def test_not_equal(self): + """Test <> comparison.""" + state = WorkflowState() + state.set("Local.val", "hello") + assert state._eval_simple('Local.val <> "world"') is True + assert state._eval_simple('Local.val <> "hello"') is False + + def test_equal(self): + """Test = comparison.""" + state = WorkflowState() + state.set("Local.val", "test") + assert state._eval_simple('Local.val = "test"') is True + assert state._eval_simple('Local.val = "other"') is False + + def test_addition_numeric(self): + """Test + operator with numbers.""" + state = WorkflowState() + state.set("Local.a", 3) + state.set("Local.b", 4) + assert state._eval_simple("Local.a + Local.b") == 7.0 + + def test_addition_string_concat(self): + """Test + operator falls back to string concat.""" + state = WorkflowState() + state.set("Local.a", "hello") + state.set("Local.b", "world") + assert state._eval_simple("Local.a + Local.b") == "helloworld" + + def test_addition_with_none(self): + """Test + treats None as 0.""" + state = WorkflowState() + state.set("Local.a", 5) + # Local.b doesn't exist, so it's None + assert state._eval_simple("Local.a + Local.b") == 5.0 + + def test_subtraction(self): + """Test - operator.""" + state = WorkflowState() + state.set("Local.a", 10) + state.set("Local.b", 3) + assert state._eval_simple("Local.a - Local.b") == 7.0 + + def test_subtraction_with_none(self): + """Test - treats None as 0.""" + state = WorkflowState() + state.set("Local.a", 5) + assert state._eval_simple("Local.a - Local.missing") == 5.0 + + def test_multiplication(self): + """Test * operator.""" + state = WorkflowState() + state.set("Local.a", 4) + state.set("Local.b", 5) + assert state._eval_simple("Local.a * Local.b") == 20.0 + + def test_multiplication_with_none(self): + """Test * treats None as 0.""" + state = WorkflowState() + state.set("Local.a", 5) + assert state._eval_simple("Local.a * Local.missing") == 0.0 + + def test_division(self): + """Test / operator.""" + state = WorkflowState() + state.set("Local.a", 20) + state.set("Local.b", 4) + assert state._eval_simple("Local.a / Local.b") == 5.0 + + def test_division_by_zero(self): + """Test / by zero returns None.""" + state = WorkflowState() + state.set("Local.a", 10) + state.set("Local.b", 0) + assert state._eval_simple("Local.a / Local.b") is None + + def test_string_literal_double_quotes(self): + """Test string literal with double quotes.""" + state = WorkflowState() + assert state._eval_simple('"hello world"') == "hello world" + + def test_string_literal_single_quotes(self): + """Test string literal with single quotes.""" + state = WorkflowState() + assert state._eval_simple("'hello world'") == "hello world" + + def test_integer_literal(self): + """Test integer literal.""" + state = WorkflowState() + assert state._eval_simple("42") == 42 + + def test_float_literal(self): + """Test float literal.""" + state = WorkflowState() + assert state._eval_simple("3.14") == 3.14 + + def test_boolean_true_literal(self): + """Test true literal (case insensitive).""" + state = WorkflowState() + assert state._eval_simple("true") is True + assert state._eval_simple("True") is True + assert state._eval_simple("TRUE") is True + + def test_boolean_false_literal(self): + """Test false literal (case insensitive).""" + state = WorkflowState() + assert state._eval_simple("false") is False + assert state._eval_simple("False") is False + assert state._eval_simple("FALSE") is False + + def test_variable_reference(self): + """Test simple variable reference.""" + state = WorkflowState() + state.set("Local.myvar", "myvalue") + assert state._eval_simple("Local.myvar") == "myvalue" + + def test_unknown_expression_returned_as_is(self): + """Test that unknown expressions are returned as-is.""" + state = WorkflowState() + result = state._eval_simple("unknown_identifier") + assert result == "unknown_identifier" + + def test_agent_namespace_reference(self): + """Test Agent namespace variable reference.""" + state = WorkflowState() + state.set_agent_result(text="agent response") + assert state._eval_simple("Agent.text") == "agent response" + + def test_conversation_namespace_reference(self): + """Test Conversation namespace variable reference.""" + state = WorkflowState() + state.add_conversation_message({"role": "user", "content": "hello"}) + result = state._eval_simple("Conversation.messages") + assert len(result) == 1 + + def test_workflow_inputs_reference(self): + """Test Workflow.Inputs reference.""" + state = WorkflowState(inputs={"name": "test"}) + assert state._eval_simple("Workflow.Inputs.name") == "test" + + +class TestWorkflowStateParseFunctionArgs: + """Tests for _parse_function_args helper.""" + + def test_simple_args(self): + """Test parsing simple comma-separated args.""" + state = WorkflowState() + args = state._parse_function_args("1, 2, 3") + assert args == ["1", "2", "3"] + + def test_string_args_with_commas(self): + """Test parsing string args containing commas.""" + state = WorkflowState() + args = state._parse_function_args('"hello, world", "another"') + assert args == ['"hello, world"', '"another"'] + + def test_nested_function_args(self): + """Test parsing nested function calls.""" + state = WorkflowState() + args = state._parse_function_args("Concat(a, b), c") + assert args == ["Concat(a, b)", "c"] + + def test_empty_args(self): + """Test parsing empty args string.""" + state = WorkflowState() + args = state._parse_function_args("") + assert args == [] + + def test_single_arg(self): + """Test parsing single argument.""" + state = WorkflowState() + args = state._parse_function_args("single") + assert args == ["single"] + + def test_deeply_nested_parens(self): + """Test parsing deeply nested parentheses.""" + state = WorkflowState() + args = state._parse_function_args("Func1(Func2(a, b)), c") + assert args == ["Func1(Func2(a, b))", "c"] + + +class TestWorkflowStateEvalIfExpression: + """Tests for eval_if_expression method.""" + + def test_dict_values_evaluated(self): + """Test that dict values are recursively evaluated.""" + state = WorkflowState() + state.set("Local.name", "World") + result = state.eval_if_expression({"greeting": "=Local.name", "static": "value"}) + assert result == {"greeting": "World", "static": "value"} + + def test_list_values_evaluated(self): + """Test that list values are recursively evaluated.""" + state = WorkflowState() + state.set("Local.val", 42) + result = state.eval_if_expression(["=Local.val", "static"]) + assert result == [42, "static"] + + def test_nested_dict_in_list(self): + """Test nested dict in list is evaluated.""" + state = WorkflowState() + state.set("Local.x", 10) + result = state.eval_if_expression([{"key": "=Local.x"}]) + assert result == [{"key": 10}] + + +class TestWorkflowStateSetErrors: + """Tests for set() error handling.""" + + def test_set_workflow_directly_raises(self): + """Test that setting Workflow directly raises error.""" + state = WorkflowState() + with pytest.raises(ValueError, match="Cannot set 'Workflow' directly"): + state.set("Workflow", "value") + + def test_set_unknown_workflow_namespace_raises(self): + """Test that setting unknown Workflow sub-namespace raises.""" + state = WorkflowState() + with pytest.raises(ValueError, match="Unknown Workflow namespace"): + state.set("Workflow.Unknown.path", "value") + + def test_set_namespace_root_raises(self): + """Test that setting namespace root raises error.""" + state = WorkflowState() + with pytest.raises(ValueError, match="Cannot replace entire namespace"): + state.set("Local", "value") + + +class TestWorkflowStateGetEdgeCases: + """Tests for get() edge cases.""" + + def test_get_empty_path(self): + """Test get with empty path returns default.""" + state = WorkflowState() + assert state.get("", "default") == "default" + + def test_get_unknown_namespace(self): + """Test get from unknown namespace returns default.""" + state = WorkflowState() + assert state.get("Unknown.path") is None + assert state.get("Unknown.path", "fallback") == "fallback" + + def test_get_with_object_attribute(self): + """Test get navigates object attributes.""" + state = WorkflowState() + + class MockObj: + attr = "attribute_value" + + state.set("Local.obj", MockObj()) + assert state.get("Local.obj.attr") == "attribute_value" + + def test_get_unknown_workflow_subspace(self): + """Test get from unknown Workflow sub-namespace.""" + state = WorkflowState() + assert state.get("Workflow.Unknown.path") is None + + class TestWorkflowStateConversationIdInit: """Tests that WorkflowState generates a real UUID for System.ConversationId.""" diff --git a/python/samples/02-agents/context_providers/azure_ai_search/azure_ai_with_search_context_agentic.py b/python/samples/02-agents/context_providers/azure_ai_search/azure_ai_with_search_context_agentic.py index 02bac618df..d3c618d8a8 100644 --- a/python/samples/02-agents/context_providers/azure_ai_search/azure_ai_with_search_context_agentic.py +++ b/python/samples/02-agents/context_providers/azure_ai_search/azure_ai_with_search_context_agentic.py @@ -135,6 +135,9 @@ async def main() -> None: async for chunk in agent.run(user_input, stream=True): if chunk.text: print(chunk.text, end="", flush=True) + for content in chunk.contents: + if content.annotations: + print(f"\n[Sources: {content.annotations}]", end="", flush=True) print("\n") diff --git a/python/samples/02-agents/context_providers/azure_ai_search/azure_ai_with_search_context_semantic.py b/python/samples/02-agents/context_providers/azure_ai_search/azure_ai_with_search_context_semantic.py index e9763531fb..2217cefd23 100644 --- a/python/samples/02-agents/context_providers/azure_ai_search/azure_ai_with_search_context_semantic.py +++ b/python/samples/02-agents/context_providers/azure_ai_search/azure_ai_with_search_context_semantic.py @@ -4,7 +4,7 @@ import asyncio import os from agent_framework import Agent -from agent_framework.azure import AzureAIAgentClient, AzureAISearchContextProvider +from agent_framework.azure import AzureAIAgentClient, AzureAISearchContextProvider, AzureOpenAIEmbeddingClient from azure.identity.aio import AzureCliCredential from dotenv import load_dotenv @@ -30,6 +30,8 @@ Prerequisites: - AZURE_SEARCH_INDEX_NAME: Your search index name - AZURE_AI_PROJECT_ENDPOINT: Your Azure AI Foundry project endpoint - AZURE_AI_MODEL_DEPLOYMENT_NAME: Your model deployment name (e.g., "gpt-4o") + - AZURE_OPENAI_EMBEDDING_MODEL_ID: (Optional) Your embedding model for hybrid search (e.g., "text-embedding-3-small") + - AZURE_OPENAI_ENDPOINT: (Optional) Your Azure OpenAI resource URL, required if using an OpenAI embedding model for hybrid search """ # Sample queries to demonstrate RAG @@ -43,12 +45,24 @@ USER_INPUTS = [ async def main() -> None: """Main function demonstrating Azure AI Search semantic mode.""" + credential = AzureCliCredential() + # Get configuration from environment search_endpoint = os.environ["AZURE_SEARCH_ENDPOINT"] search_key = os.environ.get("AZURE_SEARCH_API_KEY") index_name = os.environ["AZURE_SEARCH_INDEX_NAME"] project_endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"] model_deployment = os.environ.get("AZURE_AI_MODEL_DEPLOYMENT_NAME", "gpt-4o") + openai_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT") + embedding_model = os.environ.get("AZURE_OPENAI_EMBEDDING_MODEL_ID", "text-embedding-3-small") + + embedding_client = None + if openai_endpoint and embedding_model: + embedding_client = AzureOpenAIEmbeddingClient( + endpoint=openai_endpoint, + deployment_name=embedding_model, + credential=credential, + ) # Create Azure AI Search context provider with semantic mode (recommended, fast) print("Using SEMANTIC mode (hybrid search + semantic ranking, fast)\n") @@ -57,9 +71,13 @@ async def main() -> None: endpoint=search_endpoint, index_name=index_name, api_key=search_key, # Use api_key for API key auth, or credential for managed identity - credential=AzureCliCredential() if not search_key else None, + credential=credential if not search_key else None, mode="semantic", # Default mode top_k=3, # Retrieve top 3 most relevant documents + embedding_function=embedding_client, # Provide embedding function for hybrid search + vector_field_name="DescriptionVector" + if embedding_client + else None, # Set vector field for hybrid search if using embeddings ) # Create agent with search context provider @@ -68,7 +86,7 @@ async def main() -> None: AzureAIAgentClient( project_endpoint=project_endpoint, model_deployment_name=model_deployment, - credential=AzureCliCredential(), + credential=credential, ) as client, Agent( client=client, diff --git a/python/samples/02-agents/skills/basic_skill/README.md b/python/samples/02-agents/skills/basic_skill/README.md new file mode 100644 index 0000000000..5c810aab06 --- /dev/null +++ b/python/samples/02-agents/skills/basic_skill/README.md @@ -0,0 +1,68 @@ +# Agent Skills Sample + +This sample demonstrates how to use **Agent Skills** with a `FileAgentSkillsProvider` in the Microsoft Agent Framework. + +## What are Agent Skills? + +Agent Skills are modular packages of instructions and resources that enable AI agents to perform specialized tasks. They follow the [Agent Skills specification](https://agentskills.io/) and implement the progressive disclosure pattern: + +1. **Advertise**: Skills are advertised with name + description (~100 tokens per skill) +2. **Load**: Full instructions are loaded on-demand via `load_skill` tool +3. **Resources**: References and other files loaded via `read_skill_resource` tool + +## Skills Included + +### expense-report +Policy-based expense filing with spending limits, receipt requirements, and approval workflows. +- `references/POLICY_FAQ.md` — Detailed expense policy Q&A +- `assets/expense-report-template.md` — Submission template + +## Project Structure + +``` +basic_skills/ +├── basic_file_skills.py +├── README.md +└── skills/ + └── expense-report/ + ├── SKILL.md + ├── references/ + │ └── POLICY_FAQ.md + └── assets/ + └── expense-report-template.md +``` + +## Running the Sample + +### Prerequisites +- An [Azure AI Foundry](https://ai.azure.com/) project with a deployed model (e.g. `gpt-4o-mini`) + +### Environment Variables + +Set the required environment variables in a `.env` file (see `python/.env.example`): + +- `AZURE_AI_PROJECT_ENDPOINT`: Your Azure AI Foundry project endpoint +- `AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME`: The name of your model deployment (defaults to `gpt-4o-mini`) + +### Authentication + +This sample uses `AzureCliCredential` for authentication. Run `az login` in your terminal before running the sample. + +### Run + +```bash +cd python +uv run samples/02-agents/skills/basic_skills/basic_file_skills.py +``` + +### Examples + +The sample runs two examples: + +1. **Expense policy FAQ** — Asks about tip reimbursement; the agent loads the expense-report skill and reads the FAQ resource +2. **Filing an expense report** — Multi-turn conversation to draft an expense report using the template asset + +## Learn More + +- [Agent Skills Specification](https://agentskills.io/) +- [Microsoft Agent Framework Documentation](../../../../../docs/) diff --git a/python/samples/02-agents/skills/basic_skill/basic_skill.py b/python/samples/02-agents/skills/basic_skill/basic_skill.py new file mode 100644 index 0000000000..81cc6c1582 --- /dev/null +++ b/python/samples/02-agents/skills/basic_skill/basic_skill.py @@ -0,0 +1,88 @@ +# Copyright (c) Microsoft. All rights reserved. + +import asyncio +import os +from pathlib import Path + +from agent_framework import Agent, FileAgentSkillsProvider +from agent_framework.azure import AzureOpenAIResponsesClient +from azure.identity import AzureCliCredential +from dotenv import load_dotenv + +# Load environment variables from .env file +load_dotenv() + +""" +Agent Skills Sample + +This sample demonstrates how to use file-based Agent Skills with a FileAgentSkillsProvider. +Agent Skills are modular packages of instructions and resources that extend an agent's +capabilities. They follow the progressive disclosure pattern: + +1. Advertise — skill names and descriptions are injected into the system prompt +2. Load — full instructions are loaded on-demand via the load_skill tool +3. Read resources — supplementary files are read via the read_skill_resource tool + +This sample includes the expense-report skill: + - Policy-based expense filing with references and assets +""" + + +async def main() -> None: + """Run the Agent Skills demo.""" + # --- Configuration --- + endpoint = os.environ["AZURE_AI_PROJECT_ENDPOINT"] + deployment = os.environ.get("AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME", "gpt-4o-mini") + + # --- 1. Create the chat client --- + client = AzureOpenAIResponsesClient( + project_endpoint=endpoint, + deployment_name=deployment, + credential=AzureCliCredential(), + ) + + # --- 2. Create the skills provider --- + # Discovers skills from the 'skills' directory and makes them available to the agent + skills_dir = Path(__file__).parent / "skills" + skills_provider = FileAgentSkillsProvider(skill_paths=str(skills_dir)) + + # --- 3. Create the agent with skills --- + async with Agent( + client=client, + instructions="You are a helpful assistant.", + context_providers=[skills_provider], + ) as agent: + # --- Example 1: Expense policy question (loads FAQ resource) --- + print("Example 1: Checking expense policy FAQ") + print("---------------------------------------") + response1 = await agent.run( + "Are tips reimbursable? I left a 25% tip on a taxi ride and want to know if that's covered." + ) + print(f"Agent: {response1}\n") + + # --- Example 2: Filing an expense report (uses template asset) --- + print("Example 2: Filing an expense report") + print("---------------------------------------") + session = agent.create_session() + response2 = await agent.run( + "I had 3 client dinners and a $1,200 flight last week. " + "Return a draft expense report and ask about any missing details.", + session=session, + ) + print(f"Agent: {response2}\n") + + +if __name__ == "__main__": + asyncio.run(main()) + +""" +Sample output: +Example 1: Checking expense policy FAQ +--------------------------------------- +Agent: Tips up to 20% are reimbursable for meals, taxi/ride-share, and hotel housekeeping. +Since you left a 25% tip, the portion above 20% would require written justification... + +Example 2: Filing an expense report +--------------------------------------- +Agent: Here's a draft expense report based on what you've told me. I'll need a few more details... +""" diff --git a/python/samples/02-agents/skills/basic_skill/skills/expense-report/SKILL.md b/python/samples/02-agents/skills/basic_skill/skills/expense-report/SKILL.md new file mode 100644 index 0000000000..fc6c83cf30 --- /dev/null +++ b/python/samples/02-agents/skills/basic_skill/skills/expense-report/SKILL.md @@ -0,0 +1,40 @@ +--- +name: expense-report +description: File and validate employee expense reports according to Contoso company policy. Use when asked about expense submissions, reimbursement rules, receipt requirements, spending limits, or expense categories. +metadata: + author: contoso-finance + version: "2.1" +--- + +# Expense Report + +## Categories and Limits + +| Category | Limit | Receipt | Approval | +|---|---|---|---| +| Meals — solo | $50/day | >$25 | No | +| Meals — team/client | $75/person | Always | Manager if >$200 total | +| Lodging | $250/night | Always | Manager if >3 nights | +| Ground transport | $100/day | >$15 | No | +| Airfare | Economy | Always | Manager; VP if >$1,500 | +| Conference/training | $2,000/event | Always | Manager + L&D | +| Office supplies | $100 | Yes | No | +| Software/subscriptions | $50/month | Yes | Manager if >$200/year | + +## Filing Process + +1. Collect receipts — must show vendor, date, amount, payment method. +2. Categorize per table above. +3. Use template: [assets/expense-report-template.md](assets/expense-report-template.md). +4. For client/team meals: list attendee names and business purpose. +5. Submit — auto-approved if <$500; manager if $500–$2,000; VP if >$2,000. +6. Reimbursement: 10 business days via direct deposit. + +## Policy Rules + +- Submit within 30 days of transaction. +- Alcohol is never reimbursable. +- Foreign currency: convert to USD at transaction-date rate; note original currency and amount. +- Mixed personal/business travel: only business portion reimbursable; provide comparison quotes. +- Lost receipts (>$25): file Lost Receipt Affidavit from Finance. Max 2 per quarter. +- For policy questions not covered above, consult the FAQ: [references/POLICY_FAQ.md](references/POLICY_FAQ.md). Answers should be based on what this document and the FAQ state. diff --git a/python/samples/02-agents/skills/basic_skill/skills/expense-report/assets/expense-report-template.md b/python/samples/02-agents/skills/basic_skill/skills/expense-report/assets/expense-report-template.md new file mode 100644 index 0000000000..3f7c7dc36c --- /dev/null +++ b/python/samples/02-agents/skills/basic_skill/skills/expense-report/assets/expense-report-template.md @@ -0,0 +1,5 @@ +# Expense Report Template + +| Date | Category | Vendor | Description | Amount (USD) | Original Currency | Original Amount | Attendees | Business Purpose | Receipt Attached | +|------|----------|--------|-------------|--------------|-------------------|-----------------|-----------|------------------|------------------| +| | | | | | | | | | Yes or No | diff --git a/python/samples/02-agents/skills/basic_skill/skills/expense-report/references/POLICY_FAQ.md b/python/samples/02-agents/skills/basic_skill/skills/expense-report/references/POLICY_FAQ.md new file mode 100644 index 0000000000..8e971192f8 --- /dev/null +++ b/python/samples/02-agents/skills/basic_skill/skills/expense-report/references/POLICY_FAQ.md @@ -0,0 +1,55 @@ +# Expense Policy — Frequently Asked Questions + +## Meals + +**Q: Can I expense coffee or snacks during the workday?** +A: Daily coffee/snacks under $10 are not reimbursable (considered personal). Coffee purchased during a client meeting or team working session is reimbursable as a team meal. + +**Q: What if a team dinner exceeds the per-person limit?** +A: The $75/person limit applies as a guideline. Overages up to 20% are accepted with a written justification (e.g., "client dinner at venue chosen by client"). Overages beyond 20% require pre-approval from your VP. + +**Q: Do I need to list every attendee?** +A: Yes. For client meals, list the client's name and company. For team meals, list all employee names. For groups over 10, you may attach a separate attendee list. + +## Travel + +**Q: Can I book a premium economy or business class flight?** +A: Economy class is the standard. Premium economy is allowed for flights over 6 hours. Business class requires VP pre-approval and is generally reserved for flights over 10 hours or medical accommodation. + +**Q: What about ride-sharing (Uber/Lyft) vs. rental cars?** +A: Use ride-sharing for trips under 30 miles round-trip. Rent a car for multi-day travel or when ride-sharing would exceed $100/day. Always choose the compact/standard category unless traveling with 3+ people. + +**Q: Are tips reimbursable?** +A: Tips up to 20% are reimbursable for meals, taxi/ride-share, and hotel housekeeping. Tips above 20% require justification. + +## Lodging + +**Q: What if the $250/night limit isn't enough for the city I'm visiting?** +A: For high-cost cities (New York, San Francisco, London, Tokyo, Sydney), the limit is automatically increased to $350/night. No additional approval is needed. For other locations where rates are unusually high (e.g., during a major conference), request a per-trip exception from your manager before booking. + +**Q: Can I stay with friends/family instead and get a per-diem?** +A: No. Contoso reimburses actual lodging costs only, not per-diems. + +## Subscriptions and Software + +**Q: Can I expense a personal productivity tool?** +A: Software must be directly related to your job function. Tools like IDE licenses, design software, or project management apps are reimbursable. General productivity apps (note-taking, personal calendar) are not, unless your manager confirms a business need in writing. + +**Q: What about annual subscriptions?** +A: Annual subscriptions over $200 require manager approval before purchase. Submit the approval email with your expense report. + +## Receipts and Documentation + +**Q: My receipt is faded/damaged. What do I do?** +A: Try to obtain a duplicate from the vendor. If not possible, submit a Lost Receipt Affidavit (available from the Finance SharePoint site). You're limited to 2 affidavits per quarter. + +**Q: Do I need a receipt for parking meters or tolls?** +A: For amounts under $15, no receipt is required — just note the date, location, and amount. For $15 and above, a receipt or bank/credit card statement excerpt is required. + +## Approval and Reimbursement + +**Q: My manager is on leave. Who approves my report?** +A: Expense reports can be approved by your skip-level manager or any manager designated as an alternate approver in the expense system. + +**Q: Can I submit expenses from a previous quarter?** +A: The standard 30-day window applies. Expenses older than 30 days require a written explanation and VP approval. Expenses older than 90 days are not reimbursable except in extraordinary circumstances (extended leave, medical emergency) with CFO approval. diff --git a/python/samples/03-workflows/README.md b/python/samples/03-workflows/README.md index b72cdce54d..c5abe202ac 100644 --- a/python/samples/03-workflows/README.md +++ b/python/samples/03-workflows/README.md @@ -127,16 +127,18 @@ Orchestration-focused samples (Sequential, Concurrent, Handoff, GroupChat, Magen YAML-based declarative workflows allow you to define multi-agent orchestration patterns without writing Python code. See the [declarative workflows README](./declarative/README.md) for more details on YAML workflow syntax and available actions. -| Sample | File | Concepts | -| -------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------- | -| Conditional Workflow | [declarative/conditional_workflow/](./declarative/conditional_workflow/) | Nested conditional branching based on user input | -| Customer Support | [declarative/customer_support/](./declarative/customer_support/) | Multi-agent customer support with routing | -| Deep Research | [declarative/deep_research/](./declarative/deep_research/) | Research workflow with planning, searching, and synthesis | -| Function Tools | [declarative/function_tools/](./declarative/function_tools/) | Invoking Python functions from declarative workflows | -| Human-in-Loop | [declarative/human_in_loop/](./declarative/human_in_loop/) | Interactive workflows that request user input | -| Marketing | [declarative/marketing/](./declarative/marketing/) | Marketing content generation workflow | -| Simple Workflow | [declarative/simple_workflow/](./declarative/simple_workflow/) | Basic workflow with variable setting, conditionals, and loops | -| Student Teacher | [declarative/student_teacher/](./declarative/student_teacher/) | Student-teacher interaction pattern | +| Sample | File | Concepts | +|---|---|---| +| Agent to Function Tool | [declarative/agent_to_function_tool/](./declarative/agent_to_function_tool/) | Chain agent output to InvokeFunctionTool actions | +| Conditional Workflow | [declarative/conditional_workflow/](./declarative/conditional_workflow/) | Nested conditional branching based on user input | +| Customer Support | [declarative/customer_support/](./declarative/customer_support/) | Multi-agent customer support with routing | +| Deep Research | [declarative/deep_research/](./declarative/deep_research/) | Research workflow with planning, searching, and synthesis | +| Function Tools | [declarative/function_tools/](./declarative/function_tools/) | Invoking Python functions from declarative workflows | +| Human-in-Loop | [declarative/human_in_loop/](./declarative/human_in_loop/) | Interactive workflows that request user input | +| Invoke Function Tool | [declarative/invoke_function_tool/](./declarative/invoke_function_tool/) | Call registered Python functions with InvokeFunctionTool | +| Marketing | [declarative/marketing/](./declarative/marketing/) | Marketing content generation workflow | +| Simple Workflow | [declarative/simple_workflow/](./declarative/simple_workflow/) | Basic workflow with variable setting, conditionals, and loops | +| Student Teacher | [declarative/student_teacher/](./declarative/student_teacher/) | Student-teacher interaction pattern | ### resources diff --git a/python/samples/03-workflows/declarative/README.md b/python/samples/03-workflows/declarative/README.md index 290a297042..defd909b40 100644 --- a/python/samples/03-workflows/declarative/README.md +++ b/python/samples/03-workflows/declarative/README.md @@ -69,6 +69,9 @@ actions: - `InvokeAzureAgent` - Call an Azure AI agent - `InvokePromptAgent` - Call a local prompt agent +### Tool Invocation +- `InvokeFunctionTool` - Call a registered Python function + ### Human-in-Loop - `Question` - Request user input - `WaitForInput` - Pause for external input diff --git a/python/samples/03-workflows/declarative/agent_to_function_tool/main.py b/python/samples/03-workflows/declarative/agent_to_function_tool/main.py new file mode 100644 index 0000000000..55ba77c073 --- /dev/null +++ b/python/samples/03-workflows/declarative/agent_to_function_tool/main.py @@ -0,0 +1,261 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""Agent to Function Tool sample - demonstrates chaining agent output to function tools. + +This sample shows how to: +1. Use InvokeAzureAgent to analyze user input with an AI model +2. Pass the agent's structured output to InvokeFunctionTool actions +3. Chain multiple function tools to process and transform data + +The workflow: +1. Takes a user order request as input +2. Uses an Azure agent to extract structured order data (item, quantity, details) +3. Passes the extracted data to a function tool that calculates the order total +4. Uses another function tool to format the final confirmation message + +Run with: + python -m samples.03-workflows.declarative.agent_to_function_tool.main +""" + +import asyncio +from pathlib import Path +from typing import Any + +from agent_framework.azure import AzureOpenAIChatClient +from agent_framework.declarative import WorkflowFactory +from azure.identity import AzureCliCredential +from pydantic import BaseModel, Field + +# Pricing data for the order calculation +ITEM_PRICES = { + "pizza": {"small": 10.99, "medium": 14.99, "large": 18.99, "default": 14.99}, + "burger": {"small": 6.99, "medium": 8.99, "large": 10.99, "default": 8.99}, + "salad": {"small": 7.99, "medium": 9.99, "large": 11.99, "default": 9.99}, + "sandwich": {"small": 6.99, "medium": 8.99, "large": 10.99, "default": 8.99}, + "pasta": {"small": 11.99, "medium": 14.99, "large": 17.99, "default": 14.99}, +} + +EXTRAS_PRICES = { + "extra cheese": 2.00, + "bacon": 2.50, + "avocado": 1.50, + "mushrooms": 1.00, + "pepperoni": 2.00, +} + +# Agent instructions for order analysis +ORDER_ANALYSIS_INSTRUCTIONS = """You are an order analysis assistant. Analyze the customer's order request and extract: +- item: what they want to order (e.g., "pizza", "burger", "salad") +- quantity: how many (as a number, default to 1 if not specified) +- details: any special requests, modifications, or size (e.g., "large", "extra cheese") +- delivery_address: where to deliver (if mentioned, otherwise empty string) + +Always respond with valid JSON matching the required format.""" + + +# Pydantic model for structured agent output +class OrderAnalysis(BaseModel): + """Structured output from the order analysis agent.""" + + item: str = Field(description="The food item being ordered (e.g., pizza, burger)") + quantity: int = Field(description="Number of items ordered", default=1) + details: str = Field(description="Special requests, size, or modifications") + delivery_address: str = Field(description="Delivery address if provided, empty string otherwise", default="") + + +def calculate_order_total(order_data: dict[str, Any]) -> dict[str, Any]: + """Calculate the total cost of an order based on the agent's structured analysis. + + Args: + order_data: Structured dict from the agent containing order analysis. + + Returns: + Dictionary with pricing breakdown. + """ + # Handle case where order_data might be None or invalid + if not order_data or not isinstance(order_data, dict): + return { + "error": f"Invalid order data: {order_data}", + "subtotal": 0.0, + "tax": 0.0, + "delivery_fee": 0.0, + "total": 0.0, + } + + item = str(order_data.get("item", "")).lower() + quantity = int(order_data.get("quantity", 1)) + details = str(order_data.get("details", "")).lower() + has_delivery = bool(order_data.get("delivery_address")) + + # Determine size from details + size = "default" + for s in ["small", "medium", "large"]: + if s in details: + size = s + break + + # Get base price for item + item_key = None + for key in ITEM_PRICES: + if key in item: + item_key = key + break + + unit_price = ITEM_PRICES[item_key].get(size, ITEM_PRICES[item_key]["default"]) if item_key else 12.99 + + # Calculate extras + extras_total = 0.0 + applied_extras: list[dict[str, Any]] = [] + for extra, price in EXTRAS_PRICES.items(): + if extra in details: + extras_total += price * quantity + applied_extras.append({"name": extra, "price": price}) + + # Calculate totals + subtotal = (unit_price * quantity) + extras_total + tax = round(subtotal * 0.08, 2) # 8% tax + delivery_fee = 5.00 if has_delivery else 0.0 + total = round(subtotal + tax + delivery_fee, 2) + + return { + "item": item, + "quantity": quantity, + "size": size if size != "default" else "regular", + "unit_price": unit_price, + "extras": applied_extras, + "extras_total": extras_total, + "subtotal": round(subtotal, 2), + "tax": tax, + "delivery_fee": delivery_fee, + "total": total, + "has_delivery": has_delivery, + } + + +def format_order_confirmation(order_data: dict[str, Any], order_calculation: dict[str, Any]) -> str: + """Format a human-readable order confirmation message. + + Args: + order_data: Structured dict from the agent with order details. + order_calculation: Pricing calculation from calculate_order_total. + + Returns: + Formatted confirmation message. + """ + calc = order_calculation + + # Handle error case + if "error" in calc: + return f"Sorry, we couldn't process your order: {calc['error']}" + + # Build the confirmation message + qty = int(calc.get("quantity", 1)) + size = calc.get("size", "regular").title() + item = calc.get("item", "item").title() + lines = [ + "=" * 50, + "ORDER CONFIRMATION", + "=" * 50, + "", + f"Item: {qty}x {size} {item}", + f"Unit Price: ${calc.get('unit_price', 0):.2f}", + ] + + # Add extras if any + extras = calc.get("extras", []) + if extras: + lines.append("\nExtras:") + for extra in extras: + lines.append(f" + {extra['name'].title()}: ${extra['price']:.2f} each") + lines.append(f" Extras Total: ${calc.get('extras_total', 0):.2f}") + + lines.extend([ + "", + "-" * 30, + f"Subtotal: ${calc.get('subtotal', 0):.2f}", + f"Tax (8%): ${calc.get('tax', 0):.2f}", + ]) + + if calc.get("has_delivery"): + delivery_address = order_data.get("delivery_address", "Address provided") if order_data else "Address provided" + lines.extend([ + f"Delivery Fee: ${calc.get('delivery_fee', 0):.2f}", + f"Delivery To: {delivery_address}", + ]) + + lines.extend([ + "-" * 30, + f"TOTAL: ${calc.get('total', 0):.2f}", + "=" * 50, + "", + "Thank you for your order!", + ]) + + return "\n".join(lines) + + +async def main(): + """Run the agent to function tool workflow.""" + # Create Azure OpenAI client + chat_client = AzureOpenAIChatClient(credential=AzureCliCredential()) + + # Create the order analysis agent with structured output + order_analysis_agent = chat_client.as_agent( + name="OrderAnalysisAgent", + instructions=ORDER_ANALYSIS_INSTRUCTIONS, + default_options={"response_format": OrderAnalysis}, + ) + + # Agent registry + agents = { + "OrderAnalysisAgent": order_analysis_agent, + } + + # Get the path to the workflow YAML file + workflow_path = Path(__file__).parent / "workflow.yaml" + + # Create the workflow factory with agents and tools + factory = ( + WorkflowFactory(agents=agents) + .register_tool("calculate_order_total", calculate_order_total) + .register_tool("format_order_confirmation", format_order_confirmation) + ) + + # Create the workflow from the YAML definition + workflow = factory.create_workflow_from_yaml_path(workflow_path) + + print("=" * 60) + print("Agent to Function Tool Workflow Demo") + print("=" * 60) + print() + print("This workflow demonstrates:") + print(" 1. Using InvokeAzureAgent to analyze user input") + print(" 2. Passing agent's structured output to InvokeFunctionTool") + print(" 3. Chaining multiple function tools together") + print() + + # Test with different order inputs + test_queries = [ + "I want to order 3 large pizzas with extra cheese for delivery to 123 Main St", + "2 medium burgers with bacon please", + "Can I get a small salad with avocado and mushrooms, pick up", + ] + + for query in test_queries: + print("-" * 60) + print(f"Input: {query}") + print("-" * 60) + + # Run the workflow with streaming to capture output + try: + async for event in workflow.run(query, stream=True): + if event.type == "output" and isinstance(event.data, str): + print(event.data, end="", flush=True) + except Exception as e: + print(f"\nWorkflow error: {type(e).__name__}: {e}") + + print("\n") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/python/samples/03-workflows/declarative/agent_to_function_tool/workflow.yaml b/python/samples/03-workflows/declarative/agent_to_function_tool/workflow.yaml new file mode 100644 index 0000000000..92e127bc12 --- /dev/null +++ b/python/samples/03-workflows/declarative/agent_to_function_tool/workflow.yaml @@ -0,0 +1,56 @@ +# Agent to Function Tool Workflow +# +# This workflow demonstrates chaining an agent invocation with a function tool. +# The agent analyzes user input, and the function tool processes the agent's output. +# +# Flow: +# 1. Receive user query +# 2. Invoke an Azure agent to analyze the query and extract structured data +# 3. Pass the agent's structured output to a function tool for processing +# 4. Return the final result +# +# Example input: +# I want to order 3 large pizzas with extra cheese for delivery to 123 Main St + +kind: Workflow +trigger: + + kind: OnConversationStart + id: agent_to_function_tool_demo + actions: + + # Invoke the order analysis agent to extract structured order data + - kind: InvokeAzureAgent + id: analyze_order + agent: + name: OrderAnalysisAgent + input: + messages: =Workflow.Inputs.input + output: + response: Local.agentResponse + responseObject: Local.orderData + + # Invoke a function tool to calculate order total using the agent's output + - kind: InvokeFunctionTool + id: calculate_order + functionName: calculate_order_total + arguments: + order_data: =Local.orderData + output: + result: Local.orderCalculation + + # Invoke another function tool to format the final confirmation + - kind: InvokeFunctionTool + id: format_confirmation + functionName: format_order_confirmation + arguments: + order_data: =Local.orderData + order_calculation: =Local.orderCalculation + output: + result: Local.confirmation + + # Send the final confirmation to the user + - kind: SendActivity + id: send_confirmation + activity: + text: =Local.confirmation diff --git a/python/samples/03-workflows/declarative/invoke_function_tool/main.py b/python/samples/03-workflows/declarative/invoke_function_tool/main.py new file mode 100644 index 0000000000..a6b251ca53 --- /dev/null +++ b/python/samples/03-workflows/declarative/invoke_function_tool/main.py @@ -0,0 +1,116 @@ +# Copyright (c) Microsoft. All rights reserved. + +"""Invoke Function Tool sample - demonstrates InvokeFunctionTool workflow actions. + +This sample shows how to: +1. Define Python functions that can be called from workflows +2. Register functions with WorkflowFactory.register_tool() +3. Use the InvokeFunctionTool action in YAML to invoke registered functions +4. Pass arguments using expression syntax (=Local.variable) +5. Capture function output in workflow variables + +Run with: + python -m samples.03-workflows.declarative.invoke_function_tool.main +""" + +import asyncio +from pathlib import Path +from typing import Any + +from agent_framework.declarative import WorkflowFactory + + +# Define the function tools that will be registered with the workflow +def get_weather(location: str, unit: str = "F") -> dict[str, Any]: + """Get weather information for a location. + + This is a mock function that returns simulated weather data. + In a real application, this would call a weather API. + + Args: + location: The city or location to get weather for. + unit: Temperature unit ("F" for Fahrenheit, "C" for Celsius). + + Returns: + Dictionary with weather information. + """ + # Simulated weather data + weather_data = { + "Seattle": {"temp": 55, "condition": "rainy"}, + "New York": {"temp": 70, "condition": "partly cloudy"}, + "Los Angeles": {"temp": 85, "condition": "sunny"}, + "Chicago": {"temp": 60, "condition": "windy"}, + } + + data = weather_data.get(location, {"temp": 72, "condition": "unknown"}) + + # Convert to Celsius if requested + temp = data["temp"] + if unit.upper() == "C": + temp = round((temp - 32) * 5 / 9) # type: ignore + + return { + "location": location, + "temp": temp, + "unit": unit.upper(), + "condition": data["condition"], + } + + +def format_message(template: str, data: dict[str, Any]) -> str: + """Format a message template with data. + + Args: + template: A string template with {key} placeholders. + data: Dictionary of values to substitute. + + Returns: + Formatted message string. + """ + try: + return template.format(**data) + except KeyError as e: + return f"Error formatting message: missing key {e}" + + +async def main(): + """Run the invoke function tool workflow.""" + # Get the path to the workflow YAML file + workflow_path = Path(__file__).parent / "workflow.yaml" + + # Create the workflow factory and register our tool functions + factory = ( + WorkflowFactory().register_tool("get_weather", get_weather).register_tool("format_message", format_message) + ) + + # Create the workflow from the YAML definition + workflow = factory.create_workflow_from_yaml_path(workflow_path) + + print("=" * 60) + print("Invoke Function Tool Workflow Demo") + print("=" * 60) + + # Test with different inputs - both location and unit must be provided + # as the workflow expects them in Workflow.Inputs + test_inputs = [ + {"location": "Seattle", "unit": "F"}, + {"location": "New York", "unit": "C"}, + {"location": "Los Angeles", "unit": "F"}, + {"location": "Chicago", "unit": "C"}, + ] + + for inputs in test_inputs: + print(f"\nInput: {inputs}") + print("-" * 40) + + # Run the workflow + events = await workflow.run(inputs) + + # Get the outputs + outputs = events.get_outputs() + for output in outputs: + print(f"Output: {output}") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/python/samples/03-workflows/declarative/invoke_function_tool/workflow.yaml b/python/samples/03-workflows/declarative/invoke_function_tool/workflow.yaml new file mode 100644 index 0000000000..3bf3ad28c2 --- /dev/null +++ b/python/samples/03-workflows/declarative/invoke_function_tool/workflow.yaml @@ -0,0 +1,51 @@ +# Invoke Function Tool Workflow + +name: invoke_function_tool_demo +description: Demonstrates the InvokeFunctionTool action for invoking registered functions + +actions: + # Set up input location + - kind: SetValue + id: set_location + path: Local.location + value: =If(IsBlank(inputs.location), "Seattle", inputs.location) + + # Set up temperature unit + - kind: SetValue + id: set_unit + path: Local.unit + value: =If(IsBlank(inputs.unit), "F", inputs.unit) + + # Invoke the get_weather function tool + - kind: InvokeFunctionTool + id: invoke_weather + functionName: get_weather + arguments: + location: =Local.location + unit: =Local.unit + output: + messages: Local.weatherToolCallItems + result: Local.weatherInfo + autoSend: true + + # Format a human-readable message using another function + - kind: InvokeFunctionTool + id: format_output + functionName: format_message + arguments: + template: "The weather in {location} is {temp}°{unit}" + data: =Local.weatherInfo + output: + result: Local.formattedMessage + + # Output the result + - kind: SendActivity + id: send_weather + activity: + text: =Local.formattedMessage + + # Store the result in workflow outputs + - kind: SetValue + id: set_output + path: Workflow.Outputs.weather + value: =Local.weatherInfo diff --git a/python/uv.lock b/python/uv.lock index 272b26365e..f5c2efd880 100644 --- a/python/uv.lock +++ b/python/uv.lock @@ -59,7 +59,7 @@ overrides = [ [[package]] name = "a2a-sdk" -version = "0.3.23" +version = "0.3.24" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "google-api-core", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -68,9 +68,9 @@ dependencies = [ { name = "protobuf", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/2d/6a/2fe24e0a85240a651006c12f79bdb37156adc760a96c44bc002ebda77916/a2a_sdk-0.3.23.tar.gz", hash = "sha256:7c46b8572c4633a2b41fced2833e11e62871e8539a5b3c782ba2ba1e33d213c2", size = 255265, upload-time = "2026-02-17T08:34:34.648Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ad/76/cefa956fb2d3911cb91552a1da8ce2dbb339f1759cb475e2982f0ae2332b/a2a_sdk-0.3.24.tar.gz", hash = "sha256:3581e6e8a854cd725808f5732f90b7978e661b6d4e227a4755a8f063a3c1599d", size = 255550, upload-time = "2026-02-20T10:05:43.423Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d4/20/77d119f19ab03449d3e6bc0b1f11296d593dae99775c1d891ab1e290e416/a2a_sdk-0.3.23-py3-none-any.whl", hash = "sha256:8c2f01dffbfdd3509eafc15c4684743e6ae75e69a5df5d6f87be214c948e7530", size = 145689, upload-time = "2026-02-17T08:34:33.263Z" }, + { url = "https://files.pythonhosted.org/packages/10/6e/cae5f0caea527b39c0abd7204d9416768764573c76649ca03cc345a372be/a2a_sdk-0.3.24-py3-none-any.whl", hash = "sha256:7b248767096bb55311f57deebf6b767349388d94c1b376c60cb8f6b715e053f6", size = 145752, upload-time = "2026-02-20T10:05:41.729Z" }, ] [[package]] @@ -84,14 +84,14 @@ wheels = [ [[package]] name = "ag-ui-protocol" -version = "0.1.11" +version = "0.1.13" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/a2/c1/33ab11dc829c6c28d0d346988b2f394aa632d3ad63d1d2eb5f16eccd769b/ag_ui_protocol-0.1.11.tar.gz", hash = "sha256:b336dfebb5751e9cc2c676a3008a4bce4819004e6f6f8cba73169823564472ae", size = 6249, upload-time = "2026-02-11T12:41:36.085Z" } +sdist = { url = "https://files.pythonhosted.org/packages/04/b5/fc0b65b561d00d88811c8a7d98ee735833f81554be244340950e7b65820c/ag_ui_protocol-0.1.13.tar.gz", hash = "sha256:811d7d7dcce4783dec252918f40b717ebfa559399bf6b071c4ba47c0c1e21bcb", size = 5671, upload-time = "2026-02-19T18:40:38.602Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/14/83/5c6f4cb24d27d9cbe0c31ba2f3b4d1ff42bc6f87ba9facfa9e9d44046c6b/ag_ui_protocol-0.1.11-py3-none-any.whl", hash = "sha256:b0cc25570462a8eba8e57a098e0a2d6892a1f571a7bea7da2d4b60efd5d66789", size = 8392, upload-time = "2026-02-11T12:41:35.303Z" }, + { url = "https://files.pythonhosted.org/packages/cd/9f/b833c1ab1999da35ebad54841ae85d2c2764c931da9a6f52d8541b6901b2/ag_ui_protocol-0.1.13-py3-none-any.whl", hash = "sha256:1393fa894c1e8416efe184168a50689e760d05b32f4646eebb8ff423dddf8e8f", size = 8053, upload-time = "2026-02-19T18:40:37.27Z" }, ] [[package]] @@ -383,7 +383,7 @@ requires-dist = [ { name = "agent-framework-orchestrations", marker = "extra == 'all'", editable = "packages/orchestrations" }, { name = "agent-framework-purview", marker = "extra == 'all'", editable = "packages/purview" }, { name = "agent-framework-redis", marker = "extra == 'all'", editable = "packages/redis" }, - { name = "azure-ai-projects", specifier = ">=2.0.0b3" }, + { name = "azure-ai-projects", specifier = "==2.0.0b3" }, { name = "azure-identity", specifier = ">=1,<2" }, { name = "mcp", extras = ["ws"], specifier = ">=1.24.0,<2" }, { name = "openai", specifier = ">=1.99.0" }, @@ -886,7 +886,7 @@ wheels = [ [[package]] name = "anthropic" -version = "0.81.0" +version = "0.83.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -898,9 +898,9 @@ dependencies = [ { name = "sniffio", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f3/c2/d2bb9b3c82c386abf3b2c32ae0452a8dcb89ed2809d875e1420bea22e318/anthropic-0.81.0.tar.gz", hash = "sha256:bab2d4e45c2e81a0668fdc2da2f7fd665ed8a0295ba3c86450f9dcc3a7804524", size = 532935, upload-time = "2026-02-18T04:00:54.658Z" } +sdist = { url = "https://files.pythonhosted.org/packages/db/e5/02cd2919ec327b24234abb73082e6ab84c451182cc3cc60681af700f4c63/anthropic-0.83.0.tar.gz", hash = "sha256:a8732c68b41869266c3034541a31a29d8be0f8cd0a714f9edce3128b351eceb4", size = 534058, upload-time = "2026-02-19T19:26:38.904Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/86/27/a18e1613da66b3c9c7565c92457a60de15e824a6dd2ed9bce0fbfe615ded/anthropic-0.81.0-py3-none-any.whl", hash = "sha256:ac54407e9a1f9b35e6e6c86f75bf403f0e54d60944f99f15f685a38d6829f20b", size = 455627, upload-time = "2026-02-18T04:00:53.207Z" }, + { url = "https://files.pythonhosted.org/packages/5f/75/b9d58e4e2a4b1fc3e75ffbab978f999baf8b7c4ba9f96e60edb918ba386b/anthropic-0.83.0-py3-none-any.whl", hash = "sha256:f069ef508c73b8f9152e8850830d92bd5ef185645dbacf234bb213344a274810", size = 456991, upload-time = "2026-02-19T19:26:40.114Z" }, ] [[package]] @@ -1006,15 +1006,15 @@ wheels = [ [[package]] name = "azure-core" -version = "1.38.1" +version = "1.38.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/53/9b/23893febea484ad8183112c9419b5eb904773adb871492b5fa8ff7b21e09/azure_core-1.38.1.tar.gz", hash = "sha256:9317db1d838e39877eb94a2240ce92fa607db68adf821817b723f0d679facbf6", size = 363323, upload-time = "2026-02-11T02:03:06.051Z" } +sdist = { url = "https://files.pythonhosted.org/packages/00/fe/5c7710bc611a4070d06ba801de9a935cc87c3d4b689c644958047bdf2cba/azure_core-1.38.2.tar.gz", hash = "sha256:67562857cb979217e48dc60980243b61ea115b77326fa93d83b729e7ff0482e7", size = 363734, upload-time = "2026-02-18T19:33:05.6Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/db/88/aaea2ad269ce70b446660371286272c1f6ba66541a7f6f635baf8b0db726/azure_core-1.38.1-py3-none-any.whl", hash = "sha256:69f08ee3d55136071b7100de5b198994fc1c5f89d2b91f2f43156d20fcf200a4", size = 217930, upload-time = "2026-02-11T02:03:07.548Z" }, + { url = "https://files.pythonhosted.org/packages/42/23/6371a551800d3812d6019cd813acd985f9fac0fedc1290129211a73da4ae/azure_core-1.38.2-py3-none-any.whl", hash = "sha256:074806c75cf239ea284a33a66827695ef7aeddac0b4e19dda266a93e4665ead9", size = 217957, upload-time = "2026-02-18T19:33:07.696Z" }, ] [[package]] @@ -1330,19 +1330,19 @@ wheels = [ [[package]] name = "claude-agent-sdk" -version = "0.1.37" +version = "0.1.41" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "mcp", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform == 'win32')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/b9/12/c5b09c7fe50cc54bf3a4316059c0e2fb7653fb739f6fb35c9a2e8a363493/claude_agent_sdk-0.1.37.tar.gz", hash = "sha256:5a021582b8b44ca735415b85a2dd8732490f22bc3d51452ede82d7f2db4ee592", size = 61610, upload-time = "2026-02-16T21:50:42.115Z" } +sdist = { url = "https://files.pythonhosted.org/packages/b8/f9/4dfd1cfaa7271956bb86e73259c3a87fc032a03c28333db20aefde8706ab/claude_agent_sdk-0.1.41.tar.gz", hash = "sha256:b2b56875fe9b7b389406b53c9020794caf0a29f2b3597b2eca78a61800f9a914", size = 62440, upload-time = "2026-02-24T06:56:09.223Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/51/61/fdc15695a89cc1f3c4b0e0d714593e00a89094b95fc5dcbec6972a602197/claude_agent_sdk-0.1.37-py3-none-macosx_11_0_arm64.whl", hash = "sha256:c810592bfb2927ba619d01c5588ead0c052452a51052a548fda885ca0dbca7ab", size = 54799463, upload-time = "2026-02-16T21:50:28.258Z" }, - { url = "https://files.pythonhosted.org/packages/d9/3f/8057bd6f2dc6a077c32b9065336ced45c18aff602575c656b492b95b2428/claude_agent_sdk-0.1.37-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:61e821ba330ffc66fe9870c1ae3a76b05f69ac47da4446928ca6fe0569e1d42e", size = 69543239, upload-time = "2026-02-16T21:50:31.642Z" }, - { url = "https://files.pythonhosted.org/packages/d0/7f/d13c843edea7418747127dc5d511968c5f83709737e296e54be40098299e/claude_agent_sdk-0.1.37-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:9814fbf52dd6a3aa070da023187184cf6fc679e88d8b3fd69d72dac55f8cc319", size = 70142154, upload-time = "2026-02-16T21:50:35.353Z" }, - { url = "https://files.pythonhosted.org/packages/62/37/4ef55c5202246ac7c9319bc0b11896be5fd976051eff35109b95a039b76f/claude_agent_sdk-0.1.37-py3-none-win_amd64.whl", hash = "sha256:0934f5eba7598b613ce386cc57b985c7a9f6f1c4a1fba94e587ad84130374258", size = 72673142, upload-time = "2026-02-16T21:50:39.531Z" }, + { url = "https://files.pythonhosted.org/packages/3f/9b/ebb88bb665c2dfea9c21690f56a4397d647be3ed911de173e2f12c2d69ca/claude_agent_sdk-0.1.41-py3-none-macosx_11_0_arm64.whl", hash = "sha256:4484149ac440393a904306016bf2fffec5d2d5a76e6c559d18f3e25699f5ec87", size = 55601983, upload-time = "2026-02-24T06:55:55.695Z" }, + { url = "https://files.pythonhosted.org/packages/f8/33/e5a85efaa716be0325a581446c3f85805719383fff206ca0da54c0d84783/claude_agent_sdk-0.1.41-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:d155772d607f1cffbee6ac6018834aee090e98b2d3a8db52be6302b768e354a7", size = 70326675, upload-time = "2026-02-24T06:55:59.486Z" }, + { url = "https://files.pythonhosted.org/packages/00/f4/52e62853898766b83575e06bfaee1e6306b31a07a3171dc1dfec2738ce5c/claude_agent_sdk-0.1.41-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:24a48725cb764443861bf4eb17af1f6a323c72b39fe1a7d703bf29f744c64ad1", size = 70923548, upload-time = "2026-02-24T06:56:02.776Z" }, + { url = "https://files.pythonhosted.org/packages/75/f9/584dd08c0ea9af2c0b9ba406dad819a167b757ef8d23db8135ba4a7b177f/claude_agent_sdk-0.1.41-py3-none-win_amd64.whl", hash = "sha256:bca68993c0d2663f6046eff9ac26a03fbc4fd0eba210ab8a4a76fb00930cb8a1", size = 73259355, upload-time = "2026-02-24T06:56:06.295Z" }, ] [[package]] @@ -1362,7 +1362,7 @@ name = "clr-loader" version = "0.2.10" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "(python_full_version < '3.14' and sys_platform == 'darwin') or (python_full_version < '3.14' and sys_platform == 'linux') or (python_full_version < '3.14' and sys_platform == 'win32')" }, + { name = "cffi", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/18/24/c12faf3f61614b3131b5c98d3bf0d376b49c7feaa73edca559aeb2aee080/clr_loader-0.2.10.tar.gz", hash = "sha256:81f114afbc5005bafc5efe5af1341d400e22137e275b042a8979f3feb9fc9446", size = 83605, upload-time = "2026-01-03T23:13:06.984Z" } wheels = [ @@ -1801,7 +1801,7 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "asyncio", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "grpcio", version = "1.67.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.14' and sys_platform == 'darwin') or (python_full_version < '3.14' and sys_platform == 'linux') or (python_full_version < '3.14' and sys_platform == 'win32')" }, - { name = "grpcio", version = "1.78.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.14' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform == 'win32')" }, + { name = "grpcio", version = "1.78.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.14' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform == 'win32')" }, { name = "packaging", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "protobuf", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] @@ -1841,7 +1841,7 @@ name = "exceptiongroup" version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform == 'win32')" }, + { name = "typing-extensions", marker = "(python_full_version < '3.13' and sys_platform == 'darwin') or (python_full_version < '3.13' and sys_platform == 'linux') or (python_full_version < '3.13' and sys_platform == 'win32')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } wheels = [ @@ -1859,7 +1859,7 @@ wheels = [ [[package]] name = "fastapi" -version = "0.129.0" +version = "0.133.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "annotated-doc", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -1868,9 +1868,9 @@ dependencies = [ { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-inspection", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/48/47/75f6bea02e797abff1bca968d5997793898032d9923c1935ae2efdece642/fastapi-0.129.0.tar.gz", hash = "sha256:61315cebd2e65df5f97ec298c888f9de30430dd0612d59d6480beafbc10655af", size = 375450, upload-time = "2026-02-12T13:54:52.541Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c2/04/ab382c7c03dd545f2c964d06e87ad0d5faa944a2434186ad9c285f5d87e0/fastapi-0.133.0.tar.gz", hash = "sha256:b900a2bf5685cdb0647a41d5900bdeafc3a9e8a28ac08c6246b76699e164d60d", size = 373265, upload-time = "2026-02-24T09:53:40.143Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/dd/d0ee25348ac58245ee9f90b6f3cbb666bf01f69be7e0911f9851bddbda16/fastapi-0.129.0-py3-none-any.whl", hash = "sha256:b4946880e48f462692b31c083be0432275cbfb6e2274566b1be91479cc1a84ec", size = 102950, upload-time = "2026-02-12T13:54:54.528Z" }, + { url = "https://files.pythonhosted.org/packages/bf/b4/023e75a2ec3f5440e380df6caf4d28edc0806d007193e6fb0707237886a4/fastapi-0.133.0-py3-none-any.whl", hash = "sha256:0a78878483d60702a1dde864c24ab349a1a53ef4db6b6f74f8cd4a2b2bc67d2f", size = 104787, upload-time = "2026-02-24T09:53:41.404Z" }, ] [[package]] @@ -1953,11 +1953,11 @@ wheels = [ [[package]] name = "filelock" -version = "3.24.2" +version = "3.24.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/02/a8/dae62680be63cbb3ff87cfa2f51cf766269514ea5488479d42fec5aa6f3a/filelock-3.24.2.tar.gz", hash = "sha256:c22803117490f156e59fafce621f0550a7a853e2bbf4f87f112b11d469b6c81b", size = 37601, upload-time = "2026-02-16T02:50:45.614Z" } +sdist = { url = "https://files.pythonhosted.org/packages/73/92/a8e2479937ff39185d20dd6a851c1a63e55849e447a55e798cc2e1f49c65/filelock-3.24.3.tar.gz", hash = "sha256:011a5644dc937c22699943ebbfc46e969cdde3e171470a6e40b9533e5a72affa", size = 37935, upload-time = "2026-02-19T00:48:20.543Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e7/04/a94ebfb4eaaa08db56725a40de2887e95de4e8641b9e902c311bfa00aa39/filelock-3.24.2-py3-none-any.whl", hash = "sha256:667d7dc0b7d1e1064dd5f8f8e80bdac157a6482e8d2e02cd16fd3b6b33bd6556", size = 24152, upload-time = "2026-02-16T02:50:44Z" }, + { url = "https://files.pythonhosted.org/packages/9c/0f/5d0c71a1aefeb08efff26272149e07ab922b64f46c63363756224bd6872e/filelock-3.24.3-py3-none-any.whl", hash = "sha256:426e9a4660391f7f8a810d71b0555bce9008b0a1cc342ab1f6947d37639e002d", size = 24331, upload-time = "2026-02-19T00:48:18.465Z" }, ] [[package]] @@ -2249,7 +2249,7 @@ wheels = [ [[package]] name = "google-api-core" -version = "2.29.0" +version = "2.30.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "google-auth", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2258,9 +2258,9 @@ dependencies = [ { name = "protobuf", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/0d/10/05572d33273292bac49c2d1785925f7bc3ff2fe50e3044cf1062c1dde32e/google_api_core-2.29.0.tar.gz", hash = "sha256:84181be0f8e6b04006df75ddfe728f24489f0af57c96a529ff7cf45bc28797f7", size = 177828, upload-time = "2026-01-08T22:21:39.269Z" } +sdist = { url = "https://files.pythonhosted.org/packages/22/98/586ec94553b569080caef635f98a3723db36a38eac0e3d7eb3ea9d2e4b9a/google_api_core-2.30.0.tar.gz", hash = "sha256:02edfa9fab31e17fc0befb5f161b3bf93c9096d99aed584625f38065c511ad9b", size = 176959, upload-time = "2026-02-18T20:28:11.926Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/77/b6/85c4d21067220b9a78cfb81f516f9725ea6befc1544ec9bd2c1acd97c324/google_api_core-2.29.0-py3-none-any.whl", hash = "sha256:d30bc60980daa36e314b5d5a3e5958b0200cb44ca8fa1be2b614e932b75a3ea9", size = 173906, upload-time = "2026-01-08T22:21:36.093Z" }, + { url = "https://files.pythonhosted.org/packages/45/27/09c33d67f7e0dcf06d7ac17d196594e66989299374bfb0d4331d1038e76b/google_api_core-2.30.0-py3-none-any.whl", hash = "sha256:80be49ee937ff9aba0fd79a6eddfde35fe658b9953ab9b79c57dd7061afa8df5", size = 173288, upload-time = "2026-02-18T20:28:10.367Z" }, ] [[package]] @@ -2300,62 +2300,56 @@ wheels = [ [[package]] name = "greenlet" -version = "3.3.1" +version = "3.3.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8a/99/1cd3411c56a410994669062bd73dd58270c00cc074cac15f385a1fd91f8a/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98", size = 184690, upload-time = "2026-01-23T15:31:02.076Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/51/1664f6b78fc6ebbd98019a1fd730e83fa78f2db7058f72b1463d3612b8db/greenlet-3.3.2.tar.gz", hash = "sha256:2eaf067fc6d886931c7962e8c6bede15d2f01965560f3359b27c80bde2d151f2", size = 188267, upload-time = "2026-02-20T20:54:15.531Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/fe/65/5b235b40581ad75ab97dcd8b4218022ae8e3ab77c13c919f1a1dfe9171fd/greenlet-3.3.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:04bee4775f40ecefcdaa9d115ab44736cd4b9c5fba733575bfe9379419582e13", size = 273723, upload-time = "2026-01-23T15:30:37.521Z" }, - { url = "https://files.pythonhosted.org/packages/ce/ad/eb4729b85cba2d29499e0a04ca6fbdd8f540afd7be142fd571eea43d712f/greenlet-3.3.1-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50e1457f4fed12a50e427988a07f0f9df53cf0ee8da23fab16e6732c2ec909d4", size = 574874, upload-time = "2026-01-23T16:00:54.551Z" }, - { url = "https://files.pythonhosted.org/packages/87/32/57cad7fe4c8b82fdaa098c89498ef85ad92dfbb09d5eb713adedfc2ae1f5/greenlet-3.3.1-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:070472cd156f0656f86f92e954591644e158fd65aa415ffbe2d44ca77656a8f5", size = 586309, upload-time = "2026-01-23T16:05:25.18Z" }, - { url = "https://files.pythonhosted.org/packages/66/66/f041005cb87055e62b0d68680e88ec1a57f4688523d5e2fb305841bc8307/greenlet-3.3.1-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1108b61b06b5224656121c3c8ee8876161c491cbe74e5c519e0634c837cf93d5", size = 597461, upload-time = "2026-01-23T16:15:51.943Z" }, - { url = "https://files.pythonhosted.org/packages/87/eb/8a1ec2da4d55824f160594a75a9d8354a5fe0a300fb1c48e7944265217e1/greenlet-3.3.1-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3a300354f27dd86bae5fbf7002e6dd2b3255cd372e9242c933faf5e859b703fe", size = 586985, upload-time = "2026-01-23T15:32:47.968Z" }, - { url = "https://files.pythonhosted.org/packages/15/1c/0621dd4321dd8c351372ee8f9308136acb628600658a49be1b7504208738/greenlet-3.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e84b51cbebf9ae573b5fbd15df88887815e3253fc000a7d0ff95170e8f7e9729", size = 1547271, upload-time = "2026-01-23T16:04:18.977Z" }, - { url = "https://files.pythonhosted.org/packages/9d/53/24047f8924c83bea7a59c8678d9571209c6bfe5f4c17c94a78c06024e9f2/greenlet-3.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e0093bd1a06d899892427217f0ff2a3c8f306182b8c754336d32e2d587c131b4", size = 1613427, upload-time = "2026-01-23T15:33:44.428Z" }, - { url = "https://files.pythonhosted.org/packages/ff/07/ac9bf1ec008916d1a3373cae212884c1dcff4a4ba0d41127ce81a8deb4e9/greenlet-3.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:7932f5f57609b6a3b82cc11877709aa7a98e3308983ed93552a1c377069b20c8", size = 226100, upload-time = "2026-01-23T15:30:56.957Z" }, - { url = "https://files.pythonhosted.org/packages/ec/e8/2e1462c8fdbe0f210feb5ac7ad2d9029af8be3bf45bd9fa39765f821642f/greenlet-3.3.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5fd23b9bc6d37b563211c6abbb1b3cab27db385a4449af5c32e932f93017080c", size = 274974, upload-time = "2026-01-23T15:31:02.891Z" }, - { url = "https://files.pythonhosted.org/packages/7e/a8/530a401419a6b302af59f67aaf0b9ba1015855ea7e56c036b5928793c5bd/greenlet-3.3.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09f51496a0bfbaa9d74d36a52d2580d1ef5ed4fdfcff0a73730abfbbbe1403dd", size = 577175, upload-time = "2026-01-23T16:00:56.213Z" }, - { url = "https://files.pythonhosted.org/packages/8e/89/7e812bb9c05e1aaef9b597ac1d0962b9021d2c6269354966451e885c4e6b/greenlet-3.3.1-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb0feb07fe6e6a74615ee62a880007d976cf739b6669cce95daa7373d4fc69c5", size = 590401, upload-time = "2026-01-23T16:05:26.365Z" }, - { url = "https://files.pythonhosted.org/packages/70/ae/e2d5f0e59b94a2269b68a629173263fa40b63da32f5c231307c349315871/greenlet-3.3.1-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:67ea3fc73c8cd92f42467a72b75e8f05ed51a0e9b1d15398c913416f2dafd49f", size = 601161, upload-time = "2026-01-23T16:15:53.456Z" }, - { url = "https://files.pythonhosted.org/packages/5c/ae/8d472e1f5ac5efe55c563f3eabb38c98a44b832602e12910750a7c025802/greenlet-3.3.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:39eda9ba259cc9801da05351eaa8576e9aa83eb9411e8f0c299e05d712a210f2", size = 590272, upload-time = "2026-01-23T15:32:49.411Z" }, - { url = "https://files.pythonhosted.org/packages/a8/51/0fde34bebfcadc833550717eade64e35ec8738e6b097d5d248274a01258b/greenlet-3.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e2e7e882f83149f0a71ac822ebf156d902e7a5d22c9045e3e0d1daf59cee2cc9", size = 1550729, upload-time = "2026-01-23T16:04:20.867Z" }, - { url = "https://files.pythonhosted.org/packages/16/c9/2fb47bee83b25b119d5a35d580807bb8b92480a54b68fef009a02945629f/greenlet-3.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:80aa4d79eb5564f2e0a6144fcc744b5a37c56c4a92d60920720e99210d88db0f", size = 1615552, upload-time = "2026-01-23T15:33:45.743Z" }, - { url = "https://files.pythonhosted.org/packages/1f/54/dcf9f737b96606f82f8dd05becfb8d238db0633dd7397d542a296fe9cad3/greenlet-3.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:32e4ca9777c5addcbf42ff3915d99030d8e00173a56f80001fb3875998fe410b", size = 226462, upload-time = "2026-01-23T15:36:50.422Z" }, - { url = "https://files.pythonhosted.org/packages/91/37/61e1015cf944ddd2337447d8e97fb423ac9bc21f9963fb5f206b53d65649/greenlet-3.3.1-cp311-cp311-win_arm64.whl", hash = "sha256:da19609432f353fed186cc1b85e9440db93d489f198b4bdf42ae19cc9d9ac9b4", size = 225715, upload-time = "2026-01-23T15:33:17.298Z" }, - { url = "https://files.pythonhosted.org/packages/f9/c8/9d76a66421d1ae24340dfae7e79c313957f6e3195c144d2c73333b5bfe34/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975", size = 276443, upload-time = "2026-01-23T15:30:10.066Z" }, - { url = "https://files.pythonhosted.org/packages/81/99/401ff34bb3c032d1f10477d199724f5e5f6fbfb59816ad1455c79c1eb8e7/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36", size = 597359, upload-time = "2026-01-23T16:00:57.394Z" }, - { url = "https://files.pythonhosted.org/packages/2b/bc/4dcc0871ed557792d304f50be0f7487a14e017952ec689effe2180a6ff35/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba", size = 607805, upload-time = "2026-01-23T16:05:28.068Z" }, - { url = "https://files.pythonhosted.org/packages/3b/cd/7a7ca57588dac3389e97f7c9521cb6641fd8b6602faf1eaa4188384757df/greenlet-3.3.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c620051669fd04ac6b60ebc70478210119c56e2d5d5df848baec4312e260e4ca", size = 622363, upload-time = "2026-01-23T16:15:54.754Z" }, - { url = "https://files.pythonhosted.org/packages/cf/05/821587cf19e2ce1f2b24945d890b164401e5085f9d09cbd969b0c193cd20/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336", size = 609947, upload-time = "2026-01-23T15:32:51.004Z" }, - { url = "https://files.pythonhosted.org/packages/a4/52/ee8c46ed9f8babaa93a19e577f26e3d28a519feac6350ed6f25f1afee7e9/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1", size = 1567487, upload-time = "2026-01-23T16:04:22.125Z" }, - { url = "https://files.pythonhosted.org/packages/8f/7c/456a74f07029597626f3a6db71b273a3632aecb9afafeeca452cfa633197/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149", size = 1636087, upload-time = "2026-01-23T15:33:47.486Z" }, - { url = "https://files.pythonhosted.org/packages/34/2f/5e0e41f33c69655300a5e54aeb637cf8ff57f1786a3aba374eacc0228c1d/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a", size = 227156, upload-time = "2026-01-23T15:34:34.808Z" }, - { url = "https://files.pythonhosted.org/packages/c8/ab/717c58343cf02c5265b531384b248787e04d8160b8afe53d9eec053d7b44/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1", size = 226403, upload-time = "2026-01-23T15:31:39.372Z" }, - { url = "https://files.pythonhosted.org/packages/ec/ab/d26750f2b7242c2b90ea2ad71de70cfcd73a948a49513188a0fc0d6fc15a/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3", size = 275205, upload-time = "2026-01-23T15:30:24.556Z" }, - { url = "https://files.pythonhosted.org/packages/10/d3/be7d19e8fad7c5a78eeefb2d896a08cd4643e1e90c605c4be3b46264998f/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac", size = 599284, upload-time = "2026-01-23T16:00:58.584Z" }, - { url = "https://files.pythonhosted.org/packages/ae/21/fe703aaa056fdb0f17e5afd4b5c80195bbdab701208918938bd15b00d39b/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd", size = 610274, upload-time = "2026-01-23T16:05:29.312Z" }, - { url = "https://files.pythonhosted.org/packages/06/00/95df0b6a935103c0452dad2203f5be8377e551b8466a29650c4c5a5af6cc/greenlet-3.3.1-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:12184c61e5d64268a160226fb4818af4df02cfead8379d7f8b99a56c3a54ff3e", size = 624375, upload-time = "2026-01-23T16:15:55.915Z" }, - { url = "https://files.pythonhosted.org/packages/cb/86/5c6ab23bb3c28c21ed6bebad006515cfe08b04613eb105ca0041fecca852/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3", size = 612904, upload-time = "2026-01-23T15:32:52.317Z" }, - { url = "https://files.pythonhosted.org/packages/c2/f3/7949994264e22639e40718c2daf6f6df5169bf48fb038c008a489ec53a50/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951", size = 1567316, upload-time = "2026-01-23T16:04:23.316Z" }, - { url = "https://files.pythonhosted.org/packages/8d/6e/d73c94d13b6465e9f7cd6231c68abde838bb22408596c05d9059830b7872/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2", size = 1636549, upload-time = "2026-01-23T15:33:48.643Z" }, - { url = "https://files.pythonhosted.org/packages/5e/b3/c9c23a6478b3bcc91f979ce4ca50879e4d0b2bd7b9a53d8ecded719b92e2/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946", size = 227042, upload-time = "2026-01-23T15:33:58.216Z" }, - { url = "https://files.pythonhosted.org/packages/90/e7/824beda656097edee36ab15809fd063447b200cc03a7f6a24c34d520bc88/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d", size = 226294, upload-time = "2026-01-23T15:30:52.73Z" }, - { url = "https://files.pythonhosted.org/packages/ae/fb/011c7c717213182caf78084a9bea51c8590b0afda98001f69d9f853a495b/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5", size = 275737, upload-time = "2026-01-23T15:32:16.889Z" }, - { url = "https://files.pythonhosted.org/packages/41/2e/a3a417d620363fdbb08a48b1dd582956a46a61bf8fd27ee8164f9dfe87c2/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b", size = 646422, upload-time = "2026-01-23T16:01:00.354Z" }, - { url = "https://files.pythonhosted.org/packages/b4/09/c6c4a0db47defafd2d6bab8ddfe47ad19963b4e30f5bed84d75328059f8c/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e", size = 658219, upload-time = "2026-01-23T16:05:30.956Z" }, - { url = "https://files.pythonhosted.org/packages/e2/89/b95f2ddcc5f3c2bc09c8ee8d77be312df7f9e7175703ab780f2014a0e781/greenlet-3.3.1-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3e0f3878ca3a3ff63ab4ea478585942b53df66ddde327b59ecb191b19dbbd62d", size = 671455, upload-time = "2026-01-23T16:15:57.232Z" }, - { url = "https://files.pythonhosted.org/packages/80/38/9d42d60dffb04b45f03dbab9430898352dba277758640751dc5cc316c521/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f", size = 660237, upload-time = "2026-01-23T15:32:53.967Z" }, - { url = "https://files.pythonhosted.org/packages/96/61/373c30b7197f9e756e4c81ae90a8d55dc3598c17673f91f4d31c3c689c3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683", size = 1615261, upload-time = "2026-01-23T16:04:25.066Z" }, - { url = "https://files.pythonhosted.org/packages/fd/d3/ca534310343f5945316f9451e953dcd89b36fe7a19de652a1dc5a0eeef3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1", size = 1683719, upload-time = "2026-01-23T15:33:50.61Z" }, - { url = "https://files.pythonhosted.org/packages/52/cb/c21a3fd5d2c9c8b622e7bede6d6d00e00551a5ee474ea6d831b5f567a8b4/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a", size = 228125, upload-time = "2026-01-23T15:32:45.265Z" }, - { url = "https://files.pythonhosted.org/packages/6a/8e/8a2db6d11491837af1de64b8aff23707c6e85241be13c60ed399a72e2ef8/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79", size = 227519, upload-time = "2026-01-23T15:31:47.284Z" }, - { url = "https://files.pythonhosted.org/packages/28/24/cbbec49bacdcc9ec652a81d3efef7b59f326697e7edf6ed775a5e08e54c2/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242", size = 282706, upload-time = "2026-01-23T15:33:05.525Z" }, - { url = "https://files.pythonhosted.org/packages/86/2e/4f2b9323c144c4fe8842a4e0d92121465485c3c2c5b9e9b30a52e80f523f/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774", size = 651209, upload-time = "2026-01-23T16:01:01.517Z" }, - { url = "https://files.pythonhosted.org/packages/d9/87/50ca60e515f5bb55a2fbc5f0c9b5b156de7d2fc51a0a69abc9d23914a237/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97", size = 654300, upload-time = "2026-01-23T16:05:32.199Z" }, - { url = "https://files.pythonhosted.org/packages/7c/25/c51a63f3f463171e09cb586eb64db0861eb06667ab01a7968371a24c4f3b/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b9721549a95db96689458a1e0ae32412ca18776ed004463df3a9299c1b257ab", size = 662574, upload-time = "2026-01-23T16:15:58.364Z" }, - { url = "https://files.pythonhosted.org/packages/1d/94/74310866dfa2b73dd08659a3d18762f83985ad3281901ba0ee9a815194fb/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2", size = 653842, upload-time = "2026-01-23T15:32:55.671Z" }, - { url = "https://files.pythonhosted.org/packages/97/43/8bf0ffa3d498eeee4c58c212a3905dd6146c01c8dc0b0a046481ca29b18c/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53", size = 1614917, upload-time = "2026-01-23T16:04:26.276Z" }, - { url = "https://files.pythonhosted.org/packages/89/90/a3be7a5f378fc6e84abe4dcfb2ba32b07786861172e502388b4c90000d1b/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249", size = 1676092, upload-time = "2026-01-23T15:33:52.176Z" }, - { url = "https://files.pythonhosted.org/packages/e1/2b/98c7f93e6db9977aaee07eb1e51ca63bd5f779b900d362791d3252e60558/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451", size = 233181, upload-time = "2026-01-23T15:33:00.29Z" }, + { url = "https://files.pythonhosted.org/packages/38/3f/9859f655d11901e7b2996c6e3d33e0caa9a1d4572c3bc61ed0faa64b2f4c/greenlet-3.3.2-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:9bc885b89709d901859cf95179ec9f6bb67a3d2bb1f0e88456461bd4b7f8fd0d", size = 277747, upload-time = "2026-02-20T20:16:21.325Z" }, + { url = "https://files.pythonhosted.org/packages/fb/07/cb284a8b5c6498dbd7cba35d31380bb123d7dceaa7907f606c8ff5993cbf/greenlet-3.3.2-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b568183cf65b94919be4438dc28416b234b678c608cafac8874dfeeb2a9bbe13", size = 579202, upload-time = "2026-02-20T20:47:28.955Z" }, + { url = "https://files.pythonhosted.org/packages/ed/45/67922992b3a152f726163b19f890a85129a992f39607a2a53155de3448b8/greenlet-3.3.2-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:527fec58dc9f90efd594b9b700662ed3fb2493c2122067ac9c740d98080a620e", size = 590620, upload-time = "2026-02-20T20:55:55.581Z" }, + { url = "https://files.pythonhosted.org/packages/ad/55/9f1ebb5a825215fadcc0f7d5073f6e79e3007e3282b14b22d6aba7ca6cb8/greenlet-3.3.2-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ad0c8917dd42a819fe77e6bdfcb84e3379c0de956469301d9fd36427a1ca501f", size = 591729, upload-time = "2026-02-20T20:20:58.395Z" }, + { url = "https://files.pythonhosted.org/packages/24/b4/21f5455773d37f94b866eb3cf5caed88d6cea6dd2c6e1f9c34f463cba3ec/greenlet-3.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:97245cc10e5515dbc8c3104b2928f7f02b6813002770cfaffaf9a6e0fc2b94ef", size = 1551946, upload-time = "2026-02-20T20:49:31.102Z" }, + { url = "https://files.pythonhosted.org/packages/00/68/91f061a926abead128fe1a87f0b453ccf07368666bd59ffa46016627a930/greenlet-3.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8c1fdd7d1b309ff0da81d60a9688a8bd044ac4e18b250320a96fc68d31c209ca", size = 1618494, upload-time = "2026-02-20T20:21:06.541Z" }, + { url = "https://files.pythonhosted.org/packages/ac/78/f93e840cbaef8becaf6adafbaf1319682a6c2d8c1c20224267a5c6c8c891/greenlet-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:5d0e35379f93a6d0222de929a25ab47b5eb35b5ef4721c2b9cbcc4036129ff1f", size = 230092, upload-time = "2026-02-20T20:17:09.379Z" }, + { url = "https://files.pythonhosted.org/packages/f3/47/16400cb42d18d7a6bb46f0626852c1718612e35dcb0dffa16bbaffdf5dd2/greenlet-3.3.2-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:c56692189a7d1c7606cb794be0a8381470d95c57ce5be03fb3d0ef57c7853b86", size = 278890, upload-time = "2026-02-20T20:19:39.263Z" }, + { url = "https://files.pythonhosted.org/packages/a3/90/42762b77a5b6aa96cd8c0e80612663d39211e8ae8a6cd47c7f1249a66262/greenlet-3.3.2-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ebd458fa8285960f382841da585e02201b53a5ec2bac6b156fc623b5ce4499f", size = 581120, upload-time = "2026-02-20T20:47:30.161Z" }, + { url = "https://files.pythonhosted.org/packages/bf/6f/f3d64f4fa0a9c7b5c5b3c810ff1df614540d5aa7d519261b53fba55d4df9/greenlet-3.3.2-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a443358b33c4ec7b05b79a7c8b466f5d275025e750298be7340f8fc63dff2a55", size = 594363, upload-time = "2026-02-20T20:55:56.965Z" }, + { url = "https://files.pythonhosted.org/packages/72/83/3e06a52aca8128bdd4dcd67e932b809e76a96ab8c232a8b025b2850264c5/greenlet-3.3.2-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e2cd90d413acbf5e77ae41e5d3c9b3ac1d011a756d7284d7f3f2b806bbd6358", size = 594156, upload-time = "2026-02-20T20:20:59.955Z" }, + { url = "https://files.pythonhosted.org/packages/70/79/0de5e62b873e08fe3cef7dbe84e5c4bc0e8ed0c7ff131bccb8405cd107c8/greenlet-3.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:442b6057453c8cb29b4fb36a2ac689382fc71112273726e2423f7f17dc73bf99", size = 1554649, upload-time = "2026-02-20T20:49:32.293Z" }, + { url = "https://files.pythonhosted.org/packages/5a/00/32d30dee8389dc36d42170a9c66217757289e2afb0de59a3565260f38373/greenlet-3.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:45abe8eb6339518180d5a7fa47fa01945414d7cca5ecb745346fc6a87d2750be", size = 1619472, upload-time = "2026-02-20T20:21:07.966Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3a/efb2cf697fbccdf75b24e2c18025e7dfa54c4f31fab75c51d0fe79942cef/greenlet-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e692b2dae4cc7077cbb11b47d258533b48c8fde69a33d0d8a82e2fe8d8531d5", size = 230389, upload-time = "2026-02-20T20:17:18.772Z" }, + { url = "https://files.pythonhosted.org/packages/e1/a1/65bbc059a43a7e2143ec4fc1f9e3f673e04f9c7b371a494a101422ac4fd5/greenlet-3.3.2-cp311-cp311-win_arm64.whl", hash = "sha256:02b0a8682aecd4d3c6c18edf52bc8e51eacdd75c8eac52a790a210b06aa295fd", size = 229645, upload-time = "2026-02-20T20:18:18.695Z" }, + { url = "https://files.pythonhosted.org/packages/ea/ab/1608e5a7578e62113506740b88066bf09888322a311cff602105e619bd87/greenlet-3.3.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:ac8d61d4343b799d1e526db579833d72f23759c71e07181c2d2944e429eb09cd", size = 280358, upload-time = "2026-02-20T20:17:43.971Z" }, + { url = "https://files.pythonhosted.org/packages/a5/23/0eae412a4ade4e6623ff7626e38998cb9b11e9ff1ebacaa021e4e108ec15/greenlet-3.3.2-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ceec72030dae6ac0c8ed7591b96b70410a8be370b6a477b1dbc072856ad02bd", size = 601217, upload-time = "2026-02-20T20:47:31.462Z" }, + { url = "https://files.pythonhosted.org/packages/f8/16/5b1678a9c07098ecb9ab2dd159fafaf12e963293e61ee8d10ecb55273e5e/greenlet-3.3.2-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2a5be83a45ce6188c045bcc44b0ee037d6a518978de9a5d97438548b953a1ac", size = 611792, upload-time = "2026-02-20T20:55:58.423Z" }, + { url = "https://files.pythonhosted.org/packages/50/1f/5155f55bd71cabd03765a4aac9ac446be129895271f73872c36ebd4b04b6/greenlet-3.3.2-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43e99d1749147ac21dde49b99c9abffcbc1e2d55c67501465ef0930d6e78e070", size = 613875, upload-time = "2026-02-20T20:21:01.102Z" }, + { url = "https://files.pythonhosted.org/packages/fc/dd/845f249c3fcd69e32df80cdab059b4be8b766ef5830a3d0aa9d6cad55beb/greenlet-3.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4c956a19350e2c37f2c48b336a3afb4bff120b36076d9d7fb68cb44e05d95b79", size = 1571467, upload-time = "2026-02-20T20:49:33.495Z" }, + { url = "https://files.pythonhosted.org/packages/2a/50/2649fe21fcc2b56659a452868e695634722a6655ba245d9f77f5656010bf/greenlet-3.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6c6f8ba97d17a1e7d664151284cb3315fc5f8353e75221ed4324f84eb162b395", size = 1640001, upload-time = "2026-02-20T20:21:09.154Z" }, + { url = "https://files.pythonhosted.org/packages/9b/40/cc802e067d02af8b60b6771cea7d57e21ef5e6659912814babb42b864713/greenlet-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:34308836d8370bddadb41f5a7ce96879b72e2fdfb4e87729330c6ab52376409f", size = 231081, upload-time = "2026-02-20T20:17:28.121Z" }, + { url = "https://files.pythonhosted.org/packages/58/2e/fe7f36ff1982d6b10a60d5e0740c759259a7d6d2e1dc41da6d96de32fff6/greenlet-3.3.2-cp312-cp312-win_arm64.whl", hash = "sha256:d3a62fa76a32b462a97198e4c9e99afb9ab375115e74e9a83ce180e7a496f643", size = 230331, upload-time = "2026-02-20T20:17:23.34Z" }, + { url = "https://files.pythonhosted.org/packages/ac/48/f8b875fa7dea7dd9b33245e37f065af59df6a25af2f9561efa8d822fde51/greenlet-3.3.2-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:aa6ac98bdfd716a749b84d4034486863fd81c3abde9aa3cf8eff9127981a4ae4", size = 279120, upload-time = "2026-02-20T20:19:01.9Z" }, + { url = "https://files.pythonhosted.org/packages/49/8d/9771d03e7a8b1ee456511961e1b97a6d77ae1dea4a34a5b98eee706689d3/greenlet-3.3.2-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab0c7e7901a00bc0a7284907273dc165b32e0d109a6713babd04471327ff7986", size = 603238, upload-time = "2026-02-20T20:47:32.873Z" }, + { url = "https://files.pythonhosted.org/packages/59/0e/4223c2bbb63cd5c97f28ffb2a8aee71bdfb30b323c35d409450f51b91e3e/greenlet-3.3.2-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d248d8c23c67d2291ffd47af766e2a3aa9fa1c6703155c099feb11f526c63a92", size = 614219, upload-time = "2026-02-20T20:55:59.817Z" }, + { url = "https://files.pythonhosted.org/packages/7a/34/259b28ea7a2a0c904b11cd36c79b8cef8019b26ee5dbe24e73b469dea347/greenlet-3.3.2-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6997d360a4e6a4e936c0f9625b1c20416b8a0ea18a8e19cabbefc712e7397ab", size = 616774, upload-time = "2026-02-20T20:21:02.454Z" }, + { url = "https://files.pythonhosted.org/packages/0a/03/996c2d1689d486a6e199cb0f1cf9e4aa940c500e01bdf201299d7d61fa69/greenlet-3.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64970c33a50551c7c50491671265d8954046cb6e8e2999aacdd60e439b70418a", size = 1571277, upload-time = "2026-02-20T20:49:34.795Z" }, + { url = "https://files.pythonhosted.org/packages/d9/c4/2570fc07f34a39f2caf0bf9f24b0a1a0a47bc2e8e465b2c2424821389dfc/greenlet-3.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1a9172f5bf6bd88e6ba5a84e0a68afeac9dc7b6b412b245dd64f52d83c81e55b", size = 1640455, upload-time = "2026-02-20T20:21:10.261Z" }, + { url = "https://files.pythonhosted.org/packages/91/39/5ef5aa23bc545aa0d31e1b9b55822b32c8da93ba657295840b6b34124009/greenlet-3.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:a7945dd0eab63ded0a48e4dcade82939783c172290a7903ebde9e184333ca124", size = 230961, upload-time = "2026-02-20T20:16:58.461Z" }, + { url = "https://files.pythonhosted.org/packages/62/6b/a89f8456dcb06becff288f563618e9f20deed8dd29beea14f9a168aef64b/greenlet-3.3.2-cp313-cp313-win_arm64.whl", hash = "sha256:394ead29063ee3515b4e775216cb756b2e3b4a7e55ae8fd884f17fa579e6b327", size = 230221, upload-time = "2026-02-20T20:17:37.152Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ae/8bffcbd373b57a5992cd077cbe8858fff39110480a9d50697091faea6f39/greenlet-3.3.2-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:8d1658d7291f9859beed69a776c10822a0a799bc4bfe1bd4272bb60e62507dab", size = 279650, upload-time = "2026-02-20T20:18:00.783Z" }, + { url = "https://files.pythonhosted.org/packages/d1/c0/45f93f348fa49abf32ac8439938726c480bd96b2a3c6f4d949ec0124b69f/greenlet-3.3.2-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:18cb1b7337bca281915b3c5d5ae19f4e76d35e1df80f4ad3c1a7be91fadf1082", size = 650295, upload-time = "2026-02-20T20:47:34.036Z" }, + { url = "https://files.pythonhosted.org/packages/b3/de/dd7589b3f2b8372069ab3e4763ea5329940fc7ad9dcd3e272a37516d7c9b/greenlet-3.3.2-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c2e47408e8ce1c6f1ceea0dffcdf6ebb85cc09e55c7af407c99f1112016e45e9", size = 662163, upload-time = "2026-02-20T20:56:01.295Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d8/09bfa816572a4d83bccd6750df1926f79158b1c36c5f73786e26dbe4ee38/greenlet-3.3.2-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63d10328839d1973e5ba35e98cccbca71b232b14051fd957b6f8b6e8e80d0506", size = 664160, upload-time = "2026-02-20T20:21:04.015Z" }, + { url = "https://files.pythonhosted.org/packages/48/cf/56832f0c8255d27f6c35d41b5ec91168d74ec721d85f01a12131eec6b93c/greenlet-3.3.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e4ab3cfb02993c8cc248ea73d7dae6cec0253e9afa311c9b37e603ca9fad2ce", size = 1619181, upload-time = "2026-02-20T20:49:36.052Z" }, + { url = "https://files.pythonhosted.org/packages/0a/23/b90b60a4aabb4cec0796e55f25ffbfb579a907c3898cd2905c8918acaa16/greenlet-3.3.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94ad81f0fd3c0c0681a018a976e5c2bd2ca2d9d94895f23e7bb1af4e8af4e2d5", size = 1687713, upload-time = "2026-02-20T20:21:11.684Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ca/2101ca3d9223a1dc125140dbc063644dca76df6ff356531eb27bc267b446/greenlet-3.3.2-cp314-cp314-win_amd64.whl", hash = "sha256:8c4dd0f3997cf2512f7601563cc90dfb8957c0cff1e3a1b23991d4ea1776c492", size = 232034, upload-time = "2026-02-20T20:20:08.186Z" }, + { url = "https://files.pythonhosted.org/packages/f6/4a/ecf894e962a59dea60f04877eea0fd5724618da89f1867b28ee8b91e811f/greenlet-3.3.2-cp314-cp314-win_arm64.whl", hash = "sha256:cd6f9e2bbd46321ba3bbb4c8a15794d32960e3b0ae2cc4d49a1a53d314805d71", size = 231437, upload-time = "2026-02-20T20:18:59.722Z" }, + { url = "https://files.pythonhosted.org/packages/98/6d/8f2ef704e614bcf58ed43cfb8d87afa1c285e98194ab2cfad351bf04f81e/greenlet-3.3.2-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:e26e72bec7ab387ac80caa7496e0f908ff954f31065b0ffc1f8ecb1338b11b54", size = 286617, upload-time = "2026-02-20T20:19:29.856Z" }, + { url = "https://files.pythonhosted.org/packages/5e/0d/93894161d307c6ea237a43988f27eba0947b360b99ac5239ad3fe09f0b47/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b466dff7a4ffda6ca975979bab80bdadde979e29fc947ac3be4451428d8b0e4", size = 655189, upload-time = "2026-02-20T20:47:35.742Z" }, + { url = "https://files.pythonhosted.org/packages/f5/2c/d2d506ebd8abcb57386ec4f7ba20f4030cbe56eae541bc6fd6ef399c0b41/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b8bddc5b73c9720bea487b3bffdb1840fe4e3656fba3bd40aa1489e9f37877ff", size = 658225, upload-time = "2026-02-20T20:56:02.527Z" }, + { url = "https://files.pythonhosted.org/packages/8e/30/3a09155fbf728673a1dea713572d2d31159f824a37c22da82127056c44e4/greenlet-3.3.2-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b26b0f4428b871a751968285a1ac9648944cea09807177ac639b030bddebcea4", size = 657907, upload-time = "2026-02-20T20:21:05.259Z" }, + { url = "https://files.pythonhosted.org/packages/f3/fd/d05a4b7acd0154ed758797f0a43b4c0962a843bedfe980115e842c5b2d08/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1fb39a11ee2e4d94be9a76671482be9398560955c9e568550de0224e41104727", size = 1618857, upload-time = "2026-02-20T20:49:37.309Z" }, + { url = "https://files.pythonhosted.org/packages/6f/e1/50ee92a5db521de8f35075b5eff060dd43d39ebd46c2181a2042f7070385/greenlet-3.3.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:20154044d9085151bc309e7689d6f7ba10027f8f5a8c0676ad398b951913d89e", size = 1680010, upload-time = "2026-02-20T20:21:13.427Z" }, + { url = "https://files.pythonhosted.org/packages/29/4b/45d90626aef8e65336bed690106d1382f7a43665e2249017e9527df8823b/greenlet-3.3.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c04c5e06ec3e022cbfe2cd4a846e1d4e50087444f875ff6d2c2ad8445495cf1a", size = 237086, upload-time = "2026-02-20T20:20:45.786Z" }, ] [[package]] @@ -2430,7 +2424,7 @@ wheels = [ [[package]] name = "grpcio" -version = "1.78.0" +version = "1.78.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.14' and sys_platform == 'darwin'", @@ -2440,58 +2434,58 @@ resolution-markers = [ dependencies = [ { name = "typing-extensions", marker = "(python_full_version >= '3.14' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform == 'win32')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/06/8a/3d098f35c143a89520e568e6539cc098fcd294495910e359889ce8741c84/grpcio-1.78.0.tar.gz", hash = "sha256:7382b95189546f375c174f53a5fa873cef91c4b8005faa05cc5b3beea9c4f1c5", size = 12852416, upload-time = "2026-02-06T09:57:18.093Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/de/de568532d9907552700f80dcec38219d8d298ad9e71f5e0a095abaf2761e/grpcio-1.78.1.tar.gz", hash = "sha256:27c625532d33ace45d57e775edf1982e183ff8641c72e4e91ef7ba667a149d72", size = 12835760, upload-time = "2026-02-20T01:16:10.869Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/5a/a8/690a085b4d1fe066130de97a87de32c45062cf2ecd218df9675add895550/grpcio-1.78.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:7cc47943d524ee0096f973e1081cb8f4f17a4615f2116882a5f1416e4cfe92b5", size = 5946986, upload-time = "2026-02-06T09:54:34.043Z" }, - { url = "https://files.pythonhosted.org/packages/c7/1b/e5213c5c0ced9d2d92778d30529ad5bb2dcfb6c48c4e2d01b1f302d33d64/grpcio-1.78.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:c3f293fdc675ccba4db5a561048cca627b5e7bd1c8a6973ffedabe7d116e22e2", size = 11816533, upload-time = "2026-02-06T09:54:37.04Z" }, - { url = "https://files.pythonhosted.org/packages/18/37/1ba32dccf0a324cc5ace744c44331e300b000a924bf14840f948c559ede7/grpcio-1.78.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:10a9a644b5dd5aec3b82b5b0b90d41c0fa94c85ef42cb42cf78a23291ddb5e7d", size = 6519964, upload-time = "2026-02-06T09:54:40.268Z" }, - { url = "https://files.pythonhosted.org/packages/ed/f5/c0e178721b818072f2e8b6fde13faaba942406c634009caf065121ce246b/grpcio-1.78.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4c5533d03a6cbd7f56acfc9cfb44ea64f63d29091e40e44010d34178d392d7eb", size = 7198058, upload-time = "2026-02-06T09:54:42.389Z" }, - { url = "https://files.pythonhosted.org/packages/5b/b2/40d43c91ae9cd667edc960135f9f08e58faa1576dc95af29f66ec912985f/grpcio-1.78.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ff870aebe9a93a85283837801d35cd5f8814fe2ad01e606861a7fb47c762a2b7", size = 6727212, upload-time = "2026-02-06T09:54:44.91Z" }, - { url = "https://files.pythonhosted.org/packages/ed/88/9da42eed498f0efcfcd9156e48ae63c0cde3bea398a16c99fb5198c885b6/grpcio-1.78.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:391e93548644e6b2726f1bb84ed60048d4bcc424ce5e4af0843d28ca0b754fec", size = 7300845, upload-time = "2026-02-06T09:54:47.562Z" }, - { url = "https://files.pythonhosted.org/packages/23/3f/1c66b7b1b19a8828890e37868411a6e6925df5a9030bfa87ab318f34095d/grpcio-1.78.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:df2c8f3141f7cbd112a6ebbd760290b5849cda01884554f7c67acc14e7b1758a", size = 8284605, upload-time = "2026-02-06T09:54:50.475Z" }, - { url = "https://files.pythonhosted.org/packages/94/c4/ca1bd87394f7b033e88525384b4d1e269e8424ab441ea2fba1a0c5b50986/grpcio-1.78.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bd8cb8026e5f5b50498a3c4f196f57f9db344dad829ffae16b82e4fdbaea2813", size = 7726672, upload-time = "2026-02-06T09:54:53.11Z" }, - { url = "https://files.pythonhosted.org/packages/41/09/f16e487d4cc65ccaf670f6ebdd1a17566b965c74fc3d93999d3b2821e052/grpcio-1.78.0-cp310-cp310-win32.whl", hash = "sha256:f8dff3d9777e5d2703a962ee5c286c239bf0ba173877cc68dc02c17d042e29de", size = 4076715, upload-time = "2026-02-06T09:54:55.549Z" }, - { url = "https://files.pythonhosted.org/packages/2a/32/4ce60d94e242725fd3bcc5673c04502c82a8e87b21ea411a63992dc39f8f/grpcio-1.78.0-cp310-cp310-win_amd64.whl", hash = "sha256:94f95cf5d532d0e717eed4fc1810e8e6eded04621342ec54c89a7c2f14b581bf", size = 4799157, upload-time = "2026-02-06T09:54:59.838Z" }, - { url = "https://files.pythonhosted.org/packages/86/c7/d0b780a29b0837bf4ca9580904dfb275c1fc321ded7897d620af7047ec57/grpcio-1.78.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:2777b783f6c13b92bd7b716667452c329eefd646bfb3f2e9dabea2e05dbd34f6", size = 5951525, upload-time = "2026-02-06T09:55:01.989Z" }, - { url = "https://files.pythonhosted.org/packages/c5/b1/96920bf2ee61df85a9503cb6f733fe711c0ff321a5a697d791b075673281/grpcio-1.78.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:9dca934f24c732750389ce49d638069c3892ad065df86cb465b3fa3012b70c9e", size = 11830418, upload-time = "2026-02-06T09:55:04.462Z" }, - { url = "https://files.pythonhosted.org/packages/83/0c/7c1528f098aeb75a97de2bae18c530f56959fb7ad6c882db45d9884d6edc/grpcio-1.78.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:459ab414b35f4496138d0ecd735fed26f1318af5e52cb1efbc82a09f0d5aa911", size = 6524477, upload-time = "2026-02-06T09:55:07.111Z" }, - { url = "https://files.pythonhosted.org/packages/8d/52/e7c1f3688f949058e19a011c4e0dec973da3d0ae5e033909677f967ae1f4/grpcio-1.78.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:082653eecbdf290e6e3e2c276ab2c54b9e7c299e07f4221872380312d8cf395e", size = 7198266, upload-time = "2026-02-06T09:55:10.016Z" }, - { url = "https://files.pythonhosted.org/packages/e5/61/8ac32517c1e856677282c34f2e7812d6c328fa02b8f4067ab80e77fdc9c9/grpcio-1.78.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85f93781028ec63f383f6bc90db785a016319c561cc11151fbb7b34e0d012303", size = 6730552, upload-time = "2026-02-06T09:55:12.207Z" }, - { url = "https://files.pythonhosted.org/packages/bd/98/b8ee0158199250220734f620b12e4a345955ac7329cfd908d0bf0fda77f0/grpcio-1.78.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f12857d24d98441af6a1d5c87442d624411db486f7ba12550b07788f74b67b04", size = 7304296, upload-time = "2026-02-06T09:55:15.044Z" }, - { url = "https://files.pythonhosted.org/packages/bd/0f/7b72762e0d8840b58032a56fdbd02b78fc645b9fa993d71abf04edbc54f4/grpcio-1.78.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5397fff416b79e4b284959642a4e95ac4b0f1ece82c9993658e0e477d40551ec", size = 8288298, upload-time = "2026-02-06T09:55:17.276Z" }, - { url = "https://files.pythonhosted.org/packages/24/ae/ae4ce56bc5bb5caa3a486d60f5f6083ac3469228faa734362487176c15c5/grpcio-1.78.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:fbe6e89c7ffb48518384068321621b2a69cab509f58e40e4399fdd378fa6d074", size = 7730953, upload-time = "2026-02-06T09:55:19.545Z" }, - { url = "https://files.pythonhosted.org/packages/b5/6e/8052e3a28eb6a820c372b2eb4b5e32d195c661e137d3eca94d534a4cfd8a/grpcio-1.78.0-cp311-cp311-win32.whl", hash = "sha256:6092beabe1966a3229f599d7088b38dfc8ffa1608b5b5cdda31e591e6500f856", size = 4076503, upload-time = "2026-02-06T09:55:21.521Z" }, - { url = "https://files.pythonhosted.org/packages/08/62/f22c98c5265dfad327251fa2f840b591b1df5f5e15d88b19c18c86965b27/grpcio-1.78.0-cp311-cp311-win_amd64.whl", hash = "sha256:1afa62af6e23f88629f2b29ec9e52ec7c65a7176c1e0a83292b93c76ca882558", size = 4799767, upload-time = "2026-02-06T09:55:24.107Z" }, - { url = "https://files.pythonhosted.org/packages/4e/f4/7384ed0178203d6074446b3c4f46c90a22ddf7ae0b3aee521627f54cfc2a/grpcio-1.78.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:f9ab915a267fc47c7e88c387a3a28325b58c898e23d4995f765728f4e3dedb97", size = 5913985, upload-time = "2026-02-06T09:55:26.832Z" }, - { url = "https://files.pythonhosted.org/packages/81/ed/be1caa25f06594463f685b3790b320f18aea49b33166f4141bfdc2bfb236/grpcio-1.78.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3f8904a8165ab21e07e58bf3e30a73f4dffc7a1e0dbc32d51c61b5360d26f43e", size = 11811853, upload-time = "2026-02-06T09:55:29.224Z" }, - { url = "https://files.pythonhosted.org/packages/24/a7/f06d151afc4e64b7e3cc3e872d331d011c279aaab02831e40a81c691fb65/grpcio-1.78.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:859b13906ce098c0b493af92142ad051bf64c7870fa58a123911c88606714996", size = 6475766, upload-time = "2026-02-06T09:55:31.825Z" }, - { url = "https://files.pythonhosted.org/packages/8a/a8/4482922da832ec0082d0f2cc3a10976d84a7424707f25780b82814aafc0a/grpcio-1.78.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:b2342d87af32790f934a79c3112641e7b27d63c261b8b4395350dad43eff1dc7", size = 7170027, upload-time = "2026-02-06T09:55:34.7Z" }, - { url = "https://files.pythonhosted.org/packages/54/bf/f4a3b9693e35d25b24b0b39fa46d7d8a3c439e0a3036c3451764678fec20/grpcio-1.78.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:12a771591ae40bc65ba67048fa52ef4f0e6db8279e595fd349f9dfddeef571f9", size = 6690766, upload-time = "2026-02-06T09:55:36.902Z" }, - { url = "https://files.pythonhosted.org/packages/c7/b9/521875265cc99fe5ad4c5a17010018085cae2810a928bf15ebe7d8bcd9cc/grpcio-1.78.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:185dea0d5260cbb2d224c507bf2a5444d5abbb1fa3594c1ed7e4c709d5eb8383", size = 7266161, upload-time = "2026-02-06T09:55:39.824Z" }, - { url = "https://files.pythonhosted.org/packages/05/86/296a82844fd40a4ad4a95f100b55044b4f817dece732bf686aea1a284147/grpcio-1.78.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:51b13f9aed9d59ee389ad666b8c2214cc87b5de258fa712f9ab05f922e3896c6", size = 8253303, upload-time = "2026-02-06T09:55:42.353Z" }, - { url = "https://files.pythonhosted.org/packages/f3/e4/ea3c0caf5468537f27ad5aab92b681ed7cc0ef5f8c9196d3fd42c8c2286b/grpcio-1.78.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fd5f135b1bd58ab088930b3c613455796dfa0393626a6972663ccdda5b4ac6ce", size = 7698222, upload-time = "2026-02-06T09:55:44.629Z" }, - { url = "https://files.pythonhosted.org/packages/d7/47/7f05f81e4bb6b831e93271fb12fd52ba7b319b5402cbc101d588f435df00/grpcio-1.78.0-cp312-cp312-win32.whl", hash = "sha256:94309f498bcc07e5a7d16089ab984d42ad96af1d94b5a4eb966a266d9fcabf68", size = 4066123, upload-time = "2026-02-06T09:55:47.644Z" }, - { url = "https://files.pythonhosted.org/packages/ad/e7/d6914822c88aa2974dbbd10903d801a28a19ce9cd8bad7e694cbbcf61528/grpcio-1.78.0-cp312-cp312-win_amd64.whl", hash = "sha256:9566fe4ababbb2610c39190791e5b829869351d14369603702e890ef3ad2d06e", size = 4797657, upload-time = "2026-02-06T09:55:49.86Z" }, - { url = "https://files.pythonhosted.org/packages/05/a9/8f75894993895f361ed8636cd9237f4ab39ef87fd30db17467235ed1c045/grpcio-1.78.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:ce3a90455492bf8bfa38e56fbbe1dbd4f872a3d8eeaf7337dc3b1c8aa28c271b", size = 5920143, upload-time = "2026-02-06T09:55:52.035Z" }, - { url = "https://files.pythonhosted.org/packages/55/06/0b78408e938ac424100100fd081189451b472236e8a3a1f6500390dc4954/grpcio-1.78.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:2bf5e2e163b356978b23652c4818ce4759d40f4712ee9ec5a83c4be6f8c23a3a", size = 11803926, upload-time = "2026-02-06T09:55:55.494Z" }, - { url = "https://files.pythonhosted.org/packages/88/93/b59fe7832ff6ae3c78b813ea43dac60e295fa03606d14d89d2e0ec29f4f3/grpcio-1.78.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8f2ac84905d12918e4e55a16da17939eb63e433dc11b677267c35568aa63fc84", size = 6478628, upload-time = "2026-02-06T09:55:58.533Z" }, - { url = "https://files.pythonhosted.org/packages/ed/df/e67e3734527f9926b7d9c0dde6cd998d1d26850c3ed8eeec81297967ac67/grpcio-1.78.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:b58f37edab4a3881bc6c9bca52670610e0c9ca14e2ea3cf9debf185b870457fb", size = 7173574, upload-time = "2026-02-06T09:56:01.786Z" }, - { url = "https://files.pythonhosted.org/packages/a6/62/cc03fffb07bfba982a9ec097b164e8835546980aec25ecfa5f9c1a47e022/grpcio-1.78.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:735e38e176a88ce41840c21bb49098ab66177c64c82426e24e0082500cc68af5", size = 6692639, upload-time = "2026-02-06T09:56:04.529Z" }, - { url = "https://files.pythonhosted.org/packages/bf/9a/289c32e301b85bdb67d7ec68b752155e674ee3ba2173a1858f118e399ef3/grpcio-1.78.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2045397e63a7a0ee7957c25f7dbb36ddc110e0cfb418403d110c0a7a68a844e9", size = 7268838, upload-time = "2026-02-06T09:56:08.397Z" }, - { url = "https://files.pythonhosted.org/packages/0e/79/1be93f32add280461fa4773880196572563e9c8510861ac2da0ea0f892b6/grpcio-1.78.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:a9f136fbafe7ccf4ac7e8e0c28b31066e810be52d6e344ef954a3a70234e1702", size = 8251878, upload-time = "2026-02-06T09:56:10.914Z" }, - { url = "https://files.pythonhosted.org/packages/65/65/793f8e95296ab92e4164593674ae6291b204bb5f67f9d4a711489cd30ffa/grpcio-1.78.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:748b6138585379c737adc08aeffd21222abbda1a86a0dca2a39682feb9196c20", size = 7695412, upload-time = "2026-02-06T09:56:13.593Z" }, - { url = "https://files.pythonhosted.org/packages/1c/9f/1e233fe697ecc82845942c2822ed06bb522e70d6771c28d5528e4c50f6a4/grpcio-1.78.0-cp313-cp313-win32.whl", hash = "sha256:271c73e6e5676afe4fc52907686670c7cea22ab2310b76a59b678403ed40d670", size = 4064899, upload-time = "2026-02-06T09:56:15.601Z" }, - { url = "https://files.pythonhosted.org/packages/4d/27/d86b89e36de8a951501fb06a0f38df19853210f341d0b28f83f4aa0ffa08/grpcio-1.78.0-cp313-cp313-win_amd64.whl", hash = "sha256:f2d4e43ee362adfc05994ed479334d5a451ab7bc3f3fee1b796b8ca66895acb4", size = 4797393, upload-time = "2026-02-06T09:56:17.882Z" }, - { url = "https://files.pythonhosted.org/packages/29/f2/b56e43e3c968bfe822fa6ce5bca10d5c723aa40875b48791ce1029bb78c7/grpcio-1.78.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:e87cbc002b6f440482b3519e36e1313eb5443e9e9e73d6a52d43bd2004fcfd8e", size = 5920591, upload-time = "2026-02-06T09:56:20.758Z" }, - { url = "https://files.pythonhosted.org/packages/5d/81/1f3b65bd30c334167bfa8b0d23300a44e2725ce39bba5b76a2460d85f745/grpcio-1.78.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:c41bc64626db62e72afec66b0c8a0da76491510015417c127bfc53b2fe6d7f7f", size = 11813685, upload-time = "2026-02-06T09:56:24.315Z" }, - { url = "https://files.pythonhosted.org/packages/0e/1c/bbe2f8216a5bd3036119c544d63c2e592bdf4a8ec6e4a1867592f4586b26/grpcio-1.78.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8dfffba826efcf366b1e3ccc37e67afe676f290e13a3b48d31a46739f80a8724", size = 6487803, upload-time = "2026-02-06T09:56:27.367Z" }, - { url = "https://files.pythonhosted.org/packages/16/5c/a6b2419723ea7ddce6308259a55e8e7593d88464ce8db9f4aa857aba96fa/grpcio-1.78.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:74be1268d1439eaaf552c698cdb11cd594f0c49295ae6bb72c34ee31abbe611b", size = 7173206, upload-time = "2026-02-06T09:56:29.876Z" }, - { url = "https://files.pythonhosted.org/packages/df/1e/b8801345629a415ea7e26c83d75eb5dbe91b07ffe5210cc517348a8d4218/grpcio-1.78.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be63c88b32e6c0f1429f1398ca5c09bc64b0d80950c8bb7807d7d7fb36fb84c7", size = 6693826, upload-time = "2026-02-06T09:56:32.305Z" }, - { url = "https://files.pythonhosted.org/packages/34/84/0de28eac0377742679a510784f049738a80424b17287739fc47d63c2439e/grpcio-1.78.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:3c586ac70e855c721bda8f548d38c3ca66ac791dc49b66a8281a1f99db85e452", size = 7277897, upload-time = "2026-02-06T09:56:34.915Z" }, - { url = "https://files.pythonhosted.org/packages/ca/9c/ad8685cfe20559a9edb66f735afdcb2b7d3de69b13666fdfc542e1916ebd/grpcio-1.78.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:35eb275bf1751d2ffbd8f57cdbc46058e857cf3971041521b78b7db94bdaf127", size = 8252404, upload-time = "2026-02-06T09:56:37.553Z" }, - { url = "https://files.pythonhosted.org/packages/3c/05/33a7a4985586f27e1de4803887c417ec7ced145ebd069bc38a9607059e2b/grpcio-1.78.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:207db540302c884b8848036b80db352a832b99dfdf41db1eb554c2c2c7800f65", size = 7696837, upload-time = "2026-02-06T09:56:40.173Z" }, - { url = "https://files.pythonhosted.org/packages/73/77/7382241caf88729b106e49e7d18e3116216c778e6a7e833826eb96de22f7/grpcio-1.78.0-cp314-cp314-win32.whl", hash = "sha256:57bab6deef2f4f1ca76cc04565df38dc5713ae6c17de690721bdf30cb1e0545c", size = 4142439, upload-time = "2026-02-06T09:56:43.258Z" }, - { url = "https://files.pythonhosted.org/packages/48/b2/b096ccce418882fbfda4f7496f9357aaa9a5af1896a9a7f60d9f2b275a06/grpcio-1.78.0-cp314-cp314-win_amd64.whl", hash = "sha256:dce09d6116df20a96acfdbf85e4866258c3758180e8c49845d6ba8248b6d0bbb", size = 4929852, upload-time = "2026-02-06T09:56:45.885Z" }, + { url = "https://files.pythonhosted.org/packages/44/30/0534b643dafd54824769d6260b89c71d518e4ef8b5ad16b84d1ae9272978/grpcio-1.78.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:4393bef64cf26dc07cd6f18eaa5170ae4eebaafd4418e7e3a59ca9526a6fa30b", size = 5947661, upload-time = "2026-02-20T01:12:34.922Z" }, + { url = "https://files.pythonhosted.org/packages/4a/f8/f678566655ab822da0f713789555e7eddca7ef93da99f480c63de3aa94b4/grpcio-1.78.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:917047c19cd120b40aab9a4b8a22e9ce3562f4a1343c0d62b3cd2d5199da3d67", size = 11819948, upload-time = "2026-02-20T01:12:39.709Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0b/a4b4210d946055f4e5a8430f2802202ae8f831b4b00d36d55055c5cf4b6a/grpcio-1.78.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ff7de398bb3528d44d17e6913a7cfe639e3b15c65595a71155322df16978c5e1", size = 6519850, upload-time = "2026-02-20T01:12:42.715Z" }, + { url = "https://files.pythonhosted.org/packages/ea/d9/a1e657a73000a71fa75ec7140ff3a8dc32eb3427560620e477c6a2735527/grpcio-1.78.1-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:15f6e636d1152667ddb4022b37534c161c8477274edb26a0b65b215dd0a81e97", size = 7198654, upload-time = "2026-02-20T01:12:46.164Z" }, + { url = "https://files.pythonhosted.org/packages/aa/28/a61c5bdf53c1638e657bb5eebb93c789837820e1fdb965145f05eccc2994/grpcio-1.78.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:27b5cb669603efb7883a882275db88b6b5d6b6c9f0267d5846ba8699b7ace338", size = 6727238, upload-time = "2026-02-20T01:12:48.472Z" }, + { url = "https://files.pythonhosted.org/packages/9d/3e/aa143d0687801986a29d85788c96089449f36651cd4e2a493737ae0c5be9/grpcio-1.78.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:86edb3966778fa05bfdb333688fde5dc9079f9e2a9aa6a5c42e9564b7656ba04", size = 7300960, upload-time = "2026-02-20T01:12:51.139Z" }, + { url = "https://files.pythonhosted.org/packages/30/d3/53e0f26b46417f28d14b5951fc6a1eff79c08c8a339e967c0a19ec7cf9e9/grpcio-1.78.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:849cc62eb989bc3be5629d4f3acef79be0d0ff15622201ed251a86d17fef6494", size = 8285274, upload-time = "2026-02-20T01:12:53.315Z" }, + { url = "https://files.pythonhosted.org/packages/29/d0/e0e9fd477ce86c07ed1ed1d5c34790f050b6d58bfde77b02b36e23f8b235/grpcio-1.78.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9a00992d6fafe19d648b9ccb4952200c50d8e36d0cce8cf026c56ed3fdc28465", size = 7726620, upload-time = "2026-02-20T01:12:56.498Z" }, + { url = "https://files.pythonhosted.org/packages/5e/b5/e138a9f7810d196081b2e047c378ca12358c5906d79c42ddec41bb43d528/grpcio-1.78.1-cp310-cp310-win32.whl", hash = "sha256:f8759a1347f3b4f03d9a9d4ce8f9f31ad5e5d0144ba06ccfb1ffaeb0ba4c1e20", size = 4076778, upload-time = "2026-02-20T01:12:59.098Z" }, + { url = "https://files.pythonhosted.org/packages/4e/95/9b02316b85731df0943a635ca6d02f155f673c4f17e60be0c4892a6eb051/grpcio-1.78.1-cp310-cp310-win_amd64.whl", hash = "sha256:e840405a3f1249509892be2399f668c59b9d492068a2cf326d661a8c79e5e747", size = 4798925, upload-time = "2026-02-20T01:13:03.186Z" }, + { url = "https://files.pythonhosted.org/packages/bf/1e/ad774af3b2c84f49c6d8c4a7bea4c40f02268ea8380630c28777edda463b/grpcio-1.78.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:3a8aa79bc6e004394c0abefd4b034c14affda7b66480085d87f5fbadf43b593b", size = 5951132, upload-time = "2026-02-20T01:13:05.942Z" }, + { url = "https://files.pythonhosted.org/packages/48/9d/ad3c284bedd88c545e20675d98ae904114d8517a71b0efc0901e9166628f/grpcio-1.78.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:8e1fcb419da5811deb47b7749b8049f7c62b993ba17822e3c7231e3e0ba65b79", size = 11831052, upload-time = "2026-02-20T01:13:09.604Z" }, + { url = "https://files.pythonhosted.org/packages/6d/08/20d12865e47242d03c3ade9bb2127f5b4aded964f373284cfb357d47c5ac/grpcio-1.78.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b071dccac245c32cd6b1dd96b722283b855881ca0bf1c685cf843185f5d5d51e", size = 6524749, upload-time = "2026-02-20T01:13:21.692Z" }, + { url = "https://files.pythonhosted.org/packages/c6/53/a8b72f52b253ec0cfdf88a13e9236a9d717c332b8aa5f0ba9e4699e94b55/grpcio-1.78.1-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:d6fb962947e4fe321eeef3be1ba5ba49d32dea9233c825fcbade8e858c14aaf4", size = 7198995, upload-time = "2026-02-20T01:13:24.275Z" }, + { url = "https://files.pythonhosted.org/packages/13/3c/ac769c8ded1bcb26bb119fb472d3374b481b3cf059a0875db9fc77139c17/grpcio-1.78.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a6afd191551fd72e632367dfb083e33cd185bf9ead565f2476bba8ab864ae496", size = 6730770, upload-time = "2026-02-20T01:13:26.522Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c3/2275ef4cc5b942314321f77d66179be4097ff484e82ca34bf7baa5b1ddbc/grpcio-1.78.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b2acd83186305c0802dbc4d81ed0ec2f3e8658d7fde97cfba2f78d7372f05b89", size = 7305036, upload-time = "2026-02-20T01:13:30.923Z" }, + { url = "https://files.pythonhosted.org/packages/91/cb/3c2aa99e12cbbfc72c2ed8aa328e6041709d607d668860380e6cd00ba17d/grpcio-1.78.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5380268ab8513445740f1f77bd966d13043d07e2793487e61fd5b5d0935071eb", size = 8288641, upload-time = "2026-02-20T01:13:39.42Z" }, + { url = "https://files.pythonhosted.org/packages/0d/b2/21b89f492260ac645775d9973752ca873acfd0609d6998e9d3065a21ea2f/grpcio-1.78.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:389b77484959bdaad6a2b7dda44d7d1228381dd669a03f5660392aa0e9385b22", size = 7730967, upload-time = "2026-02-20T01:13:41.697Z" }, + { url = "https://files.pythonhosted.org/packages/24/03/6b89eddf87fdffb8fa9d37375d44d3a798f4b8116ac363a5f7ca84caa327/grpcio-1.78.1-cp311-cp311-win32.whl", hash = "sha256:9dee66d142f4a8cca36b5b98a38f006419138c3c89e72071747f8fca415a6d8f", size = 4076680, upload-time = "2026-02-20T01:13:43.781Z" }, + { url = "https://files.pythonhosted.org/packages/a7/a8/204460b1bc1dff9862e98f56a2d14be3c4171f929f8eaf8c4517174b4270/grpcio-1.78.1-cp311-cp311-win_amd64.whl", hash = "sha256:43b930cf4f9c4a2262bb3e5d5bc40df426a72538b4f98e46f158b7eb112d2d70", size = 4801074, upload-time = "2026-02-20T01:13:46.315Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ed/d2eb9d27fded1a76b2a80eb9aa8b12101da7e41ce2bac0ad3651e88a14ae/grpcio-1.78.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:41e4605c923e0e9a84a2718e4948a53a530172bfaf1a6d1ded16ef9c5849fca2", size = 5913389, upload-time = "2026-02-20T01:13:49.005Z" }, + { url = "https://files.pythonhosted.org/packages/69/1b/40034e9ab010eeb3fa41ec61d8398c6dbf7062f3872c866b8f72700e2522/grpcio-1.78.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:39da1680d260c0c619c3b5fa2dc47480ca24d5704c7a548098bca7de7f5dd17f", size = 11811839, upload-time = "2026-02-20T01:13:51.839Z" }, + { url = "https://files.pythonhosted.org/packages/b4/69/fe16ef2979ea62b8aceb3a3f1e7a8bbb8b717ae2a44b5899d5d426073273/grpcio-1.78.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b5d5881d72a09b8336a8f874784a8eeffacde44a7bc1a148bce5a0243a265ef0", size = 6475805, upload-time = "2026-02-20T01:13:55.423Z" }, + { url = "https://files.pythonhosted.org/packages/5b/1e/069e0a9062167db18446917d7c00ae2e91029f96078a072bedc30aaaa8c3/grpcio-1.78.1-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:888ceb7821acd925b1c90f0cdceaed1386e69cfe25e496e0771f6c35a156132f", size = 7169955, upload-time = "2026-02-20T01:13:59.553Z" }, + { url = "https://files.pythonhosted.org/packages/38/fc/44a57e2bb4a755e309ee4e9ed2b85c9af93450b6d3118de7e69410ee05fa/grpcio-1.78.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8942bdfc143b467c264b048862090c4ba9a0223c52ae28c9ae97754361372e42", size = 6690767, upload-time = "2026-02-20T01:14:02.31Z" }, + { url = "https://files.pythonhosted.org/packages/b8/87/21e16345d4c75046d453916166bc72a3309a382c8e97381ec4b8c1a54729/grpcio-1.78.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:716a544969660ed609164aff27b2effd3ff84e54ac81aa4ce77b1607ca917d22", size = 7266846, upload-time = "2026-02-20T01:14:12.974Z" }, + { url = "https://files.pythonhosted.org/packages/11/df/d6261983f9ca9ef4d69893765007a9a3211b91d9faf85a2591063df381c7/grpcio-1.78.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4d50329b081c223d444751076bb5b389d4f06c2b32d51b31a1e98172e6cecfb9", size = 8253522, upload-time = "2026-02-20T01:14:17.407Z" }, + { url = "https://files.pythonhosted.org/packages/de/7c/4f96a0ff113c5d853a27084d7590cd53fdb05169b596ea9f5f27f17e021e/grpcio-1.78.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7e836778c13ff70edada16567e8da0c431e8818eaae85b80d11c1ba5782eccbb", size = 7698070, upload-time = "2026-02-20T01:14:20.032Z" }, + { url = "https://files.pythonhosted.org/packages/17/3c/7b55c0b5af88fbeb3d0c13e25492d3ace41ac9dbd0f5f8f6c0fb613b6706/grpcio-1.78.1-cp312-cp312-win32.whl", hash = "sha256:07eb016ea7444a22bef465cce045512756956433f54450aeaa0b443b8563b9ca", size = 4066474, upload-time = "2026-02-20T01:14:22.602Z" }, + { url = "https://files.pythonhosted.org/packages/5d/17/388c12d298901b0acf10b612b650692bfed60e541672b1d8965acbf2d722/grpcio-1.78.1-cp312-cp312-win_amd64.whl", hash = "sha256:02b82dcd2fa580f5e82b4cf62ecde1b3c7cc9ba27b946421200706a6e5acaf85", size = 4797537, upload-time = "2026-02-20T01:14:25.444Z" }, + { url = "https://files.pythonhosted.org/packages/df/72/754754639cfd16ad04619e1435a518124b2d858e5752225376f9285d4c51/grpcio-1.78.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:2b7ad2981550ce999e25ce3f10c8863f718a352a2fd655068d29ea3fd37b4907", size = 5919437, upload-time = "2026-02-20T01:14:29.403Z" }, + { url = "https://files.pythonhosted.org/packages/5c/84/6267d1266f8bc335d3a8b7ccf981be7de41e3ed8bd3a49e57e588212b437/grpcio-1.78.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:409bfe22220889b9906739910a0ee4c197a967c21b8dd14b4b06dd477f8819ce", size = 11803701, upload-time = "2026-02-20T01:14:32.624Z" }, + { url = "https://files.pythonhosted.org/packages/f3/56/c9098e8b920a54261cd605bbb040de0cde1ca4406102db0aa2c0b11d1fb4/grpcio-1.78.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:34b6cb16f4b67eeb5206250dc5b4d5e8e3db939535e58efc330e4c61341554bd", size = 6479416, upload-time = "2026-02-20T01:14:35.926Z" }, + { url = "https://files.pythonhosted.org/packages/86/cf/5d52024371ee62658b7ed72480200524087528844ec1b65265bbcd31c974/grpcio-1.78.1-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:39d21fd30d38a5afb93f0e2e71e2ec2bd894605fb75d41d5a40060c2f98f8d11", size = 7174087, upload-time = "2026-02-20T01:14:39.98Z" }, + { url = "https://files.pythonhosted.org/packages/31/e6/5e59551afad4279e27335a6d60813b8aa3ae7b14fb62cea1d329a459c118/grpcio-1.78.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:09fbd4bcaadb6d8604ed1504b0bdf7ac18e48467e83a9d930a70a7fefa27e862", size = 6692881, upload-time = "2026-02-20T01:14:42.466Z" }, + { url = "https://files.pythonhosted.org/packages/db/8f/940062de2d14013c02f51b079eb717964d67d46f5d44f22038975c9d9576/grpcio-1.78.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:db681513a1bdd879c0b24a5a6a70398da5eaaba0e077a306410dc6008426847a", size = 7269092, upload-time = "2026-02-20T01:14:45.826Z" }, + { url = "https://files.pythonhosted.org/packages/09/87/9db657a4b5f3b15560ec591db950bc75a1a2f9e07832578d7e2b23d1a7bd/grpcio-1.78.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:f81816faa426da461e9a597a178832a351d6f1078102590a4b32c77d251b71eb", size = 8252037, upload-time = "2026-02-20T01:14:48.57Z" }, + { url = "https://files.pythonhosted.org/packages/e2/37/b980e0265479ec65e26b6e300a39ceac33ecb3f762c2861d4bac990317cf/grpcio-1.78.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ffbb760df1cd49e0989f9826b2fd48930700db6846ac171eaff404f3cfbe5c28", size = 7695243, upload-time = "2026-02-20T01:14:51.376Z" }, + { url = "https://files.pythonhosted.org/packages/98/46/5fc42c100ab702fa1ea41a75c890c563c3f96432b4a287d5a6369654f323/grpcio-1.78.1-cp313-cp313-win32.whl", hash = "sha256:1a56bf3ee99af5cf32d469de91bf5de79bdac2e18082b495fc1063ea33f4f2d0", size = 4065329, upload-time = "2026-02-20T01:14:53.952Z" }, + { url = "https://files.pythonhosted.org/packages/b0/da/806d60bb6611dfc16cf463d982bd92bd8b6bd5f87dfac66b0a44dfe20995/grpcio-1.78.1-cp313-cp313-win_amd64.whl", hash = "sha256:8991c2add0d8505178ff6c3ae54bd9386279e712be82fa3733c54067aae9eda1", size = 4797637, upload-time = "2026-02-20T01:14:57.276Z" }, + { url = "https://files.pythonhosted.org/packages/96/3a/2d2ec4d2ce2eb9d6a2b862630a0d9d4ff4239ecf1474ecff21442a78612a/grpcio-1.78.1-cp314-cp314-linux_armv7l.whl", hash = "sha256:d101fe49b1e0fb4a7aa36ed0c3821a0f67a5956ef572745452d2cd790d723a3f", size = 5920256, upload-time = "2026-02-20T01:15:00.23Z" }, + { url = "https://files.pythonhosted.org/packages/9c/92/dccb7d087a1220ed358753945230c1ddeeed13684b954cb09db6758f1271/grpcio-1.78.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:5ce1855e8cfc217cdf6bcfe0cf046d7cf81ddcc3e6894d6cfd075f87a2d8f460", size = 11813749, upload-time = "2026-02-20T01:15:03.312Z" }, + { url = "https://files.pythonhosted.org/packages/ef/47/c20e87f87986da9998f30f14776ce27e61f02482a3a030ffe265089342c6/grpcio-1.78.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd26048d066b51f39fe9206e2bcc2cea869a5e5b2d13c8d523f4179193047ebd", size = 6488739, upload-time = "2026-02-20T01:15:14.349Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c2/088bd96e255133d7d87c3eed0d598350d16cde1041bdbe2bb065967aaf91/grpcio-1.78.1-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4b8d7fda614cf2af0f73bbb042f3b7fee2ecd4aea69ec98dbd903590a1083529", size = 7173096, upload-time = "2026-02-20T01:15:17.687Z" }, + { url = "https://files.pythonhosted.org/packages/60/ce/168db121073a03355ce3552b3b1f790b5ded62deffd7d98c5f642b9d3d81/grpcio-1.78.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:656a5bd142caeb8b1efe1fe0b4434ecc7781f44c97cfc7927f6608627cf178c0", size = 6693861, upload-time = "2026-02-20T01:15:20.911Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d0/90b30ec2d9425215dd56922d85a90babbe6ee7e8256ba77d866b9c0d3aba/grpcio-1.78.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:99550e344482e3c21950c034f74668fccf8a546d50c1ecb4f717543bbdc071ba", size = 7278083, upload-time = "2026-02-20T01:15:23.698Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fb/73f9ba0b082bcd385d46205095fd9c917754685885b28fce3741e9f54529/grpcio-1.78.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:8f27683ca68359bd3f0eb4925824d71e538f84338b3ae337ead2ae43977d7541", size = 8252546, upload-time = "2026-02-20T01:15:26.517Z" }, + { url = "https://files.pythonhosted.org/packages/85/c5/6a89ea3cb5db6c3d9ed029b0396c49f64328c0cf5d2630ffeed25711920a/grpcio-1.78.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a40515b69ac50792f9b8ead260f194ba2bb3285375b6c40c7ff938f14c3df17d", size = 7696289, upload-time = "2026-02-20T01:15:29.718Z" }, + { url = "https://files.pythonhosted.org/packages/3d/05/63a7495048499ef437b4933d32e59b7f737bd5368ad6fb2479e2bd83bf2c/grpcio-1.78.1-cp314-cp314-win32.whl", hash = "sha256:2c473b54ef1618f4fb85e82ff4994de18143b74efc088b91b5a935a3a45042ba", size = 4142186, upload-time = "2026-02-20T01:15:32.786Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ce/adfe7e5f701d503be7778291757452e3fab6b19acf51917c79f5d1cf7f8a/grpcio-1.78.1-cp314-cp314-win_amd64.whl", hash = "sha256:e2a6b33d1050dce2c6f563c5caf7f7cbeebf7fba8cde37ffe3803d50526900d1", size = 4932000, upload-time = "2026-02-20T01:15:36.127Z" }, ] [[package]] @@ -2530,31 +2524,31 @@ wheels = [ [[package]] name = "hf-xet" -version = "1.2.0" +version = "1.3.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5e/6e/0f11bacf08a67f7fb5ee09740f2ca54163863b07b70d579356e9222ce5d8/hf_xet-1.2.0.tar.gz", hash = "sha256:a8c27070ca547293b6890c4bf389f713f80e8c478631432962bb7f4bc0bd7d7f", size = 506020, upload-time = "2025-10-24T19:04:32.129Z" } +sdist = { url = "https://files.pythonhosted.org/packages/4f/3a/9aa61729228fb03e946409c51963f0cd2fd7c109f4ab93edc5f04a10be86/hf_xet-1.3.0.tar.gz", hash = "sha256:9c154ad63e17aca970987b2cf17dbd8a0c09bb18aeb246f637647a8058e4522b", size = 641390, upload-time = "2026-02-24T00:16:19.935Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/a5/85ef910a0aa034a2abcfadc360ab5ac6f6bc4e9112349bd40ca97551cff0/hf_xet-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:ceeefcd1b7aed4956ae8499e2199607765fbd1c60510752003b6cc0b8413b649", size = 2861870, upload-time = "2025-10-24T19:04:11.422Z" }, - { url = "https://files.pythonhosted.org/packages/ea/40/e2e0a7eb9a51fe8828ba2d47fe22a7e74914ea8a0db68a18c3aa7449c767/hf_xet-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b70218dd548e9840224df5638fdc94bd033552963cfa97f9170829381179c813", size = 2717584, upload-time = "2025-10-24T19:04:09.586Z" }, - { url = "https://files.pythonhosted.org/packages/a5/7d/daf7f8bc4594fdd59a8a596f9e3886133fdc68e675292218a5e4c1b7e834/hf_xet-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d40b18769bb9a8bc82a9ede575ce1a44c75eb80e7375a01d76259089529b5dc", size = 3315004, upload-time = "2025-10-24T19:04:00.314Z" }, - { url = "https://files.pythonhosted.org/packages/b1/ba/45ea2f605fbf6d81c8b21e4d970b168b18a53515923010c312c06cd83164/hf_xet-1.2.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cd3a6027d59cfb60177c12d6424e31f4b5ff13d8e3a1247b3a584bf8977e6df5", size = 3222636, upload-time = "2025-10-24T19:03:58.111Z" }, - { url = "https://files.pythonhosted.org/packages/4a/1d/04513e3cab8f29ab8c109d309ddd21a2705afab9d52f2ba1151e0c14f086/hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6de1fc44f58f6dd937956c8d304d8c2dea264c80680bcfa61ca4a15e7b76780f", size = 3408448, upload-time = "2025-10-24T19:04:20.951Z" }, - { url = "https://files.pythonhosted.org/packages/f0/7c/60a2756d7feec7387db3a1176c632357632fbe7849fce576c5559d4520c7/hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f182f264ed2acd566c514e45da9f2119110e48a87a327ca271027904c70c5832", size = 3503401, upload-time = "2025-10-24T19:04:22.549Z" }, - { url = "https://files.pythonhosted.org/packages/4e/64/48fffbd67fb418ab07451e4ce641a70de1c40c10a13e25325e24858ebe5a/hf_xet-1.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:293a7a3787e5c95d7be1857358a9130694a9c6021de3f27fa233f37267174382", size = 2900866, upload-time = "2025-10-24T19:04:33.461Z" }, - { url = "https://files.pythonhosted.org/packages/e2/51/f7e2caae42f80af886db414d4e9885fac959330509089f97cccb339c6b87/hf_xet-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:10bfab528b968c70e062607f663e21e34e2bba349e8038db546646875495179e", size = 2861861, upload-time = "2025-10-24T19:04:19.01Z" }, - { url = "https://files.pythonhosted.org/packages/6e/1d/a641a88b69994f9371bd347f1dd35e5d1e2e2460a2e350c8d5165fc62005/hf_xet-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a212e842647b02eb6a911187dc878e79c4aa0aa397e88dd3b26761676e8c1f8", size = 2717699, upload-time = "2025-10-24T19:04:17.306Z" }, - { url = "https://files.pythonhosted.org/packages/df/e0/e5e9bba7d15f0318955f7ec3f4af13f92e773fbb368c0b8008a5acbcb12f/hf_xet-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:30e06daccb3a7d4c065f34fc26c14c74f4653069bb2b194e7f18f17cbe9939c0", size = 3314885, upload-time = "2025-10-24T19:04:07.642Z" }, - { url = "https://files.pythonhosted.org/packages/21/90/b7fe5ff6f2b7b8cbdf1bd56145f863c90a5807d9758a549bf3d916aa4dec/hf_xet-1.2.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:29c8fc913a529ec0a91867ce3d119ac1aac966e098cf49501800c870328cc090", size = 3221550, upload-time = "2025-10-24T19:04:05.55Z" }, - { url = "https://files.pythonhosted.org/packages/6f/cb/73f276f0a7ce46cc6a6ec7d6c7d61cbfe5f2e107123d9bbd0193c355f106/hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e159cbfcfbb29f920db2c09ed8b660eb894640d284f102ada929b6e3dc410a", size = 3408010, upload-time = "2025-10-24T19:04:28.598Z" }, - { url = "https://files.pythonhosted.org/packages/b8/1e/d642a12caa78171f4be64f7cd9c40e3ca5279d055d0873188a58c0f5fbb9/hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c91d5ae931510107f148874e9e2de8a16052b6f1b3ca3c1b12f15ccb491390f", size = 3503264, upload-time = "2025-10-24T19:04:30.397Z" }, - { url = "https://files.pythonhosted.org/packages/17/b5/33764714923fa1ff922770f7ed18c2daae034d21ae6e10dbf4347c854154/hf_xet-1.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:210d577732b519ac6ede149d2f2f34049d44e8622bf14eb3d63bbcd2d4b332dc", size = 2901071, upload-time = "2025-10-24T19:04:37.463Z" }, - { url = "https://files.pythonhosted.org/packages/96/2d/22338486473df5923a9ab7107d375dbef9173c338ebef5098ef593d2b560/hf_xet-1.2.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:46740d4ac024a7ca9b22bebf77460ff43332868b661186a8e46c227fdae01848", size = 2866099, upload-time = "2025-10-24T19:04:15.366Z" }, - { url = "https://files.pythonhosted.org/packages/7f/8c/c5becfa53234299bc2210ba314eaaae36c2875e0045809b82e40a9544f0c/hf_xet-1.2.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:27df617a076420d8845bea087f59303da8be17ed7ec0cd7ee3b9b9f579dff0e4", size = 2722178, upload-time = "2025-10-24T19:04:13.695Z" }, - { url = "https://files.pythonhosted.org/packages/9a/92/cf3ab0b652b082e66876d08da57fcc6fa2f0e6c70dfbbafbd470bb73eb47/hf_xet-1.2.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3651fd5bfe0281951b988c0facbe726aa5e347b103a675f49a3fa8144c7968fd", size = 3320214, upload-time = "2025-10-24T19:04:03.596Z" }, - { url = "https://files.pythonhosted.org/packages/46/92/3f7ec4a1b6a65bf45b059b6d4a5d38988f63e193056de2f420137e3c3244/hf_xet-1.2.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d06fa97c8562fb3ee7a378dd9b51e343bc5bc8190254202c9771029152f5e08c", size = 3229054, upload-time = "2025-10-24T19:04:01.949Z" }, - { url = "https://files.pythonhosted.org/packages/0b/dd/7ac658d54b9fb7999a0ccb07ad863b413cbaf5cf172f48ebcd9497ec7263/hf_xet-1.2.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4c1428c9ae73ec0939410ec73023c4f842927f39db09b063b9482dac5a3bb737", size = 3413812, upload-time = "2025-10-24T19:04:24.585Z" }, - { url = "https://files.pythonhosted.org/packages/92/68/89ac4e5b12a9ff6286a12174c8538a5930e2ed662091dd2572bbe0a18c8a/hf_xet-1.2.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a55558084c16b09b5ed32ab9ed38421e2d87cf3f1f89815764d1177081b99865", size = 3508920, upload-time = "2025-10-24T19:04:26.927Z" }, - { url = "https://files.pythonhosted.org/packages/cb/44/870d44b30e1dcfb6a65932e3e1506c103a8a5aea9103c337e7a53180322c/hf_xet-1.2.0-cp37-abi3-win_amd64.whl", hash = "sha256:e6584a52253f72c9f52f9e549d5895ca7a471608495c4ecaa6cc73dba2b24d69", size = 2905735, upload-time = "2025-10-24T19:04:35.928Z" }, + { url = "https://files.pythonhosted.org/packages/b7/18/16954a87cfdfdc04792f1ffc9a29c0a48253ab10ec0f4856f39c7f7bf7cd/hf_xet-1.3.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:95bdeab4747cb45f855601e39b9e86ae92b4a114978ada6e0401961fcc5d2958", size = 3759481, upload-time = "2026-02-24T00:16:03.387Z" }, + { url = "https://files.pythonhosted.org/packages/d8/6f/a55752047e9b0e69517775531c14680331f00c9cd4dc07f5e9b7f7f68a12/hf_xet-1.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f99992583f27b139392601fe99e88df155dc4de7feba98ed27ce2d3e6b4a65bb", size = 3517927, upload-time = "2026-02-24T00:16:02.108Z" }, + { url = "https://files.pythonhosted.org/packages/ef/71/a909dbf9c8b166aa3f15db2bcf5d8afbe9d53170922edde2b919cf0bc455/hf_xet-1.3.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:687a71fc6d2eaa79d864da3aa13e5d887e124d357f5f306bfff6c385eea9d990", size = 4174328, upload-time = "2026-02-24T00:15:55.056Z" }, + { url = "https://files.pythonhosted.org/packages/21/cc/dec0d971bb5872345b8d64363a0b78ed6a147eea5b4281575ce5a8150f42/hf_xet-1.3.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:75d19813ed0e24525409bc22566282ae9bc93e5d764b185565e863dc28280a45", size = 3953184, upload-time = "2026-02-24T00:15:53.43Z" }, + { url = "https://files.pythonhosted.org/packages/3d/d8/d4259146e7c7089dd3f22cd62676d665bcfbc27428a070abee8985e0ab33/hf_xet-1.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:078af43569c2e05233137a93a33d2293f95c272745eaf030a9bb5f27bb0c9e9c", size = 4152800, upload-time = "2026-02-24T00:16:10.391Z" }, + { url = "https://files.pythonhosted.org/packages/c9/0d/39d9d32e4cde689da618739197e264bba5a55d870377d5d32cdd5c03fad8/hf_xet-1.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be8731e1620cc8549025c39ed3917c8fd125efaeae54ae679214a3d573e6c109", size = 4390499, upload-time = "2026-02-24T00:16:11.671Z" }, + { url = "https://files.pythonhosted.org/packages/d9/27/5b9c323bf5513e8971702eeac43ba5cb554921e0f292ad52f20ed6028131/hf_xet-1.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:1552616c0e0fa728a4ffdffa106e91faa0fd4edb44868e79b464fad00b2758ee", size = 3634124, upload-time = "2026-02-24T00:16:20.964Z" }, + { url = "https://files.pythonhosted.org/packages/85/32/76949adb65b7ca54c1e2b0519a98f7c88221b9091ae8780fc76d7d1bae70/hf_xet-1.3.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:a61496eccf412d7c51a5613c31a2051d357ddea6be53a0672c7644cf39bfefe9", size = 3759780, upload-time = "2026-02-24T00:16:09.037Z" }, + { url = "https://files.pythonhosted.org/packages/63/c4/ad6fa712611711c129fa49eb17baaf0665647eb0abce32d94ccd44b69c6d/hf_xet-1.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:aba35218871cc438826076778958f7ab2a1f4f8d654e91c307073a815360558f", size = 3517640, upload-time = "2026-02-24T00:16:07.536Z" }, + { url = "https://files.pythonhosted.org/packages/15/6b/b44659c5261cde6320a579d0acc949f19283a13d32fc9389fc49639f435e/hf_xet-1.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c444d8f657dedd7a72aa0ef0178fe01fe92b04b58014ee49e2b3b4985aea1529", size = 4174285, upload-time = "2026-02-24T00:16:00.848Z" }, + { url = "https://files.pythonhosted.org/packages/61/cf/16ef1b366482fa4e71d1642b019158d7ac891bcb961477102ceadfe69436/hf_xet-1.3.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:6d1bbda7900d72bc591cd39a64e35ad07f89a24f90e3d7b7c692cb93a1926cde", size = 3952705, upload-time = "2026-02-24T00:15:59.355Z" }, + { url = "https://files.pythonhosted.org/packages/d5/5a/d03453902ab9373715f50f3969979782a355df94329ea958ae78304ca06b/hf_xet-1.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:588f5df302e7dba5c3b60d4e5c683f95678526c29b9f64cbeb23e9f1889c6b83", size = 4152353, upload-time = "2026-02-24T00:16:15.857Z" }, + { url = "https://files.pythonhosted.org/packages/ab/98/d3cd8cdd8d771bee9a03bd52faed6fa114a68a107a0e337aaf0b4c52bf0c/hf_xet-1.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:944ae454b296c42b18219c37f245c78d0e64a734057423e9309f4938faa85d7f", size = 4390010, upload-time = "2026-02-24T00:16:18.713Z" }, + { url = "https://files.pythonhosted.org/packages/1f/10/3c58501d44d7a148d749ffa6046cbd14aa75a7ab07c9e7a984f86294cc53/hf_xet-1.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:34cdd5f10e61b7a1a7542672d20887c85debcfeb70a471ff1506f5a4c9441e42", size = 3634277, upload-time = "2026-02-24T00:16:23.718Z" }, + { url = "https://files.pythonhosted.org/packages/a1/00/22d3d896466ded4c46ef6465b85fa434fa97d79f8f61cea322afde1d6157/hf_xet-1.3.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:df4447f69086dcc6418583315eda6ed09033ac1fbbc784fedcbbbdf67bea1680", size = 3761293, upload-time = "2026-02-24T00:16:06.012Z" }, + { url = "https://files.pythonhosted.org/packages/97/fd/ebb0ea49e9bd9eb9f52844e417e0e6e9c8a59a1e84790691873fa910adc5/hf_xet-1.3.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:39f4fe714628adc2214ab4a67391182ee751bc4db581868cb3204900817758a8", size = 3523345, upload-time = "2026-02-24T00:16:04.615Z" }, + { url = "https://files.pythonhosted.org/packages/8a/bb/72ceaaf619cad23d151a281d52e15456bae72f52c3795e820c0b64a5f637/hf_xet-1.3.0-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9b16e53ed6b5c8197cefb3fd12047a430b7034428effed463c03cec68de7e9a3", size = 4178623, upload-time = "2026-02-24T00:15:57.857Z" }, + { url = "https://files.pythonhosted.org/packages/19/30/3280f4b5e407b442923a80ac0b2d96a65be7494457c55695e63f9a2b33dd/hf_xet-1.3.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:92051a1f73019489be77f6837671024ec785a3d1b888466b09d3a9ea15c4a1b5", size = 3958884, upload-time = "2026-02-24T00:15:56.326Z" }, + { url = "https://files.pythonhosted.org/packages/8f/13/5174c6d52583e54a761c88570ca657d621ac684747613f47846debfd6d4d/hf_xet-1.3.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:943046b160e7804a85e68a659d2eee1a83ce3661f72d1294d3cc5ece0f45a355", size = 4158146, upload-time = "2026-02-24T00:16:13.158Z" }, + { url = "https://files.pythonhosted.org/packages/12/13/ea8619021b119e19efdcaeec72f762b5be923cf79b5d4434f2cbbff39829/hf_xet-1.3.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9b798a95d41b4f33b0b455c8aa76ff1fd26a587a4dd3bdec29f0a37c60b78a2f", size = 4395565, upload-time = "2026-02-24T00:16:14.574Z" }, + { url = "https://files.pythonhosted.org/packages/64/cd/b81d922118a171bfbbecffd60a477e79188ab876260412fac47226a685bf/hf_xet-1.3.0-cp37-abi3-win_amd64.whl", hash = "sha256:227eee5b99d19b9f20c31d901a0c2373af610a24a34e6c2701072c9de48d6d95", size = 3637830, upload-time = "2026-02-24T00:16:22.474Z" }, ] [[package]] @@ -2824,15 +2818,9 @@ wheels = [ [[package]] name = "jsonpath-ng" -version = "1.7.0" +version = "1.8.0" source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "ply", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/6d/86/08646239a313f895186ff0a4573452038eed8c86f54380b3ebac34d32fb2/jsonpath-ng-1.7.0.tar.gz", hash = "sha256:f6f5f7fd4e5ff79c785f1573b394043b39849fb2bb47bcead935d12b00beab3c", size = 37838, upload-time = "2024-10-11T15:41:42.404Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/35/5a/73ecb3d82f8615f32ccdadeb9356726d6cae3a4bbc840b437ceb95708063/jsonpath_ng-1.7.0-py3-none-any.whl", hash = "sha256:f3d7f9e848cba1b6da28c55b1c26ff915dc9e0b1ba7e752a53d6da8d5cbd00b6", size = 30105, upload-time = "2024-11-20T17:58:30.418Z" }, -] +sdist = { url = "https://files.pythonhosted.org/packages/32/58/250751940d75c8019659e15482d548a4aa3b6ce122c515102a4bfdac50e3/jsonpath_ng-1.8.0.tar.gz", hash = "sha256:54252968134b5e549ea5b872f1df1168bd7defe1a52fed5a358c194e1943ddc3", size = 74513, upload-time = "2026-02-24T14:42:06.182Z" } [[package]] name = "jsonschema" @@ -2971,7 +2959,7 @@ wheels = [ [[package]] name = "langfuse" -version = "3.14.3" +version = "3.14.5" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "backoff", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -2985,9 +2973,9 @@ dependencies = [ { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "wrapt", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/86/44/1da5d5fb5a07949cd5bd53cabef1dafc1af272792f51277e6226eb96ceaa/langfuse-3.14.3.tar.gz", hash = "sha256:6d1529ae88d6f2ab74e255bb79537ae37aa1a576a1ec78f4643a7a6a00502f12", size = 235121, upload-time = "2026-02-17T17:43:25.903Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/6b/7a945e8bc56cbf343b6f6171fd45870b0ea80ea38463b2db8dd5a9dc04a2/langfuse-3.14.5.tar.gz", hash = "sha256:2f543ec1540053d39b08a50ed5992caf1cd54d472a55cb8e5dcf6d4fcb7ff631", size = 235474, upload-time = "2026-02-23T10:42:47.721Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/cf/708c3aefa7687995eb4d3ae556e1adcaf1c4e99f5315810e9809c8cd9219/langfuse-3.14.3-py3-none-any.whl", hash = "sha256:e65f4168279dbc45b800021c59855a3268cf85d81e3275f7015441bf7f365bcb", size = 420438, upload-time = "2026-02-17T17:43:24.097Z" }, + { url = "https://files.pythonhosted.org/packages/a3/a1/10f04224542d6a57073c4f339b6763836a0899c98966f1d4ffcf56d2cf61/langfuse-3.14.5-py3-none-any.whl", hash = "sha256:5054b1c705ec69bce2d7077ce7419727ac629159428da013790979ca9cae77d5", size = 421240, upload-time = "2026-02-23T10:42:46.085Z" }, ] [[package]] @@ -3077,7 +3065,7 @@ wheels = [ [[package]] name = "litellm" -version = "1.81.13" +version = "1.81.15" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "aiohttp", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -3093,9 +3081,9 @@ dependencies = [ { name = "tiktoken", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "tokenizers", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/72/80/b6cb799e7100953d848e106d0575db34c75bc3b57f31f2eefdfb1e23655f/litellm-1.81.13.tar.gz", hash = "sha256:083788d9c94e3371ff1c42e40e0e8198c497772643292a65b1bc91a3b3b537ea", size = 16562861, upload-time = "2026-02-17T02:00:47.466Z" } +sdist = { url = "https://files.pythonhosted.org/packages/70/0c/62a0fdc5adae6d205338f9239175aa6a93818e58b75cf000a9c7214a3d9f/litellm-1.81.15.tar.gz", hash = "sha256:a8a6277a53280762051c5818ebc76dd5f036368b9426c6f21795ae7f1ac6ebdc", size = 16597039, upload-time = "2026-02-24T06:52:50.892Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/be/f3/fffb7932870163cea7addc392165647a9a8a5489967de486c854226f1141/litellm-1.81.13-py3-none-any.whl", hash = "sha256:ae4aea2a55e85993f5f6dd36d036519422d24812a1a3e8540d9e987f2d7a4304", size = 14587505, upload-time = "2026-02-17T02:00:44.22Z" }, + { url = "https://files.pythonhosted.org/packages/78/fd/da11826dda0d332e360b9ead6c0c992d612ecb85b00df494823843cfcda3/litellm-1.81.15-py3-none-any.whl", hash = "sha256:2fa253658702509ce09fe0e172e5a47baaadf697fb0f784c7fd4ff665ae76ae1", size = 14682123, upload-time = "2026-02-24T06:52:48.084Z" }, ] [package.optional-dependencies] @@ -3138,11 +3126,11 @@ wheels = [ [[package]] name = "litellm-proxy-extras" -version = "0.4.40" +version = "0.4.47" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/88/d5d2c5812d13772aafa202b0c459d0bd54f648d009fcd7316240e5f6f347/litellm_proxy_extras-0.4.40.tar.gz", hash = "sha256:964c151ec56a40c5d7b3532888dd19db9203306d4a70a3c54fb2eb0a1bcff154", size = 25525, upload-time = "2026-02-16T19:21:22.994Z" } +sdist = { url = "https://files.pythonhosted.org/packages/1e/e6/f4b7929116d7765e2983223a76f77ba7d597fcb4d7ba7a2cd5632037f7dd/litellm_proxy_extras-0.4.47.tar.gz", hash = "sha256:42d88929f9eaf0b827046d3712095354db843c1716ccabb2a40c806ea5f809b9", size = 28010, upload-time = "2026-02-24T03:31:11.446Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/55/939f6f7bbbc66be6388b3a59d63500ddac77ed030b1cc9bf6f7cf239397c/litellm_proxy_extras-0.4.40-py3-none-any.whl", hash = "sha256:291cc5556b739d7b17b1ff79cd8881505cc560c6d5c0706302075550ae02c4bb", size = 57362, upload-time = "2026-02-16T19:21:21.662Z" }, + { url = "https://files.pythonhosted.org/packages/4d/6d/f147ff929f2079fdda10ff461816679c4cc18d49495cce3c0ef658696a91/litellm_proxy_extras-0.4.47-py3-none-any.whl", hash = "sha256:2e900ae3edfbc20d27556f092d914974d37bac213efe88b8fd5287f77b2b7ca7", size = 63670, upload-time = "2026-02-24T03:31:13.047Z" }, ] [[package]] @@ -3389,31 +3377,31 @@ wheels = [ [[package]] name = "microsoft-agents-activity" -version = "0.7.0" +version = "0.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/f8/e9/7f8086719f28815baca72b2f2600ce1e62b7cd53826bb406c52f28e81998/microsoft_agents_activity-0.7.0.tar.gz", hash = "sha256:77eeb6ffa9ee9e6237e1dbf5e962ea641ff60f20b0966e68e903ffbc10ebd41d", size = 60673, upload-time = "2026-01-21T18:05:24.601Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ce/8a/3dbdf47f3ddabf646987ddf6f5260e77865c6812177b8759f1c7fc395ac8/microsoft_agents_activity-0.8.0.tar.gz", hash = "sha256:f9e7d92db119cf93dd0642a5e698732c40a450c064306ad076b0d83d95eae114", size = 61226, upload-time = "2026-02-24T18:28:49.283Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/e1/f3/64dc3bf13e46c6a09cc1983f66da2e42bf726586fe0f77f915977a6be7d8/microsoft_agents_activity-0.7.0-py3-none-any.whl", hash = "sha256:8d30a25dfd0f491b834be52b4a21ff90ab3b9360ec7e50770c050f1d4a39e5ce", size = 132592, upload-time = "2026-01-21T18:05:33.533Z" }, + { url = "https://files.pythonhosted.org/packages/f8/10/18b87c552112917496256d4e9e50a49bd712015d285f01a3c6e18cdfdd74/microsoft_agents_activity-0.8.0-py3-none-any.whl", hash = "sha256:16f0e7fd5ba8f64c43ceac514b7b22734e97b4478b7e97963232ca893cfe336d", size = 132917, upload-time = "2026-02-24T18:28:59.002Z" }, ] [[package]] name = "microsoft-agents-copilotstudio-client" -version = "0.7.0" +version = "0.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "microsoft-agents-hosting-core", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d3/6e/6f3c6c2df7e6bc13b44eaca70696d29a76d18b884f125fc892ac2fb689b2/microsoft_agents_copilotstudio_client-0.7.0.tar.gz", hash = "sha256:2e6d7b8d2fccf313f6dffd3df17a21137730151c0557ad1ec08c6fb631a30d5f", size = 12636, upload-time = "2026-01-21T18:05:26.593Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/5d/a8567b03ff7d29d575aa8c4ebfb53d3f6ee8765cedd8550fae68e9df917d/microsoft_agents_copilotstudio_client-0.8.0.tar.gz", hash = "sha256:7416b2e7906977bd55b66f0b23853fb0c55d4a367cc8bf30cc8aba63d0949514", size = 27196, upload-time = "2026-02-24T18:28:52.033Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3c/6d/023ea0254ccb3b97ee36540df2d87aa718912f70d6b6c529569fae675ca3/microsoft_agents_copilotstudio_client-0.7.0-py3-none-any.whl", hash = "sha256:a69947c49e782b552c5ede877277e73a86280aa2335a291f08fe3622ebfdabe9", size = 13425, upload-time = "2026-01-21T18:05:35.729Z" }, + { url = "https://files.pythonhosted.org/packages/6b/6b/999ab044edfe924f0330bd2ce200f3fa9c2a84550212587781c68d617679/microsoft_agents_copilotstudio_client-0.8.0-py3-none-any.whl", hash = "sha256:d00936e2a0b48482380d81695f00af86d71c82c0b464947cc723834b63c91553", size = 23715, upload-time = "2026-02-24T18:29:01.3Z" }, ] [[package]] name = "microsoft-agents-hosting-core" -version = "0.7.0" +version = "0.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "azure-core", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -3422,9 +3410,9 @@ dependencies = [ { name = "pyjwt", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "python-dotenv", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/aa/da/26d461cb222ab41f38a3c72ca43900a65b8e8b6b71d6d1207fad1edc3e7b/microsoft_agents_hosting_core-0.7.0.tar.gz", hash = "sha256:31448279c47e39d63edc347c1d3b4de8043aa1b4c51a1f01d40d7d451221b202", size = 90446, upload-time = "2026-01-21T18:05:29.28Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ad/8a/5ab47498bbc74989c30dbfbcb7862211117bdbeba4e3d844bb281c0e05bf/microsoft_agents_hosting_core-0.8.0.tar.gz", hash = "sha256:d3b34803f73d7f677b797733dfe5c561af876e8721c426d6379a762fe6e86fa4", size = 94079, upload-time = "2026-02-24T18:28:54.156Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ed/e4/8d9e2e3f3a3106d0c80141631385206a6946f0b414cf863db851b98533e7/microsoft_agents_hosting_core-0.7.0-py3-none-any.whl", hash = "sha256:d03549fff01f38c1a96da4f79375c33378205ee9b5c6e01b87ba576f59b7887f", size = 133749, upload-time = "2026-01-21T18:05:38.002Z" }, + { url = "https://files.pythonhosted.org/packages/d8/ff/a1497b3ea63ab0658518fc18532179e5696c5d8d7b28683ec82c34323e54/microsoft_agents_hosting_core-0.8.0-py3-none-any.whl", hash = "sha256:603f53f14bebc7888b5664718bbd24038dafffdd282c81d0e635fca7acfc6aef", size = 139555, upload-time = "2026-02-24T18:29:03.479Z" }, ] [[package]] @@ -3484,16 +3472,16 @@ wheels = [ [[package]] name = "msal" -version = "1.34.0" +version = "1.35.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "cryptography", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "pyjwt", extra = ["crypto"], marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/cf/0e/c857c46d653e104019a84f22d4494f2119b4fe9f896c92b4b864b3b045cc/msal-1.34.0.tar.gz", hash = "sha256:76ba83b716ea5a6d75b0279c0ac353a0e05b820ca1f6682c0eb7f45190c43c2f", size = 153961, upload-time = "2025-09-22T23:05:48.989Z" } +sdist = { url = "https://files.pythonhosted.org/packages/95/ec/52e6c9ad90ad7eb3035f5e511123e89d1ecc7617f0c94653264848623c12/msal-1.35.0.tar.gz", hash = "sha256:76ab7513dbdac88d76abdc6a50110f082b7ed3ff1080aca938c53fc88bc75b51", size = 164057, upload-time = "2026-02-24T10:58:28.415Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/c2/dc/18d48843499e278538890dc709e9ee3dea8375f8be8e82682851df1b48b5/msal-1.34.0-py3-none-any.whl", hash = "sha256:f669b1644e4950115da7a176441b0e13ec2975c29528d8b9e81316023676d6e1", size = 116987, upload-time = "2025-09-22T23:05:47.294Z" }, + { url = "https://files.pythonhosted.org/packages/56/26/5463e615de18ad8b80d75d14c612ef3c866fcc07c1c52e8eac7948984214/msal-1.35.0-py3-none-any.whl", hash = "sha256:baf268172d2b736e5d409689424d2f321b4142cab231b4b96594c86762e7e01d", size = 120082, upload-time = "2026-02-24T10:58:27.219Z" }, ] [[package]] @@ -3703,11 +3691,11 @@ wheels = [ [[package]] name = "narwhals" -version = "2.16.0" +version = "2.17.0" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/fc/6f/713be67779028d482c6e0f2dde5bc430021b2578a4808c1c9f6d7ad48257/narwhals-2.16.0.tar.gz", hash = "sha256:155bb45132b370941ba0396d123cf9ed192bf25f39c4cea726f2da422ca4e145", size = 618268, upload-time = "2026-02-02T10:31:00.545Z" } +sdist = { url = "https://files.pythonhosted.org/packages/75/59/81d0f4cad21484083466f278e6b392addd9f4205b48d45b5c8771670ebf8/narwhals-2.17.0.tar.gz", hash = "sha256:ebd5bc95bcfa2f8e89a8ac09e2765a63055162837208e67b42d6eeb6651d5e67", size = 620306, upload-time = "2026-02-23T09:44:34.142Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/03/cc/7cb74758e6df95e0c4e1253f203b6dd7f348bf2f29cf89e9210a2416d535/narwhals-2.16.0-py3-none-any.whl", hash = "sha256:846f1fd7093ac69d63526e50732033e86c30ea0026a44d9b23991010c7d1485d", size = 443951, upload-time = "2026-02-02T10:30:58.635Z" }, + { url = "https://files.pythonhosted.org/packages/4b/27/20770bd6bf8fbe1e16f848ba21da9df061f38d2e6483952c29d2bb5d1d8b/narwhals-2.17.0-py3-none-any.whl", hash = "sha256:2ac5307b7c2b275a7d66eeda906b8605e3d7a760951e188dcfff86e8ebe083dd", size = 444897, upload-time = "2026-02-23T09:44:32.006Z" }, ] [[package]] @@ -3903,7 +3891,7 @@ wheels = [ [[package]] name = "openai" -version = "2.21.0" +version = "2.24.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "anyio", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -3915,14 +3903,14 @@ dependencies = [ { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/92/e5/3d197a0947a166649f566706d7a4c8f7fe38f1fa7b24c9bcffe4c7591d44/openai-2.21.0.tar.gz", hash = "sha256:81b48ce4b8bbb2cc3af02047ceb19561f7b1dc0d4e52d1de7f02abfd15aa59b7", size = 644374, upload-time = "2026-02-14T00:12:01.577Z" } +sdist = { url = "https://files.pythonhosted.org/packages/55/13/17e87641b89b74552ed408a92b231283786523edddc95f3545809fab673c/openai-2.24.0.tar.gz", hash = "sha256:1e5769f540dbd01cb33bc4716a23e67b9d695161a734aff9c5f925e2bf99a673", size = 658717, upload-time = "2026-02-24T20:02:07.958Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cc/56/0a89092a453bb2c676d66abee44f863e742b2110d4dbb1dbcca3f7e5fc33/openai-2.21.0-py3-none-any.whl", hash = "sha256:0bc1c775e5b1536c294eded39ee08f8407656537ccc71b1004104fe1602e267c", size = 1103065, upload-time = "2026-02-14T00:11:59.603Z" }, + { url = "https://files.pythonhosted.org/packages/c9/30/844dc675ee6902579b8eef01ed23917cc9319a1c9c0c14ec6e39340c96d0/openai-2.24.0-py3-none-any.whl", hash = "sha256:fed30480d7d6c884303287bde864980a4b137b60553ffbcf9ab4a233b7a73d94", size = 1120122, upload-time = "2026-02-24T20:02:05.669Z" }, ] [[package]] name = "openai-agents" -version = "0.9.1" +version = "0.10.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "griffe", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -3933,14 +3921,14 @@ dependencies = [ { name = "types-requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/97/6a/0a396fac3f2a5cec51634513428582d8d4687ed18883410fd42957f53878/openai_agents-0.9.1.tar.gz", hash = "sha256:54c8af9efbe9d54d9ba40b85075e0dc4c773ad8e1cb7625de7d3da294765dd64", size = 2381645, upload-time = "2026-02-17T05:36:53.294Z" } +sdist = { url = "https://files.pythonhosted.org/packages/15/2c/a58fefef46bba20f5d8760509aebbe2a581d6ceb11f2ec56345e52b1d85d/openai_agents-0.10.1.tar.gz", hash = "sha256:41c5ae9f1f6e5c23826745ff99dc59a313929d9ddf8f451ac20d7d5dd47627ea", size = 2425265, upload-time = "2026-02-24T01:49:25.901Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/78/17c9b833f44d161b2fa6d102aef61d5969a7edcd36db4e659f000b25f6da/openai_agents-0.9.1-py3-none-any.whl", hash = "sha256:c51962fc50078e3f77b94d2adf31af28083d888c6de60cbbb2d83e95a6e0e947", size = 388137, upload-time = "2026-02-17T05:36:51.283Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7c/69e94f7580c6fb999c26bec9a680e94e76db66460438c8ece0b09b898d1b/openai_agents-0.10.1-py3-none-any.whl", hash = "sha256:12b3295d7b240533060032e625bef472a07761f5eef732412e30bd82f4c14945", size = 400624, upload-time = "2026-02-24T01:49:23.561Z" }, ] [[package]] name = "openai-chatkit" -version = "1.6.1" +version = "1.6.2" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "jinja2", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -3949,9 +3937,9 @@ dependencies = [ { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "uvicorn", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/d7/77/ddf5b0a49dc9b42af005e544ad521892b79519c491fae5cbbaa28f071b40/openai_chatkit-1.6.1.tar.gz", hash = "sha256:470b97db391f199984de04c93bd461d2311c38a3ed19b35c56f9bd40b47e1d08", size = 61046, upload-time = "2026-02-17T18:51:51.442Z" } +sdist = { url = "https://files.pythonhosted.org/packages/40/87/87826ce30c34a9d3c71eecdd96f7add26a57cba2ec0e6fbf933e321f2254/openai_chatkit-1.6.2.tar.gz", hash = "sha256:fd91e8bf0e14244dc86f20c5f93f8386beff3aa1afbcd6f1fec7c1f52de856c6", size = 61562, upload-time = "2026-02-20T20:57:20.228Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/44/22/3f9ffe41ee15756509360828ffbf243fe02e6c2eb9c9f77c3b0382768490/openai_chatkit-1.6.1-py3-none-any.whl", hash = "sha256:1c7e1e33742b88ec5715133d79f0e751406577d51d22aad8fbbf979923aaa36b", size = 42291, upload-time = "2026-02-17T18:51:50.3Z" }, + { url = "https://files.pythonhosted.org/packages/14/50/0043bc560068f810b42f7cc14cdf5c7e0c8521f5bffd157adb1ae3c9303c/openai_chatkit-1.6.2-py3-none-any.whl", hash = "sha256:9cd64c49539780be5411a8907b4f67e156949b6d73e8bdbade60254aca8a537e", size = 42566, upload-time = "2026-02-20T20:57:19.088Z" }, ] [[package]] @@ -3999,7 +3987,7 @@ source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "googleapis-common-protos", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "grpcio", version = "1.67.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.14' and sys_platform == 'darwin') or (python_full_version < '3.14' and sys_platform == 'linux') or (python_full_version < '3.14' and sys_platform == 'win32')" }, - { name = "grpcio", version = "1.78.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.14' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform == 'win32')" }, + { name = "grpcio", version = "1.78.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.14' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform == 'win32')" }, { name = "opentelemetry-api", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-exporter-otlp-proto-common", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "opentelemetry-proto", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -4085,11 +4073,15 @@ wheels = [ [[package]] name = "opentelemetry-semantic-conventions-ai" -version = "0.4.13" +version = "0.4.14" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ba/e6/40b59eda51ac47009fb47afcdf37c6938594a0bd7f3b9fadcbc6058248e3/opentelemetry_semantic_conventions_ai-0.4.13.tar.gz", hash = "sha256:94efa9fb4ffac18c45f54a3a338ffeb7eedb7e1bb4d147786e77202e159f0036", size = 5368, upload-time = "2025-08-22T10:14:17.387Z" } +dependencies = [ + { name = "opentelemetry-sdk", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "opentelemetry-semantic-conventions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/74/33/f77151a8c9bf93094074533ea751305e9f3fec1a4197b0f218d09cb8dce2/opentelemetry_semantic_conventions_ai-0.4.14.tar.gz", hash = "sha256:0495774011933010db7dbfa5111a2fa649edeedef922e39c898154c81eae89d8", size = 18418, upload-time = "2026-02-22T20:25:34.42Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/35/b5/cf25da2218910f0d6cdf7f876a06bed118c4969eacaf60a887cbaef44f44/opentelemetry_semantic_conventions_ai-0.4.13-py3-none-any.whl", hash = "sha256:883a30a6bb5deaec0d646912b5f9f6dcbb9f6f72557b73d0f2560bf25d13e2d5", size = 6080, upload-time = "2025-08-22T10:14:16.477Z" }, + { url = "https://files.pythonhosted.org/packages/56/d5/cdc62ce0f7357cd91682bb1e31d7a68a3c0da5abdbd8c69ffa9aec555f1b/opentelemetry_semantic_conventions_ai-0.4.14-py3-none-any.whl", hash = "sha256:218e0bf656b1d459c5bc608e2a30272b7ab0a4a5b69c1bd5b659c3918f4ad144", size = 5824, upload-time = "2026-02-22T20:25:33.307Z" }, ] [[package]] @@ -4499,15 +4491,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, ] -[[package]] -name = "ply" -version = "3.11" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/e5/69/882ee5c9d017149285cab114ebeab373308ef0f874fcdac9beb90e0ac4da/ply-3.11.tar.gz", hash = "sha256:00c7c1aaa88358b9c765b6d3000c6eec0ba42abca5351b095321aef446081da3", size = 159130, upload-time = "2018-02-15T19:01:31.097Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/a3/58/35da89ee790598a0700ea49b2a66594140f44dec458c07e8e3d4979137fc/ply-3.11-py2.py3-none-any.whl", hash = "sha256:096f9b8350b65ebd2fd1346b12452efe5b9607f7482813ffca50c22722a807ce", size = 49567, upload-time = "2018-02-15T19:01:27.172Z" }, -] - [[package]] name = "poethepoet" version = "0.42.0" @@ -4564,7 +4547,7 @@ wheels = [ [[package]] name = "posthog" -version = "7.9.1" +version = "7.9.3" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "backoff", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -4574,9 +4557,9 @@ dependencies = [ { name = "six", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5b/8c/0b66a64bca61d927b7e3ddab564419213303ab9f2bce42036b894c3919d7/posthog-7.9.1.tar.gz", hash = "sha256:448fb0ec4d5cabb8967a36512b8a9aa50d1e46657913245031b41ca434ca9882", size = 172247, upload-time = "2026-02-17T16:59:40.345Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/06/bcffcd262c861695fbaa74490b872e37d6fc41d3dcc1a43207d20525522f/posthog-7.9.3.tar.gz", hash = "sha256:55f7580265d290936ac4c112a4e2031a41743be4f90d4183ac9f85b721ff13ae", size = 172336, upload-time = "2026-02-18T22:20:24.085Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/78/47/9033ff9020f9b473e4f89b349f821c2ad053241cf2274693f838c9edbc7b/posthog-7.9.1-py3-none-any.whl", hash = "sha256:fe1c4869545f0bfaf458618f03875ea226f17ea23a94553e2e9d611dc77af722", size = 197851, upload-time = "2026-02-17T16:59:37.679Z" }, + { url = "https://files.pythonhosted.org/packages/11/7e/0e06a96823fa7c11ce73920e6ff77e82445db62ac4eae0b6f211edb4c4c2/posthog-7.9.3-py3-none-any.whl", hash = "sha256:2ddcacdef6c4afb124ebfcf27d7be58388943a7e24f8d4a51a52732c9b90bad6", size = 197819, upload-time = "2026-02-18T22:20:22.015Z" }, ] [[package]] @@ -4584,8 +4567,8 @@ name = "powerfx" version = "0.0.34" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "(python_full_version < '3.14' and sys_platform == 'darwin') or (python_full_version < '3.14' and sys_platform == 'linux') or (python_full_version < '3.14' and sys_platform == 'win32')" }, - { name = "pythonnet", marker = "(python_full_version < '3.14' and sys_platform == 'darwin') or (python_full_version < '3.14' and sys_platform == 'linux') or (python_full_version < '3.14' and sys_platform == 'win32')" }, + { name = "cffi", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, + { name = "pythonnet", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9f/fb/6c4bf87e0c74ca1c563921ce89ca1c5785b7576bca932f7255cdf81082a7/powerfx-0.0.34.tar.gz", hash = "sha256:956992e7afd272657ed16d80f4cad24ec95d9e4a79fb9dfa4a068a09e136af32", size = 3237555, upload-time = "2025-12-22T15:50:59.682Z" } wheels = [ @@ -5010,16 +4993,16 @@ wheels = [ [[package]] name = "pydantic-settings" -version = "2.13.0" +version = "2.13.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "python-dotenv", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "typing-inspection", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/96/a1/ae859ffac5a3338a66b74c5e29e244fd3a3cc483c89feaf9f56c39898d75/pydantic_settings-2.13.0.tar.gz", hash = "sha256:95d875514610e8595672800a5c40b073e99e4aae467fa7c8f9c263061ea2e1fe", size = 222450, upload-time = "2026-02-15T12:11:23.476Z" } +sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/b0/1a/dd1b9d7e627486cf8e7523d09b70010e05a4bc41414f4ae6ce184cf0afb6/pydantic_settings-2.13.0-py3-none-any.whl", hash = "sha256:d67b576fff39cd086b595441bf9c75d4193ca9c0ed643b90360694d0f1240246", size = 58429, upload-time = "2026-02-15T12:11:22.133Z" }, + { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" }, ] [[package]] @@ -5248,7 +5231,7 @@ name = "pythonnet" version = "3.0.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "clr-loader", marker = "(python_full_version < '3.14' and sys_platform == 'darwin') or (python_full_version < '3.14' and sys_platform == 'linux') or (python_full_version < '3.14' and sys_platform == 'win32')" }, + { name = "clr-loader", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9a/d6/1afd75edd932306ae9bd2c2d961d603dc2b52fcec51b04afea464f1f6646/pythonnet-3.0.5.tar.gz", hash = "sha256:48e43ca463941b3608b32b4e236db92d8d40db4c58a75ace902985f76dac21cf", size = 239212, upload-time = "2024-12-13T08:30:44.393Z" } wheels = [ @@ -5352,11 +5335,11 @@ wheels = [ [[package]] name = "qdrant-client" -version = "1.16.2" +version = "1.17.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "grpcio", version = "1.67.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.14' and sys_platform == 'darwin') or (python_full_version < '3.14' and sys_platform == 'linux') or (python_full_version < '3.14' and sys_platform == 'win32')" }, - { name = "grpcio", version = "1.78.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.14' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform == 'win32')" }, + { name = "grpcio", version = "1.78.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.14' and sys_platform == 'darwin') or (python_full_version >= '3.14' and sys_platform == 'linux') or (python_full_version >= '3.14' and sys_platform == 'win32')" }, { name = "httpx", extra = ["http2"], marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform == 'win32')" }, { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform == 'darwin') or (python_full_version >= '3.11' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, @@ -5365,9 +5348,9 @@ dependencies = [ { name = "pydantic", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "urllib3", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/ca/7d/3cd10e26ae97b35cf856ca1dc67576e42414ae39502c51165bb36bb1dff8/qdrant_client-1.16.2.tar.gz", hash = "sha256:ca4ef5f9be7b5eadeec89a085d96d5c723585a391eb8b2be8192919ab63185f0", size = 331112, upload-time = "2025-12-12T10:58:30.866Z" } +sdist = { url = "https://files.pythonhosted.org/packages/20/fb/c9c4cecf6e7fdff2dbaeee0de40e93fe495379eb5fe2775b184ea45315da/qdrant_client-1.17.0.tar.gz", hash = "sha256:47eb033edb9be33a4babb4d87b0d8d5eaf03d52112dca0218db7f2030bf41ba9", size = 344839, upload-time = "2026-02-19T16:03:17.069Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/08/13/8ce16f808297e16968269de44a14f4fef19b64d9766be1d6ba5ba78b579d/qdrant_client-1.16.2-py3-none-any.whl", hash = "sha256:442c7ef32ae0f005e88b5d3c0783c63d4912b97ae756eb5e052523be682f17d3", size = 377186, upload-time = "2025-12-12T10:58:29.282Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/dfadbc9d8c9872e8ac45fa96f5099bb2855f23426bfea1bbcdc85e64ef6e/qdrant_client-1.17.0-py3-none-any.whl", hash = "sha256:f5b452c68c42b3580d3d266446fb00d3c6e3aae89c916e16585b3c704e108438", size = 390381, upload-time = "2026-02-19T16:03:15.486Z" }, ] [[package]] @@ -5418,123 +5401,123 @@ wheels = [ [[package]] name = "regex" -version = "2026.1.15" +version = "2026.2.19" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0b/86/07d5056945f9ec4590b518171c4254a5925832eb727b56d3c38a7476f316/regex-2026.1.15.tar.gz", hash = "sha256:164759aa25575cbc0651bef59a0b18353e54300d79ace8084c818ad8ac72b7d5", size = 414811, upload-time = "2026-01-14T23:18:02.775Z" } +sdist = { url = "https://files.pythonhosted.org/packages/ff/c0/d8079d4f6342e4cec5c3e7d7415b5cd3e633d5f4124f7a4626908dbe84c7/regex-2026.2.19.tar.gz", hash = "sha256:6fb8cb09b10e38f3ae17cc6dc04a1df77762bd0351b6ba9041438e7cc85ec310", size = 414973, upload-time = "2026-02-19T19:03:47.899Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/ea/d2/e6ee96b7dff201a83f650241c52db8e5bd080967cb93211f57aa448dc9d6/regex-2026.1.15-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4e3dd93c8f9abe8aa4b6c652016da9a3afa190df5ad822907efe6b206c09896e", size = 488166, upload-time = "2026-01-14T23:13:46.408Z" }, - { url = "https://files.pythonhosted.org/packages/23/8a/819e9ce14c9f87af026d0690901b3931f3101160833e5d4c8061fa3a1b67/regex-2026.1.15-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:97499ff7862e868b1977107873dd1a06e151467129159a6ffd07b66706ba3a9f", size = 290632, upload-time = "2026-01-14T23:13:48.688Z" }, - { url = "https://files.pythonhosted.org/packages/d5/c3/23dfe15af25d1d45b07dfd4caa6003ad710dcdcb4c4b279909bdfe7a2de8/regex-2026.1.15-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0bda75ebcac38d884240914c6c43d8ab5fb82e74cde6da94b43b17c411aa4c2b", size = 288500, upload-time = "2026-01-14T23:13:50.503Z" }, - { url = "https://files.pythonhosted.org/packages/c6/31/1adc33e2f717df30d2f4d973f8776d2ba6ecf939301efab29fca57505c95/regex-2026.1.15-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7dcc02368585334f5bc81fc73a2a6a0bbade60e7d83da21cead622faf408f32c", size = 781670, upload-time = "2026-01-14T23:13:52.453Z" }, - { url = "https://files.pythonhosted.org/packages/23/ce/21a8a22d13bc4adcb927c27b840c948f15fc973e21ed2346c1bd0eae22dc/regex-2026.1.15-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:693b465171707bbe882a7a05de5e866f33c76aa449750bee94a8d90463533cc9", size = 850820, upload-time = "2026-01-14T23:13:54.894Z" }, - { url = "https://files.pythonhosted.org/packages/6c/4f/3eeacdf587a4705a44484cd0b30e9230a0e602811fb3e2cc32268c70d509/regex-2026.1.15-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b0d190e6f013ea938623a58706d1469a62103fb2a241ce2873a9906e0386582c", size = 898777, upload-time = "2026-01-14T23:13:56.908Z" }, - { url = "https://files.pythonhosted.org/packages/79/a9/1898a077e2965c35fc22796488141a22676eed2d73701e37c73ad7c0b459/regex-2026.1.15-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ff818702440a5878a81886f127b80127f5d50563753a28211482867f8318106", size = 791750, upload-time = "2026-01-14T23:13:58.527Z" }, - { url = "https://files.pythonhosted.org/packages/4c/84/e31f9d149a178889b3817212827f5e0e8c827a049ff31b4b381e76b26e2d/regex-2026.1.15-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f052d1be37ef35a54e394de66136e30fa1191fab64f71fc06ac7bc98c9a84618", size = 782674, upload-time = "2026-01-14T23:13:59.874Z" }, - { url = "https://files.pythonhosted.org/packages/d2/ff/adf60063db24532add6a1676943754a5654dcac8237af024ede38244fd12/regex-2026.1.15-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6bfc31a37fd1592f0c4fc4bfc674b5c42e52efe45b4b7a6a14f334cca4bcebe4", size = 767906, upload-time = "2026-01-14T23:14:01.298Z" }, - { url = "https://files.pythonhosted.org/packages/af/3e/e6a216cee1e2780fec11afe7fc47b6f3925d7264e8149c607ac389fd9b1a/regex-2026.1.15-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3d6ce5ae80066b319ae3bc62fd55a557c9491baa5efd0d355f0de08c4ba54e79", size = 774798, upload-time = "2026-01-14T23:14:02.715Z" }, - { url = "https://files.pythonhosted.org/packages/0f/98/23a4a8378a9208514ed3efc7e7850c27fa01e00ed8557c958df0335edc4a/regex-2026.1.15-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:1704d204bd42b6bb80167df0e4554f35c255b579ba99616def38f69e14a5ccb9", size = 845861, upload-time = "2026-01-14T23:14:04.824Z" }, - { url = "https://files.pythonhosted.org/packages/f8/57/d7605a9d53bd07421a8785d349cd29677fe660e13674fa4c6cbd624ae354/regex-2026.1.15-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:e3174a5ed4171570dc8318afada56373aa9289eb6dc0d96cceb48e7358b0e220", size = 755648, upload-time = "2026-01-14T23:14:06.371Z" }, - { url = "https://files.pythonhosted.org/packages/6f/76/6f2e24aa192da1e299cc1101674a60579d3912391867ce0b946ba83e2194/regex-2026.1.15-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:87adf5bd6d72e3e17c9cb59ac4096b1faaf84b7eb3037a5ffa61c4b4370f0f13", size = 836250, upload-time = "2026-01-14T23:14:08.343Z" }, - { url = "https://files.pythonhosted.org/packages/11/3a/1f2a1d29453299a7858eab7759045fc3d9d1b429b088dec2dc85b6fa16a2/regex-2026.1.15-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e85dc94595f4d766bd7d872a9de5ede1ca8d3063f3bdf1e2c725f5eb411159e3", size = 779919, upload-time = "2026-01-14T23:14:09.954Z" }, - { url = "https://files.pythonhosted.org/packages/c0/67/eab9bc955c9dcc58e9b222c801e39cff7ca0b04261792a2149166ce7e792/regex-2026.1.15-cp310-cp310-win32.whl", hash = "sha256:21ca32c28c30d5d65fc9886ff576fc9b59bbca08933e844fa2363e530f4c8218", size = 265888, upload-time = "2026-01-14T23:14:11.35Z" }, - { url = "https://files.pythonhosted.org/packages/1d/62/31d16ae24e1f8803bddb0885508acecaec997fcdcde9c243787103119ae4/regex-2026.1.15-cp310-cp310-win_amd64.whl", hash = "sha256:3038a62fc7d6e5547b8915a3d927a0fbeef84cdbe0b1deb8c99bbd4a8961b52a", size = 277830, upload-time = "2026-01-14T23:14:12.908Z" }, - { url = "https://files.pythonhosted.org/packages/e5/36/5d9972bccd6417ecd5a8be319cebfd80b296875e7f116c37fb2a2deecebf/regex-2026.1.15-cp310-cp310-win_arm64.whl", hash = "sha256:505831646c945e3e63552cc1b1b9b514f0e93232972a2d5bedbcc32f15bc82e3", size = 270376, upload-time = "2026-01-14T23:14:14.782Z" }, - { url = "https://files.pythonhosted.org/packages/d0/c9/0c80c96eab96948363d270143138d671d5731c3a692b417629bf3492a9d6/regex-2026.1.15-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ae6020fb311f68d753b7efa9d4b9a5d47a5d6466ea0d5e3b5a471a960ea6e4a", size = 488168, upload-time = "2026-01-14T23:14:16.129Z" }, - { url = "https://files.pythonhosted.org/packages/17/f0/271c92f5389a552494c429e5cc38d76d1322eb142fb5db3c8ccc47751468/regex-2026.1.15-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:eddf73f41225942c1f994914742afa53dc0d01a6e20fe14b878a1b1edc74151f", size = 290636, upload-time = "2026-01-14T23:14:17.715Z" }, - { url = "https://files.pythonhosted.org/packages/a0/f9/5f1fd077d106ca5655a0f9ff8f25a1ab55b92128b5713a91ed7134ff688e/regex-2026.1.15-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e8cd52557603f5c66a548f69421310886b28b7066853089e1a71ee710e1cdc1", size = 288496, upload-time = "2026-01-14T23:14:19.326Z" }, - { url = "https://files.pythonhosted.org/packages/b5/e1/8f43b03a4968c748858ec77f746c286d81f896c2e437ccf050ebc5d3128c/regex-2026.1.15-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5170907244b14303edc5978f522f16c974f32d3aa92109fabc2af52411c9433b", size = 793503, upload-time = "2026-01-14T23:14:20.922Z" }, - { url = "https://files.pythonhosted.org/packages/8d/4e/a39a5e8edc5377a46a7c875c2f9a626ed3338cb3bb06931be461c3e1a34a/regex-2026.1.15-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2748c1ec0663580b4510bd89941a31560b4b439a0b428b49472a3d9944d11cd8", size = 860535, upload-time = "2026-01-14T23:14:22.405Z" }, - { url = "https://files.pythonhosted.org/packages/dc/1c/9dce667a32a9477f7a2869c1c767dc00727284a9fa3ff5c09a5c6c03575e/regex-2026.1.15-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2f2775843ca49360508d080eaa87f94fa248e2c946bbcd963bb3aae14f333413", size = 907225, upload-time = "2026-01-14T23:14:23.897Z" }, - { url = "https://files.pythonhosted.org/packages/a4/3c/87ca0a02736d16b6262921425e84b48984e77d8e4e572c9072ce96e66c30/regex-2026.1.15-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9ea2604370efc9a174c1b5dcc81784fb040044232150f7f33756049edfc9026", size = 800526, upload-time = "2026-01-14T23:14:26.039Z" }, - { url = "https://files.pythonhosted.org/packages/4b/ff/647d5715aeea7c87bdcbd2f578f47b415f55c24e361e639fe8c0cc88878f/regex-2026.1.15-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0dcd31594264029b57bf16f37fd7248a70b3b764ed9e0839a8f271b2d22c0785", size = 773446, upload-time = "2026-01-14T23:14:28.109Z" }, - { url = "https://files.pythonhosted.org/packages/af/89/bf22cac25cb4ba0fe6bff52ebedbb65b77a179052a9d6037136ae93f42f4/regex-2026.1.15-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c08c1f3e34338256732bd6938747daa3c0d5b251e04b6e43b5813e94d503076e", size = 783051, upload-time = "2026-01-14T23:14:29.929Z" }, - { url = "https://files.pythonhosted.org/packages/1e/f4/6ed03e71dca6348a5188363a34f5e26ffd5db1404780288ff0d79513bce4/regex-2026.1.15-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e43a55f378df1e7a4fa3547c88d9a5a9b7113f653a66821bcea4718fe6c58763", size = 854485, upload-time = "2026-01-14T23:14:31.366Z" }, - { url = "https://files.pythonhosted.org/packages/d9/9a/8e8560bd78caded8eb137e3e47612430a05b9a772caf60876435192d670a/regex-2026.1.15-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f82110ab962a541737bd0ce87978d4c658f06e7591ba899192e2712a517badbb", size = 762195, upload-time = "2026-01-14T23:14:32.802Z" }, - { url = "https://files.pythonhosted.org/packages/38/6b/61fc710f9aa8dfcd764fe27d37edfaa023b1a23305a0d84fccd5adb346ea/regex-2026.1.15-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:27618391db7bdaf87ac6c92b31e8f0dfb83a9de0075855152b720140bda177a2", size = 845986, upload-time = "2026-01-14T23:14:34.898Z" }, - { url = "https://files.pythonhosted.org/packages/fd/2e/fbee4cb93f9d686901a7ca8d94285b80405e8c34fe4107f63ffcbfb56379/regex-2026.1.15-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bfb0d6be01fbae8d6655c8ca21b3b72458606c4aec9bbc932db758d47aba6db1", size = 788992, upload-time = "2026-01-14T23:14:37.116Z" }, - { url = "https://files.pythonhosted.org/packages/ed/14/3076348f3f586de64b1ab75a3fbabdaab7684af7f308ad43be7ef1849e55/regex-2026.1.15-cp311-cp311-win32.whl", hash = "sha256:b10e42a6de0e32559a92f2f8dc908478cc0fa02838d7dbe764c44dca3fa13569", size = 265893, upload-time = "2026-01-14T23:14:38.426Z" }, - { url = "https://files.pythonhosted.org/packages/0f/19/772cf8b5fc803f5c89ba85d8b1870a1ca580dc482aa030383a9289c82e44/regex-2026.1.15-cp311-cp311-win_amd64.whl", hash = "sha256:e9bf3f0bbdb56633c07d7116ae60a576f846efdd86a8848f8d62b749e1209ca7", size = 277840, upload-time = "2026-01-14T23:14:39.785Z" }, - { url = "https://files.pythonhosted.org/packages/78/84/d05f61142709474da3c0853222d91086d3e1372bcdab516c6fd8d80f3297/regex-2026.1.15-cp311-cp311-win_arm64.whl", hash = "sha256:41aef6f953283291c4e4e6850607bd71502be67779586a61472beacb315c97ec", size = 270374, upload-time = "2026-01-14T23:14:41.592Z" }, - { url = "https://files.pythonhosted.org/packages/92/81/10d8cf43c807d0326efe874c1b79f22bfb0fb226027b0b19ebc26d301408/regex-2026.1.15-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4c8fcc5793dde01641a35905d6731ee1548f02b956815f8f1cab89e515a5bdf1", size = 489398, upload-time = "2026-01-14T23:14:43.741Z" }, - { url = "https://files.pythonhosted.org/packages/90/b0/7c2a74e74ef2a7c32de724658a69a862880e3e4155cba992ba04d1c70400/regex-2026.1.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bfd876041a956e6a90ad7cdb3f6a630c07d491280bfeed4544053cd434901681", size = 291339, upload-time = "2026-01-14T23:14:45.183Z" }, - { url = "https://files.pythonhosted.org/packages/19/4d/16d0773d0c818417f4cc20aa0da90064b966d22cd62a8c46765b5bd2d643/regex-2026.1.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9250d087bc92b7d4899ccd5539a1b2334e44eee85d848c4c1aef8e221d3f8c8f", size = 289003, upload-time = "2026-01-14T23:14:47.25Z" }, - { url = "https://files.pythonhosted.org/packages/c6/e4/1fc4599450c9f0863d9406e944592d968b8d6dfd0d552a7d569e43bceada/regex-2026.1.15-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8a154cf6537ebbc110e24dabe53095e714245c272da9c1be05734bdad4a61aa", size = 798656, upload-time = "2026-01-14T23:14:48.77Z" }, - { url = "https://files.pythonhosted.org/packages/b2/e6/59650d73a73fa8a60b3a590545bfcf1172b4384a7df2e7fe7b9aab4e2da9/regex-2026.1.15-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8050ba2e3ea1d8731a549e83c18d2f0999fbc99a5f6bd06b4c91449f55291804", size = 864252, upload-time = "2026-01-14T23:14:50.528Z" }, - { url = "https://files.pythonhosted.org/packages/6e/ab/1d0f4d50a1638849a97d731364c9a80fa304fec46325e48330c170ee8e80/regex-2026.1.15-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf065240704cb8951cc04972cf107063917022511273e0969bdb34fc173456c", size = 912268, upload-time = "2026-01-14T23:14:52.952Z" }, - { url = "https://files.pythonhosted.org/packages/dd/df/0d722c030c82faa1d331d1921ee268a4e8fb55ca8b9042c9341c352f17fa/regex-2026.1.15-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c32bef3e7aeee75746748643667668ef941d28b003bfc89994ecf09a10f7a1b5", size = 803589, upload-time = "2026-01-14T23:14:55.182Z" }, - { url = "https://files.pythonhosted.org/packages/66/23/33289beba7ccb8b805c6610a8913d0131f834928afc555b241caabd422a9/regex-2026.1.15-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d5eaa4a4c5b1906bd0d2508d68927f15b81821f85092e06f1a34a4254b0e1af3", size = 775700, upload-time = "2026-01-14T23:14:56.707Z" }, - { url = "https://files.pythonhosted.org/packages/e7/65/bf3a42fa6897a0d3afa81acb25c42f4b71c274f698ceabd75523259f6688/regex-2026.1.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:86c1077a3cc60d453d4084d5b9649065f3bf1184e22992bd322e1f081d3117fb", size = 787928, upload-time = "2026-01-14T23:14:58.312Z" }, - { url = "https://files.pythonhosted.org/packages/f4/f5/13bf65864fc314f68cdd6d8ca94adcab064d4d39dbd0b10fef29a9da48fc/regex-2026.1.15-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:2b091aefc05c78d286657cd4db95f2e6313375ff65dcf085e42e4c04d9c8d410", size = 858607, upload-time = "2026-01-14T23:15:00.657Z" }, - { url = "https://files.pythonhosted.org/packages/a3/31/040e589834d7a439ee43fb0e1e902bc81bd58a5ba81acffe586bb3321d35/regex-2026.1.15-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:57e7d17f59f9ebfa9667e6e5a1c0127b96b87cb9cede8335482451ed00788ba4", size = 763729, upload-time = "2026-01-14T23:15:02.248Z" }, - { url = "https://files.pythonhosted.org/packages/9b/84/6921e8129687a427edf25a34a5594b588b6d88f491320b9de5b6339a4fcb/regex-2026.1.15-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:c6c4dcdfff2c08509faa15d36ba7e5ef5fcfab25f1e8f85a0c8f45bc3a30725d", size = 850697, upload-time = "2026-01-14T23:15:03.878Z" }, - { url = "https://files.pythonhosted.org/packages/8a/87/3d06143d4b128f4229158f2de5de6c8f2485170c7221e61bf381313314b2/regex-2026.1.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cf8ff04c642716a7f2048713ddc6278c5fd41faa3b9cab12607c7abecd012c22", size = 789849, upload-time = "2026-01-14T23:15:06.102Z" }, - { url = "https://files.pythonhosted.org/packages/77/69/c50a63842b6bd48850ebc7ab22d46e7a2a32d824ad6c605b218441814639/regex-2026.1.15-cp312-cp312-win32.whl", hash = "sha256:82345326b1d8d56afbe41d881fdf62f1926d7264b2fc1537f99ae5da9aad7913", size = 266279, upload-time = "2026-01-14T23:15:07.678Z" }, - { url = "https://files.pythonhosted.org/packages/f2/36/39d0b29d087e2b11fd8191e15e81cce1b635fcc845297c67f11d0d19274d/regex-2026.1.15-cp312-cp312-win_amd64.whl", hash = "sha256:4def140aa6156bc64ee9912383d4038f3fdd18fee03a6f222abd4de6357ce42a", size = 277166, upload-time = "2026-01-14T23:15:09.257Z" }, - { url = "https://files.pythonhosted.org/packages/28/32/5b8e476a12262748851fa8ab1b0be540360692325975b094e594dfebbb52/regex-2026.1.15-cp312-cp312-win_arm64.whl", hash = "sha256:c6c565d9a6e1a8d783c1948937ffc377dd5771e83bd56de8317c450a954d2056", size = 270415, upload-time = "2026-01-14T23:15:10.743Z" }, - { url = "https://files.pythonhosted.org/packages/f8/2e/6870bb16e982669b674cce3ee9ff2d1d46ab80528ee6bcc20fb2292efb60/regex-2026.1.15-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e69d0deeb977ffe7ed3d2e4439360089f9c3f217ada608f0f88ebd67afb6385e", size = 489164, upload-time = "2026-01-14T23:15:13.962Z" }, - { url = "https://files.pythonhosted.org/packages/dc/67/9774542e203849b0286badf67199970a44ebdb0cc5fb739f06e47ada72f8/regex-2026.1.15-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3601ffb5375de85a16f407854d11cca8fe3f5febbe3ac78fb2866bb220c74d10", size = 291218, upload-time = "2026-01-14T23:15:15.647Z" }, - { url = "https://files.pythonhosted.org/packages/b2/87/b0cda79f22b8dee05f774922a214da109f9a4c0eca5da2c9d72d77ea062c/regex-2026.1.15-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4c5ef43b5c2d4114eb8ea424bb8c9cec01d5d17f242af88b2448f5ee81caadbc", size = 288895, upload-time = "2026-01-14T23:15:17.788Z" }, - { url = "https://files.pythonhosted.org/packages/3b/6a/0041f0a2170d32be01ab981d6346c83a8934277d82c780d60b127331f264/regex-2026.1.15-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:968c14d4f03e10b2fd960f1d5168c1f0ac969381d3c1fcc973bc45fb06346599", size = 798680, upload-time = "2026-01-14T23:15:19.342Z" }, - { url = "https://files.pythonhosted.org/packages/58/de/30e1cfcdbe3e891324aa7568b7c968771f82190df5524fabc1138cb2d45a/regex-2026.1.15-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56a5595d0f892f214609c9f76b41b7428bed439d98dc961efafdd1354d42baae", size = 864210, upload-time = "2026-01-14T23:15:22.005Z" }, - { url = "https://files.pythonhosted.org/packages/64/44/4db2f5c5ca0ccd40ff052ae7b1e9731352fcdad946c2b812285a7505ca75/regex-2026.1.15-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf650f26087363434c4e560011f8e4e738f6f3e029b85d4904c50135b86cfa5", size = 912358, upload-time = "2026-01-14T23:15:24.569Z" }, - { url = "https://files.pythonhosted.org/packages/79/b6/e6a5665d43a7c42467138c8a2549be432bad22cbd206f5ec87162de74bd7/regex-2026.1.15-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18388a62989c72ac24de75f1449d0fb0b04dfccd0a1a7c1c43af5eb503d890f6", size = 803583, upload-time = "2026-01-14T23:15:26.526Z" }, - { url = "https://files.pythonhosted.org/packages/e7/53/7cd478222169d85d74d7437e74750005e993f52f335f7c04ff7adfda3310/regex-2026.1.15-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d220a2517f5893f55daac983bfa9fe998a7dbcaee4f5d27a88500f8b7873788", size = 775782, upload-time = "2026-01-14T23:15:29.352Z" }, - { url = "https://files.pythonhosted.org/packages/ca/b5/75f9a9ee4b03a7c009fe60500fe550b45df94f0955ca29af16333ef557c5/regex-2026.1.15-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9c08c2fbc6120e70abff5d7f28ffb4d969e14294fb2143b4b5c7d20e46d1714", size = 787978, upload-time = "2026-01-14T23:15:31.295Z" }, - { url = "https://files.pythonhosted.org/packages/72/b3/79821c826245bbe9ccbb54f6eadb7879c722fd3e0248c17bfc90bf54e123/regex-2026.1.15-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7ef7d5d4bd49ec7364315167a4134a015f61e8266c6d446fc116a9ac4456e10d", size = 858550, upload-time = "2026-01-14T23:15:33.558Z" }, - { url = "https://files.pythonhosted.org/packages/4a/85/2ab5f77a1c465745bfbfcb3ad63178a58337ae8d5274315e2cc623a822fa/regex-2026.1.15-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6e42844ad64194fa08d5ccb75fe6a459b9b08e6d7296bd704460168d58a388f3", size = 763747, upload-time = "2026-01-14T23:15:35.206Z" }, - { url = "https://files.pythonhosted.org/packages/6d/84/c27df502d4bfe2873a3e3a7cf1bdb2b9cc10284d1a44797cf38bed790470/regex-2026.1.15-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:cfecdaa4b19f9ca534746eb3b55a5195d5c95b88cac32a205e981ec0a22b7d31", size = 850615, upload-time = "2026-01-14T23:15:37.523Z" }, - { url = "https://files.pythonhosted.org/packages/7d/b7/658a9782fb253680aa8ecb5ccbb51f69e088ed48142c46d9f0c99b46c575/regex-2026.1.15-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:08df9722d9b87834a3d701f3fca570b2be115654dbfd30179f30ab2f39d606d3", size = 789951, upload-time = "2026-01-14T23:15:39.582Z" }, - { url = "https://files.pythonhosted.org/packages/fc/2a/5928af114441e059f15b2f63e188bd00c6529b3051c974ade7444b85fcda/regex-2026.1.15-cp313-cp313-win32.whl", hash = "sha256:d426616dae0967ca225ab12c22274eb816558f2f99ccb4a1d52ca92e8baf180f", size = 266275, upload-time = "2026-01-14T23:15:42.108Z" }, - { url = "https://files.pythonhosted.org/packages/4f/16/5bfbb89e435897bff28cf0352a992ca719d9e55ebf8b629203c96b6ce4f7/regex-2026.1.15-cp313-cp313-win_amd64.whl", hash = "sha256:febd38857b09867d3ed3f4f1af7d241c5c50362e25ef43034995b77a50df494e", size = 277145, upload-time = "2026-01-14T23:15:44.244Z" }, - { url = "https://files.pythonhosted.org/packages/56/c1/a09ff7392ef4233296e821aec5f78c51be5e91ffde0d163059e50fd75835/regex-2026.1.15-cp313-cp313-win_arm64.whl", hash = "sha256:8e32f7896f83774f91499d239e24cebfadbc07639c1494bb7213983842348337", size = 270411, upload-time = "2026-01-14T23:15:45.858Z" }, - { url = "https://files.pythonhosted.org/packages/3c/38/0cfd5a78e5c6db00e6782fdae70458f89850ce95baa5e8694ab91d89744f/regex-2026.1.15-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ec94c04149b6a7b8120f9f44565722c7ae31b7a6d2275569d2eefa76b83da3be", size = 492068, upload-time = "2026-01-14T23:15:47.616Z" }, - { url = "https://files.pythonhosted.org/packages/50/72/6c86acff16cb7c959c4355826bbf06aad670682d07c8f3998d9ef4fee7cd/regex-2026.1.15-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40c86d8046915bb9aeb15d3f3f15b6fd500b8ea4485b30e1bbc799dab3fe29f8", size = 292756, upload-time = "2026-01-14T23:15:49.307Z" }, - { url = "https://files.pythonhosted.org/packages/4e/58/df7fb69eadfe76526ddfce28abdc0af09ffe65f20c2c90932e89d705153f/regex-2026.1.15-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:726ea4e727aba21643205edad8f2187ec682d3305d790f73b7a51c7587b64bdd", size = 291114, upload-time = "2026-01-14T23:15:51.484Z" }, - { url = "https://files.pythonhosted.org/packages/ed/6c/a4011cd1cf96b90d2cdc7e156f91efbd26531e822a7fbb82a43c1016678e/regex-2026.1.15-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1cb740d044aff31898804e7bf1181cc72c03d11dfd19932b9911ffc19a79070a", size = 807524, upload-time = "2026-01-14T23:15:53.102Z" }, - { url = "https://files.pythonhosted.org/packages/1d/25/a53ffb73183f69c3e9f4355c4922b76d2840aee160af6af5fac229b6201d/regex-2026.1.15-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05d75a668e9ea16f832390d22131fe1e8acc8389a694c8febc3e340b0f810b93", size = 873455, upload-time = "2026-01-14T23:15:54.956Z" }, - { url = "https://files.pythonhosted.org/packages/66/0b/8b47fc2e8f97d9b4a851736f3890a5f786443aa8901061c55f24c955f45b/regex-2026.1.15-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d991483606f3dbec93287b9f35596f41aa2e92b7c2ebbb935b63f409e243c9af", size = 915007, upload-time = "2026-01-14T23:15:57.041Z" }, - { url = "https://files.pythonhosted.org/packages/c2/fa/97de0d681e6d26fabe71968dbee06dd52819e9a22fdce5dac7256c31ed84/regex-2026.1.15-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:194312a14819d3e44628a44ed6fea6898fdbecb0550089d84c403475138d0a09", size = 812794, upload-time = "2026-01-14T23:15:58.916Z" }, - { url = "https://files.pythonhosted.org/packages/22/38/e752f94e860d429654aa2b1c51880bff8dfe8f084268258adf9151cf1f53/regex-2026.1.15-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe2fda4110a3d0bc163c2e0664be44657431440722c5c5315c65155cab92f9e5", size = 781159, upload-time = "2026-01-14T23:16:00.817Z" }, - { url = "https://files.pythonhosted.org/packages/e9/a7/d739ffaef33c378fc888302a018d7f81080393d96c476b058b8c64fd2b0d/regex-2026.1.15-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:124dc36c85d34ef2d9164da41a53c1c8c122cfb1f6e1ec377a1f27ee81deb794", size = 795558, upload-time = "2026-01-14T23:16:03.267Z" }, - { url = "https://files.pythonhosted.org/packages/3e/c4/542876f9a0ac576100fc73e9c75b779f5c31e3527576cfc9cb3009dcc58a/regex-2026.1.15-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1774cd1981cd212506a23a14dba7fdeaee259f5deba2df6229966d9911e767a", size = 868427, upload-time = "2026-01-14T23:16:05.646Z" }, - { url = "https://files.pythonhosted.org/packages/fc/0f/d5655bea5b22069e32ae85a947aa564912f23758e112cdb74212848a1a1b/regex-2026.1.15-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:b5f7d8d2867152cdb625e72a530d2ccb48a3d199159144cbdd63870882fb6f80", size = 769939, upload-time = "2026-01-14T23:16:07.542Z" }, - { url = "https://files.pythonhosted.org/packages/20/06/7e18a4fa9d326daeda46d471a44ef94201c46eaa26dbbb780b5d92cbfdda/regex-2026.1.15-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:492534a0ab925d1db998defc3c302dae3616a2fc3fe2e08db1472348f096ddf2", size = 854753, upload-time = "2026-01-14T23:16:10.395Z" }, - { url = "https://files.pythonhosted.org/packages/3b/67/dc8946ef3965e166f558ef3b47f492bc364e96a265eb4a2bb3ca765c8e46/regex-2026.1.15-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c661fc820cfb33e166bf2450d3dadbda47c8d8981898adb9b6fe24e5e582ba60", size = 799559, upload-time = "2026-01-14T23:16:12.347Z" }, - { url = "https://files.pythonhosted.org/packages/a5/61/1bba81ff6d50c86c65d9fd84ce9699dd106438ee4cdb105bf60374ee8412/regex-2026.1.15-cp313-cp313t-win32.whl", hash = "sha256:99ad739c3686085e614bf77a508e26954ff1b8f14da0e3765ff7abbf7799f952", size = 268879, upload-time = "2026-01-14T23:16:14.049Z" }, - { url = "https://files.pythonhosted.org/packages/e9/5e/cef7d4c5fb0ea3ac5c775fd37db5747f7378b29526cc83f572198924ff47/regex-2026.1.15-cp313-cp313t-win_amd64.whl", hash = "sha256:32655d17905e7ff8ba5c764c43cb124e34a9245e45b83c22e81041e1071aee10", size = 280317, upload-time = "2026-01-14T23:16:15.718Z" }, - { url = "https://files.pythonhosted.org/packages/b4/52/4317f7a5988544e34ab57b4bde0f04944c4786128c933fb09825924d3e82/regex-2026.1.15-cp313-cp313t-win_arm64.whl", hash = "sha256:b2a13dd6a95e95a489ca242319d18fc02e07ceb28fa9ad146385194d95b3c829", size = 271551, upload-time = "2026-01-14T23:16:17.533Z" }, - { url = "https://files.pythonhosted.org/packages/52/0a/47fa888ec7cbbc7d62c5f2a6a888878e76169170ead271a35239edd8f0e8/regex-2026.1.15-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:d920392a6b1f353f4aa54328c867fec3320fa50657e25f64abf17af054fc97ac", size = 489170, upload-time = "2026-01-14T23:16:19.835Z" }, - { url = "https://files.pythonhosted.org/packages/ac/c4/d000e9b7296c15737c9301708e9e7fbdea009f8e93541b6b43bdb8219646/regex-2026.1.15-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b5a28980a926fa810dbbed059547b02783952e2efd9c636412345232ddb87ff6", size = 291146, upload-time = "2026-01-14T23:16:21.541Z" }, - { url = "https://files.pythonhosted.org/packages/f9/b6/921cc61982e538682bdf3bdf5b2c6ab6b34368da1f8e98a6c1ddc503c9cf/regex-2026.1.15-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:621f73a07595d83f28952d7bd1e91e9d1ed7625fb7af0064d3516674ec93a2a2", size = 288986, upload-time = "2026-01-14T23:16:23.381Z" }, - { url = "https://files.pythonhosted.org/packages/ca/33/eb7383dde0bbc93f4fb9d03453aab97e18ad4024ac7e26cef8d1f0a2cff0/regex-2026.1.15-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d7d92495f47567a9b1669c51fc8d6d809821849063d168121ef801bbc213846", size = 799098, upload-time = "2026-01-14T23:16:25.088Z" }, - { url = "https://files.pythonhosted.org/packages/27/56/b664dccae898fc8d8b4c23accd853f723bde0f026c747b6f6262b688029c/regex-2026.1.15-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8dd16fba2758db7a3780a051f245539c4451ca20910f5a5e6ea1c08d06d4a76b", size = 864980, upload-time = "2026-01-14T23:16:27.297Z" }, - { url = "https://files.pythonhosted.org/packages/16/40/0999e064a170eddd237bae9ccfcd8f28b3aa98a38bf727a086425542a4fc/regex-2026.1.15-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1e1808471fbe44c1a63e5f577a1d5f02fe5d66031dcbdf12f093ffc1305a858e", size = 911607, upload-time = "2026-01-14T23:16:29.235Z" }, - { url = "https://files.pythonhosted.org/packages/07/78/c77f644b68ab054e5a674fb4da40ff7bffb2c88df58afa82dbf86573092d/regex-2026.1.15-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0751a26ad39d4f2ade8fe16c59b2bf5cb19eb3d2cd543e709e583d559bd9efde", size = 803358, upload-time = "2026-01-14T23:16:31.369Z" }, - { url = "https://files.pythonhosted.org/packages/27/31/d4292ea8566eaa551fafc07797961c5963cf5235c797cc2ae19b85dfd04d/regex-2026.1.15-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0c7684c7f9ca241344ff95a1de964f257a5251968484270e91c25a755532c5", size = 775833, upload-time = "2026-01-14T23:16:33.141Z" }, - { url = "https://files.pythonhosted.org/packages/ce/b2/cff3bf2fea4133aa6fb0d1e370b37544d18c8350a2fa118c7e11d1db0e14/regex-2026.1.15-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:74f45d170a21df41508cb67165456538425185baaf686281fa210d7e729abc34", size = 788045, upload-time = "2026-01-14T23:16:35.005Z" }, - { url = "https://files.pythonhosted.org/packages/8d/99/2cb9b69045372ec877b6f5124bda4eb4253bc58b8fe5848c973f752bc52c/regex-2026.1.15-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f1862739a1ffb50615c0fde6bae6569b5efbe08d98e59ce009f68a336f64da75", size = 859374, upload-time = "2026-01-14T23:16:36.919Z" }, - { url = "https://files.pythonhosted.org/packages/09/16/710b0a5abe8e077b1729a562d2f297224ad079f3a66dce46844c193416c8/regex-2026.1.15-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:453078802f1b9e2b7303fb79222c054cb18e76f7bdc220f7530fdc85d319f99e", size = 763940, upload-time = "2026-01-14T23:16:38.685Z" }, - { url = "https://files.pythonhosted.org/packages/dd/d1/7585c8e744e40eb3d32f119191969b91de04c073fca98ec14299041f6e7e/regex-2026.1.15-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:a30a68e89e5a218b8b23a52292924c1f4b245cb0c68d1cce9aec9bbda6e2c160", size = 850112, upload-time = "2026-01-14T23:16:40.646Z" }, - { url = "https://files.pythonhosted.org/packages/af/d6/43e1dd85df86c49a347aa57c1f69d12c652c7b60e37ec162e3096194a278/regex-2026.1.15-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9479cae874c81bf610d72b85bb681a94c95722c127b55445285fb0e2c82db8e1", size = 789586, upload-time = "2026-01-14T23:16:42.799Z" }, - { url = "https://files.pythonhosted.org/packages/93/38/77142422f631e013f316aaae83234c629555729a9fbc952b8a63ac91462a/regex-2026.1.15-cp314-cp314-win32.whl", hash = "sha256:d639a750223132afbfb8f429c60d9d318aeba03281a5f1ab49f877456448dcf1", size = 271691, upload-time = "2026-01-14T23:16:44.671Z" }, - { url = "https://files.pythonhosted.org/packages/4a/a9/ab16b4649524ca9e05213c1cdbb7faa85cc2aa90a0230d2f796cbaf22736/regex-2026.1.15-cp314-cp314-win_amd64.whl", hash = "sha256:4161d87f85fa831e31469bfd82c186923070fc970b9de75339b68f0c75b51903", size = 280422, upload-time = "2026-01-14T23:16:46.607Z" }, - { url = "https://files.pythonhosted.org/packages/be/2a/20fd057bf3521cb4791f69f869635f73e0aaf2b9ad2d260f728144f9047c/regex-2026.1.15-cp314-cp314-win_arm64.whl", hash = "sha256:91c5036ebb62663a6b3999bdd2e559fd8456d17e2b485bf509784cd31a8b1705", size = 273467, upload-time = "2026-01-14T23:16:48.967Z" }, - { url = "https://files.pythonhosted.org/packages/ad/77/0b1e81857060b92b9cad239104c46507dd481b3ff1fa79f8e7f865aae38a/regex-2026.1.15-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ee6854c9000a10938c79238de2379bea30c82e4925a371711af45387df35cab8", size = 492073, upload-time = "2026-01-14T23:16:51.154Z" }, - { url = "https://files.pythonhosted.org/packages/70/f3/f8302b0c208b22c1e4f423147e1913fd475ddd6230565b299925353de644/regex-2026.1.15-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c2b80399a422348ce5de4fe40c418d6299a0fa2803dd61dc0b1a2f28e280fcf", size = 292757, upload-time = "2026-01-14T23:16:53.08Z" }, - { url = "https://files.pythonhosted.org/packages/bf/f0/ef55de2460f3b4a6da9d9e7daacd0cb79d4ef75c64a2af316e68447f0df0/regex-2026.1.15-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:dca3582bca82596609959ac39e12b7dad98385b4fefccb1151b937383cec547d", size = 291122, upload-time = "2026-01-14T23:16:55.383Z" }, - { url = "https://files.pythonhosted.org/packages/cf/55/bb8ccbacabbc3a11d863ee62a9f18b160a83084ea95cdfc5d207bfc3dd75/regex-2026.1.15-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef71d476caa6692eea743ae5ea23cde3260677f70122c4d258ca952e5c2d4e84", size = 807761, upload-time = "2026-01-14T23:16:57.251Z" }, - { url = "https://files.pythonhosted.org/packages/8f/84/f75d937f17f81e55679a0509e86176e29caa7298c38bd1db7ce9c0bf6075/regex-2026.1.15-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c243da3436354f4af6c3058a3f81a97d47ea52c9bd874b52fd30274853a1d5df", size = 873538, upload-time = "2026-01-14T23:16:59.349Z" }, - { url = "https://files.pythonhosted.org/packages/b8/d9/0da86327df70349aa8d86390da91171bd3ca4f0e7c1d1d453a9c10344da3/regex-2026.1.15-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8355ad842a7c7e9e5e55653eade3b7d1885ba86f124dd8ab1f722f9be6627434", size = 915066, upload-time = "2026-01-14T23:17:01.607Z" }, - { url = "https://files.pythonhosted.org/packages/2a/5e/f660fb23fc77baa2a61aa1f1fe3a4eea2bbb8a286ddec148030672e18834/regex-2026.1.15-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f192a831d9575271a22d804ff1a5355355723f94f31d9eef25f0d45a152fdc1a", size = 812938, upload-time = "2026-01-14T23:17:04.366Z" }, - { url = "https://files.pythonhosted.org/packages/69/33/a47a29bfecebbbfd1e5cd3f26b28020a97e4820f1c5148e66e3b7d4b4992/regex-2026.1.15-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:166551807ec20d47ceaeec380081f843e88c8949780cd42c40f18d16168bed10", size = 781314, upload-time = "2026-01-14T23:17:06.378Z" }, - { url = "https://files.pythonhosted.org/packages/65/ec/7ec2bbfd4c3f4e494a24dec4c6943a668e2030426b1b8b949a6462d2c17b/regex-2026.1.15-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f9ca1cbdc0fbfe5e6e6f8221ef2309988db5bcede52443aeaee9a4ad555e0dac", size = 795652, upload-time = "2026-01-14T23:17:08.521Z" }, - { url = "https://files.pythonhosted.org/packages/46/79/a5d8651ae131fe27d7c521ad300aa7f1c7be1dbeee4d446498af5411b8a9/regex-2026.1.15-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b30bcbd1e1221783c721483953d9e4f3ab9c5d165aa709693d3f3946747b1aea", size = 868550, upload-time = "2026-01-14T23:17:10.573Z" }, - { url = "https://files.pythonhosted.org/packages/06/b7/25635d2809664b79f183070786a5552dd4e627e5aedb0065f4e3cf8ee37d/regex-2026.1.15-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2a8d7b50c34578d0d3bf7ad58cde9652b7d683691876f83aedc002862a35dc5e", size = 769981, upload-time = "2026-01-14T23:17:12.871Z" }, - { url = "https://files.pythonhosted.org/packages/16/8b/fc3fcbb2393dcfa4a6c5ffad92dc498e842df4581ea9d14309fcd3c55fb9/regex-2026.1.15-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9d787e3310c6a6425eb346be4ff2ccf6eece63017916fd77fe8328c57be83521", size = 854780, upload-time = "2026-01-14T23:17:14.837Z" }, - { url = "https://files.pythonhosted.org/packages/d0/38/dde117c76c624713c8a2842530be9c93ca8b606c0f6102d86e8cd1ce8bea/regex-2026.1.15-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:619843841e220adca114118533a574a9cd183ed8a28b85627d2844c500a2b0db", size = 799778, upload-time = "2026-01-14T23:17:17.369Z" }, - { url = "https://files.pythonhosted.org/packages/e3/0d/3a6cfa9ae99606afb612d8fb7a66b245a9d5ff0f29bb347c8a30b6ad561b/regex-2026.1.15-cp314-cp314t-win32.whl", hash = "sha256:e90b8db97f6f2c97eb045b51a6b2c5ed69cedd8392459e0642d4199b94fabd7e", size = 274667, upload-time = "2026-01-14T23:17:19.301Z" }, - { url = "https://files.pythonhosted.org/packages/5b/b2/297293bb0742fd06b8d8e2572db41a855cdf1cae0bf009b1cb74fe07e196/regex-2026.1.15-cp314-cp314t-win_amd64.whl", hash = "sha256:5ef19071f4ac9f0834793af85bd04a920b4407715624e40cb7a0631a11137cdf", size = 284386, upload-time = "2026-01-14T23:17:21.231Z" }, - { url = "https://files.pythonhosted.org/packages/95/e4/a3b9480c78cf8ee86626cb06f8d931d74d775897d44201ccb813097ae697/regex-2026.1.15-cp314-cp314t-win_arm64.whl", hash = "sha256:ca89c5e596fc05b015f27561b3793dc2fa0917ea0d7507eebb448efd35274a70", size = 274837, upload-time = "2026-01-14T23:17:23.146Z" }, + { url = "https://files.pythonhosted.org/packages/af/de/f10b4506acfd684de4e42b0aa56ccea1a778a18864da8f6d319a40591062/regex-2026.2.19-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f5a37a17d110f9d5357a43aa7e3507cb077bf3143d1c549a45c4649e90e40a70", size = 488369, upload-time = "2026-02-19T18:59:45.01Z" }, + { url = "https://files.pythonhosted.org/packages/8b/2f/b4eaef1f0b4d0bf2a73eaf07c08f6c13422918a4180c9211ce0521746d0c/regex-2026.2.19-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:676c4e6847a83a1d5732b4ed553881ad36f0a8133627bb695a89ecf3571499d3", size = 290743, upload-time = "2026-02-19T18:59:48.527Z" }, + { url = "https://files.pythonhosted.org/packages/76/7c/805413bd0a88d04688c0725c222cfb811bd54a2f571004c24199a1ae55d6/regex-2026.2.19-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:82336faeecac33297cd42857c3b36f12b91810e3fdd276befdd128f73a2b43fa", size = 288652, upload-time = "2026-02-19T18:59:50.2Z" }, + { url = "https://files.pythonhosted.org/packages/08/ff/2c4cd530a878b1975398e76faef4285f11e7c9ccf1aaedfd528bfcc1f580/regex-2026.2.19-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:52136f5b71f095cb74b736cc3a1b578030dada2e361ef2f07ca582240b703946", size = 781759, upload-time = "2026-02-19T18:59:51.836Z" }, + { url = "https://files.pythonhosted.org/packages/37/45/9608ab1b41f6740ff4076eabadde8e8b3f3400942b348ac41e8599ccc131/regex-2026.2.19-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4192464fe3e6cb0ef6751f7d3b16f886d8270d359ed1590dd555539d364f0ff7", size = 850947, upload-time = "2026-02-19T18:59:53.739Z" }, + { url = "https://files.pythonhosted.org/packages/90/3a/66471b6c4f7cac17e14bf5300e46661bba2b17ffb0871bd2759e837a6f82/regex-2026.2.19-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e561dd47a85d2660d3d3af4e6cb2da825cf20f121e577147963f875b83d32786", size = 898794, upload-time = "2026-02-19T18:59:55.993Z" }, + { url = "https://files.pythonhosted.org/packages/c2/d2/38c53929a5931f7398e5e49f5a5a3079cb2aba30119b4350608364cfad8c/regex-2026.2.19-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00ec994d7824bf01cd6c7d14c7a6a04d9aeaf7c42a2bc22d2359d715634d539b", size = 791922, upload-time = "2026-02-19T18:59:58.216Z" }, + { url = "https://files.pythonhosted.org/packages/8b/bd/b046e065630fa25059d9c195b7b5308ea94da45eee65d40879772500f74c/regex-2026.2.19-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2cb00aabd96b345d56a8c2bc328c8d6c4d29935061e05078bf1f02302e12abf5", size = 783345, upload-time = "2026-02-19T18:59:59.948Z" }, + { url = "https://files.pythonhosted.org/packages/d4/8f/045c643d2fa255a985e8f87d848e4be230b711a8935e4bdc58e60b8f7b84/regex-2026.2.19-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f374366ed35673ea81b86a8859c457d4fae6ba092b71024857e9e237410c7404", size = 768055, upload-time = "2026-02-19T19:00:01.65Z" }, + { url = "https://files.pythonhosted.org/packages/72/9f/ab7ae9f5447559562f1a788bbc85c0e526528c5e6c20542d18e4afc86aad/regex-2026.2.19-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f9417fd853fcd00b7d55167e692966dd12d95ba1a88bf08a62002ccd85030790", size = 774955, upload-time = "2026-02-19T19:00:03.368Z" }, + { url = "https://files.pythonhosted.org/packages/37/5c/f16fc23c56f60b6f4ff194604a6e53bb8aec7b6e8e4a23a482dee8d77235/regex-2026.2.19-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:12e86a01594031abf892686fcb309b041bf3de3d13d99eb7e2b02a8f3c687df1", size = 846010, upload-time = "2026-02-19T19:00:05.079Z" }, + { url = "https://files.pythonhosted.org/packages/51/c8/6be4c854135d7c9f35d4deeafdaf124b039ecb4ffcaeb7ed0495ad2c97ca/regex-2026.2.19-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:79014115e6fdf18fd9b32e291d58181bf42d4298642beaa13fd73e69810e4cb6", size = 755938, upload-time = "2026-02-19T19:00:07.148Z" }, + { url = "https://files.pythonhosted.org/packages/d6/8d/f683d49b9663a5324b95a328e69d397f6dade7cb84154eec116bf79fe150/regex-2026.2.19-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:31aefac2506967b7dd69af2c58eca3cc8b086d4110b66d6ac6e9026f0ee5b697", size = 835773, upload-time = "2026-02-19T19:00:08.939Z" }, + { url = "https://files.pythonhosted.org/packages/16/cd/619224b90da09f167fe4497c350a0d0b30edc539ee9244bf93e604c073c3/regex-2026.2.19-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:49cef7bb2a491f91a8869c7cdd90babf0a417047ab0bf923cd038ed2eab2ccb8", size = 780075, upload-time = "2026-02-19T19:00:10.838Z" }, + { url = "https://files.pythonhosted.org/packages/5b/88/19cfb0c262d6f9d722edef29157125418bf90eb3508186bf79335afeedae/regex-2026.2.19-cp310-cp310-win32.whl", hash = "sha256:3a039474986e7a314ace6efb9ce52f5da2bdb80ac4955358723d350ec85c32ad", size = 266004, upload-time = "2026-02-19T19:00:12.371Z" }, + { url = "https://files.pythonhosted.org/packages/82/af/5b487e0287ef72545d7ae92edecdacbe3d44e531cac24fda7de5598ba8dd/regex-2026.2.19-cp310-cp310-win_amd64.whl", hash = "sha256:5b81ff4f9cad99f90c807a00c5882fbcda86d8b3edd94e709fb531fc52cb3d25", size = 277895, upload-time = "2026-02-19T19:00:13.75Z" }, + { url = "https://files.pythonhosted.org/packages/4c/19/b6715a187ffca4d2979af92a46ce922445ba41f910bf187ccd666a2d52ef/regex-2026.2.19-cp310-cp310-win_arm64.whl", hash = "sha256:a032bc01a4bc73fc3cadba793fce28eb420da39338f47910c59ffcc11a5ba5ef", size = 270465, upload-time = "2026-02-19T19:00:15.127Z" }, + { url = "https://files.pythonhosted.org/packages/6f/93/43f405a98f54cc59c786efb4fc0b644615ed2392fc89d57d30da11f35b5b/regex-2026.2.19-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:93b16a18cadb938f0f2306267161d57eb33081a861cee9ffcd71e60941eb5dfc", size = 488365, upload-time = "2026-02-19T19:00:17.857Z" }, + { url = "https://files.pythonhosted.org/packages/66/46/da0efce22cd8f5ae28eeb25ac69703f49edcad3331ac22440776f4ea0867/regex-2026.2.19-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:78af1e499cab704131f6f4e2f155b7f54ce396ca2acb6ef21a49507e4752e0be", size = 290737, upload-time = "2026-02-19T19:00:19.869Z" }, + { url = "https://files.pythonhosted.org/packages/fb/19/f735078448132c1c974974d30d5306337bc297fe6b6f126164bff72c1019/regex-2026.2.19-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:eb20c11aa4c3793c9ad04c19a972078cdadb261b8429380364be28e867a843f2", size = 288654, upload-time = "2026-02-19T19:00:21.307Z" }, + { url = "https://files.pythonhosted.org/packages/e2/3e/6d7c24a2f423c03ad03e3fbddefa431057186ac1c4cb4fa98b03c7f39808/regex-2026.2.19-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:db5fd91eec71e7b08de10011a2223d0faa20448d4e1380b9daa179fa7bf58906", size = 793785, upload-time = "2026-02-19T19:00:22.926Z" }, + { url = "https://files.pythonhosted.org/packages/67/32/fdb8107504b3122a79bde6705ac1f9d495ed1fe35b87d7cfc1864471999a/regex-2026.2.19-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fdbade8acba71bb45057c2b72f477f0b527c4895f9c83e6cfc30d4a006c21726", size = 860731, upload-time = "2026-02-19T19:00:25.196Z" }, + { url = "https://files.pythonhosted.org/packages/9a/fd/cc8c6f05868defd840be6e75919b1c3f462357969ac2c2a0958363b4dc23/regex-2026.2.19-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:31a5f561eb111d6aae14202e7043fb0b406d3c8dddbbb9e60851725c9b38ab1d", size = 907350, upload-time = "2026-02-19T19:00:27.093Z" }, + { url = "https://files.pythonhosted.org/packages/b5/1b/4590db9caa8db3d5a3fe31197c4e42c15aab3643b549ef6a454525fa3a61/regex-2026.2.19-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4584a3ee5f257b71e4b693cc9be3a5104249399f4116fe518c3f79b0c6fc7083", size = 800628, upload-time = "2026-02-19T19:00:29.392Z" }, + { url = "https://files.pythonhosted.org/packages/76/05/513eaa5b96fa579fd0b813e19ec047baaaf573d7374ff010fa139b384bf7/regex-2026.2.19-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:196553ba2a2f47904e5dc272d948a746352e2644005627467e055be19d73b39e", size = 773711, upload-time = "2026-02-19T19:00:30.996Z" }, + { url = "https://files.pythonhosted.org/packages/95/65/5aed06d8c54563d37fea496cf888be504879a3981a7c8e12c24b2c92c209/regex-2026.2.19-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0c10869d18abb759a3317c757746cc913d6324ce128b8bcec99350df10419f18", size = 783186, upload-time = "2026-02-19T19:00:34.598Z" }, + { url = "https://files.pythonhosted.org/packages/2c/57/79a633ad90f2371b4ef9cd72ba3a69a1a67d0cfaab4fe6fa8586d46044ef/regex-2026.2.19-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e689fed279cbe797a6b570bd18ff535b284d057202692c73420cb93cca41aa32", size = 854854, upload-time = "2026-02-19T19:00:37.306Z" }, + { url = "https://files.pythonhosted.org/packages/eb/2d/0f113d477d9e91ec4545ec36c82e58be25038d06788229c91ad52da2b7f5/regex-2026.2.19-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0782bd983f19ac7594039c9277cd6f75c89598c1d72f417e4d30d874105eb0c7", size = 762279, upload-time = "2026-02-19T19:00:39.793Z" }, + { url = "https://files.pythonhosted.org/packages/39/cb/237e9fa4f61469fd4f037164dbe8e675a376c88cf73aaaa0aedfd305601c/regex-2026.2.19-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:dbb240c81cfed5d4a67cb86d7676d9f7ec9c3f186310bec37d8a1415210e111e", size = 846172, upload-time = "2026-02-19T19:00:42.134Z" }, + { url = "https://files.pythonhosted.org/packages/ac/7c/104779c5915cc4eb557a33590f8a3f68089269c64287dd769afd76c7ce61/regex-2026.2.19-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:80d31c3f1fe7e4c6cd1831cd4478a0609903044dfcdc4660abfe6fb307add7f0", size = 789078, upload-time = "2026-02-19T19:00:43.908Z" }, + { url = "https://files.pythonhosted.org/packages/a8/4a/eae4e88b1317fb2ff57794915e0099198f51e760f6280b320adfa0ad396d/regex-2026.2.19-cp311-cp311-win32.whl", hash = "sha256:66e6a43225ff1064f8926adbafe0922b370d381c3330edaf9891cade52daa790", size = 266013, upload-time = "2026-02-19T19:00:47.274Z" }, + { url = "https://files.pythonhosted.org/packages/f9/29/ba89eb8fae79705e07ad1bd69e568f776159d2a8093c9dbc5303ee618298/regex-2026.2.19-cp311-cp311-win_amd64.whl", hash = "sha256:59a7a5216485a1896c5800e9feb8ff9213e11967b482633b6195d7da11450013", size = 277906, upload-time = "2026-02-19T19:00:49.011Z" }, + { url = "https://files.pythonhosted.org/packages/e3/1a/042d8f04b28e318df92df69d8becb0f42221eb3dd4fe5e976522f4337c76/regex-2026.2.19-cp311-cp311-win_arm64.whl", hash = "sha256:ec661807ffc14c8d14bb0b8c1bb3d5906e476bc96f98b565b709d03962ee4dd4", size = 270463, upload-time = "2026-02-19T19:00:50.988Z" }, + { url = "https://files.pythonhosted.org/packages/b3/73/13b39c7c9356f333e564ab4790b6cb0df125b8e64e8d6474e73da49b1955/regex-2026.2.19-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:c1665138776e4ac1aa75146669236f7a8a696433ec4e525abf092ca9189247cc", size = 489541, upload-time = "2026-02-19T19:00:52.728Z" }, + { url = "https://files.pythonhosted.org/packages/15/77/fcc7bd9a67000d07fbcc11ed226077287a40d5c84544e62171d29d3ef59c/regex-2026.2.19-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d792b84709021945597e05656aac059526df4e0c9ef60a0eaebb306f8fafcaa8", size = 291414, upload-time = "2026-02-19T19:00:54.51Z" }, + { url = "https://files.pythonhosted.org/packages/f9/87/3997fc72dc59233426ef2e18dfdd105bb123812fff740ee9cc348f1a3243/regex-2026.2.19-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:db970bcce4d63b37b3f9eb8c893f0db980bbf1d404a1d8d2b17aa8189de92c53", size = 289140, upload-time = "2026-02-19T19:00:56.841Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d0/b7dd3883ed1cff8ee0c0c9462d828aaf12be63bf5dc55453cbf423523b13/regex-2026.2.19-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:03d706fbe7dfec503c8c3cb76f9352b3e3b53b623672aa49f18a251a6c71b8e6", size = 798767, upload-time = "2026-02-19T19:00:59.014Z" }, + { url = "https://files.pythonhosted.org/packages/4a/7e/8e2d09103832891b2b735a2515abf377db21144c6dd5ede1fb03c619bf09/regex-2026.2.19-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8dbff048c042beef60aa1848961384572c5afb9e8b290b0f1203a5c42cf5af65", size = 864436, upload-time = "2026-02-19T19:01:00.772Z" }, + { url = "https://files.pythonhosted.org/packages/8a/2e/afea8d23a6db1f67f45e3a0da3057104ce32e154f57dd0c8997274d45fcd/regex-2026.2.19-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ccaaf9b907ea6b4223d5cbf5fa5dff5f33dc66f4907a25b967b8a81339a6e332", size = 912391, upload-time = "2026-02-19T19:01:02.865Z" }, + { url = "https://files.pythonhosted.org/packages/59/3c/ea5a4687adaba5e125b9bd6190153d0037325a0ba3757cc1537cc2c8dd90/regex-2026.2.19-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:75472631eee7898e16a8a20998d15106cb31cfde21cdf96ab40b432a7082af06", size = 803702, upload-time = "2026-02-19T19:01:05.298Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c5/624a0705e8473a26488ec1a3a4e0b8763ecfc682a185c302dfec71daea35/regex-2026.2.19-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d89f85a5ccc0cec125c24be75610d433d65295827ebaf0d884cbe56df82d4774", size = 775980, upload-time = "2026-02-19T19:01:07.047Z" }, + { url = "https://files.pythonhosted.org/packages/4d/4b/ed776642533232b5599b7c1f9d817fe11faf597e8a92b7a44b841daaae76/regex-2026.2.19-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0d9f81806abdca3234c3dd582b8a97492e93de3602c8772013cb4affa12d1668", size = 788122, upload-time = "2026-02-19T19:01:08.744Z" }, + { url = "https://files.pythonhosted.org/packages/8c/58/e93e093921d13b9784b4f69896b6e2a9e09580a265c59d9eb95e87d288f2/regex-2026.2.19-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9dadc10d1c2bbb1326e572a226d2ec56474ab8aab26fdb8cf19419b372c349a9", size = 858910, upload-time = "2026-02-19T19:01:10.488Z" }, + { url = "https://files.pythonhosted.org/packages/85/77/ff1d25a0c56cd546e0455cbc93235beb33474899690e6a361fa6b52d265b/regex-2026.2.19-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:6bc25d7e15f80c9dc7853cbb490b91c1ec7310808b09d56bd278fe03d776f4f6", size = 764153, upload-time = "2026-02-19T19:01:12.156Z" }, + { url = "https://files.pythonhosted.org/packages/cd/ef/8ec58df26d52d04443b1dc56f9be4b409f43ed5ae6c0248a287f52311fc4/regex-2026.2.19-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:965d59792f5037d9138da6fed50ba943162160443b43d4895b182551805aff9c", size = 850348, upload-time = "2026-02-19T19:01:14.147Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b3/c42fd5ed91639ce5a4225b9df909180fc95586db071f2bf7c68d2ccbfbe6/regex-2026.2.19-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:38d88c6ed4a09ed61403dbdf515d969ccba34669af3961ceb7311ecd0cef504a", size = 789977, upload-time = "2026-02-19T19:01:15.838Z" }, + { url = "https://files.pythonhosted.org/packages/b6/22/bc3b58ebddbfd6ca5633e71fd41829ee931963aad1ebeec55aad0c23044e/regex-2026.2.19-cp312-cp312-win32.whl", hash = "sha256:5df947cabab4b643d4791af5e28aecf6bf62e6160e525651a12eba3d03755e6b", size = 266381, upload-time = "2026-02-19T19:01:17.952Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4a/6ff550b63e67603ee60e69dc6bd2d5694e85046a558f663b2434bdaeb285/regex-2026.2.19-cp312-cp312-win_amd64.whl", hash = "sha256:4146dc576ea99634ae9c15587d0c43273b4023a10702998edf0fa68ccb60237a", size = 277274, upload-time = "2026-02-19T19:01:19.826Z" }, + { url = "https://files.pythonhosted.org/packages/cc/29/9ec48b679b1e87e7bc8517dff45351eab38f74fbbda1fbcf0e9e6d4e8174/regex-2026.2.19-cp312-cp312-win_arm64.whl", hash = "sha256:cdc0a80f679353bd68450d2a42996090c30b2e15ca90ded6156c31f1a3b63f3b", size = 270509, upload-time = "2026-02-19T19:01:22.075Z" }, + { url = "https://files.pythonhosted.org/packages/d2/2d/a849835e76ac88fcf9e8784e642d3ea635d183c4112150ca91499d6703af/regex-2026.2.19-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8df08decd339e8b3f6a2eb5c05c687fe9d963ae91f352bc57beb05f5b2ac6879", size = 489329, upload-time = "2026-02-19T19:01:23.841Z" }, + { url = "https://files.pythonhosted.org/packages/da/aa/78ff4666d3855490bae87845a5983485e765e1f970da20adffa2937b241d/regex-2026.2.19-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3aa0944f1dc6e92f91f3b306ba7f851e1009398c84bfd370633182ee4fc26a64", size = 291308, upload-time = "2026-02-19T19:01:25.605Z" }, + { url = "https://files.pythonhosted.org/packages/cd/58/714384efcc07ae6beba528a541f6e99188c5cc1bc0295337f4e8a868296d/regex-2026.2.19-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c13228fbecb03eadbfd8f521732c5fda09ef761af02e920a3148e18ad0e09968", size = 289033, upload-time = "2026-02-19T19:01:27.243Z" }, + { url = "https://files.pythonhosted.org/packages/75/ec/6438a9344d2869cf5265236a06af1ca6d885e5848b6561e10629bc8e5a11/regex-2026.2.19-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0d0e72703c60d68b18b27cde7cdb65ed2570ae29fb37231aa3076bfb6b1d1c13", size = 798798, upload-time = "2026-02-19T19:01:28.877Z" }, + { url = "https://files.pythonhosted.org/packages/c2/be/b1ce2d395e3fd2ce5f2fde2522f76cade4297cfe84cd61990ff48308749c/regex-2026.2.19-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:46e69a4bf552e30e74a8aa73f473c87efcb7f6e8c8ece60d9fd7bf13d5c86f02", size = 864444, upload-time = "2026-02-19T19:01:30.933Z" }, + { url = "https://files.pythonhosted.org/packages/d5/97/a3406460c504f7136f140d9461960c25f058b0240e4424d6fb73c7a067ab/regex-2026.2.19-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8edda06079bd770f7f0cf7f3bba1a0b447b96b4a543c91fe0c142d034c166161", size = 912633, upload-time = "2026-02-19T19:01:32.744Z" }, + { url = "https://files.pythonhosted.org/packages/8b/d9/e5dbef95008d84e9af1dc0faabbc34a7fbc8daa05bc5807c5cf86c2bec49/regex-2026.2.19-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9cbc69eae834afbf634f7c902fc72ff3e993f1c699156dd1af1adab5d06b7fe7", size = 803718, upload-time = "2026-02-19T19:01:34.61Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e5/61d80132690a1ef8dc48e0f44248036877aebf94235d43f63a20d1598888/regex-2026.2.19-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bcf57d30659996ee5c7937999874504c11b5a068edc9515e6a59221cc2744dd1", size = 775975, upload-time = "2026-02-19T19:01:36.525Z" }, + { url = "https://files.pythonhosted.org/packages/05/32/ae828b3b312c972cf228b634447de27237d593d61505e6ad84723f8eabba/regex-2026.2.19-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8e6e77cd92216eb489e21e5652a11b186afe9bdefca8a2db739fd6b205a9e0a4", size = 788129, upload-time = "2026-02-19T19:01:38.498Z" }, + { url = "https://files.pythonhosted.org/packages/cb/25/d74f34676f22bec401eddf0e5e457296941e10cbb2a49a571ca7a2c16e5a/regex-2026.2.19-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:b9ab8dec42afefa6314ea9b31b188259ffdd93f433d77cad454cd0b8d235ce1c", size = 858818, upload-time = "2026-02-19T19:01:40.409Z" }, + { url = "https://files.pythonhosted.org/packages/1e/eb/0bc2b01a6b0b264e1406e5ef11cae3f634c3bd1a6e61206fd3227ce8e89c/regex-2026.2.19-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:294c0fb2e87c6bcc5f577c8f609210f5700b993151913352ed6c6af42f30f95f", size = 764186, upload-time = "2026-02-19T19:01:43.009Z" }, + { url = "https://files.pythonhosted.org/packages/eb/37/5fe5a630d0d99ecf0c3570f8905dafbc160443a2d80181607770086c9812/regex-2026.2.19-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:c0924c64b082d4512b923ac016d6e1dcf647a3560b8a4c7e55cbbd13656cb4ed", size = 850363, upload-time = "2026-02-19T19:01:45.015Z" }, + { url = "https://files.pythonhosted.org/packages/c3/45/ef68d805294b01ec030cfd388724ba76a5a21a67f32af05b17924520cb0b/regex-2026.2.19-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:790dbf87b0361606cb0d79b393c3e8f4436a14ee56568a7463014565d97da02a", size = 790026, upload-time = "2026-02-19T19:01:47.51Z" }, + { url = "https://files.pythonhosted.org/packages/d6/3a/40d3b66923dfc5aeba182f194f0ca35d09afe8c031a193e6ae46971a0a0e/regex-2026.2.19-cp313-cp313-win32.whl", hash = "sha256:43cdde87006271be6963896ed816733b10967baaf0e271d529c82e93da66675b", size = 266372, upload-time = "2026-02-19T19:01:49.469Z" }, + { url = "https://files.pythonhosted.org/packages/3d/f2/39082e8739bfd553497689e74f9d5e5bb531d6f8936d0b94f43e18f219c0/regex-2026.2.19-cp313-cp313-win_amd64.whl", hash = "sha256:127ea69273485348a126ebbf3d6052604d3c7da284f797bba781f364c0947d47", size = 277253, upload-time = "2026-02-19T19:01:51.208Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c2/852b9600d53fb47e47080c203e2cdc0ac7e84e37032a57e0eaa37446033a/regex-2026.2.19-cp313-cp313-win_arm64.whl", hash = "sha256:5e56c669535ac59cbf96ca1ece0ef26cb66809990cda4fa45e1e32c3b146599e", size = 270505, upload-time = "2026-02-19T19:01:52.865Z" }, + { url = "https://files.pythonhosted.org/packages/a9/a2/e0b4575b93bc84db3b1fab24183e008691cd2db5c0ef14ed52681fbd94dd/regex-2026.2.19-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:93d881cab5afdc41a005dba1524a40947d6f7a525057aa64aaf16065cf62faa9", size = 492202, upload-time = "2026-02-19T19:01:54.816Z" }, + { url = "https://files.pythonhosted.org/packages/24/b5/b84fec8cbb5f92a7eed2b6b5353a6a9eed9670fee31817c2da9eb85dc797/regex-2026.2.19-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:80caaa1ddcc942ec7be18427354f9d58a79cee82dea2a6b3d4fd83302e1240d7", size = 292884, upload-time = "2026-02-19T19:01:58.254Z" }, + { url = "https://files.pythonhosted.org/packages/70/0c/fe89966dfae43da46f475362401f03e4d7dc3a3c955b54f632abc52669e0/regex-2026.2.19-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d793c5b4d2b4c668524cd1651404cfc798d40694c759aec997e196fe9729ec60", size = 291236, upload-time = "2026-02-19T19:01:59.966Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f7/bda2695134f3e63eb5cccbbf608c2a12aab93d261ff4e2fe49b47fabc948/regex-2026.2.19-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5100acb20648d9efd3f4e7e91f51187f95f22a741dcd719548a6cf4e1b34b3f", size = 807660, upload-time = "2026-02-19T19:02:01.632Z" }, + { url = "https://files.pythonhosted.org/packages/11/56/6e3a4bf5e60d17326b7003d91bbde8938e439256dec211d835597a44972d/regex-2026.2.19-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5e3a31e94d10e52a896adaa3adf3621bd526ad2b45b8c2d23d1bbe74c7423007", size = 873585, upload-time = "2026-02-19T19:02:03.522Z" }, + { url = "https://files.pythonhosted.org/packages/35/5e/c90c6aa4d1317cc11839359479cfdd2662608f339e84e81ba751c8a4e461/regex-2026.2.19-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8497421099b981f67c99eba4154cf0dfd8e47159431427a11cfb6487f7791d9e", size = 915243, upload-time = "2026-02-19T19:02:05.608Z" }, + { url = "https://files.pythonhosted.org/packages/90/7c/981ea0694116793001496aaf9524e5c99e122ec3952d9e7f1878af3a6bf1/regex-2026.2.19-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1e7a08622f7d51d7a068f7e4052a38739c412a3e74f55817073d2e2418149619", size = 812922, upload-time = "2026-02-19T19:02:08.115Z" }, + { url = "https://files.pythonhosted.org/packages/2d/be/9eda82afa425370ffdb3fa9f3ea42450b9ae4da3ff0a4ec20466f69e371b/regex-2026.2.19-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8abe671cf0f15c26b1ad389bf4043b068ce7d3b1c5d9313e12895f57d6738555", size = 781318, upload-time = "2026-02-19T19:02:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/c6/d5/50f0bbe56a8199f60a7b6c714e06e54b76b33d31806a69d0703b23ce2a9e/regex-2026.2.19-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5a8f28dd32a4ce9c41758d43b5b9115c1c497b4b1f50c457602c1d571fa98ce1", size = 795649, upload-time = "2026-02-19T19:02:11.96Z" }, + { url = "https://files.pythonhosted.org/packages/c5/09/d039f081e44a8b0134d0bb2dd805b0ddf390b69d0b58297ae098847c572f/regex-2026.2.19-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:654dc41a5ba9b8cc8432b3f1aa8906d8b45f3e9502442a07c2f27f6c63f85db5", size = 868844, upload-time = "2026-02-19T19:02:14.043Z" }, + { url = "https://files.pythonhosted.org/packages/ef/53/e2903b79a19ec8557fe7cd21cd093956ff2dbc2e0e33969e3adbe5b184dd/regex-2026.2.19-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:4a02faea614e7fdd6ba8b3bec6c8e79529d356b100381cec76e638f45d12ca04", size = 770113, upload-time = "2026-02-19T19:02:16.161Z" }, + { url = "https://files.pythonhosted.org/packages/8f/e2/784667767b55714ebb4e59bf106362327476b882c0b2f93c25e84cc99b1a/regex-2026.2.19-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d96162140bb819814428800934c7b71b7bffe81fb6da2d6abc1dcca31741eca3", size = 854922, upload-time = "2026-02-19T19:02:18.155Z" }, + { url = "https://files.pythonhosted.org/packages/59/78/9ef4356bd4aed752775bd18071034979b85f035fec51f3a4f9dea497a254/regex-2026.2.19-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c227f2922153ee42bbeb355fd6d009f8c81d9d7bdd666e2276ce41f53ed9a743", size = 799636, upload-time = "2026-02-19T19:02:20.04Z" }, + { url = "https://files.pythonhosted.org/packages/cf/54/fcfc9287f20c5c9bd8db755aafe3e8cf4d99a6a3f1c7162ee182e0ca9374/regex-2026.2.19-cp313-cp313t-win32.whl", hash = "sha256:a178df8ec03011153fbcd2c70cb961bc98cbbd9694b28f706c318bee8927c3db", size = 268968, upload-time = "2026-02-19T19:02:22.816Z" }, + { url = "https://files.pythonhosted.org/packages/1e/a0/ff24c6cb1273e42472706d277147fc38e1f9074a280fb6034b0fc9b69415/regex-2026.2.19-cp313-cp313t-win_amd64.whl", hash = "sha256:2c1693ca6f444d554aa246b592355b5cec030ace5a2729eae1b04ab6e853e768", size = 280390, upload-time = "2026-02-19T19:02:25.231Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b6/a3f6ad89d780ffdeebb4d5e2e3e30bd2ef1f70f6a94d1760e03dd1e12c60/regex-2026.2.19-cp313-cp313t-win_arm64.whl", hash = "sha256:c0761d7ae8d65773e01515ebb0b304df1bf37a0a79546caad9cbe79a42c12af7", size = 271643, upload-time = "2026-02-19T19:02:27.175Z" }, + { url = "https://files.pythonhosted.org/packages/2d/e2/7ad4e76a6dddefc0d64dbe12a4d3ca3947a19ddc501f864a5df2a8222ddd/regex-2026.2.19-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:03d191a9bcf94d31af56d2575210cb0d0c6a054dbcad2ea9e00aa4c42903b919", size = 489306, upload-time = "2026-02-19T19:02:29.058Z" }, + { url = "https://files.pythonhosted.org/packages/14/95/ee1736135733afbcf1846c58671046f99c4d5170102a150ebb3dd8d701d9/regex-2026.2.19-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:516ee067c6c721d0d0bfb80a2004edbd060fffd07e456d4e1669e38fe82f922e", size = 291218, upload-time = "2026-02-19T19:02:31.083Z" }, + { url = "https://files.pythonhosted.org/packages/ef/08/180d1826c3d7065200a5168c6b993a44947395c7bb6e04b2c2a219c34225/regex-2026.2.19-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:997862c619994c4a356cb7c3592502cbd50c2ab98da5f61c5c871f10f22de7e5", size = 289097, upload-time = "2026-02-19T19:02:33.485Z" }, + { url = "https://files.pythonhosted.org/packages/28/93/0651924c390c5740f5f896723f8ddd946a6c63083a7d8647231c343912ff/regex-2026.2.19-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02b9e1b8a7ebe2807cd7bbdf662510c8e43053a23262b9f46ad4fc2dfc9d204e", size = 799147, upload-time = "2026-02-19T19:02:35.669Z" }, + { url = "https://files.pythonhosted.org/packages/a7/00/2078bd8bcd37d58a756989adbfd9f1d0151b7ca4085a9c2a07e917fbac61/regex-2026.2.19-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6c8fb3b19652e425ff24169dad3ee07f99afa7996caa9dfbb3a9106cd726f49a", size = 865239, upload-time = "2026-02-19T19:02:38.012Z" }, + { url = "https://files.pythonhosted.org/packages/2a/13/75195161ec16936b35a365fa8c1dd2ab29fd910dd2587765062b174d8cfc/regex-2026.2.19-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50f1ee9488dd7a9fda850ec7c68cad7a32fa49fd19733f5403a3f92b451dcf73", size = 911904, upload-time = "2026-02-19T19:02:40.737Z" }, + { url = "https://files.pythonhosted.org/packages/96/72/ac42f6012179343d1c4bd0ffee8c948d841cb32ea188d37e96d80527fcc9/regex-2026.2.19-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ab780092b1424d13200aa5a62996e95f65ee3db8509be366437439cdc0af1a9f", size = 803518, upload-time = "2026-02-19T19:02:42.923Z" }, + { url = "https://files.pythonhosted.org/packages/bc/d1/75a08e2269b007b9783f0f86aa64488e023141219cb5f14dc1e69cda56c6/regex-2026.2.19-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:17648e1a88e72d88641b12635e70e6c71c5136ba14edba29bf8fc6834005a265", size = 775866, upload-time = "2026-02-19T19:02:45.189Z" }, + { url = "https://files.pythonhosted.org/packages/92/41/70e7d05faf6994c2ca7a9fcaa536da8f8e4031d45b0ec04b57040ede201f/regex-2026.2.19-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f914ae8c804c8a8a562fe216100bc156bfb51338c1f8d55fe32cf407774359a", size = 788224, upload-time = "2026-02-19T19:02:47.804Z" }, + { url = "https://files.pythonhosted.org/packages/c8/83/34a2dd601f9deb13c20545c674a55f4a05c90869ab73d985b74d639bac43/regex-2026.2.19-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c7e121a918bbee3f12ac300ce0a0d2f2c979cf208fb071ed8df5a6323281915c", size = 859682, upload-time = "2026-02-19T19:02:50.583Z" }, + { url = "https://files.pythonhosted.org/packages/8e/30/136db9a09a7f222d6e48b806f3730e7af6499a8cad9c72ac0d49d52c746e/regex-2026.2.19-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2fedd459c791da24914ecc474feecd94cf7845efb262ac3134fe27cbd7eda799", size = 764223, upload-time = "2026-02-19T19:02:52.777Z" }, + { url = "https://files.pythonhosted.org/packages/9e/ea/bb947743c78a16df481fa0635c50aa1a439bb80b0e6dc24cd4e49c716679/regex-2026.2.19-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:ea8dfc99689240e61fb21b5fc2828f68b90abf7777d057b62d3166b7c1543c4c", size = 850101, upload-time = "2026-02-19T19:02:55.87Z" }, + { url = "https://files.pythonhosted.org/packages/25/27/e3bfe6e97a99f7393665926be02fef772da7f8aa59e50bc3134e4262a032/regex-2026.2.19-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9fff45852160960f29e184ec8a5be5ab4063cfd0b168d439d1fc4ac3744bf29e", size = 789904, upload-time = "2026-02-19T19:02:58.523Z" }, + { url = "https://files.pythonhosted.org/packages/84/7b/7e2be6f00cea59d08761b027ad237002e90cac74b1607200ebaa2ba3d586/regex-2026.2.19-cp314-cp314-win32.whl", hash = "sha256:5390b130cce14a7d1db226a3896273b7b35be10af35e69f1cca843b6e5d2bb2d", size = 271784, upload-time = "2026-02-19T19:03:00.418Z" }, + { url = "https://files.pythonhosted.org/packages/f7/f6/639911530335773e7ec60bcaa519557b719586024c1d7eaad1daf87b646b/regex-2026.2.19-cp314-cp314-win_amd64.whl", hash = "sha256:e581f75d5c0b15669139ca1c2d3e23a65bb90e3c06ba9d9ea194c377c726a904", size = 280506, upload-time = "2026-02-19T19:03:02.302Z" }, + { url = "https://files.pythonhosted.org/packages/cd/ec/2582b56b4e036d46bb9b5d74a18548439ffa16c11cf59076419174d80f48/regex-2026.2.19-cp314-cp314-win_arm64.whl", hash = "sha256:7187fdee1be0896c1499a991e9bf7c78e4b56b7863e7405d7bb687888ac10c4b", size = 273557, upload-time = "2026-02-19T19:03:04.836Z" }, + { url = "https://files.pythonhosted.org/packages/49/0b/f901cfeb4efd83e4f5c3e9f91a6de77e8e5ceb18555698aca3a27e215ed3/regex-2026.2.19-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:5ec1d7c080832fdd4e150c6f5621fe674c70c63b3ae5a4454cebd7796263b175", size = 492196, upload-time = "2026-02-19T19:03:08.188Z" }, + { url = "https://files.pythonhosted.org/packages/94/0a/349b959e3da874e15eda853755567b4cde7e5309dbb1e07bfe910cfde452/regex-2026.2.19-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8457c1bc10ee9b29cdfd897ccda41dce6bde0e9abd514bcfef7bcd05e254d411", size = 292878, upload-time = "2026-02-19T19:03:10.272Z" }, + { url = "https://files.pythonhosted.org/packages/98/b0/9d81b3c2c5ddff428f8c506713737278979a2c476f6e3675a9c51da0c389/regex-2026.2.19-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cce8027010d1ffa3eb89a0b19621cdc78ae548ea2b49fea1f7bfb3ea77064c2b", size = 291235, upload-time = "2026-02-19T19:03:12.5Z" }, + { url = "https://files.pythonhosted.org/packages/04/e7/be7818df8691dbe9508c381ea2cc4c1153e4fdb1c4b06388abeaa93bd712/regex-2026.2.19-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11c138febb40546ff9e026dbbc41dc9fb8b29e61013fa5848ccfe045f5b23b83", size = 807893, upload-time = "2026-02-19T19:03:15.064Z" }, + { url = "https://files.pythonhosted.org/packages/0c/b6/b898a8b983190cfa0276031c17beb73cfd1db07c03c8c37f606d80b655e2/regex-2026.2.19-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:74ff212aa61532246bb3036b3dfea62233414b0154b8bc3676975da78383cac3", size = 873696, upload-time = "2026-02-19T19:03:17.848Z" }, + { url = "https://files.pythonhosted.org/packages/1a/98/126ba671d54f19080ec87cad228fb4f3cc387fff8c4a01cb4e93f4ff9d94/regex-2026.2.19-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d00c95a2b6bfeb3ea1cb68d1751b1dfce2b05adc2a72c488d77a780db06ab867", size = 915493, upload-time = "2026-02-19T19:03:20.343Z" }, + { url = "https://files.pythonhosted.org/packages/b2/10/550c84a1a1a7371867fe8be2bea7df55e797cbca4709974811410e195c5d/regex-2026.2.19-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:311fcccb76af31be4c588d5a17f8f1a059ae8f4b097192896ebffc95612f223a", size = 813094, upload-time = "2026-02-19T19:03:23.287Z" }, + { url = "https://files.pythonhosted.org/packages/29/fb/ba221d2fc76a27b6b7d7a60f73a7a6a7bac21c6ba95616a08be2bcb434b0/regex-2026.2.19-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:77cfd6b5e7c4e8bf7a39d243ea05882acf5e3c7002b0ef4756de6606893b0ecd", size = 781583, upload-time = "2026-02-19T19:03:26.872Z" }, + { url = "https://files.pythonhosted.org/packages/26/f1/af79231301297c9e962679efc04a31361b58dc62dec1fc0cb4b8dd95956a/regex-2026.2.19-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6380f29ff212ec922b6efb56100c089251940e0526a0d05aa7c2d9b571ddf2fe", size = 795875, upload-time = "2026-02-19T19:03:29.223Z" }, + { url = "https://files.pythonhosted.org/packages/a0/90/1e1d76cb0a2d0a4f38a039993e1c5cd971ae50435d751c5bae4f10e1c302/regex-2026.2.19-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:655f553a1fa3ab8a7fd570eca793408b8d26a80bfd89ed24d116baaf13a38969", size = 868916, upload-time = "2026-02-19T19:03:31.415Z" }, + { url = "https://files.pythonhosted.org/packages/9a/67/a1c01da76dbcfed690855a284c665cc0a370e7d02d1bd635cf9ff7dd74b8/regex-2026.2.19-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:015088b8558502f1f0bccd58754835aa154a7a5b0bd9d4c9b7b96ff4ae9ba876", size = 770386, upload-time = "2026-02-19T19:03:33.972Z" }, + { url = "https://files.pythonhosted.org/packages/49/6f/94842bf294f432ff3836bfd91032e2ecabea6d284227f12d1f935318c9c4/regex-2026.2.19-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9e6693b8567a59459b5dda19104c4a4dbbd4a1c78833eacc758796f2cfef1854", size = 855007, upload-time = "2026-02-19T19:03:36.238Z" }, + { url = "https://files.pythonhosted.org/packages/ff/93/393cd203ca0d1d368f05ce12d2c7e91a324bc93c240db2e6d5ada05835f4/regex-2026.2.19-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4071209fd4376ab5ceec72ad3507e9d3517c59e38a889079b98916477a871868", size = 799863, upload-time = "2026-02-19T19:03:38.497Z" }, + { url = "https://files.pythonhosted.org/packages/43/d9/35afda99bd92bf1a5831e55a4936d37ea4bed6e34c176a3c2238317faf4f/regex-2026.2.19-cp314-cp314t-win32.whl", hash = "sha256:2905ff4a97fad42f2d0834d8b1ea3c2f856ec209837e458d71a061a7d05f9f01", size = 274742, upload-time = "2026-02-19T19:03:40.804Z" }, + { url = "https://files.pythonhosted.org/packages/ae/42/7edc3344dcc87b698e9755f7f685d463852d481302539dae07135202d3ca/regex-2026.2.19-cp314-cp314t-win_amd64.whl", hash = "sha256:64128549b600987e0f335c2365879895f860a9161f283b14207c800a6ed623d3", size = 284443, upload-time = "2026-02-19T19:03:42.954Z" }, + { url = "https://files.pythonhosted.org/packages/3a/45/affdf2d851b42adf3d13fc5b3b059372e9bd299371fd84cf5723c45871fa/regex-2026.2.19-cp314-cp314t-win_arm64.whl", hash = "sha256:a09ae430e94c049dc6957f6baa35ee3418a3a77f3c12b6e02883bd80a2b679b0", size = 274932, upload-time = "2026-02-19T19:03:45.488Z" }, ] [[package]] @@ -5689,16 +5672,16 @@ wheels = [ [[package]] name = "rq" -version = "2.6.1" +version = "2.7.0" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "click", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "croniter", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "redis", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/86/6f/a2848f5ba0ca7f1f879c7ad44a2e7b06b98197a7da39be39eda775807f33/rq-2.6.1.tar.gz", hash = "sha256:db5c0d125ac9dbd4438f9a5225ea3e64050542b416fd791d424e2ab5b2853289", size = 675386, upload-time = "2025-11-22T06:45:16.673Z" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/9b/93b7180220fe462b4128425e687665bcdeffddc51683d41e7fbe509c2d2e/rq-2.7.0.tar.gz", hash = "sha256:c2156fc7249b5d43dda918c4355cfbf8d0d299a5cdd3963918e9c8daf4b1e0c0", size = 679396, upload-time = "2026-02-22T11:10:50.775Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/4b/cc/919ccbf0c9b4f8b0f68c3f53e6d8e1e94af4d74cee4e6d3cb2e81f7d0da9/rq-2.6.1-py3-none-any.whl", hash = "sha256:5cc88d3bb5263a407fb2ba2dc6fe8dc710dae94b6f74396cdfe1b32beded9408", size = 112578, upload-time = "2025-11-22T06:45:13.529Z" }, + { url = "https://files.pythonhosted.org/packages/0d/1a/3b64696bc0c33aa1d86d3e6add03c4e0afe51110264fd41208bd95c2665c/rq-2.7.0-py3-none-any.whl", hash = "sha256:4b320e95968208d2e249fa0d3d90ee309478e2d7ea60a116f8ff9aa343a4c117", size = 115728, upload-time = "2026-02-22T11:10:48.401Z" }, ] [[package]] @@ -5820,7 +5803,7 @@ resolution-markers = [ dependencies = [ { name = "joblib", marker = "(python_full_version >= '3.11' and sys_platform == 'darwin') or (python_full_version >= '3.11' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform == 'darwin') or (python_full_version >= '3.11' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, - { name = "scipy", version = "1.17.0", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform == 'darwin') or (python_full_version >= '3.11' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, + { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform == 'darwin') or (python_full_version >= '3.11' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, { name = "threadpoolctl", marker = "(python_full_version >= '3.11' and sys_platform == 'darwin') or (python_full_version >= '3.11' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0e/d4/40988bf3b8e34feec1d0e6a051446b1f66225f8529b9309becaeef62b6c4/scikit_learn-1.8.0.tar.gz", hash = "sha256:9bccbb3b40e3de10351f8f5068e105d0f4083b1a65fa07b6634fbc401a6287fd", size = 7335585, upload-time = "2025-12-10T07:08:53.618Z" } @@ -5926,7 +5909,7 @@ wheels = [ [[package]] name = "scipy" -version = "1.17.0" +version = "1.17.1" source = { registry = "https://pypi.org/simple" } resolution-markers = [ "python_full_version >= '3.14' and sys_platform == 'darwin'", @@ -5945,68 +5928,68 @@ resolution-markers = [ dependencies = [ { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.11' and sys_platform == 'darwin') or (python_full_version >= '3.11' and sys_platform == 'linux') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/56/3e/9cca699f3486ce6bc12ff46dc2031f1ec8eb9ccc9a320fdaf925f1417426/scipy-1.17.0.tar.gz", hash = "sha256:2591060c8e648d8b96439e111ac41fd8342fdeff1876be2e19dea3fe8930454e", size = 30396830, upload-time = "2026-01-10T21:34:23.009Z" } +sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/1e/4b/c89c131aa87cad2b77a54eb0fb94d633a842420fa7e919dc2f922037c3d8/scipy-1.17.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:2abd71643797bd8a106dff97894ff7869eeeb0af0f7a5ce02e4227c6a2e9d6fd", size = 31381316, upload-time = "2026-01-10T21:24:33.42Z" }, - { url = "https://files.pythonhosted.org/packages/5e/5f/a6b38f79a07d74989224d5f11b55267714707582908a5f1ae854cf9a9b84/scipy-1.17.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:ef28d815f4d2686503e5f4f00edc387ae58dfd7a2f42e348bb53359538f01558", size = 27966760, upload-time = "2026-01-10T21:24:38.911Z" }, - { url = "https://files.pythonhosted.org/packages/c1/20/095ad24e031ee8ed3c5975954d816b8e7e2abd731e04f8be573de8740885/scipy-1.17.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:272a9f16d6bb4667e8b50d25d71eddcc2158a214df1b566319298de0939d2ab7", size = 20138701, upload-time = "2026-01-10T21:24:43.249Z" }, - { url = "https://files.pythonhosted.org/packages/89/11/4aad2b3858d0337756f3323f8960755704e530b27eb2a94386c970c32cbe/scipy-1.17.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:7204fddcbec2fe6598f1c5fdf027e9f259106d05202a959a9f1aecf036adc9f6", size = 22480574, upload-time = "2026-01-10T21:24:47.266Z" }, - { url = "https://files.pythonhosted.org/packages/85/bd/f5af70c28c6da2227e510875cadf64879855193a687fb19951f0f44cfd6b/scipy-1.17.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fc02c37a5639ee67d8fb646ffded6d793c06c5622d36b35cfa8fe5ececb8f042", size = 32862414, upload-time = "2026-01-10T21:24:52.566Z" }, - { url = "https://files.pythonhosted.org/packages/ef/df/df1457c4df3826e908879fe3d76bc5b6e60aae45f4ee42539512438cfd5d/scipy-1.17.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dac97a27520d66c12a34fd90a4fe65f43766c18c0d6e1c0a80f114d2260080e4", size = 35112380, upload-time = "2026-01-10T21:24:58.433Z" }, - { url = "https://files.pythonhosted.org/packages/5f/bb/88e2c16bd1dd4de19d80d7c5e238387182993c2fb13b4b8111e3927ad422/scipy-1.17.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ebb7446a39b3ae0fe8f416a9a3fdc6fba3f11c634f680f16a239c5187bc487c0", size = 34922676, upload-time = "2026-01-10T21:25:04.287Z" }, - { url = "https://files.pythonhosted.org/packages/02/ba/5120242cc735f71fc002cff0303d536af4405eb265f7c60742851e7ccfe9/scipy-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:474da16199f6af66601a01546144922ce402cb17362e07d82f5a6cf8f963e449", size = 37507599, upload-time = "2026-01-10T21:25:09.851Z" }, - { url = "https://files.pythonhosted.org/packages/52/c8/08629657ac6c0da198487ce8cd3de78e02cfde42b7f34117d56a3fe249dc/scipy-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:255c0da161bd7b32a6c898e7891509e8a9289f0b1c6c7d96142ee0d2b114c2ea", size = 36380284, upload-time = "2026-01-10T21:25:15.632Z" }, - { url = "https://files.pythonhosted.org/packages/6c/4a/465f96d42c6f33ad324a40049dfd63269891db9324aa66c4a1c108c6f994/scipy-1.17.0-cp311-cp311-win_arm64.whl", hash = "sha256:85b0ac3ad17fa3be50abd7e69d583d98792d7edc08367e01445a1e2076005379", size = 24370427, upload-time = "2026-01-10T21:25:20.514Z" }, - { url = "https://files.pythonhosted.org/packages/0b/11/7241a63e73ba5a516f1930ac8d5b44cbbfabd35ac73a2d08ca206df007c4/scipy-1.17.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:0d5018a57c24cb1dd828bcf51d7b10e65986d549f52ef5adb6b4d1ded3e32a57", size = 31364580, upload-time = "2026-01-10T21:25:25.717Z" }, - { url = "https://files.pythonhosted.org/packages/ed/1d/5057f812d4f6adc91a20a2d6f2ebcdb517fdbc87ae3acc5633c9b97c8ba5/scipy-1.17.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:88c22af9e5d5a4f9e027e26772cc7b5922fab8bcc839edb3ae33de404feebd9e", size = 27969012, upload-time = "2026-01-10T21:25:30.921Z" }, - { url = "https://files.pythonhosted.org/packages/e3/21/f6ec556c1e3b6ec4e088da667d9987bb77cc3ab3026511f427dc8451187d/scipy-1.17.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f3cd947f20fe17013d401b64e857c6b2da83cae567adbb75b9dcba865abc66d8", size = 20140691, upload-time = "2026-01-10T21:25:34.802Z" }, - { url = "https://files.pythonhosted.org/packages/7a/fe/5e5ad04784964ba964a96f16c8d4676aa1b51357199014dce58ab7ec5670/scipy-1.17.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e8c0b331c2c1f531eb51f1b4fc9ba709521a712cce58f1aa627bc007421a5306", size = 22463015, upload-time = "2026-01-10T21:25:39.277Z" }, - { url = "https://files.pythonhosted.org/packages/4a/69/7c347e857224fcaf32a34a05183b9d8a7aca25f8f2d10b8a698b8388561a/scipy-1.17.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5194c445d0a1c7a6c1a4a4681b6b7c71baad98ff66d96b949097e7513c9d6742", size = 32724197, upload-time = "2026-01-10T21:25:44.084Z" }, - { url = "https://files.pythonhosted.org/packages/d1/fe/66d73b76d378ba8cc2fe605920c0c75092e3a65ae746e1e767d9d020a75a/scipy-1.17.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9eeb9b5f5997f75507814ed9d298ab23f62cf79f5a3ef90031b1ee2506abdb5b", size = 35009148, upload-time = "2026-01-10T21:25:50.591Z" }, - { url = "https://files.pythonhosted.org/packages/af/07/07dec27d9dc41c18d8c43c69e9e413431d20c53a0339c388bcf72f353c4b/scipy-1.17.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:40052543f7bbe921df4408f46003d6f01c6af109b9e2c8a66dd1cf6cf57f7d5d", size = 34798766, upload-time = "2026-01-10T21:25:59.41Z" }, - { url = "https://files.pythonhosted.org/packages/81/61/0470810c8a093cdacd4ba7504b8a218fd49ca070d79eca23a615f5d9a0b0/scipy-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0cf46c8013fec9d3694dc572f0b54100c28405d55d3e2cb15e2895b25057996e", size = 37405953, upload-time = "2026-01-10T21:26:07.75Z" }, - { url = "https://files.pythonhosted.org/packages/92/ce/672ed546f96d5d41ae78c4b9b02006cedd0b3d6f2bf5bb76ea455c320c28/scipy-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:0937a0b0d8d593a198cededd4c439a0ea216a3f36653901ea1f3e4be949056f8", size = 36328121, upload-time = "2026-01-10T21:26:16.509Z" }, - { url = "https://files.pythonhosted.org/packages/9d/21/38165845392cae67b61843a52c6455d47d0cc2a40dd495c89f4362944654/scipy-1.17.0-cp312-cp312-win_arm64.whl", hash = "sha256:f603d8a5518c7426414d1d8f82e253e454471de682ce5e39c29adb0df1efb86b", size = 24314368, upload-time = "2026-01-10T21:26:23.087Z" }, - { url = "https://files.pythonhosted.org/packages/0c/51/3468fdfd49387ddefee1636f5cf6d03ce603b75205bf439bbf0e62069bfd/scipy-1.17.0-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:65ec32f3d32dfc48c72df4291345dae4f048749bc8d5203ee0a3f347f96c5ce6", size = 31344101, upload-time = "2026-01-10T21:26:30.25Z" }, - { url = "https://files.pythonhosted.org/packages/b2/9a/9406aec58268d437636069419e6977af953d1e246df941d42d3720b7277b/scipy-1.17.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:1f9586a58039d7229ce77b52f8472c972448cded5736eaf102d5658bbac4c269", size = 27950385, upload-time = "2026-01-10T21:26:36.801Z" }, - { url = "https://files.pythonhosted.org/packages/4f/98/e7342709e17afdfd1b26b56ae499ef4939b45a23a00e471dfb5375eea205/scipy-1.17.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:9fad7d3578c877d606b1150135c2639e9de9cecd3705caa37b66862977cc3e72", size = 20122115, upload-time = "2026-01-10T21:26:42.107Z" }, - { url = "https://files.pythonhosted.org/packages/fd/0e/9eeeb5357a64fd157cbe0302c213517c541cc16b8486d82de251f3c68ede/scipy-1.17.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:423ca1f6584fc03936972b5f7c06961670dbba9f234e71676a7c7ccf938a0d61", size = 22442402, upload-time = "2026-01-10T21:26:48.029Z" }, - { url = "https://files.pythonhosted.org/packages/c9/10/be13397a0e434f98e0c79552b2b584ae5bb1c8b2be95db421533bbca5369/scipy-1.17.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe508b5690e9eaaa9467fc047f833af58f1152ae51a0d0aed67aa5801f4dd7d6", size = 32696338, upload-time = "2026-01-10T21:26:55.521Z" }, - { url = "https://files.pythonhosted.org/packages/63/1e/12fbf2a3bb240161651c94bb5cdd0eae5d4e8cc6eaeceb74ab07b12a753d/scipy-1.17.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6680f2dfd4f6182e7d6db161344537da644d1cf85cf293f015c60a17ecf08752", size = 34977201, upload-time = "2026-01-10T21:27:03.501Z" }, - { url = "https://files.pythonhosted.org/packages/19/5b/1a63923e23ccd20bd32156d7dd708af5bbde410daa993aa2500c847ab2d2/scipy-1.17.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eec3842ec9ac9de5917899b277428886042a93db0b227ebbe3a333b64ec7643d", size = 34777384, upload-time = "2026-01-10T21:27:11.423Z" }, - { url = "https://files.pythonhosted.org/packages/39/22/b5da95d74edcf81e540e467202a988c50fef41bd2011f46e05f72ba07df6/scipy-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d7425fcafbc09a03731e1bc05581f5fad988e48c6a861f441b7ab729a49a55ea", size = 37379586, upload-time = "2026-01-10T21:27:20.171Z" }, - { url = "https://files.pythonhosted.org/packages/b9/b6/8ac583d6da79e7b9e520579f03007cb006f063642afd6b2eeb16b890bf93/scipy-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:87b411e42b425b84777718cc41516b8a7e0795abfa8e8e1d573bf0ef014f0812", size = 36287211, upload-time = "2026-01-10T21:28:43.122Z" }, - { url = "https://files.pythonhosted.org/packages/55/fb/7db19e0b3e52f882b420417644ec81dd57eeef1bd1705b6f689d8ff93541/scipy-1.17.0-cp313-cp313-win_arm64.whl", hash = "sha256:357ca001c6e37601066092e7c89cca2f1ce74e2a520ca78d063a6d2201101df2", size = 24312646, upload-time = "2026-01-10T21:28:49.893Z" }, - { url = "https://files.pythonhosted.org/packages/20/b6/7feaa252c21cc7aff335c6c55e1b90ab3e3306da3f048109b8b639b94648/scipy-1.17.0-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:ec0827aa4d36cb79ff1b81de898e948a51ac0b9b1c43e4a372c0508c38c0f9a3", size = 31693194, upload-time = "2026-01-10T21:27:27.454Z" }, - { url = "https://files.pythonhosted.org/packages/76/bb/bbb392005abce039fb7e672cb78ac7d158700e826b0515cab6b5b60c26fb/scipy-1.17.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:819fc26862b4b3c73a60d486dbb919202f3d6d98c87cf20c223511429f2d1a97", size = 28365415, upload-time = "2026-01-10T21:27:34.26Z" }, - { url = "https://files.pythonhosted.org/packages/37/da/9d33196ecc99fba16a409c691ed464a3a283ac454a34a13a3a57c0d66f3a/scipy-1.17.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:363ad4ae2853d88ebcde3ae6ec46ccca903ea9835ee8ba543f12f575e7b07e4e", size = 20537232, upload-time = "2026-01-10T21:27:40.306Z" }, - { url = "https://files.pythonhosted.org/packages/56/9d/f4b184f6ddb28e9a5caea36a6f98e8ecd2a524f9127354087ce780885d83/scipy-1.17.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:979c3a0ff8e5ba254d45d59ebd38cde48fce4f10b5125c680c7a4bfe177aab07", size = 22791051, upload-time = "2026-01-10T21:27:46.539Z" }, - { url = "https://files.pythonhosted.org/packages/9b/9d/025cccdd738a72140efc582b1641d0dd4caf2e86c3fb127568dc80444e6e/scipy-1.17.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:130d12926ae34399d157de777472bf82e9061c60cc081372b3118edacafe1d00", size = 32815098, upload-time = "2026-01-10T21:27:54.389Z" }, - { url = "https://files.pythonhosted.org/packages/48/5f/09b879619f8bca15ce392bfc1894bd9c54377e01d1b3f2f3b595a1b4d945/scipy-1.17.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6e886000eb4919eae3a44f035e63f0fd8b651234117e8f6f29bad1cd26e7bc45", size = 35031342, upload-time = "2026-01-10T21:28:03.012Z" }, - { url = "https://files.pythonhosted.org/packages/f2/9a/f0f0a9f0aa079d2f106555b984ff0fbb11a837df280f04f71f056ea9c6e4/scipy-1.17.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:13c4096ac6bc31d706018f06a49abe0485f96499deb82066b94d19b02f664209", size = 34893199, upload-time = "2026-01-10T21:28:10.832Z" }, - { url = "https://files.pythonhosted.org/packages/90/b8/4f0f5cf0c5ea4d7548424e6533e6b17d164f34a6e2fb2e43ffebb6697b06/scipy-1.17.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cacbaddd91fcffde703934897c5cd2c7cb0371fac195d383f4e1f1c5d3f3bd04", size = 37438061, upload-time = "2026-01-10T21:28:19.684Z" }, - { url = "https://files.pythonhosted.org/packages/f9/cc/2bd59140ed3b2fa2882fb15da0a9cb1b5a6443d67cfd0d98d4cec83a57ec/scipy-1.17.0-cp313-cp313t-win_amd64.whl", hash = "sha256:edce1a1cf66298cccdc48a1bdf8fb10a3bf58e8b58d6c3883dd1530e103f87c0", size = 36328593, upload-time = "2026-01-10T21:28:28.007Z" }, - { url = "https://files.pythonhosted.org/packages/13/1b/c87cc44a0d2c7aaf0f003aef2904c3d097b422a96c7e7c07f5efd9073c1b/scipy-1.17.0-cp313-cp313t-win_arm64.whl", hash = "sha256:30509da9dbec1c2ed8f168b8d8aa853bc6723fede1dbc23c7d43a56f5ab72a67", size = 24625083, upload-time = "2026-01-10T21:28:35.188Z" }, - { url = "https://files.pythonhosted.org/packages/1a/2d/51006cd369b8e7879e1c630999a19d1fbf6f8b5ed3e33374f29dc87e53b3/scipy-1.17.0-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:c17514d11b78be8f7e6331b983a65a7f5ca1fd037b95e27b280921fe5606286a", size = 31346803, upload-time = "2026-01-10T21:28:57.24Z" }, - { url = "https://files.pythonhosted.org/packages/d6/2e/2349458c3ce445f53a6c93d4386b1c4c5c0c540917304c01222ff95ff317/scipy-1.17.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:4e00562e519c09da34c31685f6acc3aa384d4d50604db0f245c14e1b4488bfa2", size = 27967182, upload-time = "2026-01-10T21:29:04.107Z" }, - { url = "https://files.pythonhosted.org/packages/5e/7c/df525fbfa77b878d1cfe625249529514dc02f4fd5f45f0f6295676a76528/scipy-1.17.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f7df7941d71314e60a481e02d5ebcb3f0185b8d799c70d03d8258f6c80f3d467", size = 20139125, upload-time = "2026-01-10T21:29:10.179Z" }, - { url = "https://files.pythonhosted.org/packages/33/11/fcf9d43a7ed1234d31765ec643b0515a85a30b58eddccc5d5a4d12b5f194/scipy-1.17.0-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:aabf057c632798832f071a8dde013c2e26284043934f53b00489f1773b33527e", size = 22443554, upload-time = "2026-01-10T21:29:15.888Z" }, - { url = "https://files.pythonhosted.org/packages/80/5c/ea5d239cda2dd3d31399424967a24d556cf409fbea7b5b21412b0fd0a44f/scipy-1.17.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a38c3337e00be6fd8a95b4ed66b5d988bac4ec888fd922c2ea9fe5fb1603dd67", size = 32757834, upload-time = "2026-01-10T21:29:23.406Z" }, - { url = "https://files.pythonhosted.org/packages/b8/7e/8c917cc573310e5dc91cbeead76f1b600d3fb17cf0969db02c9cf92e3cfa/scipy-1.17.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00fb5f8ec8398ad90215008d8b6009c9db9fa924fd4c7d6be307c6f945f9cd73", size = 34995775, upload-time = "2026-01-10T21:29:31.915Z" }, - { url = "https://files.pythonhosted.org/packages/c5/43/176c0c3c07b3f7df324e7cdd933d3e2c4898ca202b090bd5ba122f9fe270/scipy-1.17.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f2a4942b0f5f7c23c7cd641a0ca1955e2ae83dedcff537e3a0259096635e186b", size = 34841240, upload-time = "2026-01-10T21:29:39.995Z" }, - { url = "https://files.pythonhosted.org/packages/44/8c/d1f5f4b491160592e7f084d997de53a8e896a3ac01cd07e59f43ca222744/scipy-1.17.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:dbf133ced83889583156566d2bdf7a07ff89228fe0c0cb727f777de92092ec6b", size = 37394463, upload-time = "2026-01-10T21:29:48.723Z" }, - { url = "https://files.pythonhosted.org/packages/9f/ec/42a6657f8d2d087e750e9a5dde0b481fd135657f09eaf1cf5688bb23c338/scipy-1.17.0-cp314-cp314-win_amd64.whl", hash = "sha256:3625c631a7acd7cfd929e4e31d2582cf00f42fcf06011f59281271746d77e061", size = 37053015, upload-time = "2026-01-10T21:30:51.418Z" }, - { url = "https://files.pythonhosted.org/packages/27/58/6b89a6afd132787d89a362d443a7bddd511b8f41336a1ae47f9e4f000dc4/scipy-1.17.0-cp314-cp314-win_arm64.whl", hash = "sha256:9244608d27eafe02b20558523ba57f15c689357c85bdcfe920b1828750aa26eb", size = 24951312, upload-time = "2026-01-10T21:30:56.771Z" }, - { url = "https://files.pythonhosted.org/packages/e9/01/f58916b9d9ae0112b86d7c3b10b9e685625ce6e8248df139d0fcb17f7397/scipy-1.17.0-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:2b531f57e09c946f56ad0b4a3b2abee778789097871fc541e267d2eca081cff1", size = 31706502, upload-time = "2026-01-10T21:29:56.326Z" }, - { url = "https://files.pythonhosted.org/packages/59/8e/2912a87f94a7d1f8b38aabc0faf74b82d3b6c9e22be991c49979f0eceed8/scipy-1.17.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:13e861634a2c480bd237deb69333ac79ea1941b94568d4b0efa5db5e263d4fd1", size = 28380854, upload-time = "2026-01-10T21:30:01.554Z" }, - { url = "https://files.pythonhosted.org/packages/bd/1c/874137a52dddab7d5d595c1887089a2125d27d0601fce8c0026a24a92a0b/scipy-1.17.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:eb2651271135154aa24f6481cbae5cc8af1f0dd46e6533fb7b56aa9727b6a232", size = 20552752, upload-time = "2026-01-10T21:30:05.93Z" }, - { url = "https://files.pythonhosted.org/packages/3f/f0/7518d171cb735f6400f4576cf70f756d5b419a07fe1867da34e2c2c9c11b/scipy-1.17.0-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:c5e8647f60679790c2f5c76be17e2e9247dc6b98ad0d3b065861e082c56e078d", size = 22803972, upload-time = "2026-01-10T21:30:10.651Z" }, - { url = "https://files.pythonhosted.org/packages/7c/74/3498563a2c619e8a3ebb4d75457486c249b19b5b04a30600dfd9af06bea5/scipy-1.17.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5fb10d17e649e1446410895639f3385fd2bf4c3c7dfc9bea937bddcbc3d7b9ba", size = 32829770, upload-time = "2026-01-10T21:30:16.359Z" }, - { url = "https://files.pythonhosted.org/packages/48/d1/7b50cedd8c6c9d6f706b4b36fa8544d829c712a75e370f763b318e9638c1/scipy-1.17.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8547e7c57f932e7354a2319fab613981cde910631979f74c9b542bb167a8b9db", size = 35051093, upload-time = "2026-01-10T21:30:22.987Z" }, - { url = "https://files.pythonhosted.org/packages/e2/82/a2d684dfddb87ba1b3ea325df7c3293496ee9accb3a19abe9429bce94755/scipy-1.17.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33af70d040e8af9d5e7a38b5ed3b772adddd281e3062ff23fec49e49681c38cf", size = 34909905, upload-time = "2026-01-10T21:30:28.704Z" }, - { url = "https://files.pythonhosted.org/packages/ef/5e/e565bd73991d42023eb82bb99e51c5b3d9e2c588ca9d4b3e2cc1d3ca62a6/scipy-1.17.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9eb55bb97d00f8b7ab95cb64f873eb0bf54d9446264d9f3609130381233483f", size = 37457743, upload-time = "2026-01-10T21:30:34.819Z" }, - { url = "https://files.pythonhosted.org/packages/58/a8/a66a75c3d8f1fb2b83f66007d6455a06a6f6cf5618c3dc35bc9b69dd096e/scipy-1.17.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1ff269abf702f6c7e67a4b7aad981d42871a11b9dd83c58d2d2ea624efbd1088", size = 37098574, upload-time = "2026-01-10T21:30:40.782Z" }, - { url = "https://files.pythonhosted.org/packages/56/a5/df8f46ef7da168f1bc52cd86e09a9de5c6f19cc1da04454d51b7d4f43408/scipy-1.17.0-cp314-cp314t-win_arm64.whl", hash = "sha256:031121914e295d9791319a1875444d55079885bbae5bdc9c5e0f2ee5f09d34ff", size = 25246266, upload-time = "2026-01-10T21:30:45.923Z" }, + { url = "https://files.pythonhosted.org/packages/df/75/b4ce781849931fef6fd529afa6b63711d5a733065722d0c3e2724af9e40a/scipy-1.17.1-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:1f95b894f13729334fb990162e911c9e5dc1ab390c58aa6cbecb389c5b5e28ec", size = 31613675, upload-time = "2026-02-23T00:16:00.13Z" }, + { url = "https://files.pythonhosted.org/packages/f7/58/bccc2861b305abdd1b8663d6130c0b3d7cc22e8d86663edbc8401bfd40d4/scipy-1.17.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:e18f12c6b0bc5a592ed23d3f7b891f68fd7f8241d69b7883769eb5d5dfb52696", size = 28162057, upload-time = "2026-02-23T00:16:09.456Z" }, + { url = "https://files.pythonhosted.org/packages/6d/ee/18146b7757ed4976276b9c9819108adbc73c5aad636e5353e20746b73069/scipy-1.17.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a3472cfbca0a54177d0faa68f697d8ba4c80bbdc19908c3465556d9f7efce9ee", size = 20334032, upload-time = "2026-02-23T00:16:17.358Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e6/cef1cf3557f0c54954198554a10016b6a03b2ec9e22a4e1df734936bd99c/scipy-1.17.1-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:766e0dc5a616d026a3a1cffa379af959671729083882f50307e18175797b3dfd", size = 22709533, upload-time = "2026-02-23T00:16:25.791Z" }, + { url = "https://files.pythonhosted.org/packages/4d/60/8804678875fc59362b0fb759ab3ecce1f09c10a735680318ac30da8cd76b/scipy-1.17.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:744b2bf3640d907b79f3fd7874efe432d1cf171ee721243e350f55234b4cec4c", size = 33062057, upload-time = "2026-02-23T00:16:36.931Z" }, + { url = "https://files.pythonhosted.org/packages/09/7d/af933f0f6e0767995b4e2d705a0665e454d1c19402aa7e895de3951ebb04/scipy-1.17.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43af8d1f3bea642559019edfe64e9b11192a8978efbd1539d7bc2aaa23d92de4", size = 35349300, upload-time = "2026-02-23T00:16:49.108Z" }, + { url = "https://files.pythonhosted.org/packages/b4/3d/7ccbbdcbb54c8fdc20d3b6930137c782a163fa626f0aef920349873421ba/scipy-1.17.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd96a1898c0a47be4520327e01f874acfd61fb48a9420f8aa9f6483412ffa444", size = 35127333, upload-time = "2026-02-23T00:17:01.293Z" }, + { url = "https://files.pythonhosted.org/packages/e8/19/f926cb11c42b15ba08e3a71e376d816ac08614f769b4f47e06c3580c836a/scipy-1.17.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4eb6c25dd62ee8d5edf68a8e1c171dd71c292fdae95d8aeb3dd7d7de4c364082", size = 37741314, upload-time = "2026-02-23T00:17:12.576Z" }, + { url = "https://files.pythonhosted.org/packages/95/da/0d1df507cf574b3f224ccc3d45244c9a1d732c81dcb26b1e8a766ae271a8/scipy-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:d30e57c72013c2a4fe441c2fcb8e77b14e152ad48b5464858e07e2ad9fbfceff", size = 36607512, upload-time = "2026-02-23T00:17:23.424Z" }, + { url = "https://files.pythonhosted.org/packages/68/7f/bdd79ceaad24b671543ffe0ef61ed8e659440eb683b66f033454dcee90eb/scipy-1.17.1-cp311-cp311-win_arm64.whl", hash = "sha256:9ecb4efb1cd6e8c4afea0daa91a87fbddbce1b99d2895d151596716c0b2e859d", size = 24599248, upload-time = "2026-02-23T00:17:34.561Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/b992b488d6f299dbe3f11a20b24d3dda3d46f1a635ede1c46b5b17a7b163/scipy-1.17.1-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:35c3a56d2ef83efc372eaec584314bd0ef2e2f0d2adb21c55e6ad5b344c0dcb8", size = 31610954, upload-time = "2026-02-23T00:17:49.855Z" }, + { url = "https://files.pythonhosted.org/packages/b2/02/cf107b01494c19dc100f1d0b7ac3cc08666e96ba2d64db7626066cee895e/scipy-1.17.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:fcb310ddb270a06114bb64bbe53c94926b943f5b7f0842194d585c65eb4edd76", size = 28172662, upload-time = "2026-02-23T00:18:01.64Z" }, + { url = "https://files.pythonhosted.org/packages/cf/a9/599c28631bad314d219cf9ffd40e985b24d603fc8a2f4ccc5ae8419a535b/scipy-1.17.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:cc90d2e9c7e5c7f1a482c9875007c095c3194b1cfedca3c2f3291cdc2bc7c086", size = 20344366, upload-time = "2026-02-23T00:18:12.015Z" }, + { url = "https://files.pythonhosted.org/packages/35/f5/906eda513271c8deb5af284e5ef0206d17a96239af79f9fa0aebfe0e36b4/scipy-1.17.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:c80be5ede8f3f8eded4eff73cc99a25c388ce98e555b17d31da05287015ffa5b", size = 22704017, upload-time = "2026-02-23T00:18:21.502Z" }, + { url = "https://files.pythonhosted.org/packages/da/34/16f10e3042d2f1d6b66e0428308ab52224b6a23049cb2f5c1756f713815f/scipy-1.17.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e19ebea31758fac5893a2ac360fedd00116cbb7628e650842a6691ba7ca28a21", size = 32927842, upload-time = "2026-02-23T00:18:35.367Z" }, + { url = "https://files.pythonhosted.org/packages/01/8e/1e35281b8ab6d5d72ebe9911edcdffa3f36b04ed9d51dec6dd140396e220/scipy-1.17.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:02ae3b274fde71c5e92ac4d54bc06c42d80e399fec704383dcd99b301df37458", size = 35235890, upload-time = "2026-02-23T00:18:49.188Z" }, + { url = "https://files.pythonhosted.org/packages/c5/5c/9d7f4c88bea6e0d5a4f1bc0506a53a00e9fcb198de372bfe4d3652cef482/scipy-1.17.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8a604bae87c6195d8b1045eddece0514d041604b14f2727bbc2b3020172045eb", size = 35003557, upload-time = "2026-02-23T00:18:54.74Z" }, + { url = "https://files.pythonhosted.org/packages/65/94/7698add8f276dbab7a9de9fb6b0e02fc13ee61d51c7c3f85ac28b65e1239/scipy-1.17.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f590cd684941912d10becc07325a3eeb77886fe981415660d9265c4c418d0bea", size = 37625856, upload-time = "2026-02-23T00:19:00.307Z" }, + { url = "https://files.pythonhosted.org/packages/a2/84/dc08d77fbf3d87d3ee27f6a0c6dcce1de5829a64f2eae85a0ecc1f0daa73/scipy-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:41b71f4a3a4cab9d366cd9065b288efc4d4f3c0b37a91a8e0947fb5bd7f31d87", size = 36549682, upload-time = "2026-02-23T00:19:07.67Z" }, + { url = "https://files.pythonhosted.org/packages/bc/98/fe9ae9ffb3b54b62559f52dedaebe204b408db8109a8c66fdd04869e6424/scipy-1.17.1-cp312-cp312-win_arm64.whl", hash = "sha256:f4115102802df98b2b0db3cce5cb9b92572633a1197c77b7553e5203f284a5b3", size = 24547340, upload-time = "2026-02-23T00:19:12.024Z" }, + { url = "https://files.pythonhosted.org/packages/76/27/07ee1b57b65e92645f219b37148a7e7928b82e2b5dbeccecb4dff7c64f0b/scipy-1.17.1-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:5e3c5c011904115f88a39308379c17f91546f77c1667cea98739fe0fccea804c", size = 31590199, upload-time = "2026-02-23T00:19:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/ec/ae/db19f8ab842e9b724bf5dbb7db29302a91f1e55bc4d04b1025d6d605a2c5/scipy-1.17.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6fac755ca3d2c3edcb22f479fceaa241704111414831ddd3bc6056e18516892f", size = 28154001, upload-time = "2026-02-23T00:19:22.241Z" }, + { url = "https://files.pythonhosted.org/packages/5b/58/3ce96251560107b381cbd6e8413c483bbb1228a6b919fa8652b0d4090e7f/scipy-1.17.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:7ff200bf9d24f2e4d5dc6ee8c3ac64d739d3a89e2326ba68aaf6c4a2b838fd7d", size = 20325719, upload-time = "2026-02-23T00:19:26.329Z" }, + { url = "https://files.pythonhosted.org/packages/b2/83/15087d945e0e4d48ce2377498abf5ad171ae013232ae31d06f336e64c999/scipy-1.17.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4b400bdc6f79fa02a4d86640310dde87a21fba0c979efff5248908c6f15fad1b", size = 22683595, upload-time = "2026-02-23T00:19:30.304Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e0/e58fbde4a1a594c8be8114eb4aac1a55bcd6587047efc18a61eb1f5c0d30/scipy-1.17.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2b64ca7d4aee0102a97f3ba22124052b4bd2152522355073580bf4845e2550b6", size = 32896429, upload-time = "2026-02-23T00:19:35.536Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5f/f17563f28ff03c7b6799c50d01d5d856a1d55f2676f537ca8d28c7f627cd/scipy-1.17.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:581b2264fc0aa555f3f435a5944da7504ea3a065d7029ad60e7c3d1ae09c5464", size = 35203952, upload-time = "2026-02-23T00:19:42.259Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a5/9afd17de24f657fdfe4df9a3f1ea049b39aef7c06000c13db1530d81ccca/scipy-1.17.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:beeda3d4ae615106d7094f7e7cef6218392e4465cc95d25f900bebabfded0950", size = 34979063, upload-time = "2026-02-23T00:19:47.547Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/88b1d2384b424bf7c924f2038c1c409f8d88bb2a8d49d097861dd64a57b2/scipy-1.17.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6609bc224e9568f65064cfa72edc0f24ee6655b47575954ec6339534b2798369", size = 37598449, upload-time = "2026-02-23T00:19:53.238Z" }, + { url = "https://files.pythonhosted.org/packages/35/e5/d6d0e51fc888f692a35134336866341c08655d92614f492c6860dc45bb2c/scipy-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:37425bc9175607b0268f493d79a292c39f9d001a357bebb6b88fdfaff13f6448", size = 36510943, upload-time = "2026-02-23T00:20:50.89Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fd/3be73c564e2a01e690e19cc618811540ba5354c67c8680dce3281123fb79/scipy-1.17.1-cp313-cp313-win_arm64.whl", hash = "sha256:5cf36e801231b6a2059bf354720274b7558746f3b1a4efb43fcf557ccd484a87", size = 24545621, upload-time = "2026-02-23T00:20:55.871Z" }, + { url = "https://files.pythonhosted.org/packages/6f/6b/17787db8b8114933a66f9dcc479a8272e4b4da75fe03b0c282f7b0ade8cd/scipy-1.17.1-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:d59c30000a16d8edc7e64152e30220bfbd724c9bbb08368c054e24c651314f0a", size = 31936708, upload-time = "2026-02-23T00:19:58.694Z" }, + { url = "https://files.pythonhosted.org/packages/38/2e/524405c2b6392765ab1e2b722a41d5da33dc5c7b7278184a8ad29b6cb206/scipy-1.17.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:010f4333c96c9bb1a4516269e33cb5917b08ef2166d5556ca2fd9f082a9e6ea0", size = 28570135, upload-time = "2026-02-23T00:20:03.934Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c3/5bd7199f4ea8556c0c8e39f04ccb014ac37d1468e6cfa6a95c6b3562b76e/scipy-1.17.1-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:2ceb2d3e01c5f1d83c4189737a42d9cb2fc38a6eeed225e7515eef71ad301dce", size = 20741977, upload-time = "2026-02-23T00:20:07.935Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b8/8ccd9b766ad14c78386599708eb745f6b44f08400a5fd0ade7cf89b6fc93/scipy-1.17.1-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:844e165636711ef41f80b4103ed234181646b98a53c8f05da12ca5ca289134f6", size = 23029601, upload-time = "2026-02-23T00:20:12.161Z" }, + { url = "https://files.pythonhosted.org/packages/6d/a0/3cb6f4d2fb3e17428ad2880333cac878909ad1a89f678527b5328b93c1d4/scipy-1.17.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:158dd96d2207e21c966063e1635b1063cd7787b627b6f07305315dd73d9c679e", size = 33019667, upload-time = "2026-02-23T00:20:17.208Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c3/2d834a5ac7bf3a0c806ad1508efc02dda3c8c61472a56132d7894c312dea/scipy-1.17.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:74cbb80d93260fe2ffa334efa24cb8f2f0f622a9b9febf8b483c0b865bfb3475", size = 35264159, upload-time = "2026-02-23T00:20:23.087Z" }, + { url = "https://files.pythonhosted.org/packages/4d/77/d3ed4becfdbd217c52062fafe35a72388d1bd82c2d0ba5ca19d6fcc93e11/scipy-1.17.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:dbc12c9f3d185f5c737d801da555fb74b3dcfa1a50b66a1a93e09190f41fab50", size = 35102771, upload-time = "2026-02-23T00:20:28.636Z" }, + { url = "https://files.pythonhosted.org/packages/bd/12/d19da97efde68ca1ee5538bb261d5d2c062f0c055575128f11a2730e3ac1/scipy-1.17.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94055a11dfebe37c656e70317e1996dc197e1a15bbcc351bcdd4610e128fe1ca", size = 37665910, upload-time = "2026-02-23T00:20:34.743Z" }, + { url = "https://files.pythonhosted.org/packages/06/1c/1172a88d507a4baaf72c5a09bb6c018fe2ae0ab622e5830b703a46cc9e44/scipy-1.17.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e30bdeaa5deed6bc27b4cc490823cd0347d7dae09119b8803ae576ea0ce52e4c", size = 36562980, upload-time = "2026-02-23T00:20:40.575Z" }, + { url = "https://files.pythonhosted.org/packages/70/b0/eb757336e5a76dfa7911f63252e3b7d1de00935d7705cf772db5b45ec238/scipy-1.17.1-cp313-cp313t-win_arm64.whl", hash = "sha256:a720477885a9d2411f94a93d16f9d89bad0f28ca23c3f8daa521e2dcc3f44d49", size = 24856543, upload-time = "2026-02-23T00:20:45.313Z" }, + { url = "https://files.pythonhosted.org/packages/cf/83/333afb452af6f0fd70414dc04f898647ee1423979ce02efa75c3b0f2c28e/scipy-1.17.1-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:a48a72c77a310327f6a3a920092fa2b8fd03d7deaa60f093038f22d98e096717", size = 31584510, upload-time = "2026-02-23T00:21:01.015Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a6/d05a85fd51daeb2e4ea71d102f15b34fedca8e931af02594193ae4fd25f7/scipy-1.17.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:45abad819184f07240d8a696117a7aacd39787af9e0b719d00285549ed19a1e9", size = 28170131, upload-time = "2026-02-23T00:21:05.888Z" }, + { url = "https://files.pythonhosted.org/packages/db/7b/8624a203326675d7746a254083a187398090a179335b2e4a20e2ddc46e83/scipy-1.17.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:3fd1fcdab3ea951b610dc4cef356d416d5802991e7e32b5254828d342f7b7e0b", size = 20342032, upload-time = "2026-02-23T00:21:09.904Z" }, + { url = "https://files.pythonhosted.org/packages/c9/35/2c342897c00775d688d8ff3987aced3426858fd89d5a0e26e020b660b301/scipy-1.17.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:7bdf2da170b67fdf10bca777614b1c7d96ae3ca5794fd9587dce41eb2966e866", size = 22678766, upload-time = "2026-02-23T00:21:14.313Z" }, + { url = "https://files.pythonhosted.org/packages/ef/f2/7cdb8eb308a1a6ae1e19f945913c82c23c0c442a462a46480ce487fdc0ac/scipy-1.17.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:adb2642e060a6549c343603a3851ba76ef0b74cc8c079a9a58121c7ec9fe2350", size = 32957007, upload-time = "2026-02-23T00:21:19.663Z" }, + { url = "https://files.pythonhosted.org/packages/0b/2e/7eea398450457ecb54e18e9d10110993fa65561c4f3add5e8eccd2b9cd41/scipy-1.17.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eee2cfda04c00a857206a4330f0c5e3e56535494e30ca445eb19ec624ae75118", size = 35221333, upload-time = "2026-02-23T00:21:25.278Z" }, + { url = "https://files.pythonhosted.org/packages/d9/77/5b8509d03b77f093a0d52e606d3c4f79e8b06d1d38c441dacb1e26cacf46/scipy-1.17.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d2650c1fb97e184d12d8ba010493ee7b322864f7d3d00d3f9bb97d9c21de4068", size = 35042066, upload-time = "2026-02-23T00:21:31.358Z" }, + { url = "https://files.pythonhosted.org/packages/f9/df/18f80fb99df40b4070328d5ae5c596f2f00fffb50167e31439e932f29e7d/scipy-1.17.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:08b900519463543aa604a06bec02461558a6e1cef8fdbb8098f77a48a83c8118", size = 37612763, upload-time = "2026-02-23T00:21:37.247Z" }, + { url = "https://files.pythonhosted.org/packages/4b/39/f0e8ea762a764a9dc52aa7dabcfad51a354819de1f0d4652b6a1122424d6/scipy-1.17.1-cp314-cp314-win_amd64.whl", hash = "sha256:3877ac408e14da24a6196de0ddcace62092bfc12a83823e92e49e40747e52c19", size = 37290984, upload-time = "2026-02-23T00:22:35.023Z" }, + { url = "https://files.pythonhosted.org/packages/7c/56/fe201e3b0f93d1a8bcf75d3379affd228a63d7e2d80ab45467a74b494947/scipy-1.17.1-cp314-cp314-win_arm64.whl", hash = "sha256:f8885db0bc2bffa59d5c1b72fad7a6a92d3e80e7257f967dd81abb553a90d293", size = 25192877, upload-time = "2026-02-23T00:22:39.798Z" }, + { url = "https://files.pythonhosted.org/packages/96/ad/f8c414e121f82e02d76f310f16db9899c4fcde36710329502a6b2a3c0392/scipy-1.17.1-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:1cc682cea2ae55524432f3cdff9e9a3be743d52a7443d0cba9017c23c87ae2f6", size = 31949750, upload-time = "2026-02-23T00:21:42.289Z" }, + { url = "https://files.pythonhosted.org/packages/7c/b0/c741e8865d61b67c81e255f4f0a832846c064e426636cd7de84e74d209be/scipy-1.17.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:2040ad4d1795a0ae89bfc7e8429677f365d45aa9fd5e4587cf1ea737f927b4a1", size = 28585858, upload-time = "2026-02-23T00:21:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1b/3985219c6177866628fa7c2595bfd23f193ceebbe472c98a08824b9466ff/scipy-1.17.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:131f5aaea57602008f9822e2115029b55d4b5f7c070287699fe45c661d051e39", size = 20757723, upload-time = "2026-02-23T00:21:52.039Z" }, + { url = "https://files.pythonhosted.org/packages/c0/19/2a04aa25050d656d6f7b9e7b685cc83d6957fb101665bfd9369ca6534563/scipy-1.17.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:9cdc1a2fcfd5c52cfb3045feb399f7b3ce822abdde3a193a6b9a60b3cb5854ca", size = 23043098, upload-time = "2026-02-23T00:21:56.185Z" }, + { url = "https://files.pythonhosted.org/packages/86/f1/3383beb9b5d0dbddd030335bf8a8b32d4317185efe495374f134d8be6cce/scipy-1.17.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e3dcd57ab780c741fde8dc68619de988b966db759a3c3152e8e9142c26295ad", size = 33030397, upload-time = "2026-02-23T00:22:01.404Z" }, + { url = "https://files.pythonhosted.org/packages/41/68/8f21e8a65a5a03f25a79165ec9d2b28c00e66dc80546cf5eb803aeeff35b/scipy-1.17.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a9956e4d4f4a301ebf6cde39850333a6b6110799d470dbbb1e25326ac447f52a", size = 35281163, upload-time = "2026-02-23T00:22:07.024Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/c8a5e19479554007a5632ed7529e665c315ae7492b4f946b0deb39870e39/scipy-1.17.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:a4328d245944d09fd639771de275701ccadf5f781ba0ff092ad141e017eccda4", size = 35116291, upload-time = "2026-02-23T00:22:12.585Z" }, + { url = "https://files.pythonhosted.org/packages/52/52/e57eceff0e342a1f50e274264ed47497b59e6a4e3118808ee58ddda7b74a/scipy-1.17.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a77cbd07b940d326d39a1d1b37817e2ee4d79cb30e7338f3d0cddffae70fcaa2", size = 37682317, upload-time = "2026-02-23T00:22:18.513Z" }, + { url = "https://files.pythonhosted.org/packages/11/2f/b29eafe4a3fbc3d6de9662b36e028d5f039e72d345e05c250e121a230dd4/scipy-1.17.1-cp314-cp314t-win_amd64.whl", hash = "sha256:eb092099205ef62cd1782b006658db09e2fed75bffcae7cc0d44052d8aa0f484", size = 37345327, upload-time = "2026-02-23T00:22:24.442Z" }, + { url = "https://files.pythonhosted.org/packages/07/39/338d9219c4e87f3e708f18857ecd24d22a0c3094752393319553096b98af/scipy-1.17.1-cp314-cp314t-win_arm64.whl", hash = "sha256:200e1050faffacc162be6a486a984a0497866ec54149a01270adc8a59b7c7d21", size = 25489165, upload-time = "2026-02-23T00:22:29.563Z" }, ] [[package]] @@ -6165,58 +6148,62 @@ wheels = [ [[package]] name = "sqlalchemy" -version = "2.0.46" +version = "2.0.47" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "greenlet", marker = "(platform_machine == 'AMD64' and sys_platform == 'darwin') or (platform_machine == 'WIN32' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'darwin') or (platform_machine == 'amd64' and sys_platform == 'darwin') or (platform_machine == 'ppc64le' and sys_platform == 'darwin') or (platform_machine == 'win32' and sys_platform == 'darwin') or (platform_machine == 'x86_64' and sys_platform == 'darwin') or (platform_machine == 'AMD64' and sys_platform == 'linux') or (platform_machine == 'WIN32' and sys_platform == 'linux') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'amd64' and sys_platform == 'linux') or (platform_machine == 'ppc64le' and sys_platform == 'linux') or (platform_machine == 'win32' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32') or (platform_machine == 'WIN32' and sys_platform == 'win32') or (platform_machine == 'aarch64' and sys_platform == 'win32') or (platform_machine == 'amd64' and sys_platform == 'win32') or (platform_machine == 'ppc64le' and sys_platform == 'win32') or (platform_machine == 'win32' and sys_platform == 'win32') or (platform_machine == 'x86_64' and sys_platform == 'win32')" }, { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/06/aa/9ce0f3e7a9829ead5c8ce549392f33a12c4555a6c0609bb27d882e9c7ddf/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7", size = 9865393, upload-time = "2026-01-21T18:03:45.119Z" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/4b/1e00561093fe2cd8eef09d406da003c8a118ff02d6548498c1ae677d68d9/sqlalchemy-2.0.47.tar.gz", hash = "sha256:e3e7feb57b267fe897e492b9721ae46d5c7de6f9e8dee58aacf105dc4e154f3d", size = 9886323, upload-time = "2026-02-24T16:34:27.947Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/40/26/66ba59328dc25e523bfcb0f8db48bdebe2035e0159d600e1f01c0fc93967/sqlalchemy-2.0.46-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:895296687ad06dc9b11a024cf68e8d9d3943aa0b4964278d2553b86f1b267735", size = 2155051, upload-time = "2026-01-21T18:27:28.965Z" }, - { url = "https://files.pythonhosted.org/packages/21/cd/9336732941df972fbbfa394db9caa8bb0cf9fe03656ec728d12e9cbd6edc/sqlalchemy-2.0.46-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ab65cb2885a9f80f979b85aa4e9c9165a31381ca322cbde7c638fe6eefd1ec39", size = 3234666, upload-time = "2026-01-21T18:32:28.72Z" }, - { url = "https://files.pythonhosted.org/packages/38/62/865ae8b739930ec433cd4123760bee7f8dafdc10abefd725a025604fb0de/sqlalchemy-2.0.46-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:52fe29b3817bd191cc20bad564237c808967972c97fa683c04b28ec8979ae36f", size = 3232917, upload-time = "2026-01-21T18:44:54.064Z" }, - { url = "https://files.pythonhosted.org/packages/24/38/805904b911857f2b5e00fdea44e9570df62110f834378706939825579296/sqlalchemy-2.0.46-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:09168817d6c19954d3b7655da6ba87fcb3a62bb575fb396a81a8b6a9fadfe8b5", size = 3185790, upload-time = "2026-01-21T18:32:30.581Z" }, - { url = "https://files.pythonhosted.org/packages/69/4f/3260bb53aabd2d274856337456ea52f6a7eccf6cce208e558f870cec766b/sqlalchemy-2.0.46-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:be6c0466b4c25b44c5d82b0426b5501de3c424d7a3220e86cd32f319ba56798e", size = 3207206, upload-time = "2026-01-21T18:44:55.93Z" }, - { url = "https://files.pythonhosted.org/packages/ce/b3/67c432d7f9d88bb1a61909b67e29f6354d59186c168fb5d381cf438d3b73/sqlalchemy-2.0.46-cp310-cp310-win32.whl", hash = "sha256:1bc3f601f0a818d27bfe139f6766487d9c88502062a2cd3a7ee6c342e81d5047", size = 2115296, upload-time = "2026-01-21T18:33:12.498Z" }, - { url = "https://files.pythonhosted.org/packages/4a/8c/25fb284f570f9d48e6c240f0269a50cec9cf009a7e08be4c0aaaf0654972/sqlalchemy-2.0.46-cp310-cp310-win_amd64.whl", hash = "sha256:e0c05aff5c6b1bb5fb46a87e0f9d2f733f83ef6cbbbcd5c642b6c01678268061", size = 2138540, upload-time = "2026-01-21T18:33:14.22Z" }, - { url = "https://files.pythonhosted.org/packages/69/ac/b42ad16800d0885105b59380ad69aad0cce5a65276e269ce2729a2343b6a/sqlalchemy-2.0.46-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:261c4b1f101b4a411154f1da2b76497d73abbfc42740029205d4d01fa1052684", size = 2154851, upload-time = "2026-01-21T18:27:30.54Z" }, - { url = "https://files.pythonhosted.org/packages/a0/60/d8710068cb79f64d002ebed62a7263c00c8fd95f4ebd4b5be8f7ca93f2bc/sqlalchemy-2.0.46-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:181903fe8c1b9082995325f1b2e84ac078b1189e2819380c2303a5f90e114a62", size = 3311241, upload-time = "2026-01-21T18:32:33.45Z" }, - { url = "https://files.pythonhosted.org/packages/2b/0f/20c71487c7219ab3aa7421c7c62d93824c97c1460f2e8bb72404b0192d13/sqlalchemy-2.0.46-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:590be24e20e2424a4c3c1b0835e9405fa3d0af5823a1a9fc02e5dff56471515f", size = 3310741, upload-time = "2026-01-21T18:44:57.887Z" }, - { url = "https://files.pythonhosted.org/packages/65/80/d26d00b3b249ae000eee4db206fcfc564bf6ca5030e4747adf451f4b5108/sqlalchemy-2.0.46-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7568fe771f974abadce52669ef3a03150ff03186d8eb82613bc8adc435a03f01", size = 3263116, upload-time = "2026-01-21T18:32:35.044Z" }, - { url = "https://files.pythonhosted.org/packages/da/ee/74dda7506640923821340541e8e45bd3edd8df78664f1f2e0aae8077192b/sqlalchemy-2.0.46-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf7e1e78af38047e08836d33502c7a278915698b7c2145d045f780201679999", size = 3285327, upload-time = "2026-01-21T18:44:59.254Z" }, - { url = "https://files.pythonhosted.org/packages/9f/25/6dcf8abafff1389a21c7185364de145107b7394ecdcb05233815b236330d/sqlalchemy-2.0.46-cp311-cp311-win32.whl", hash = "sha256:9d80ea2ac519c364a7286e8d765d6cd08648f5b21ca855a8017d9871f075542d", size = 2114564, upload-time = "2026-01-21T18:33:15.85Z" }, - { url = "https://files.pythonhosted.org/packages/93/5f/e081490f8523adc0088f777e4ebad3cac21e498ec8a3d4067074e21447a1/sqlalchemy-2.0.46-cp311-cp311-win_amd64.whl", hash = "sha256:585af6afe518732d9ccd3aea33af2edaae4a7aa881af5d8f6f4fe3a368699597", size = 2139233, upload-time = "2026-01-21T18:33:17.528Z" }, - { url = "https://files.pythonhosted.org/packages/b6/35/d16bfa235c8b7caba3730bba43e20b1e376d2224f407c178fbf59559f23e/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c", size = 2153405, upload-time = "2026-01-21T19:05:54.143Z" }, - { url = "https://files.pythonhosted.org/packages/06/6c/3192e24486749862f495ddc6584ed730c0c994a67550ec395d872a2ad650/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9", size = 3334702, upload-time = "2026-01-21T18:46:45.384Z" }, - { url = "https://files.pythonhosted.org/packages/ea/a2/b9f33c8d68a3747d972a0bb758c6b63691f8fb8a49014bc3379ba15d4274/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b", size = 3347664, upload-time = "2026-01-21T18:40:09.979Z" }, - { url = "https://files.pythonhosted.org/packages/aa/d2/3e59e2a91eaec9db7e8dc6b37b91489b5caeb054f670f32c95bcba98940f/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53", size = 3277372, upload-time = "2026-01-21T18:46:47.168Z" }, - { url = "https://files.pythonhosted.org/packages/dd/dd/67bc2e368b524e2192c3927b423798deda72c003e73a1e94c21e74b20a85/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e", size = 3312425, upload-time = "2026-01-21T18:40:11.548Z" }, - { url = "https://files.pythonhosted.org/packages/43/82/0ecd68e172bfe62247e96cb47867c2d68752566811a4e8c9d8f6e7c38a65/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb", size = 2113155, upload-time = "2026-01-21T18:42:49.748Z" }, - { url = "https://files.pythonhosted.org/packages/bc/2a/2821a45742073fc0331dc132552b30de68ba9563230853437cac54b2b53e/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff", size = 2140078, upload-time = "2026-01-21T18:42:51.197Z" }, - { url = "https://files.pythonhosted.org/packages/b3/4b/fa7838fe20bb752810feed60e45625a9a8b0102c0c09971e2d1d95362992/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00", size = 2150268, upload-time = "2026-01-21T19:05:56.621Z" }, - { url = "https://files.pythonhosted.org/packages/46/c1/b34dccd712e8ea846edf396e00973dda82d598cb93762e55e43e6835eba9/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2", size = 3276511, upload-time = "2026-01-21T18:46:49.022Z" }, - { url = "https://files.pythonhosted.org/packages/96/48/a04d9c94753e5d5d096c628c82a98c4793b9c08ca0e7155c3eb7d7db9f24/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee", size = 3292881, upload-time = "2026-01-21T18:40:13.089Z" }, - { url = "https://files.pythonhosted.org/packages/be/f4/06eda6e91476f90a7d8058f74311cb65a2fb68d988171aced81707189131/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad", size = 3224559, upload-time = "2026-01-21T18:46:50.974Z" }, - { url = "https://files.pythonhosted.org/packages/ab/a2/d2af04095412ca6345ac22b33b89fe8d6f32a481e613ffcb2377d931d8d0/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e", size = 3262728, upload-time = "2026-01-21T18:40:14.883Z" }, - { url = "https://files.pythonhosted.org/packages/31/48/1980c7caa5978a3b8225b4d230e69a2a6538a3562b8b31cea679b6933c83/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f", size = 2111295, upload-time = "2026-01-21T18:42:52.366Z" }, - { url = "https://files.pythonhosted.org/packages/2d/54/f8d65bbde3d877617c4720f3c9f60e99bb7266df0d5d78b6e25e7c149f35/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef", size = 2137076, upload-time = "2026-01-21T18:42:53.924Z" }, - { url = "https://files.pythonhosted.org/packages/56/ba/9be4f97c7eb2b9d5544f2624adfc2853e796ed51d2bb8aec90bc94b7137e/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10", size = 3556533, upload-time = "2026-01-21T18:33:06.636Z" }, - { url = "https://files.pythonhosted.org/packages/20/a6/b1fc6634564dbb4415b7ed6419cdfeaadefd2c39cdab1e3aa07a5f2474c2/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764", size = 3523208, upload-time = "2026-01-21T18:45:08.436Z" }, - { url = "https://files.pythonhosted.org/packages/a1/d8/41e0bdfc0f930ff236f86fccd12962d8fa03713f17ed57332d38af6a3782/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b", size = 3464292, upload-time = "2026-01-21T18:33:08.208Z" }, - { url = "https://files.pythonhosted.org/packages/f0/8b/9dcbec62d95bea85f5ecad9b8d65b78cc30fb0ffceeb3597961f3712549b/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447", size = 3473497, upload-time = "2026-01-21T18:45:10.552Z" }, - { url = "https://files.pythonhosted.org/packages/e9/f8/5ecdfc73383ec496de038ed1614de9e740a82db9ad67e6e4514ebc0708a3/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada", size = 2152079, upload-time = "2026-01-21T19:05:58.477Z" }, - { url = "https://files.pythonhosted.org/packages/e5/bf/eba3036be7663ce4d9c050bc3d63794dc29fbe01691f2bf5ccb64e048d20/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366", size = 3272216, upload-time = "2026-01-21T18:46:52.634Z" }, - { url = "https://files.pythonhosted.org/packages/05/45/1256fb597bb83b58a01ddb600c59fe6fdf0e5afe333f0456ed75c0f8d7bd/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d", size = 3277208, upload-time = "2026-01-21T18:40:16.38Z" }, - { url = "https://files.pythonhosted.org/packages/d9/a0/2053b39e4e63b5d7ceb3372cface0859a067c1ddbd575ea7e9985716f771/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e", size = 3221994, upload-time = "2026-01-21T18:46:54.622Z" }, - { url = "https://files.pythonhosted.org/packages/1e/87/97713497d9502553c68f105a1cb62786ba1ee91dea3852ae4067ed956a50/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf", size = 3243990, upload-time = "2026-01-21T18:40:18.253Z" }, - { url = "https://files.pythonhosted.org/packages/a8/87/5d1b23548f420ff823c236f8bea36b1a997250fd2f892e44a3838ca424f4/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908", size = 2114215, upload-time = "2026-01-21T18:42:55.232Z" }, - { url = "https://files.pythonhosted.org/packages/3a/20/555f39cbcf0c10cf452988b6a93c2a12495035f68b3dbd1a408531049d31/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b", size = 2139867, upload-time = "2026-01-21T18:42:56.474Z" }, - { url = "https://files.pythonhosted.org/packages/3e/f0/f96c8057c982d9d8a7a68f45d69c674bc6f78cad401099692fe16521640a/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa", size = 3561202, upload-time = "2026-01-21T18:33:10.337Z" }, - { url = "https://files.pythonhosted.org/packages/d7/53/3b37dda0a5b137f21ef608d8dfc77b08477bab0fe2ac9d3e0a66eaeab6fc/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863", size = 3526296, upload-time = "2026-01-21T18:45:12.657Z" }, - { url = "https://files.pythonhosted.org/packages/33/75/f28622ba6dde79cd545055ea7bd4062dc934e0621f7b3be2891f8563f8de/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede", size = 3470008, upload-time = "2026-01-21T18:33:11.725Z" }, - { url = "https://files.pythonhosted.org/packages/a9/42/4afecbbc38d5e99b18acef446453c76eec6fbd03db0a457a12a056836e22/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330", size = 3476137, upload-time = "2026-01-21T18:45:15.001Z" }, - { url = "https://files.pythonhosted.org/packages/fc/a1/9c4efa03300926601c19c18582531b45aededfb961ab3c3585f1e24f120b/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e", size = 1937882, upload-time = "2026-01-21T18:22:10.456Z" }, + { url = "https://files.pythonhosted.org/packages/ec/75/17db77c57129c223c7d98518ad1e1faa24ee350c22a44b55390d8463c28c/sqlalchemy-2.0.47-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:33a917ede39406ddb93c3e642b5bc480be7c5fd0f3d0d6ae1036d466fb963f1a", size = 2157331, upload-time = "2026-02-24T16:43:52.693Z" }, + { url = "https://files.pythonhosted.org/packages/b0/d6/3658f7e5c376de774c009f2bb9c0ddf88a35b89c5bfb15ee7174a17b1a5f/sqlalchemy-2.0.47-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:561d027c829b01e040bdade6b6f5b429249d056ef95d7bdcb9211539ecc82803", size = 3236939, upload-time = "2026-02-24T17:28:57.419Z" }, + { url = "https://files.pythonhosted.org/packages/4e/38/f4b94f85d1c26cb9ee0e57449754de816c326f9586b9a8c5247eb49146de/sqlalchemy-2.0.47-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fa5072a37e68c565363c009b7afa5b199b488c87940ec02719860093a08f34ca", size = 3235190, upload-time = "2026-02-24T17:27:07.884Z" }, + { url = "https://files.pythonhosted.org/packages/94/f2/36714f1de01e135a2bf142b662e416e5338ab63c47878e31051338c66e2d/sqlalchemy-2.0.47-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:1e7ed17dd4312a298b6024bfd1baf51654bc49e3f03c798005babf0c7922d6a7", size = 3188064, upload-time = "2026-02-24T17:28:58.908Z" }, + { url = "https://files.pythonhosted.org/packages/ab/94/fcd978e7625cd1c97d9f1d7363e18e37d24314e572acd7c091e3a4210106/sqlalchemy-2.0.47-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:6992e353fcb0593eb42d95ad84b3e58fe40b5e37fd332b9ccba28f4b2f36d1fc", size = 3209480, upload-time = "2026-02-24T17:27:09.823Z" }, + { url = "https://files.pythonhosted.org/packages/23/29/c633202b9900ab65f0162f59df737b57f30010f44d892b186810c9ed58b7/sqlalchemy-2.0.47-cp310-cp310-win32.whl", hash = "sha256:05a6d58ed99ebd01303c92d29a0c9cbf70f637b3ddd155f5172c5a7239940998", size = 2117652, upload-time = "2026-02-24T17:14:34.635Z" }, + { url = "https://files.pythonhosted.org/packages/00/39/54acf13913932b8508058d47a169e6fcde9adaa4cbfa16cbf30da1f6a482/sqlalchemy-2.0.47-cp310-cp310-win_amd64.whl", hash = "sha256:4a7aa4a584cc97e268c11e700dea0b763874eaebb435e75e7d0ffee5d90f5030", size = 2140883, upload-time = "2026-02-24T17:14:35.875Z" }, + { url = "https://files.pythonhosted.org/packages/94/13/886338d3e8ab5ddcfe84d54302c749b1793e16c4bba63d7004e3f7baa8ec/sqlalchemy-2.0.47-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3a1dbf0913879c443617d6b64403cf2801c941651db8c60e96d204ed9388d6b0", size = 2157124, upload-time = "2026-02-24T16:43:54.706Z" }, + { url = "https://files.pythonhosted.org/packages/b6/bb/a897f6a66c9986aa9f27f5cf8550637d8a5ea368fd7fb42f6dac3105b4dc/sqlalchemy-2.0.47-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:775effbb97ea3b00c4dd3aeaf3ba8acba6e3e2b4b41d17d67a27e696843dbc95", size = 3313513, upload-time = "2026-02-24T17:29:00.527Z" }, + { url = "https://files.pythonhosted.org/packages/59/fb/69bfae022b681507565ab0d34f0c80aa1e9f954a5a7cbfb0ed054966ac8d/sqlalchemy-2.0.47-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56cc834a3ffac34270cc2a41875e0f40e97aa651f4f3ca1cfbbf421c044cb62b", size = 3313014, upload-time = "2026-02-24T17:27:11.679Z" }, + { url = "https://files.pythonhosted.org/packages/04/f3/0eba329f7c182d53205a228c4fd24651b95489b431ea2bd830887b4c13c4/sqlalchemy-2.0.47-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:49b5e0c7244262f39e767c018e4fdb5e5dbc23cd54c5ddac8eea8f0ba32ef890", size = 3265389, upload-time = "2026-02-24T17:29:02.497Z" }, + { url = "https://files.pythonhosted.org/packages/5c/06/654edc084b3b46ac79e04200d7c46467ae80c759c4ee41c897f9272b036f/sqlalchemy-2.0.47-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:15cd822a3f1f6f77b5b841a30c1a07a07f7dee3385f17e638e1722de9ab683be", size = 3287604, upload-time = "2026-02-24T17:27:13.295Z" }, + { url = "https://files.pythonhosted.org/packages/78/33/c18c8f63b61981219d3aa12321bb7ccee605034d195e868ed94f9727b27c/sqlalchemy-2.0.47-cp311-cp311-win32.whl", hash = "sha256:9847a19548cd283a65e1ce0afd54016598d55ff72682d6fd3e493af6fc044064", size = 2116916, upload-time = "2026-02-24T17:14:37.392Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c6/a59e3f9796fff844e16afbd821db9abfd6e12698db9441a231a96193a100/sqlalchemy-2.0.47-cp311-cp311-win_amd64.whl", hash = "sha256:722abf1c82aeca46a1a0803711244a48a298279eeaec9e02f7bfee9e064182e5", size = 2141587, upload-time = "2026-02-24T17:14:39.746Z" }, + { url = "https://files.pythonhosted.org/packages/80/88/74eb470223ff88ea6572a132c0b8de8c1d8ed7b843d3b44a8a3c77f31d39/sqlalchemy-2.0.47-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4fa91b19d6b9821c04cc8f7aa2476429cc8887b9687c762815aa629f5c0edec1", size = 2155687, upload-time = "2026-02-24T17:05:46.451Z" }, + { url = "https://files.pythonhosted.org/packages/ef/ba/1447d3d558971b036cb93b557595cb5dcdfe728f1c7ac4dec16505ef5756/sqlalchemy-2.0.47-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7c5bbbd14eff577c8c79cbfe39a0771eecd20f430f3678533476f0087138f356", size = 3336978, upload-time = "2026-02-24T17:18:04.597Z" }, + { url = "https://files.pythonhosted.org/packages/8a/07/b47472d2ffd0776826f17ccf0b4d01b224c99fbd1904aeb103dffbb4b1cc/sqlalchemy-2.0.47-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5a6c555da8d4280a3c4c78c5b7a3f990cee2b2884e5f934f87a226191682ff7", size = 3349939, upload-time = "2026-02-24T17:27:18.937Z" }, + { url = "https://files.pythonhosted.org/packages/bb/c6/95fa32b79b57769da3e16f054cf658d90940317b5ca0ec20eac84aa19c4f/sqlalchemy-2.0.47-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ed48a1701d24dff3bb49a5bce94d6bc84cbe33d98af2aa2d3cdcce3dea1709ec", size = 3279648, upload-time = "2026-02-24T17:18:07.038Z" }, + { url = "https://files.pythonhosted.org/packages/bb/c8/3d07e7c73928dc59a0bed40961ca4e313e797bce650b088e8d5fdd3ad939/sqlalchemy-2.0.47-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4f3178c920ad98158f0b6309382194df04b14808fa6052ae07099fdde29d5602", size = 3314695, upload-time = "2026-02-24T17:27:20.93Z" }, + { url = "https://files.pythonhosted.org/packages/6b/d2/ed32b1611c1e19fdb028eee1adc5a9aa138c2952d09ae11f1670170f80ae/sqlalchemy-2.0.47-cp312-cp312-win32.whl", hash = "sha256:b9c11ac9934dd59ece9619fe42780a08abe2faab7b0543bb00d5eabea4f421b9", size = 2115502, upload-time = "2026-02-24T17:22:52.546Z" }, + { url = "https://files.pythonhosted.org/packages/fd/52/9de590356a4dd8e9ef5a881dbba64b2bbc4cbc71bf02bc68e775fb9b1899/sqlalchemy-2.0.47-cp312-cp312-win_amd64.whl", hash = "sha256:db43b72cf8274a99e089755c9c1e0b947159b71adbc2c83c3de2e38d5d607acb", size = 2142435, upload-time = "2026-02-24T17:22:54.268Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/0af64ce7d8f60ec5328c10084e2f449e7912a9b8bdbefdcfb44454a25f49/sqlalchemy-2.0.47-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:456a135b790da5d3c6b53d0ef71ac7b7d280b7f41eb0c438986352bf03ca7143", size = 2152551, upload-time = "2026-02-24T17:05:47.675Z" }, + { url = "https://files.pythonhosted.org/packages/63/79/746b8d15f6940e2ac469ce22d7aa5b1124b1ab820bad9b046eb3000c88a6/sqlalchemy-2.0.47-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09a2f7698e44b3135433387da5d8846cf7cc7c10e5425af7c05fee609df978b6", size = 3278782, upload-time = "2026-02-24T17:18:10.012Z" }, + { url = "https://files.pythonhosted.org/packages/91/b1/bd793ddb34345d1ed43b13ab2d88c95d7d4eb2e28f5b5a99128b9cc2bca2/sqlalchemy-2.0.47-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a0bbc72e6a177c78d724f9106aaddc0d26a2ada89c6332b5935414eccf04cbd5", size = 3295155, upload-time = "2026-02-24T17:27:22.827Z" }, + { url = "https://files.pythonhosted.org/packages/97/84/7213def33f94e5ca6f5718d259bc9f29de0363134648425aa218d4356b23/sqlalchemy-2.0.47-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:75460456b043b78b6006e41bdf5b86747ee42eafaf7fffa3b24a6e9a456a2092", size = 3226834, upload-time = "2026-02-24T17:18:11.465Z" }, + { url = "https://files.pythonhosted.org/packages/ef/06/456810204f4dc29b5f025b1b0a03b4bd6b600ebf3c1040aebd90a257fa33/sqlalchemy-2.0.47-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5d9adaa616c3bc7d80f9ded57cd84b51d6617cad6a5456621d858c9f23aaee01", size = 3265001, upload-time = "2026-02-24T17:27:24.813Z" }, + { url = "https://files.pythonhosted.org/packages/fb/20/df3920a4b2217dbd7390a5bd277c1902e0393f42baaf49f49b3c935e7328/sqlalchemy-2.0.47-cp313-cp313-win32.whl", hash = "sha256:76e09f974382a496a5ed985db9343628b1cb1ac911f27342e4cc46a8bac10476", size = 2113647, upload-time = "2026-02-24T17:22:55.747Z" }, + { url = "https://files.pythonhosted.org/packages/46/06/7873ddf69918efbfabd7211829f4bd8019739d0a719253112d305d3ba51d/sqlalchemy-2.0.47-cp313-cp313-win_amd64.whl", hash = "sha256:0664089b0bf6724a0bfb49a0cf4d4da24868a0a5c8e937cd7db356d5dcdf2c66", size = 2139425, upload-time = "2026-02-24T17:22:57.033Z" }, + { url = "https://files.pythonhosted.org/packages/54/fa/61ad9731370c90ac7ea5bf8f5eaa12c48bb4beec41c0fa0360becf4ac10d/sqlalchemy-2.0.47-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed0c967c701ae13da98eb220f9ddab3044ab63504c1ba24ad6a59b26826ad003", size = 3558809, upload-time = "2026-02-24T17:12:15.232Z" }, + { url = "https://files.pythonhosted.org/packages/33/d5/221fac96f0529391fe374875633804c866f2b21a9c6d3a6ca57d9c12cfd7/sqlalchemy-2.0.47-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d3537943a61fd25b241e976426a0c6814434b93cf9b09d39e8e78f3c9eb9a487", size = 3525480, upload-time = "2026-02-24T17:27:59.602Z" }, + { url = "https://files.pythonhosted.org/packages/ec/55/8247d53998c3673e4a8d1958eba75c6f5cc3b39082029d400bb1f2a911ae/sqlalchemy-2.0.47-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:57f7e336a64a0dba686c66392d46b9bc7af2c57d55ce6dc1697b4ef32b043ceb", size = 3466569, upload-time = "2026-02-24T17:12:16.94Z" }, + { url = "https://files.pythonhosted.org/packages/6b/b5/c1f0eea1bac6790845f71420a7fe2f2a0566203aa57543117d4af3b77d1c/sqlalchemy-2.0.47-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dff735a621858680217cb5142b779bad40ef7322ddbb7c12062190db6879772e", size = 3475770, upload-time = "2026-02-24T17:28:02.034Z" }, + { url = "https://files.pythonhosted.org/packages/c5/ed/2f43f92474ea0c43c204657dc47d9d002cd738b96ca2af8e6d29a9b5e42d/sqlalchemy-2.0.47-cp313-cp313t-win32.whl", hash = "sha256:3893dc096bb3cca9608ea3487372ffcea3ae9b162f40e4d3c51dd49db1d1b2dc", size = 2141300, upload-time = "2026-02-24T17:14:37.024Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a9/8b73f9f1695b6e92f7aaf1711135a1e3bbeb78bca9eded35cb79180d3c6d/sqlalchemy-2.0.47-cp313-cp313t-win_amd64.whl", hash = "sha256:b5103427466f4b3e61f04833ae01f9a914b1280a2a8bcde3a9d7ab11f3755b42", size = 2173053, upload-time = "2026-02-24T17:14:38.688Z" }, + { url = "https://files.pythonhosted.org/packages/c1/30/98243209aae58ed80e090ea988d5182244ca7ab3ff59e6d850c3dfc7651e/sqlalchemy-2.0.47-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b03010a5a5dfe71676bc83f2473ebe082478e32d77e6f082c8fe15a31c3b42a6", size = 2154355, upload-time = "2026-02-24T17:05:48.959Z" }, + { url = "https://files.pythonhosted.org/packages/ab/62/12ca6ea92055fe486d6558a2a4efe93e194ff597463849c01f88e5adb99d/sqlalchemy-2.0.47-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f8e3371aa9024520883a415a09cc20c33cfd3eeccf9e0f4f4c367f940b9cbd44", size = 3274486, upload-time = "2026-02-24T17:18:13.659Z" }, + { url = "https://files.pythonhosted.org/packages/97/88/7dfbdeaa8d42b1584e65d6cc713e9d33b6fa563e0d546d5cb87e545bb0e5/sqlalchemy-2.0.47-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9449f747e50d518c6e1b40cc379e48bfc796453c47b15e627ea901c201e48a6", size = 3279481, upload-time = "2026-02-24T17:27:26.491Z" }, + { url = "https://files.pythonhosted.org/packages/d0/b7/75e1c1970616a9dd64a8a6fd788248da2ddaf81c95f4875f2a1e8aee4128/sqlalchemy-2.0.47-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:21410f60d5cac1d6bfe360e05bd91b179be4fa0aa6eea6be46054971d277608f", size = 3224269, upload-time = "2026-02-24T17:18:15.078Z" }, + { url = "https://files.pythonhosted.org/packages/31/ac/eec1a13b891df9a8bc203334caf6e6aac60b02f61b018ef3b4124b8c4120/sqlalchemy-2.0.47-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:819841dd5bb4324c284c09e2874cf96fe6338bfb57a64548d9b81a4e39c9871f", size = 3246262, upload-time = "2026-02-24T17:27:27.986Z" }, + { url = "https://files.pythonhosted.org/packages/c9/b0/661b0245b06421058610da39f8ceb34abcc90b49f90f256380968d761dbe/sqlalchemy-2.0.47-cp314-cp314-win32.whl", hash = "sha256:e255ee44821a7ef45649c43064cf94e74f81f61b4df70547304b97a351e9b7db", size = 2116528, upload-time = "2026-02-24T17:22:59.363Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ef/1035a90d899e61810791c052004958be622a2cf3eb3df71c3fe20778c5d0/sqlalchemy-2.0.47-cp314-cp314-win_amd64.whl", hash = "sha256:209467ff73ea1518fe1a5aaed9ba75bb9e33b2666e2553af9ccd13387bf192cb", size = 2142181, upload-time = "2026-02-24T17:23:01.001Z" }, + { url = "https://files.pythonhosted.org/packages/76/bb/17a1dd09cbba91258218ceb582225f14b5364d2683f9f5a274f72f2d764f/sqlalchemy-2.0.47-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e78fd9186946afaa287f8a1fe147ead06e5d566b08c0afcb601226e9c7322a64", size = 3563477, upload-time = "2026-02-24T17:12:18.46Z" }, + { url = "https://files.pythonhosted.org/packages/66/8f/1a03d24c40cc321ef2f2231f05420d140bb06a84f7047eaa7eaa21d230ba/sqlalchemy-2.0.47-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5740e2f31b5987ed9619d6912ae5b750c03637f2078850da3002934c9532f172", size = 3528568, upload-time = "2026-02-24T17:28:03.732Z" }, + { url = "https://files.pythonhosted.org/packages/fd/53/d56a213055d6b038a5384f0db5ece7343334aca230ff3f0fa1561106f22c/sqlalchemy-2.0.47-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb9ac00d03de93acb210e8ec7243fefe3e012515bf5fd2f0898c8dff38bc77a4", size = 3472284, upload-time = "2026-02-24T17:12:20.319Z" }, + { url = "https://files.pythonhosted.org/packages/ff/19/c235d81b9cfdd6130bf63143b7bade0dc4afa46c4b634d5d6b2a96bea233/sqlalchemy-2.0.47-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c72a0b9eb2672d70d112cb149fbaf172d466bc691014c496aaac594f1988e706", size = 3478410, upload-time = "2026-02-24T17:28:05.892Z" }, + { url = "https://files.pythonhosted.org/packages/0e/db/cafdeca5ecdaa3bb0811ba5449501da677ce0d83be8d05c5822da72d2e86/sqlalchemy-2.0.47-cp314-cp314t-win32.whl", hash = "sha256:c200db1128d72a71dc3c31c24b42eb9fd85b2b3e5a3c9ba1e751c11ac31250ff", size = 2147164, upload-time = "2026-02-24T17:14:40.783Z" }, + { url = "https://files.pythonhosted.org/packages/fc/5e/ff41a010e9e0f76418b02ad352060a4341bb15f0af66cedc924ab376c7c6/sqlalchemy-2.0.47-cp314-cp314t-win_amd64.whl", hash = "sha256:669837759b84e575407355dcff912835892058aea9b80bd1cb76d6a151cf37f7", size = 2182154, upload-time = "2026-02-24T17:14:43.205Z" }, + { url = "https://files.pythonhosted.org/packages/15/9f/7c378406b592fcf1fc157248607b495a40e3202ba4a6f1372a2ba6447717/sqlalchemy-2.0.47-py3-none-any.whl", hash = "sha256:e2647043599297a1ef10e720cf310846b7f31b6c841fee093d2b09d81215eb93", size = 1940159, upload-time = "2026-02-24T17:15:07.158Z" }, ] [[package]] @@ -6504,7 +6491,7 @@ wheels = [ [[package]] name = "typer" -version = "0.24.0" +version = "0.24.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "annotated-doc", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, @@ -6512,9 +6499,9 @@ dependencies = [ { name = "rich", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, { name = "shellingham", marker = "sys_platform == 'darwin' or sys_platform == 'linux' or sys_platform == 'win32'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/5a/b6/3e681d3b6bb22647509bdbfdd18055d5adc0dce5c5585359fa46ff805fdc/typer-0.24.0.tar.gz", hash = "sha256:f9373dc4eff901350694f519f783c29b6d7a110fc0dcc11b1d7e353b85ca6504", size = 118380, upload-time = "2026-02-16T22:08:48.496Z" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/85/d0/4da85c2a45054bb661993c93524138ace4956cb075a7ae0c9d1deadc331b/typer-0.24.0-py3-none-any.whl", hash = "sha256:5fc435a9c8356f6160ed6e85a6301fdd6e3d8b2851da502050d1f92c5e9eddc8", size = 56441, upload-time = "2026-02-16T22:08:47.535Z" }, + { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" }, ] [[package]] @@ -6612,27 +6599,27 @@ wheels = [ [[package]] name = "uv" -version = "0.10.4" +version = "0.10.5" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/c2/bb/dfd872ab6515e5609dc899acb65ccaf8cbedddefa3e34e8da0a5b3e13070/uv-0.10.4.tar.gz", hash = "sha256:b9ecf9f9145b95ddd6627b106e2e74f4204393b41bea2488079872699c03612e", size = 3875347, upload-time = "2026-02-17T22:01:22.28Z" } +sdist = { url = "https://files.pythonhosted.org/packages/90/2f/472ff992c50e5947ef0570d291cfa3a70b423e5dcc6bee99b7a8e7b6da49/uv-0.10.5.tar.gz", hash = "sha256:c45de48b7fa6dd034de8515a7d129f85f4e74080b9f09a7bfc0bcce2798f8023", size = 3919437, upload-time = "2026-02-24T00:55:11.392Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/d8/a3/565e5e45b5006c108ccd596682768c00be988421a83be92193c90bd889e4/uv-0.10.4-py3-none-linux_armv6l.whl", hash = "sha256:97cd6856145dec1d50821468bb6a10c14f3d71015eb97bb657163c837b5ffe79", size = 22352134, upload-time = "2026-02-17T22:01:30.071Z" }, - { url = "https://files.pythonhosted.org/packages/3e/c6/b86f3fdcde9f270e6dc1ff631a4fe73971bf4162c4dd169c7621110361b8/uv-0.10.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:44dd91ef224cfce2203716ecf244c3d3641269d1c99996aab852248caf2aeba4", size = 21417697, upload-time = "2026-02-17T22:01:51.162Z" }, - { url = "https://files.pythonhosted.org/packages/63/91/c4ddf7e55e05394967615050cc364a999157a44c008d0e1e9db2ed49a11c/uv-0.10.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:751959135a62f006ef51f3fcc5d02ec67986defa0424d470cce0918eede36a55", size = 20082236, upload-time = "2026-02-17T22:01:43.025Z" }, - { url = "https://files.pythonhosted.org/packages/25/92/606701b147d421ba2afe327d25f1ec5f59e519157b7e530d09cf61781d22/uv-0.10.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:c184891b496c5fa04a7e1396d7f1953f52c97a5635636330854ab68f9e8ec212", size = 21921200, upload-time = "2026-02-17T22:01:24.131Z" }, - { url = "https://files.pythonhosted.org/packages/c3/79/942e75d0920a9e4cac76257cd3e2c238f1963d7e45423793f92e84eaa480/uv-0.10.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:5b8a2170ecc700d82ed322fa056789ae2281353fef094e44f563c2f32ab8f438", size = 21974822, upload-time = "2026-02-17T22:01:45.337Z" }, - { url = "https://files.pythonhosted.org/packages/60/71/e5b1140c5c7296f935037a967717a82591522bbc93b4e67c4554dfbb4380/uv-0.10.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:decaf620106efa0d09ca27a8301dd83b8a5371e42649cd2704cfd11fe31af7d7", size = 21953309, upload-time = "2026-02-17T22:01:38.225Z" }, - { url = "https://files.pythonhosted.org/packages/70/a3/03ac1ff2058413c2c7d347f3b3396f291e192b096d2625a201c00bd962c6/uv-0.10.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f7d1035db05ac5b94387395428bdcbfce685f6c8eb2b711b66a5a1b397111913", size = 23217053, upload-time = "2026-02-17T22:01:09.278Z" }, - { url = "https://files.pythonhosted.org/packages/e3/d5/9b02140e8ff29d9b575335662288493cdcde5f123337613c04613017cf23/uv-0.10.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e754f9c8fd7532a28da7deaa6e400de5e7b459f7846bd5320db215a074fa8664", size = 24053086, upload-time = "2026-02-17T22:01:32.722Z" }, - { url = "https://files.pythonhosted.org/packages/f8/80/7023e1b0f9180226f8c3aa3e207383671cb524eb8bbd8a8eecf1c0cfe867/uv-0.10.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d419ef8d4fbd5be0af952a60c76d4f6183acb827cc729095d11c63e7dfaec24c", size = 23121689, upload-time = "2026-02-17T22:01:26.835Z" }, - { url = "https://files.pythonhosted.org/packages/f2/b3/4b9580d62e1245df52e8516cf3e404ff39cc72634d2d749d47b1dada4161/uv-0.10.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82978155e571f2ac3dd57077bd746bfe41b65fa19accc3c92d1f09632cd36c63", size = 23136767, upload-time = "2026-02-17T22:01:40.729Z" }, - { url = "https://files.pythonhosted.org/packages/bd/4e/058976e2a5513f11954e09595a1821d5db1819e96e00bafded19c6a470e9/uv-0.10.4-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:8437e56a7d0f8ecd7421e8b84024dd8153179b8f1371ca1bd66b79fa7fb4c2c1", size = 22003202, upload-time = "2026-02-17T22:01:12.447Z" }, - { url = "https://files.pythonhosted.org/packages/41/c5/da0fc5b732f7dd1f99116ce19e3c1cae7dfa7d04528a0c38268f20643edf/uv-0.10.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:ff1c6a465ec035dfe2dfd745b2e85061f47ab3c5cc626eead491994c028eacc6", size = 22720004, upload-time = "2026-02-17T22:01:53.551Z" }, - { url = "https://files.pythonhosted.org/packages/71/17/13c24dd56c135553645c2c62543eba928e88479fdd2d8356fdf35a0113bc/uv-0.10.4-py3-none-musllinux_1_1_i686.whl", hash = "sha256:525dc49a02b78fcd77431f013f2c48b2a152e31808e792c0d1aee4600495a320", size = 22401692, upload-time = "2026-02-17T22:01:35.368Z" }, - { url = "https://files.pythonhosted.org/packages/9c/b2/7a5fdbc0bfd8364e6290457794127d5e766dbc6d44bb15d1a9e318bc356b/uv-0.10.4-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:7d514b30877fda6e83874ccbd1379e0249cfa064511c5858433edcf697d0d4e3", size = 23330968, upload-time = "2026-02-17T22:01:15.237Z" }, - { url = "https://files.pythonhosted.org/packages/d1/df/004e32be4cd24338422842dd93383f2df0be4554efb6872fef37997ff3ca/uv-0.10.4-py3-none-win32.whl", hash = "sha256:4aed1237847dbd694475c06e8608f2f5f6509181ac148ee35694400d382a3784", size = 21373394, upload-time = "2026-02-17T22:01:20.362Z" }, - { url = "https://files.pythonhosted.org/packages/31/dd/1900452678d46f6a649ab8167bededb02500b0561fc9f69e1f52607895c7/uv-0.10.4-py3-none-win_amd64.whl", hash = "sha256:4a1c595cf692fa611019a7ad9bf4b0757fccd0a3f838ca05e53db82912ddaa39", size = 23813606, upload-time = "2026-02-17T22:01:17.733Z" }, - { url = "https://files.pythonhosted.org/packages/7b/e8/c6ba7ceee3ec58d21156b4968449e6a12af15eea8d26308b3b3ffeef2baf/uv-0.10.4-py3-none-win_arm64.whl", hash = "sha256:28c59a02d7a648b75a9c2ea735773d9d357a1eee773b78593c275b0bef1a4b73", size = 22180241, upload-time = "2026-02-17T22:01:56.305Z" }, + { url = "https://files.pythonhosted.org/packages/35/01/1521344a015f7fc01198f9d8560838adbeb9e80b835a23c25c712d8a8c08/uv-0.10.5-py3-none-linux_armv6l.whl", hash = "sha256:d1ccf2e7cf08b8a1477195da50476fb645bf20907072a39074f482049056aa5d", size = 22401966, upload-time = "2026-02-24T00:55:09.111Z" }, + { url = "https://files.pythonhosted.org/packages/3e/47/b4a4690f13d44f110ba7534a950a6ca63f61cc3d81c28f9c81afa9b74634/uv-0.10.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:63435e86321993dd5d90f440524f3f1b874b34aab30b7bf6752b48497117bfc4", size = 21504807, upload-time = "2026-02-24T00:55:18.55Z" }, + { url = "https://files.pythonhosted.org/packages/61/58/28725e2d223b36812f692123934c1cbd7a6bc5261d6cf0f3850889768c66/uv-0.10.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:2cec424513140aa179d1c4decfcf86201497df7bc5674c13a20882d3b2837c7e", size = 20194774, upload-time = "2026-02-24T00:54:49.789Z" }, + { url = "https://files.pythonhosted.org/packages/6b/d4/87113bce59b9711e55995d2db66faffdb98952e371eab2d44fe4b0d79bf7/uv-0.10.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:3aa708beef7fab912d115ba1ccaad383a7006dc1a8e5ecdd9656574188221a84", size = 22044475, upload-time = "2026-02-24T00:54:56.924Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2c/af72b186786c4dd9a3d71d747cd0e02868b6eb7836b29c51e0d4cfe649de/uv-0.10.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:74c6d2d38160bbb2d596560f27875c3906c0e94e61c6279b5111d3f2d74dbcd9", size = 22038345, upload-time = "2026-02-24T00:54:59.245Z" }, + { url = "https://files.pythonhosted.org/packages/61/8f/573edcdffe160093ef640b34690f13a2c6f35e03674fe52207bd9f63f23c/uv-0.10.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f3ff5bab65eb305d1cf024c5eb091b12f3d7b40e5a78409fb0afb937b2614001", size = 22006975, upload-time = "2026-02-24T00:55:28.954Z" }, + { url = "https://files.pythonhosted.org/packages/f0/28/9dbad27f80cc6b162f41c3becf154a1ba54177957ead4ae4faf3125b526f/uv-0.10.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dd263e573a5259e6ce9854698e0c31e8ebdaa0a8d0701943db159854bbd6dcdf", size = 23326569, upload-time = "2026-02-24T00:55:33.966Z" }, + { url = "https://files.pythonhosted.org/packages/1d/a0/f5ee404b9601bfb03d36241637d0d2ff1089115e532bcd77de0d29a0a89b/uv-0.10.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:faaa30c94ffeda248c29b7185ce4d5809de4c54f2a1c16f0120d50564473d9b4", size = 24197070, upload-time = "2026-02-24T00:55:06.621Z" }, + { url = "https://files.pythonhosted.org/packages/dc/e8/c0c33168ca17f582727d33e629fa1673bc1e1c2411b174f2f78c1d16d287/uv-0.10.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:49db2d27555d6f7c69422d2d5f79ebe2dc4ed6a859a698d015d48de51e16aaab", size = 23277854, upload-time = "2026-02-24T00:55:31.444Z" }, + { url = "https://files.pythonhosted.org/packages/8f/d9/4bb264bdb7f2e95efe09622cc6512288a842956bb4c2c3d6fe711eaef7df/uv-0.10.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a8acf9be268ce2fc2c16117b5884f0724498d7191f8db2d12d8a7c7482652d38", size = 23252223, upload-time = "2026-02-24T00:55:16.256Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ac/b669f622c0e978754083aad3d7916594828ad5c3b634cb8374b7a841e153/uv-0.10.5-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:0fbd426d2c215098cd8e08dfa36ad0a313ebe5eb90107ab7b3b8d5563b9b0c03", size = 22124089, upload-time = "2026-02-24T00:55:20.916Z" }, + { url = "https://files.pythonhosted.org/packages/1f/0a/e9f44902757ec1723e8f1970463ce477ce11c79fa52a09001fbc8934128a/uv-0.10.5-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:24825579973a05b7d482f1bba5e1b6d687d8e6ddf0ca088ff893e94ab34943a2", size = 22828770, upload-time = "2026-02-24T00:55:26.571Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/d69ba9636c560b771b96c08bcfb4424829cc53983d8c7b71e0d2f301e7fb/uv-0.10.5-py3-none-musllinux_1_1_i686.whl", hash = "sha256:0338429ec4bb0b64620d05905a3fc1dc420df2a0e22b1a9b01dcc9e430067622", size = 22530138, upload-time = "2026-02-24T00:55:13.363Z" }, + { url = "https://files.pythonhosted.org/packages/92/72/15ef087c4a4ab1531d77b267345a2321301b09345fbe6419f8a8b94ffc3d/uv-0.10.5-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:515042b1f4a05396496a3db9ffc338b2f8f7bb39214fdbcb425b0462630f9270", size = 23448538, upload-time = "2026-02-24T00:54:53.364Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5c/b07bc4fd89fad1a0b7946d40469850552738613fcd678a4ecee5e892aa8c/uv-0.10.5-py3-none-win32.whl", hash = "sha256:b235b4a5f25fb3bb93b96aebb6a2623eda0c2f48a6471b172a89e10444aa3626", size = 21507185, upload-time = "2026-02-24T00:55:01.646Z" }, + { url = "https://files.pythonhosted.org/packages/43/31/c564541cd1a27001a245241e1ac82ef4132fb5d96cab13a4a19e91981eaf/uv-0.10.5-py3-none-win_amd64.whl", hash = "sha256:4924af9facedde12eba2190463d84a4940062a875322e29ef59c8f447951e5c7", size = 23945906, upload-time = "2026-02-24T00:55:04.065Z" }, + { url = "https://files.pythonhosted.org/packages/e0/f5/71fa52581b25d5aa8917b3d3956db9c3d1ed511d4785bb7c94bf02872160/uv-0.10.5-py3-none-win_arm64.whl", hash = "sha256:43445370bb0729917b9a61d18bc3aec4e55c12e86463e6c4536fafde4d4da9e0", size = 22343346, upload-time = "2026-02-24T00:55:23.699Z" }, ] [[package]]