Build AI methods with your coding agent, then run them anywhere: as an MCP for chatbots, as a webapp for people, or via API for your software.
dev to release/v0.14.2 (#413)
Thomas Hebrard3a9e8546c55f
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 291491b34..74fc6a13e 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -1,5 +1,15 @@# Changelog+## [v0.14.2] - 2025-10-29++### Chaged++- Improved pipe builder.++### Added++- CLI to generate inputs JSON.+## [v0.14.1] - 2025-10-27### Addeddiff --git a/docs/pages/build-reliable-ai-workflows-with-pipelex/define_your_concepts.md b/docs/pages/build-reliable-ai-workflows-with-pipelex/define_your_concepts.mdindex 1a978c6bc..4b5468e47 100644--- a/docs/pages/build-reliable-ai-workflows-with-pipelex/define_your_concepts.md+++ b/docs/pages/build-reliable-ai-workflows-with-pipelex/define_your_concepts.md@@ -327,21 +327,21 @@ type = "PipeLLM"description = "Analyze a PDF document"inputs = { document = "PDF" }output = "Text"-prompt_template = "Analyze this document and provide a summary"+prompt = "Analyze this document and provide a summary"[pipe.process_image]type = "PipeLLM"description = "Describe an image"inputs = { photo = "Image" }output = "Text"-prompt_template = "Describe what you see in this image"+prompt = "Describe what you see in this image"[pipe.extract_from_page]type = "PipeLLM"description = "Extract information from a document page"inputs = { page_content = "Page" }output = "ExtractedInfo"-prompt_template = "Extract key information from this page content"+prompt = "Extract key information from this page content"```### Refining Native Conceptsdiff --git a/docs/pages/build-reliable-ai-workflows-with-pipelex/pipe-controllers/PipeBatch.md b/docs/pages/build-reliable-ai-workflows-with-pipelex/pipe-controllers/PipeBatch.mdindex 4d58a3868..76792b107 100644--- a/docs/pages/build-reliable-ai-workflows-with-pipelex/pipe-controllers/PipeBatch.md+++ b/docs/pages/build-reliable-ai-workflows-with-pipelex/pipe-controllers/PipeBatch.md@@ -47,7 +47,7 @@ type = "PipeLLM"description = "Summarize a single article"inputs = { article = "ArticleText" }output = "ArticleSummary"-prompt_template = "Please provide a one-sentence summary of the following article:\n\n@article_text"+prompt = "Please provide a one-sentence summary of the following article:\n\n@article_text"# The PipeBatch definition[pipe.summarize_all_articles]diff --git a/docs/pages/build-reliable-ai-workflows-with-pipelex/pipe-operators/PipeCompose.md b/docs/pages/build-reliable-ai-workflows-with-pipelex/pipe-operators/PipeCompose.mdindex b01451c7c..be34c34e7 100644--- a/docs/pages/build-reliable-ai-workflows-with-pipelex/pipe-operators/PipeCompose.md+++ b/docs/pages/build-reliable-ai-workflows-with-pipelex/pipe-operators/PipeCompose.md@@ -25,44 +25,5 @@ The Jinja2 template has access to all the "stuffs" currently in the working memo| `type` | string | The type of the pipe: `PipeCompose` | Yes || `description` | string | A description of the Jinja2 operation. | Yes || `output` | string | The concept for the output. Defaults to `native.Text`. | No |-| `jinja2_name` | string | The name of a pre-loaded template file. | Yes (or `jinja2`) |-| `jinja2` | string | An inline Jinja2 template string. | Yes (or `jinja2_name`) |+| `template` | string | An inline Jinja2 template string. | Yes || `extra_context` | table (dict) | A table of key-value pairs to add to the rendering context, making them available as variables in the template. | No |--### Example: Generating a report from a template file--This example assumes you have a user profile object and a list of activities in the working memory, and a template file named `weekly_report.md` has been registered.--**`weekly_report.md` template file:**-```jinja-# Weekly Report for {{ user.name }}--Hello {{ user.first_name }},--Here is a summary of your activity this week:--{% for activity in activities %}-- {{ activity.timestamp }}: {{ activity.description }}-{% else %}-- No activity logged this week.-{% endfor %}--Report generated on: {{ report_date }}-```--**Pipeline PLX definition:**-```plx-[pipe.generate_weekly_report]-type = "PipeCompose"-description = "Generate a formatted weekly report for a user"-output = "WeeklyReportText"-jinja2_name = "weekly_report.md"-extra_context = { report_date = "2023-10-27" }-```--In this scenario:--- `PipeCompose` will load the `weekly_report.md` template.-- It will use the `user` and `activities` objects from the working memory.-- It will add `report_date` to the context from the `extra_context` table.-- The rendered markdown text will be saved as the `WeeklyReportText` concept.\ No newline at end of filediff --git a/docs/pages/cookbook-examples/hello-world.md b/docs/pages/cookbook-examples/hello-world.mdindex 644769c5f..627af5fff 100644--- a/docs/pages/cookbook-examples/hello-world.md+++ b/docs/pages/cookbook-examples/hello-world.md@@ -71,7 +71,7 @@ Write a haiku about Hello World.```2. Install dependencies:```bash- pip install -r requirements.txt+ pip install .```3. Set up your environment variables by copying `.env.example` to `.env` and adding your API keys.4. Run the example:diff --git a/pipelex/builder/builder.plx b/pipelex/builder/builder.plxindex 9b342ab4e..beebf0fbc 100644--- a/pipelex/builder/builder.plx+++ b/pipelex/builder/builder.plx@@ -6,47 +6,27 @@ UserBrief = "A short, natural-language description of what the user wants."PlanDraft = "Natural-language pipeline plan text describing sequences, inputs, outputs."ConceptDrafts = "Textual draft of the concepts to create."PipelexBundleSpec = "A Pipelex bundle spec."-ValidationResult = "Status (success or failure) and details of the validation failure if applicable."BundleHeaderSpec = "A domain information object."+FlowDraft = "Draft of the flow of the pipeline."-# ────────────────────────────────────────────────────────────────────────────────-# Main-# ────────────────────────────────────────────────────────────────────────────────[pipe][pipe.pipe_builder]type = "PipeSequence"description = "This pipe is going to be the entry point for the builder. It will take a UserBrief and return a PipelexBundleSpec."inputs = { brief = "UserBrief" }-output = "PipelexBundleSpec"+output = "builder.PipelexBundleSpec"steps = [{ pipe = "draft_the_plan", result = "plan_draft" },{ pipe = "draft_the_concepts", result = "concept_drafts" },{ pipe = "structure_concepts", result = "concept_specs" },+ { pipe = "draft_flow", result = "flow_draft" },+ { pipe = "review_flow", result = "prepared_flow" },{ pipe = "design_pipe_signatures", result = "pipe_signatures" },- { pipe = "detail_pipe_spec", batch_over = "pipe_signatures", batch_as = "pipe_signature", result = "pipe_specs" },{ pipe = "write_bundle_header", result = "bundle_header_spec" },+ { pipe = "detail_pipe_spec", batch_over = "pipe_signatures", batch_as = "pipe_signature", result = "pipe_specs" },{ pipe = "assemble_pipelex_bundle_spec", result = "pipelex_bundle_spec" }]-[pipe.write_bundle_header]-type = "PipeLLM"-description = "Write the bundle header."-inputs = { brief = "UserBrief", pipe_signatures = "PipeSignature" }-output = "BundleHeaderSpec"-model = "llm_to_engineer"-prompt = """-Name and define the domain of this process:-@brief--@pipe_signatures--For example, if the brief is about generating and analyzing a compliance matrix out of a RFP,-the domain would be "rfp_compliance" and the description would be "Generating and analyzing compliance related to RFPs".-The domain name should be not more than 4 words, in snake_case.-For the description, be concise.-The main pipe is the one that will carry out the main task of the pipeline, it should be pretty obvious to identify.-"""-[pipe.draft_the_plan]type = "PipeLLM"description = "Turn the brief into a pseudo-code plan describing controllers, pipes, their inputs/outputs."@@ -54,59 +34,47 @@ inputs = { brief = "UserBrief" }output = "PlanDraft"model = "llm_to_engineer"prompt = """-Return a draft of a plan that narrates the pipeline as pseudo-steps (no code):-- Be clear which is the main pipe of the pipeline, don't write "main" in its pipe_code, but make it clear in its description.-- Explicitly indicate when you are running things in sequence,- or in parallel (several independant steps in parallel),- or in batch (same operation applied to N elements of a list)- or based on a condition+# Return a draft of a plan that narrates the pipeline as pseudo-steps (no code):- For each pipe: state the pipe's description, inputs (by name using snake_case), and the output (by name using snake_case),DO NOT indicate the inputs or output type. Just name them.-- Be aware of the steps where you will want structured outputs or inputs. Make sense of it but be concise.-- Do not bother with planning a final step that gathers all the elements unless it's clear from the brief that the user wants the pipe to do that.+- Note where you will want structured outputs or inputs.-Available pipe controllers:-- PipeSequence: A pipe that executes a sequence of pipes: it needs to reference the pipes it will execute.-- PipeParallel: A pipe that executes a few pipes in parallel. It needs to reference the pipes it will execute.- The results of each pipe will be in the working memory. The output MUST BE "Dynamic".-- PipeCondition: A pipe that based on a conditional expression, branches to a specific pipe.- You have to explain what the expression of the condition is,- and reference the different pipes that well be executed according to the condition.--When describing the task of a pipe controller, be concise, don't detail all the sub-pipes.--Available pipe operators:-- PipeLLM: A pipe that uses an LLM to generate text or structured objects. It is a vision LLM so it can also use images.- CRITICAL: When extracting MULTIPLE items (articles, employees, products), use bracket notation in output with SINGULAR concepts!- - Create concept "Article" (not "Articles") with fields "item_name", "quantity" (not "item_names", "quantities")- - Then set output = "Article[]" to get a variable list, or output = "Article[5]" for exactly 5 items- - Examples: output = "Text[]" (multiple texts), output = "Image[3]" (exactly 3 images), output = "Employee[]" (list of employees)-- PipeImgGen: A pipe that uses an AI model to generate images.- - VERY IMPORTANT: IF YOU DECIDE TO CREATE A PipeImgGen to generate an image, YOU ALSO HAVE TO CREATE A PIPELLM THAT WILL WRITE THE PROMPT- AND THAT NEEDS TO PRECEED THE PIPEIMGEN, based on the necessary elements, unless it's clear from the brief that the prompt should be part of the main pipe's original inputs.-- PipeExtract: A pipe that uses OCR technology to extract text from an image or a pdf.- - Always outputs a list of pages: output = "Page[]"- VERY IMPORTANT: THE INPUT OF THE PIPEEXTRACT MUST BE either an image or a pdf or a concept which refines one of them.+## Memory and flow:+- We have a memory system: the outputs of each pipe are added to the memory and can be used as inputs by subsequent pipes.+- The pipeline's initial inputs are added to the memory at the beginning.+- You don't need to flatten lists at the end or even in intermediate steps: our system manages branching and the memory flows into each branch.+- At the end of the pipeline, all the memory is delivered so there is not need to gather all the elements unless expressly requested by the brief.++## Available orchestration controllers:+- SEQUENCE: execute a sequence of pipes in order. It must reference the pipes it will execute.+- BATCH: concurrently executes THE SAME pipe on each element of a list taken from the memory. BATCH is a map operator: it transforms the input list in a new list of outputs, so if you want to apply several steps to the individual items, the batch MUST branch into a SEQUENCE of these steps.+- PARALLEL: concurrently executes DIFFERENT PIPES on any stuff from the memory. The outputs of each of the parallel pipes will be usable in the following steps.+- CONDITION: branches to a specific pipe, based on the evaluation of a conditional expression and according to an outcome map. There can also be a default outcome.-Be smart about multiplicity: when a step is to generate a variable or fixed number of items, use the multiplicity notation to specify it.-Don't create numbered variables like `idea_1`, `idea_2`, etc: trust that the pipes will handle the multiplicity for you.-You can name the variables with a plural name like "ideas" and make them use a concept with a singular name and a multiplicity like "Idea[]" or "Idea[5]".+When describing the task of a pipe controller, be concise, don't detail all the sub-pipes but list the pipes they will use.-Be smart about splitting the workflow into steps (sequence or parallel):-- You can use an LLM to extract or analyze several things at the same time, they can be output as a single concept which will be structured with attributes etc.-- But don't ask the LLM for many things which are unrelated, it would lose reliability.+## Available pipe operators:+- LLM: uses a Vision/LLM to generate text or structured objects. It can generate single items or lists of items.+- IMG_GEN: uses an AI model to generate images from a prompt that is either the result of a previous step or part of the pipeline's original inputs. As the image generation prompt MUST be a text, you can plan to use an LLM step to write it.+- EXTRACT: extracts content from an image or a pdf, always outputs a list of pages (possibly a list of one page). Use it only when you need to use OCR or PDF extraction.-Apply the DRY principle: don't repeat yourself. if you have a task to apply several times, make it a dedicated pipe.-If you're in a sequence and you are to apply that pipe to a previous output which is multiple, plan to batch over it.+----You must never include nore than one batch step in the same pipe sequence.-Instead, you must create a pipe sequence specifically for the process to apply to each batched element-and that sub pipe will have the second batch step.+Now let's write the plan.-Keep your style concise, no need to write tags such as "Description:", just write what you need to write.+Make it narrative concise markdown format, no need to write tags such as "Description:", just write what you need to write.Do not write any intro or outro, just write the plan.+What is important is to name the variables, from the initial inputs to the final outputs.+And the variable names must be consistent between the various steps.+In case of multiple items used as list in inputs or outputs, name them with a plural variable name when they are multiple, but then use the singular variable name when working with each item of the list.++It's also VERY IMPORTANT to list all the variables used by each pipe. All the memory is available, yes, so you can combine any inputs, but you must state which ones you will actually use in each pipe.++Apply the DRY principle: don't repeat yourself. if you have a task to apply several times, describe it as a dedicated pipe.+@brief+"""[pipe.draft_the_concepts]@@ -120,9 +88,10 @@ We are working on writing an AI pipeline to fulfill this brief:@briefWe have already written a plan for the pipeline. It's built using pipes, each with its own inputs (one or more) and output (single).+Your job is to clarify the different concepts used in the plan.+Variables are snake_case and concepts are PascalCase.-Your job is to clarify the different concepts used in the plan.We want clear concepts but we don't want too many concepts. If a concept can be reused in the pipeline, it's the same concept.For instance:- If you have a "FlowerDescription" concept, then it can be used for rose_description, tulip_description, beautiful_flower_description, dead_flower_description, etc.@@ -142,7 +111,7 @@ Else, if you need structure for your concept, draft its structure:- field name in snake_case- description:- description: the description of the field, in natural language- - type: the type of the field (text, integer,boolean, number, date)+ - type: the type of the field (text, integer, boolean, number, date)- required: add required = true if the field is required (otherwise, leave it empty)- default_value: the default value of the field@@ -157,89 +126,197 @@ List the concept drafts in Markdown format with a heading 3 for each, e.g. `###[pipe.structure_concepts]type = "PipeLLM"description = "Structure the concept definitions."-inputs = { concept_drafts = "ConceptDrafts", brief = "UserBrief" }+inputs = { concept_drafts = "ConceptDrafts" }output = "concept.ConceptSpec[]"model = "llm_to_engineer"system_prompt = """You are an expert at data extraction and json formatting."""prompt = """-You are on a big journey to construct a pipeline, and this is one of the steps.-Here is the overalle mission of the user:-@brief--Your task here is to extract a list of ConceptSpec from these concept drafts:@concept_drafts"""-[pipe.design_pipe_signatures]++[pipe.draft_flow]type = "PipeLLM"-description = "Write the pipe signatures for the plan."+description = "Draft the flow of the pipeline."inputs = { plan_draft = "PlanDraft", brief = "UserBrief", concept_specs = "concept.ConceptSpec" }-output = "pipe_design.PipeSignature[]"+output = "builder.FlowDraft"model = "llm_to_engineer"system_prompt = """-You are a Senior engineer, very well versed in creating pipelines.-You are very thorough about naming stuff, structured and rigorous in your planning.+You are a Senior engineer."""prompt = """-Your job is to structure the required PipeSignatures for defining a pipeline which has already been drafted.+# Your job is to structure the flow we have drafted based on a brief:@brief@plan_draft{% if concept_specs %}-We have already defined the concepts you can use for inputs/outputs:+We have already defined the concepts you must use for the inputs and outputs of the pipes:@concept_specsAnd of course you still have the native concepts if required: Text, Image, PDF, Number, Page.{% else %}-You can use the native concepts for inputs/outputs as required: Text, Image, PDF, Number, Page.+You can use the native concepts for the inputs and outputs of the pipes, as required: Text, Image, PDF, Number, Page.{% endif %}-Define the contracts of the pipes to build:-- For each pipe: give a unique snake_case pipe_code, a type and description, specify inputs (one or more) and output (one)-- Add as much details as possible for the description.-- Be clear which is the main pipe of the pipeline, don't write "main" in its pipe_code, but make it clear in its description.+## For PipeOperators:++The flow you design must include the contracts for each of the PipeOperators to use: PipeLLM, PipeImgGen, PipeExtract.+Shape of the contract for PipeOperator is:+- type: PipeLLM | PipeImgGen | PipeExtract+- description: What the pipe does (string)+- inputs: Dictionary mapping variable names (snake_case) to concept codes (PascalCase), possibly with multiplicity brackets.+- result: Variable name for the pipe's result (snake_case). Can be referenced in subsequent pipes.+- output: Output concept code (PascalCase) possibly with multiplicity: 'Text' (single), 'Article[]' (list), 'Image[5]' (exactly 5).++## For the PipeControllers, which really define the flow, we need a more detailed contract, related to each type of controller:++### Start with the same contract as pipe operators above:+- type: PipeSequence | PipeParallel | PipeCondition | PipeBatch+- description: ditto+- inputs: ditto+- result: ditto+- output: ditto++### Then add the details for each type of controller:++**PipeSequence:**+- steps: List of sub-pipes to execute sequentially. Each step has: pipe (name of the pipe to execute), result (variable name).++**PipeParallel:**+- parallels: List of sub-pipes to execute concurrently.+- add_each_output: Boolean - include individual outputs in combined result.+- combined_output: Optional ConceptCode (PascalCase) for combined structure.++**PipeBatch:**+- branch_pipe_code: Pipe to apply to each item in the list (applied concurrently to all items).+- For PipeBatch, there must be at least one input which is a list, corresponding to input_list_name.+ That name is typically a plural noun like "ideas" or "images".+ And the concept corresponding to that input list must be multiple, using the [] notation,+ i.e. something like "Ideas[]" or "Images[]".+- input_list_name: List variable to iterate over (snake_case, plural).+- input_item_name: Name for individual items in each branch (snake_case, singular).++**PipeCondition:**+- jinja2_expression_template: Jinja2 expression to evaluate.+- outcomes: Mapping dict[str, str] of expression results to pipe codes.+- default_outcome: Fallback pipe_code or "fail"/"continue" if no match.++## More rules:+- For each pipe: give a unique snake_case pipe_code, based on a verb, and craft description of what the pipe does.+- When specifying the inputs and outputs of the pipes, you must indicate the concept associated to each variable name.+- The output concept of a PipeSequence must always be the same as the output concept of the last pipe in the sequence.+- Regarding PipeImgGen, which uses an AI model to generate images from a text prompt: as the image generation prompt MUST be a text, you must use a PipeLLM step to write the prompt, unless the prompt is part of the pipeline's initial inputs.+- When a variable comprises multiple items, use bracket notation along with the SINGULAR concept:+ - The concept is singular, like "Article" (not "Articles")+ - You can set output = "Article[]" to get a list of arbitrary length, or set output = "Article[5]" for exactly 5 items+ - Examples: output = "Text[]" (multiple texts), output = "Image[3]" (exactly 3 images), output = "Employee[]" (list of employees)+ - In particular, a PipeBatch always as an input which is a list on which it is batching, use indeterminate multiplicity for the list, i.e. "Concept[]".++## Flow:+- We have a memory system: the outputs of each pipe are added to the memory and can be used as inputs by subsequent pipes.+- The pipeline's initial inputs are added to the memory at the beginning.- Do not bother with planning a final step that gathers all the elements unless it's clear from the brief that the user wants the pipe to do that.+- You don't need to flatten lists at the end or even in intermediate steps: our system manages branching and the memory flows into each branch.+- At the end of the pipeline, all the memory is delivered so there is not need to gather all the elements unless expressly requested by the brief.+- If you have a sequence which has only one step, then don't make that a sequence, make it a single pipe. Or check if you forgot to include another step maybe.+- If you're in a sequence and you are to apply a pipe to a previous output which is multiple, use a PipeBatch step.+- PipeBatch is a map operator: it transforms the input list in a new list of outputs, so if you want to apply several steps to the individual items, the branch_pipe_code MUST be a PipeSequence of these steps.+- Apply the DRY principle: don't repeat yourself. if you have a task to apply several times, make it a dedicated pipe you can use and reuse.++IMPORTANT: define the main pipe of the pipeline, i.e. unless it's a single pipe workflow, the main pipe is the overall orchestrator sequence of the whole pipeline. Give it a clear name, make it clear it's the main pipe in a "# Comment", but don't name it "main" or "orchestrator" or "pipeline", just state it's main in a comment.++If the main pipe has an input which is multiple (a list) then don't hesitate to batch over it.++At the end, recap the list of variables used, with a super concise recap of what they represent, also state their concept and multiplicity, and if the concept refines a native concept, state it too. Btw, by default, unstructured concepts refine Text, state it when it's the case.+"""+++[pipe.review_flow]+type = "PipeLLM"+description = "Review a draft flow and make it consistent."+inputs = { flow_draft = "builder.FlowDraft", brief = "UserBrief" }+output = "builder.FlowDraft"+model = "llm_to_engineer"+system_prompt = """+You are a Senior engineer.+"""+prompt = """+Your job is to review a draft flow that was designed from a bried.++@brief++@flow_draft++Recap the flow by narrating the we have step by step, from the beginning to the end.+Is the flow consistent? Issues to watch out for:+- Do we have a main pipe appropriate to answer the brief? Otherwise we'll have to add one.+- Check that the inputs of the main pipe are consistent with the brief. For instance it should not require as input some variable which is to be generated by its own flow steps.+- If the main pipe has an input which is multiple (a list), are we correctly batching over it?+- Are there any missing variables or variable names that are not the expected names?+- PipeImgGen must take a single input which must be a text or a concept that refines text, if it's not the case, it needs fixing. For instance if the input is some structured concept, you'll have to add a PipeLLM step to write the prompt from the structured concept.++If the flow is consistent, state it in a declarative sentence like "The flow has been checked and is consistent:" and then copy the flow like you received it.++Otherwise, state that it was fixed like "The flow has been checked and fixed:" and then write the fixed flow. Your fixed flow must be flawless and consistent.+"""++[pipe.design_pipe_signatures]+type = "PipeLLM"+description = "Write the pipe signatures for the plan."+inputs = { prepared_flow = "builder.FlowDraft", brief = "UserBrief" }+output = "pipe_design.PipeSignature[]"+model = "llm_to_engineer"+system_prompt = """+You are a Senior engineer.+"""+prompt = """+# Your job is to structure the required PipeSignatures that make up the AI workflow we have prepared based on a brief.++@brief++@prepared_flow-Available pipe controllers:-- PipeSequence: A pipe that executes a sequence of pipes: it needs to reference the pipes it will execute.-- PipeParallel: A pipe that executes a few pipes in parallel. It needs to reference the pipes it will execute.- The results of each pipe will be in the working memory. The output MUST BE "Dynamic".-- PipeCondition: A pipe that based on a conditional expression, branches to a specific pipe.- You have to explain what the expression of the condition is,- and reference the different pipes that well be executed according to the condition.--When describing the task of a pipe controller, be concise, don't detail all the sub-pipes.--Available pipe operators:-- PipeLLM: A pipe that uses an LLM to generate text or structured objects. It is a vision LLM so it can also use images.- CRITICAL: When extracting MULTIPLE items (articles, employees, products), use bracket notation in output with SINGULAR concepts!- - Create concept "Article" (not "Articles") with fields "item_name", "quantity" (not "item_names", "quantities")- - Then set output = "Article[]" to get a variable list, or output = "Article[5]" for exactly 5 items+## The PipeSignatures are like contracts for the pipes to build:+- For each pipe: give a unique snake_case pipe_code, based on a verb, and craft description of what the pipe does.+- Be clear which is the main pipe of the pipeline, don't write "main" in its pipe_code, but make it clear in its description.+- Contrary to the draft, now when specifying the inputs and outputs of the pipes, you must indicate the concept associated to each variable name.+- When a variable comprises multiple items, use bracket notation along with the SINGULAR concept:+ - The concept is singular, like "Article" (not "Articles")+ - You can set output = "Article[]" to get a list of arbitrary length, or set output = "Article[5]" for exactly 5 items- Examples: output = "Text[]" (multiple texts), output = "Image[3]" (exactly 3 images), output = "Employee[]" (list of employees)-- PipeImgGen: A pipe that uses an AI model to generate images.- - Use bracket notation for multiple images: output = "Image[3]" generates exactly 3 images- VERY IMPORTANT: IF YOU DECIDE TO CREATE A PipeImgGen, YOU ALSO HAVE TO CREATE A PIPELLM THAT WILL WRITE THE PROMPT, AND THAT NEEDS TO PRECEED THE PIPEIMGEN, based on the necessary elements.- That means that in the MAIN pipeline, the prompt MUST NOT be considered as an input. It should be the output of a step that generates the prompt.-- PipeExtract: A pipe that extracts text from an image or a pdf. PipeExtract must have exactly one input which must be either an `Image` or a `PDF`.- - Always outputs a list of pages: output = "Page[]"--Be smart about multiplicity: when a step is to generate a variable or fixed number of items, use the multiplicity notation to specify it.-Don't create numbered variables like `idea_1`, `idea_2`, etc: trust that the pipes will handle the multiplicity for you.-You can name the variables with a plural name like "ideas" and make them use a concept with a singular name and a multiplicity like "Idea[]" or "Idea[5]".--Be smart about splitting the workflow into steps (sequence or parallel):-- You can use an LLM to extract or analyze several things at the same time, they can be output as a single concept which will be structured with attributes etc.-- But don't ask the LLM for many things which are unrelated, it would lose reliability.-- Apply the DRY principle: don't repeat yourself. if you have a task to apply several times, make it a dedicated pipe.-- If you're in a sequence and you are to apply that pipe to a previous output which is multiple, use batch_over/batch_as attributes in that step.-- The output concept of a pipe sequence must always be the same as the output concept of the last pipe in the sequence.--You must never include nore than one batch step in the same pipe sequence.-Instead, you must create a pipe sequence specifically for the process to apply to each batched element-and that sub pipe will have the second batch step.+- The output concept of a PipeSequence must always be the same as the output concept of the last pipe in the sequence.+- Pipe controllers (PipeSequence, PipeParallel, PipeCondition) depend on other pipes, so you must list these dependencies in the pipe_dependencies attribute.+- Regarding PipeImgGen, which uses an AI model to generate images from a text prompt: as the image generation prompt MUST be a text, you must use a PipeLLM step to write the prompt, unless it's part of the pipeline's initial inputs.+++## Flow:+- We have a memory system: the outputs of each pipe are added to the memory and can be used as inputs by subsequent pipes.+- The pipeline's initial inputs are added to the memory at the beginning.+- Do not bother with planning a final step that gathers all the elements unless it's clear from the brief that the user wants the pipe to do that.+- You don't need to flatten lists at the end or even in intermediate steps: our system manages branching and the memory flows into each branch.+- At the end of the pipeline, all the memory is delivered so there is not need to gather all the elements unless expressly requested by the brief.+"""++[pipe.write_bundle_header]+type = "PipeLLM"+description = "Write the bundle header."+inputs = { brief = "UserBrief", pipe_signatures = "PipeSignature" }+output = "BundleHeaderSpec"+model = "llm_to_engineer"+prompt = """+Name and define the domain of this process:+@brief++@pipe_signatures++For example, if the brief is about generating and analyzing a compliance matrix out of a RFP,+the domain would be "rfp_compliance" and the description would be "Generating and analyzing compliance related to RFPs".+The domain name should be not more than 4 words, in snake_case.+For the description, be concise.+The main pipe is the one that will carry out the main task of the pipeline, it should be pretty obvious to identify."""[pipe.assemble_pipelex_bundle_spec]@@ -248,3 +325,4 @@ description = "Compile the pipelex bundle spec."inputs = { pipe_specs = "PipeSpec", concept_specs = "ConceptSpec", bundle_header_spec = "BundleHeaderSpec" }output = "PipelexBundleSpec"function_name = "assemble_pipelex_bundle_spec"+diff --git a/pipelex/builder/builder_loop.py b/pipelex/builder/builder_loop.pyindex f5e75ab60..a8be0004b 100644--- a/pipelex/builder/builder_loop.py+++ b/pipelex/builder/builder_loop.py@@ -1,4 +1,6 @@-from pipelex import pretty_print+from rich.console import Console++from pipelex import log, pretty_printfrom pipelex.builder.builder import (PipelexBundleSpec,PipeSpecUnion,@@ -10,7 +12,7 @@ from pipelex.builder.builder_errors import (PipelexBundleNoFixForError,PipelexBundleUnexpectedError,)-from pipelex.builder.builder_validation import validate_bundle_spec+from pipelex.builder.builder_validation import fix_inputs_consistency, validate_bundle_specfrom pipelex.client.protocol import PipelineInputsfrom pipelex.core.pipes.pipe_blueprint import AllowedPipeCategoriesfrom pipelex.exceptions import PipelineExecutionError, StaticValidationErrorType, WorkingMemoryStuffNotFoundError@@ -18,6 +20,7 @@ from pipelex.hub import get_required_pipefrom pipelex.language.plx_factory import PlxFactoryfrom pipelex.pipeline.execute import execute_pipelinefrom pipelex.tools.misc.file_utils import get_incremental_file_path, save_text_to_path+from pipelex.tools.misc.json_utils import save_as_json_to_pathclass BuilderLoop:@@ -27,6 +30,7 @@ class BuilderLoop:inputs: PipelineInputs | None = None,is_save_first_iteration_enabled: bool = True,is_save_second_iteration_enabled: bool = True,+ is_save_working_memory_enabled: bool = True,) -> PipelexBundleSpec:pretty_print(f"Building and fixing with {pipe_code}")try:@@ -36,9 +40,19 @@ class BuilderLoop:)except PipelineExecutionError as exc:msg = f"Builder loop: Failed to execute pipeline: {exc}."+ console = Console(stderr=True)+ console.print_exception()raise PipeBuilderError(message=msg) from excpretty_print(pipe_output, title="Pipe Output")+ if is_save_working_memory_enabled:+ working_memory_path = get_incremental_file_path(+ base_path="results",+ base_name="working_memory",+ extension="json",+ )+ save_as_json_to_path(object_to_save=pipe_output.working_memory.smart_dump(), path=working_memory_path)+try:pipelex_bundle_spec = pipe_output.working_memory.get_stuff_as(name="pipelex_bundle_spec", content_type=PipelexBundleSpec)except WorkingMemoryStuffNotFoundError as exc:@@ -55,6 +69,29 @@ class BuilderLoop:)save_text_to_path(text=plx_content, path=first_iteration_path)+ # Fix input consistency for all PipeController pipes before validation+ log.dev("🔄 Calling fix_inputs_consistency() to ensure PipeController inputs are consistent")+ try:+ pipelex_bundle_spec = fix_inputs_consistency(bundle_spec=pipelex_bundle_spec)+ except PipelexBundleError as bundle_error:+ # Let the error fall through to the existing error handling+ pretty_print(bundle_error.as_structured_content(), title="Pipelex Bundle Error (during input fix)")+ pipelex_bundle_spec = self._fix_bundle_error(+ bundle_error=bundle_error,+ pipelex_bundle_spec=pipelex_bundle_spec,+ is_save_second_iteration_enabled=is_save_second_iteration_enabled,+ )++ # Save the fixed bundle for debugging if enabled+ if is_save_first_iteration_enabled:+ plx_content_after_fix = PlxFactory.make_plx_content(blueprint=pipelex_bundle_spec.to_blueprint())+ first_iteration_after_fix_path = get_incremental_file_path(+ base_path="results",+ base_name="generated_pipeline_1st_iteration_after_fix",+ extension="plx",+ )+ save_text_to_path(text=plx_content_after_fix, path=first_iteration_after_fix_path)+try:await validate_bundle_spec(bundle_spec=pipelex_bundle_spec)except PipelexBundleError as bundle_error:diff --git a/pipelex/builder/builder_validation.py b/pipelex/builder/builder_validation.pyindex 3ff9ef8a5..a2e25ae3c 100644--- a/pipelex/builder/builder_validation.py+++ b/pipelex/builder/builder_validation.py@@ -1,3 +1,4 @@+from pipelex import logfrom pipelex.builder.builder_errors import (ConceptDefinitionErrorData,ConceptSpecError,@@ -15,6 +16,7 @@ from pipelex.builder.bundle_spec import PipelexBundleSpecfrom pipelex.builder.pipe.pipe_spec_map import pipe_type_to_spec_classfrom pipelex.core.bundles.pipelex_bundle_blueprint import PipelexBundleBlueprintfrom pipelex.core.memory.working_memory import WorkingMemory+from pipelex.core.pipes.pipe_blueprint import AllowedPipeCategoriesfrom pipelex.exceptions import (ConceptLoadingError,DomainLoadingError,@@ -22,7 +24,7 @@ from pipelex.exceptions import (PipeLoadingError,StaticValidationError,)-from pipelex.hub import get_library_manager+from pipelex.hub import get_library_manager, get_required_pipefrom pipelex.pipe_run.dry_run import DryRunOutput, dry_run_pipes@@ -31,6 +33,144 @@ async def validate_bundle_spec_from_memory(working_memory: WorkingMemory):await validate_bundle_spec(bundle_spec=pipelex_bundle_spec)+def fix_inputs_consistency(bundle_spec: PipelexBundleSpec) -> PipelexBundleSpec:+ """Proactively fix input declarations for all PipeController pipes.++ This function rebuilds the inputs dict for all PipeController pipes (PipeSequence,+ PipeParallel, PipeCondition, PipeBatch) based on their actual requirements computed+ by the needed_inputs() method. This ensures consistency before validation.++ Args:+ bundle_spec: The bundle spec to fix.++ Returns:+ The modified bundle spec with fixed inputs.++ Raises:+ PipelexBundleError: If loading the bundle fails or other errors occur.+ """+ log.dev(f"🔧 Starting input consistency fix for domain '{bundle_spec.domain}'")++ if not bundle_spec.pipe:+ log.dev("No pipes found in bundle spec, skipping input consistency fix")+ return bundle_spec++ # Convert to blueprint and load into library+ try:+ bundle_blueprint = bundle_spec.to_blueprint()+ except ConceptSpecError as concept_spec_error:+ concept_failures = [concept_spec_error.concept_failure]+ raise PipelexBundleError(message=concept_spec_error.message, concept_failures=concept_failures) from concept_spec_error+ except PipeSpecError as pipe_spec_error:+ pipe_failures = [pipe_spec_error.pipe_failure]+ raise PipelexBundleError(message=pipe_spec_error.message, pipe_failures=pipe_failures) from pipe_spec_error++ log.dev(f"Loading bundle blueprint for domain '{bundle_spec.domain}' into library manager")+ library_manager = get_library_manager()+ try:+ library_manager.load_from_blueprint(blueprint=bundle_blueprint)+ log.dev(f"Successfully loaded bundle with {len(bundle_spec.pipe)} pipes")+ except StaticValidationError as static_validation_error:+ static_validation_error_data = StaticValidationErrorData(+ error_type=static_validation_error.error_type,+ domain=static_validation_error.domain,+ pipe_code=static_validation_error.pipe_code,+ variable_names=static_validation_error.variable_names,+ required_concept_codes=static_validation_error.required_concept_codes,+ provided_concept_code=static_validation_error.provided_concept_code,+ file_path=static_validation_error.file_path,+ explanation=static_validation_error.explanation,+ )+ raise PipelexBundleError(+ message=static_validation_error.desc(), static_validation_error=static_validation_error_data+ ) from static_validation_error+ except DomainLoadingError as domain_loading_error:+ domain_failures = [DomainFailure(domain_code=domain_loading_error.domain_code, error_message=str(domain_loading_error))]+ raise PipelexBundleError(message=domain_loading_error.message, domain_failures=domain_failures) from domain_loading_error+ except ConceptLoadingError as concept_loading_error:+ concept_def_error = concept_loading_error.concept_definition_error+ concept_definition_error_data = ConceptDefinitionErrorData(+ message=str(concept_def_error),+ domain_code=concept_def_error.domain_code,+ concept_code=concept_def_error.concept_code,+ description=concept_def_error.description,+ structure_class_python_code=concept_def_error.structure_class_python_code,+ structure_class_syntax_error_data=concept_def_error.structure_class_syntax_error_data,+ source=concept_def_error.source,+ )+ raise PipelexBundleError(+ message=concept_loading_error.message, concept_definition_errors=[concept_definition_error_data]+ ) from concept_loading_error+ except PipeLoadingError as pipe_loading_error:+ pipe_def_error = pipe_loading_error.pipe_definition_error+ pipe_definition_error_data = PipeDefinitionErrorData(+ message=str(pipe_def_error),+ domain_code=pipe_def_error.domain_code,+ pipe_code=pipe_def_error.pipe_code,+ description=pipe_def_error.description,+ source=pipe_def_error.source,+ )+ raise PipelexBundleError(message=pipe_loading_error.message, pipe_definition_errors=[pipe_definition_error_data]) from pipe_loading_error+ except PipeInputError as pipe_input_error:+ pipe_input_error_data = PipeInputErrorData(+ message=str(pipe_input_error),+ pipe_code=pipe_input_error.pipe_code,+ variable_name=pipe_input_error.variable_name,+ concept_code=pipe_input_error.concept_code,+ )+ raise PipelexBundleError(message=pipe_input_error.message, pipe_input_errors=[pipe_input_error_data]) from pipe_input_error++ # Fix inputs for all PipeController pipes+ log.dev("Starting to fix inputs for PipeController pipes")+ fixed_count = 0+ try:+ for pipe_code, pipe_spec in bundle_spec.pipe.items():+ # Check if this is a PipeController+ if AllowedPipeCategories.is_controller_by_str(category_str=pipe_spec.pipe_category):+ log.dev(f" Checking inputs for {pipe_spec.type} pipe '{pipe_code}'")++ # Get the loaded pipe instance+ pipe = get_required_pipe(pipe_code=pipe_code)++ # Get the actual needed inputs+ needed_inputs = pipe.needed_inputs()++ # Store old inputs for logging+ old_inputs = pipe_spec.inputs.copy()++ # Rebuild the inputs dict from needed_inputs, preserving multiplicity+ new_inputs: dict[str, str] = {}+ for named_requirement in needed_inputs.named_input_requirements:+ concept_code = named_requirement.concept.code+ # Preserve multiplicity brackets+ if named_requirement.multiplicity is not None:+ if named_requirement.multiplicity is True:+ # Variable-length list []+ concept_code = f"{concept_code}[]"+ else:+ # Fixed-length list [N] where N is an int+ concept_code = f"{concept_code}[{named_requirement.multiplicity}]"+ new_inputs[named_requirement.variable_name] = concept_code++ # Update the pipe spec inputs+ pipe_spec.inputs = new_inputs++ # Log the changes+ if old_inputs != new_inputs:+ log.dev(f" Old inputs: {old_inputs}")+ log.dev(f" New inputs: {new_inputs}")+ fixed_count += 1+ else:+ log.dev(" ✅")+ finally:+ # Clean up by removing the bundle from library manager+ log.dev("Cleaning up: removing bundle from library manager")+ library_manager.remove_from_blueprint(blueprint=bundle_blueprint)++ log.dev(f"✅ Input consistency fix completed: fixed {fixed_count} PipeController pipe(s)")+ return bundle_spec++async def validate_bundle_spec(bundle_spec: PipelexBundleSpec):try:bundle_blueprint = bundle_spec.to_blueprint()diff --git a/pipelex/builder/pipe/pipe_batch_spec.py b/pipelex/builder/pipe/pipe_batch_spec.pyindex 7eb6605d2..24132f7f7 100644--- a/pipelex/builder/pipe/pipe_batch_spec.py+++ b/pipelex/builder/pipe/pipe_batch_spec.py@@ -8,20 +8,18 @@ from pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBluepriclass PipeBatchSpec(PipeSpec):- """Spec for batch processing pipe operations in the Pipelex framework.+ """Spec for batch processing pipe operations concurrently.- PipeBatch enables parallel execution of a single pipe across multiple items- in a list. Each item is processed independently, making it ideal for data- transformation, enrichment, or analysis tasks on collections.-- This controller is commonly used within PipeSequence for inline batch processing,- where the batch configuration is specified directly in the sequence step using- batch_over and batch_as parameters in SubPipeBlueprint.+ PipeBatch enables concurrent execution of the same pipe applied to multiple items+ provided as an input list. Each item is processed independently. The result is a list+ the results of each branch. So this like a map operation.Validation Rules:- 1. branch_pipe_code must reference an existing pipe in the pipeline.- 2. When input_list_name is specified, it must reference a list in context.- 3. The branch pipe should be designed to process single items.+ - There must be at least one input which is a list, corresponding to input_list_name.+ That name is typically a plural noun like "ideas" or "images".+ And the concept corresponding to that input list must be multiple, using the [] notation,+ i.e. something like "Ideas[]" or "Images[]".+ - input_item_name is typically the singular noun corresponding to the items in the list, like "idea" or "image"."""@@ -30,9 +28,8 @@ class PipeBatchSpec(PipeSpec):branch_pipe_code: str = Field(description="The pipe code to execute for each item in the input list. This pipe is instantiated once per item in parallel.")- input_list_name: str | None = Field(default=None, description="Name of the list in WorkingMemory to iterate over, if needed.")- input_item_name: str | None = Field(- default=None,+ input_list_name: str = Field(description="Name of the list in WorkingMemory to iterate over, if needed.")+ input_item_name: str = Field(description="Name assigned to individual items within each execution branch. This is how the branch pipe accesses its specific input item.",)diff --git a/pipelex/builder/pipe/pipe_design.plx b/pipelex/builder/pipe/pipe_design.plxindex 03bb869f7..e4743db63 100644--- a/pipelex/builder/pipe/pipe_design.plx+++ b/pipelex/builder/pipe/pipe_design.plx@@ -23,9 +23,9 @@ PipeFailure = "Details of a single pipe failure during dry run."type = "PipeCondition"description = "Route by signature.type to the correct spec emitter."inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "ConceptSpec" }-output = "Dynamic"+output = "Anything"expression = "pipe_signature.type"-default_outcome = "continue"+default_outcome = "fail"[pipe.detail_pipe_spec.outcomes]PipeSequence = "detail_pipe_sequence"@@ -34,6 +34,7 @@ PipeCondition = "detail_pipe_condition"PipeLLM = "detail_pipe_llm"PipeExtract = "detail_pipe_extract"PipeImgGen = "detail_pipe_img_gen"+PipeBatch = "detail_pipe_batch"# ────────────────────────────────────────────────────────────────────────────────# PIPE CONTROLLERS@@ -43,21 +44,23 @@ PipeImgGen = "detail_pipe_img_gen"type = "PipeLLM"description = "Build a PipeSequenceSpec from the signature (children referenced by code)."inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }-output = "PipeSequenceSpec"+output = "pipe_design.PipeSequenceSpec"model = "llm_to_engineer"prompt = """-Your job is to design a PipeSequenceSpec to orchestrate a sequence of pipe steps that will run one after the other.+# Orchestrate a sequence of pipe steps that will run one after the other.-This PipeSequence is part of a larger pipeline:@plan_draft-You will specifically generate the PipeSequence related to this signature:+You must pick the relevant concepts for inputs and outputs from the following possibilities:+@concept_specs+++ you can use the native concepts: Text, Image, PDF, Number, Page+@pipe_signature-Here are the concepts you can use for inputs/outputs:-@concept_specs+Based on the pipe signature, build the PipeSequenceSpec.-- If you are to apply a pipe step to a previous output which is multiple, use batch_over/batch_as attributes in that step.+Note:- The output concept of a pipe sequence must always be the same as the output concept of the last pipe in the sequence."""@@ -65,38 +68,63 @@ Here are the concepts you can use for inputs/outputs:type = "PipeLLM"description = "Build a PipeParallelSpec from the signature."inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }-output = "PipeParallelSpec"+output = "pipe_design.PipeParallelSpec"model = "llm_to_engineer"prompt = """-Your job is to design a PipeParallelSpec to orchestrate a bunch of pipe steps that will run in parallel.+Orchestrate a set of independent pipes that will run concurrently.-This PipeParallel is part of a larger pipeline:@plan_draft-You will specifically generate the PipeParallel related to this signature:+You must pick the relevant concepts for inputs and outputs from the following possibilities:+@concept_specs+++ you can use the native concepts: Text, Image, PDF, Number, Page+@pipe_signature-Here are the concepts you can use for inputs/outputs:-@concept_specs+Based on the pipe signature, build the PipeParallelSpec."""[pipe.detail_pipe_condition]type = "PipeLLM"description = "Build a PipeConditionSpec from the signature (provide expression/outcome consistent with children)."inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }-output = "PipeConditionSpec"+output = "pipe_design.PipeConditionSpec"model = "llm_to_engineer"prompt = """-Your job is to design a PipeConditionSpec to route to the correct pipe step based on a conditional expression.+Design a PipeConditionSpec to route to the correct pipe based on a conditional expression.-This PipeCondition is part of a larger pipeline:@plan_draft-You will specifically generate the PipeCondition related to this signature:+You must pick the relevant concepts for inputs and outputs from the following possibilities:+@concept_specs+++ you can use the native concepts: Text, Image, PDF, Number, Page+@pipe_signature-Here are the concepts you can use for inputs/outputs:+Based on the pipe signature, build the PipeConditionSpec.+"""++[pipe.detail_pipe_batch]+type = "PipeLLM"+description = "Build a PipeBatchSpec from the signature."+inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }+output = "pipe_design.PipeBatchSpec"+model = "llm_to_engineer"+prompt = """+Design a PipeBatchSpec to run a pipe in batch.+Whatever it's really going to do has already been decided as part of this plan:+@plan_draft++You must pick the relevant concepts for inputs and outputs from the following possibilities:@concept_specs+++ you can use the native concepts: Text, Image, PDF, Number, Page++Based on the pipe signature, build the PipeComposeSpec.++@pipe_signature"""# ────────────────────────────────────────────────────────────────────────────────@@ -107,91 +135,91 @@ Here are the concepts you can use for inputs/outputs:type = "PipeLLM"description = "Build a PipeLLMSpec from the signature."inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }-output = "PipeLLMSpec"+output = "pipe_design.PipeLLMSpec"model = "llm_to_engineer"prompt = """-Your job is to design a PipeLLMSpec to use an LLM to generate a text, or a structured object using different kinds of inputs.-Whatever it's really going to do has already been decided, as you can see:--This PipeLLM is part of a larger pipeline:+Design a PipeLLMSpec to use an LLM to generate a text, or a structured object using different kinds of inputs.+Whatever it's really going to do has already been decided as part of this plan:@plan_draft-You will specifically generate the PipeLLM related to this signature:-@pipe_signature+You must pick the relevant concepts for inputs and outputs from the following possibilities:+@concept_specs-If we are generating a structured concept, indicate it in the system_prompt to clarify the task. But DO NOT detail the structure in any of the user/system prompts: we will add the schema later. So, don't write a bullet-list of all the attributes to determine.-If it's to generate free form text, the prompt should indicate to be concise.-If it's to generate an image generation prompt, the prompt should indicate to be VERY concise and focus and apply the best practice for image generation.++ you can use the native concepts: Text, Image, PDF, Number, Page-Here are the concepts you can use for inputs/outputs:-@concept_specs+Based on the pipe signature, build the PipeLLMSpec.++@pipe_signature++Notes:+- If we are generating a structured concept, indicate it in the system_prompt to clarify the task.+- But DO NOT detail the structure in any of the user/system prompts: we will add the schema later. So, don't write a bullet-list of all the attributes to determine.+- If it's to generate free form text, the prompt should indicate to be concise.+- If it's to generate an image generation prompt, the prompt should indicate to be VERY concise and focus and apply the best practice for image generation."""[pipe.detail_pipe_extract]type = "PipeLLM"description = "Build a PipeExtractSpec from the signature."inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }-output = "PipeExtractSpec"+output = "pipe_design.PipeExtractSpec"model = "llm_to_engineer"prompt = """-Your job is to design a PipeExtractSpec to extract text from an image or a pdf.--This PipeExtract is part of a larger pipeline:+Design a PipeExtractSpec to extract text from an image or a pdf.+Whatever it's really going to do has already been decided as part of this plan:@plan_draft-You will specifically generate the PipeExtract related to this signature:-@pipe_signature--Here are the concepts you can use for inputs/outputs:+You must pick the relevant concepts for inputs and outputs from the following possibilities:@concept_specs+++ you can use the native concepts: Text, Image, PDF, Number, Page++Based on the pipe signature, build the PipeExtractSpec.++@pipe_signature"""[pipe.detail_pipe_img_gen]type = "PipeLLM"description = "Build a PipeImgGenSpec from the signature."inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }-output = "PipeImgGenSpec"+output = "pipe_design.PipeImgGenSpec"model = "llm_to_engineer"prompt = """Your job is to design a PipeImgGenSpec to generate an image from a text prompt.--This PipeImgGen is part of a larger pipeline:+Whatever it's really going to do has already been decided as part of this plan:@plan_draft-You will specifically generate the PipeImgGen related to this signature:-@pipe_signature+You must pick the relevant concepts for inputs and outputs from the following possibilities:+@concept_specs-The inputs for the image has to be a single input which must be a Text or another concept which refines Text.++ you can use the native concepts: Text, Image, PDF, Number, Page-Here are the concepts you can use for inputs/outputs:-@concept_specs+Based on the pipe signature, build the PipeImgGenSpec.++@pipe_signature++Notes:+- The inputs for the image has to be a single input which must be a Text or another concept which refines Text."""[pipe.detail_pipe_compose]type = "PipeLLM"description = "Build a PipeComposeSpec from the signature."inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }-output = "PipeComposeSpec"+output = "pipe_design.PipeComposeSpec"model = "llm_to_engineer"prompt = """-Your job is to design a PipeComposeSpec to render a jinja2 template.--This PipeCompose is part of a larger pipeline:+Design a PipeComposeSpec to render a jinja2 template.+Whatever it's really going to do has already been decided as part of this plan:@plan_draft-You will specifically generate the PipeCompose related to this signature:-@pipe_signature+You must pick the relevant concepts for inputs and outputs from the following possibilities:+@concept_specs-You can ONLY USE THE INPUTS IN THIS PIPE SIGNATURE.++ you can use the native concepts: Text, Image, PDF, Number, Page-Here are the Jinja2 filters that are supported:-default — Returns a fallback value if the input is undefined (or falsey if enabled).-tag - Returns by tagging it with a title.-format - Apply the given values to a printf-style format string, like string % values.-length — Returns the number of items (alias: count).-upper — Converts a string to uppercase.-lower — Converts a string to lowercase.+Based on the pipe signature, build the PipeComposeSpec.-Here are the concepts you can use for inputs/outputs:-@concept_specs-"""+@pipe_signature+"""\ No newline at end of filediff --git a/pipelex/builder/pipe/pipe_signature.py b/pipelex/builder/pipe/pipe_signature.pyindex 815a9ea8b..ad122b243 100644--- a/pipelex/builder/pipe/pipe_signature.py+++ b/pipelex/builder/pipe/pipe_signature.py@@ -17,14 +17,15 @@ class PipeSignature(StructuredContent):It defines the inputs, outputs, and the purpose of the pipe without implementation details.Multiplicity Notation:- Use bracket notation to specify how many items are produced, but only for the outputs:+ Use bracket notation to specify multiplicity for both inputs and outputs:- No brackets: single item (default)- []: variable-length list- [N]: exactly N items (where N is a positive integer)Examples:- - output = "Text[]" - produces multiple text items- - output = "Image[3]" - produces exactly 3 images+ - output = "Text" - one text items+ - output = "Text[]" - multiple text items+ - output = "Image[3]" - exactly 3 images"""code: str = Field(description="Pipe code identifying the pipe. Must be snake_case.")diff --git a/pipelex/builder/pipe/sub_pipe_spec.py b/pipelex/builder/pipe/sub_pipe_spec.pyindex 209633623..5ed62a240 100644--- a/pipelex/builder/pipe/sub_pipe_spec.py+++ b/pipelex/builder/pipe/sub_pipe_spec.py@@ -1,31 +1,22 @@-from pydantic import ConfigDict, model_validator+from pydantic import ConfigDict-from pipelex.core.pipe_errors import PipeDefinitionErrorfrom pipelex.core.stuffs.structured_content import StructuredContentfrom pipelex.pipe_controllers.sub_pipe_blueprint import SubPipeBlueprint-from pipelex.types import Selfclass SubPipeSpec(StructuredContent):"""Spec for a single step within a pipe controller.SubPipeSpec defines individual pipe executions within controller pipes- (PipeSequence, PipeParallel, PipeBatch, PipeCondition). Supports output- cardinality control and batch processing configuration.+ (PipeSequence, PipeParallel, PipeBatch, PipeCondition).Attributes:pipe_code: The pipe code to execute. Must reference an existing pipe in the pipeline.result: Name to assign to the pipe's output in the context.- batch_over: Name of the list in context to iterate over for batch processing.- When false (default), no batching occurs. When specified as string,- references a list in context. Requires batch_as when set.- batch_as: Name to assign to the current item during batch iteration.- Required when batch_over is specified.Validation Rules:- 2. batch_over and batch_as must be specified together (both or neither).- 3. pipe must reference a valid pipe code.- 4. result, when specified, should follow naming conventions.+ - pipe must reference a valid pipe code.+ - result, when specified, should follow naming conventions."""@@ -33,25 +24,11 @@ class SubPipeSpec(StructuredContent):pipe_code: strresult: str- batch_over: str | None = None- batch_as: str | None = None-- @model_validator(mode="after")- def validate_batch_params(self) -> Self:- if self.batch_over and not self.batch_as:- msg = f"In pipe '{self.pipe_code}': When 'batch_over' is specified, 'batch_as' must also be provided"- raise PipeDefinitionError(msg)-- if self.batch_as and not self.batch_over:- msg = f"In pipe '{self.pipe_code}': When 'batch_as' is specified, 'batch_over' must also be provided"- raise PipeDefinitionError(msg)-- return selfdef to_blueprint(self) -> SubPipeBlueprint:return SubPipeBlueprint(pipe=self.pipe_code,result=self.result,- batch_over=self.batch_over,- batch_as=self.batch_as,+ batch_over=None,+ batch_as=None,)diff --git a/pipelex/cli/commands/build_cmd.py b/pipelex/cli/commands/build_cmd.pyindex 673aab60e..09a1bd842 100644--- a/pipelex/cli/commands/build_cmd.py+++ b/pipelex/cli/commands/build_cmd.py@@ -10,7 +10,7 @@ from pipelex import pretty_printfrom pipelex.builder.builder import PipelexBundleSpec, load_and_validate_bundlefrom pipelex.builder.builder_errors import PipeBuilderError, PipelexBundleErrorfrom pipelex.builder.builder_loop import BuilderLoop-from pipelex.builder.runner_code import generate_runner_code+from pipelex.builder.runner_code import generate_input_memory_json_string, generate_runner_codefrom pipelex.exceptions import PipeInputError, PipelineExecutionErrorfrom pipelex.hub import get_report_delegate, get_required_pipefrom pipelex.language.plx_factory import PlxFactory@@ -32,11 +32,18 @@ pipelex build pipe "Imagine a cute animal mascot for a startup based on its elevpipelex build pipe "Imagine a cute animal mascot for a startup based on its elevator pitch and some brand guidelines"pipelex build pipe "Imagine a cute animal mascot for a startup based on its elevator pitch and some brand guidelines, \include 3 variants of the ideas and 2 variants of each prompt"+pipelex build pipe "Imagine a cute animal mascot for a startup based on its elevator pitch \+ and some brand guidelines, propose 2 different ideas, and for each, 3 style variants in the image generation prompt, \+ at the end we want the rendered image" --output results/mascot.plx+pipelex build pipe "Given an expense report, apply company rules"pipelex build pipe "Take a CV in a PDF file, a Job offer text, and analyze if they match"pipelex build pipe "Take a CV in a PDF file and a Job offer text, analyze if they match and generate 5 questions for the interview"pipelex build pipe "Take a CV and Job offer in PDF, analyze if they match and generate 5 questions for the interview"+pipelex build pipe \+ "Take a Job offer text and a bunch of CVs (PDF), analyze how each CV matches the Job offer and generate 5 questions for each interview"+pipelex build partial "Given an expense report, apply company rules" -o results/generated.jsonpipelex build flow "Given an expense report, apply company rules" -o results/flow.json@@ -51,6 +58,7 @@ COMMAND = "build"SUB_COMMAND_PIPE = "pipe"SUB_COMMAND_RUNNER = "runner"+SUB_COMMAND_INPUTS = "inputs"SUB_COMMAND_ONE_SHOT_PIPE = "one-shot-pipe"SUB_COMMAND_PARTIAL_PIPE = "partial-pipe"@@ -113,6 +121,21 @@ def build_pipe_cmd(save_text_to_path(text=plx_content, path=output_path)typer.secho(f"\n✅ Pipeline saved to: {output_path}", fg=typer.colors.GREEN)+ # Generate input JSON for the main pipe+ main_pipe_code = pipelex_bundle_spec.main_pipe+ if main_pipe_code:+ try:+ # Load the bundle from the file we just saved to register the pipe+ _ = await load_and_validate_bundle(output_path)+ pipe = get_required_pipe(pipe_code=main_pipe_code)+ inputs_json_str = generate_input_memory_json_string(pipe.inputs, indent=2)+ inputs_json_path = "results/inputs.json"+ ensure_directory_for_file_path(file_path=inputs_json_path)+ save_text_to_path(text=inputs_json_str, path=inputs_json_path)+ typer.secho(f"✅ Input example saved to: {inputs_json_path}", fg=typer.colors.GREEN)+ except Exception as exc:+ typer.secho(f"⚠️ Warning: Could not generate input JSON: {exc}", fg=typer.colors.YELLOW)+with new_context():tag(name=EventProperty.INTEGRATION, value=IntegrationMode.CLI)tag(name=EventProperty.PIPELEX_VERSION, value=PACKAGE_VERSION)@@ -272,6 +295,144 @@ def prepare_runner_cmd(asyncio.run(prepare_runner(pipe_code=pipe_code, bundle_path=bundle_path))+@build_app.command(SUB_COMMAND_INPUTS, help="Generate example input JSON for a pipe")+def generate_inputs_cmd(+ target: Annotated[+ str | None,+ typer.Argument(help="Pipe code or bundle file path (auto-detected)"),+ ] = None,+ pipe: Annotated[+ str | None,+ typer.Option("--pipe", help="Pipe code to use, can be omitted if you specify a bundle (.plx) that declares a main pipe"),+ ] = None,+ bundle: Annotated[+ str | None,+ typer.Option("--bundle", help="Bundle file path (.plx) - uses its main_pipe unless you specify a pipe code"),+ ] = None,+ output_path: Annotated[+ str | None,+ typer.Option("--output", "-o", help="Path to save the generated JSON file, defaults to 'results/inputs.json'"),+ ] = None,+) -> None:+ """Generate example input JSON for a pipe.++ The generated JSON file will include example values for all pipe inputs+ based on their concept types.++ Examples:+ pipelex build inputs my_pipe+ pipelex build inputs --bundle my_bundle.plx+ pipelex build inputs --bundle my_bundle.plx --pipe my_pipe+ pipelex build inputs my_bundle.plx+ pipelex build inputs my_pipe --output custom_inputs.json+ """+ # Validate mutual exclusivity+ provided_options = sum([target is not None, pipe is not None, bundle is not None])+ if provided_options == 0:+ ctx: click.Context = click.get_current_context()+ typer.echo(ctx.get_help())+ raise typer.Exit(0)++ # Let's analyze the options and determine what pipe code to use and if we need to load a bundle+ pipe_code: str | None = None+ bundle_path: str | None = None++ # Determine source:+ if target:+ if target.endswith(".plx"):+ bundle_path = target+ if bundle:+ typer.secho(+ "Failed to run: cannot use option --bundle if you're already passing a bundle file (.plx) as positional argument",+ fg=typer.colors.RED,+ err=True,+ )+ raise typer.Exit(1)+ else:+ pipe_code = target+ if pipe:+ typer.secho(+ "Failed to run: cannot use option --pipe if you're already passing a pipe code as positional argument",+ fg=typer.colors.RED,+ err=True,+ )+ raise typer.Exit(1)++ if bundle:+ assert not bundle_path, "bundle_path should be None at this stage if --bundle is provided"+ bundle_path = bundle++ if pipe:+ assert not pipe_code, "pipe_code should be None at this stage if --pipe is provided"+ pipe_code = pipe++ if not pipe_code and not bundle_path:+ typer.secho("Failed to run: no pipe code or bundle file specified", fg=typer.colors.RED, err=True)+ raise typer.Exit(1)++ async def generate_inputs(pipe_code: str | None = None, bundle_path: str | None = None):+ # Initialize Pipelex+ Pipelex.make(integration_mode=IntegrationMode.CLI)++ if bundle_path:+ try:+ bundle_blueprint = await load_and_validate_bundle(bundle_path)+ if not pipe_code:+ main_pipe_code = bundle_blueprint.main_pipe+ if not main_pipe_code:+ typer.secho(f"Bundle '{bundle_path}' does not declare a main_pipe", fg=typer.colors.RED, err=True)+ raise typer.Exit(1)+ pipe_code = main_pipe_code+ typer.echo(f"Using main pipe '{pipe_code}' from bundle '{bundle_path}'")+ else:+ typer.echo(f"Using pipe '{pipe_code}' from bundle '{bundle_path}'")+ except FileNotFoundError as exc:+ typer.secho(f"Failed to load bundle '{bundle_path}': {exc}", fg=typer.colors.RED, err=True)+ raise typer.Exit(1) from exc+ except PipelexBundleError as exc:+ typer.secho(f"Failed to load bundle '{bundle_path}': {exc}", fg=typer.colors.RED, err=True)+ raise typer.Exit(1) from exc+ except PipeInputError as exc:+ typer.secho(f"Failed to load bundle '{bundle_path}': {exc}", fg=typer.colors.RED, err=True)+ raise typer.Exit(1) from exc+ elif not pipe_code:+ typer.secho("Failed to run: no pipe code specified", fg=typer.colors.RED, err=True)+ raise typer.Exit(1)++ # Get the pipe+ try:+ pipe = get_required_pipe(pipe_code=pipe_code)+ except Exception as exc:+ typer.secho(f"❌ Error: Could not find pipe '{pipe_code}': {exc}", fg=typer.colors.RED)+ raise typer.Exit(1) from exc++ # Generate the input JSON+ try:+ inputs_json_str = generate_input_memory_json_string(pipe.inputs, indent=2)+ except Exception as exc:+ typer.secho(f"❌ Error generating input JSON: {exc}", fg=typer.colors.RED)+ raise typer.Exit(1) from exc++ # Determine output path+ final_output_path = output_path or "results/inputs.json"++ # Save the file+ try:+ ensure_directory_for_file_path(file_path=final_output_path)+ save_text_to_path(text=inputs_json_str, path=final_output_path)+ typer.secho(f"✅ Generated input JSON file: {final_output_path}", fg=typer.colors.GREEN)+ except Exception as exc:+ typer.secho(f"❌ Error saving file: {exc}", fg=typer.colors.RED)+ raise typer.Exit(1) from exc++ with new_context():+ tag(name=EventProperty.INTEGRATION, value=IntegrationMode.CLI)+ tag(name=EventProperty.PIPELEX_VERSION, value=PACKAGE_VERSION)+ tag(name=EventProperty.CLI_COMMAND, value=f"{COMMAND} {SUB_COMMAND_INPUTS}")++ asyncio.run(generate_inputs(pipe_code=pipe_code, bundle_path=bundle_path))++@build_app.command(SUB_COMMAND_ONE_SHOT_PIPE, help="Developer utility for contributors: deliver pipeline in one shot, without validation loop")def build_one_shot_cmd(brief: Annotated[diff --git a/pipelex/cli/commands/validate_cmd.py b/pipelex/cli/commands/validate_cmd.pyindex 916cc087c..7a0e732fb 100644--- a/pipelex/cli/commands/validate_cmd.py+++ b/pipelex/cli/commands/validate_cmd.py@@ -8,6 +8,7 @@ import typerfrom posthog import new_context, tagfrom rich.console import Consolefrom rich.syntax import Syntax+from rich.traceback import Tracebackfrom pipelex import log, pretty_printfrom pipelex.builder.builder_errors import PipelexBundleError@@ -130,16 +131,17 @@ def validate_cmd(else:typer.secho(f"✅ Successfully validated all pipes in bundle '{bundle_path}' (including '{pipe_code}')", fg=typer.colors.GREEN)except FileNotFoundError as exc:- typer.secho(f"Failed to load bundle '{bundle_path}': {exc}", fg=typer.colors.RED, err=True)- console.print(exc)+ console.print(Traceback())+ typer.secho(f"Failed to load bundle '{bundle_path}':", fg=typer.colors.RED, err=True)raise typer.Exit(1) from excexcept PipelexBundleError as bundle_error:+ console.print(Traceback())typer.secho(f"\n❌ Failed to validate bundle '{bundle_path}':", fg=typer.colors.RED, err=True)present_validation_error(details_provider=bundle_error)raise typer.Exit(1) from bundle_errorexcept PipeInputError as exc:- typer.secho(f"\n❌ Failed to validate bundle '{bundle_path}': {exc}", fg=typer.colors.RED, err=True)- console.print(exc)+ console.print(Traceback())+ typer.secho(f"\n❌ Failed to validate bundle '{bundle_path}':", fg=typer.colors.RED, err=True)raise typer.Exit(1) from excelif pipe_code:# Validate a single pipe by codediff --git a/pipelex/cogt/extract/extract_worker_factory.py b/pipelex/cogt/extract/extract_worker_factory.pyindex 22ffefa04..b7b60b1e4 100644--- a/pipelex/cogt/extract/extract_worker_factory.py+++ b/pipelex/cogt/extract/extract_worker_factory.py@@ -23,7 +23,7 @@ class ExtractWorkerFactory:if importlib.util.find_spec("mistralai") is None:lib_name = "mistralai"lib_extra_name = "mistral"- msg = "The mistralai SDK is required to use Mistral OCR models through the mistralai client."+ msg = "The mistralai SDK is required in order to use Mistral OCR models through the mistralai client."raise MissingDependencyError(lib_name,lib_extra_name,diff --git a/pipelex/cogt/img_gen/img_gen_worker_factory.py b/pipelex/cogt/img_gen/img_gen_worker_factory.pyindex f04584cdc..fbe0199fe 100644--- a/pipelex/cogt/img_gen/img_gen_worker_factory.py+++ b/pipelex/cogt/img_gen/img_gen_worker_factory.py@@ -34,7 +34,7 @@ class ImgGenWorkerFactory:except ImportError as exc:lib_name = "fal-client"lib_extra_name = "fal"- msg = "The fal-client SDK is required to use FAL models (generation of images)."+ msg = "The fal-client SDK is required in order to use FAL models (generation of images)."raise MissingDependencyError(lib_name,lib_extra_name,diff --git a/pipelex/cogt/llm/llm_worker_factory.py b/pipelex/cogt/llm/llm_worker_factory.pyindex fca23efe3..b723fea74 100644--- a/pipelex/cogt/llm/llm_worker_factory.py+++ b/pipelex/cogt/llm/llm_worker_factory.py@@ -49,7 +49,7 @@ class LLMWorkerFactory:lib_name = "anthropic"lib_extra_name = "anthropic"msg = (- "The anthropic SDK is required to use Anthropic models via the anthropic client. "+ "The anthropic SDK is required in order to use Anthropic models via the anthropic client. ""However, you can use Anthropic models through bedrock directly ""by using the 'bedrock-anthropic-claude' llm family. (eg: bedrock-anthropic-claude)")@@ -79,7 +79,7 @@ class LLMWorkerFactory:lib_name = "mistralai"lib_extra_name = "mistral"msg = (- "The mistralai SDK is required to use Mistral models through the mistralai client. "+ "The mistralai SDK is required in order to use Mistral models through the mistralai client. ""However, you can use Mistral models through bedrock directly ""by using the 'bedrock-mistral' llm family. (eg: bedrock-mistral-large)")@@ -131,7 +131,10 @@ class LLMWorkerFactory:if importlib.util.find_spec("google.genai") is None:lib_name = "google-genai"lib_extra_name = "google"- msg = "The google-genai SDK is required to use Google Gemini API directly. You can install it with 'pip install google-genai'."+ msg = (+ "The google-genai SDK is required in order to use Google Gemini API directly. "+ "You can install it with 'pip install google-genai'."+ )raise MissingDependencyError(lib_name,lib_extra_name,diff --git a/pipelex/cogt/model_backends/model_lists.py b/pipelex/cogt/model_backends/model_lists.pyindex c283ae6fe..7be68947f 100644--- a/pipelex/cogt/model_backends/model_lists.py+++ b/pipelex/cogt/model_backends/model_lists.py@@ -82,7 +82,7 @@ class ModelLister:lib_name = "anthropic"lib_extra_name = "anthropic"msg = (- "The anthropic SDK is required to use Anthropic models via the anthropic client. "+ "The anthropic SDK is required in order to use Anthropic models via the anthropic client. ""However, you can use Anthropic models through bedrock directly ""by using the 'bedrock-anthropic-claude' llm family. (eg: bedrock-anthropic-claude)")@@ -113,7 +113,7 @@ class ModelLister:lib_name = "mistralai"lib_extra_name = "mistral"msg = (- "The mistralai SDK is required to use Mistral models through the mistralai client. "+ "The mistralai SDK is required in order to use Mistral models through the mistralai client. ""However, you can use Mistral models through bedrock directly ""by using the 'bedrock-mistral' llm family. (eg: bedrock-mistral-large)")@@ -222,7 +222,7 @@ class ModelLister:lib_name = "anthropic"lib_extra_name = "anthropic"msg = (- "The anthropic SDK is required to use Anthropic models via the anthropic client. "+ "The anthropic SDK is required in order to use Anthropic models via the anthropic client. ""However, you can use Anthropic models through bedrock directly ""by using the 'bedrock-anthropic-claude' llm family. (eg: bedrock-anthropic-claude)")@@ -276,7 +276,7 @@ class ModelLister:lib_name = "mistralai"lib_extra_name = "mistral"msg = (- "The mistralai SDK is required to use Mistral models through the mistralai client. "+ "The mistralai SDK is required in order to use Mistral models through the mistralai client. ""However, you can use Mistral models through bedrock directly ""by using the 'bedrock-mistral' llm family. (eg: bedrock-mistral-large)")diff --git a/pipelex/core/pipes/input_requirements.py b/pipelex/core/pipes/input_requirements.pyindex 044fc0d8f..207c62465 100644--- a/pipelex/core/pipes/input_requirements.py+++ b/pipelex/core/pipes/input_requirements.py@@ -73,7 +73,7 @@ class InputRequirements(RootModel[InputRequirementsRoot]):def get_required_input_requirement(self, variable_name: str) -> InputRequirement:requirement = self.root.get(variable_name)if not requirement:- msg = f"Variable '{variable_name}' not found in input spec"+ msg = f"Variable '{variable_name}' not found the input requirements"raise PipeInputNotFoundError(msg)return requirementdiff --git a/pipelex/pipe_controllers/batch/pipe_batch.py b/pipelex/pipe_controllers/batch/pipe_batch.pyindex 5ad58495c..ff422d21a 100644--- a/pipelex/pipe_controllers/batch/pipe_batch.py+++ b/pipelex/pipe_controllers/batch/pipe_batch.py@@ -7,7 +7,6 @@ from typing_extensions import overridefrom pipelex.config import get_configfrom pipelex.core.memory.working_memory import MAIN_STUFF_NAME, WorkingMemory-from pipelex.core.pipe_errors import PipeDefinitionErrorfrom pipelex.core.pipes.input_requirements import InputRequirementsfrom pipelex.core.pipes.pipe_output import PipeOutputfrom pipelex.core.stuffs.list_content import ListContent@@ -35,7 +34,7 @@ class PipeBatch(PipeController):type: Literal["PipeBatch"] = "PipeBatch"branch_pipe_code: str- batch_params: BatchParams | None = None+ batch_params: BatchParams@overridedef pipe_dependencies(self) -> set[str]:@@ -55,11 +54,16 @@ class PipeBatch(PipeController):self._validate_required_variables()def _validate_required_variables(self) -> Self:- # Now check that the required vairables ARE in the inputs of the pipe+ # Now check that the required variables ARE in the inputs of the piperequired_variables = self.required_variables()for variable_name in required_variables:+ if variable_name == self.batch_params.input_item_stuff_name:+ continueif variable_name not in self.inputs.root:- msg = f"Input '{variable_name}' of pipe '{self.code}' is not in the inputs of the pipe '{self.branch_pipe_code}'"+ msg = (+ f"Input '{variable_name}' required by branch pipe '{self.branch_pipe_code}' "+ f"of PipeBatch '{self.code}', is not listed in its inputs"+ )raise PipeInputError(message=msg, pipe_code=self.code, variable_name=variable_name, concept_code=None)return self@@ -70,9 +74,9 @@ class PipeBatch(PipeController):pipe = get_required_pipe(pipe_code=self.branch_pipe_code)for variable_name, _ in pipe.inputs.items:required_variables.add(variable_name)- # 2. Check that the input_item_stuff_name is in the inputs of the pipe- if self.batch_params and self.batch_params.input_item_stuff_name:- required_variables.add(self.batch_params.input_item_stuff_name)+ # 2. Check that the input_list_stuff_name is in the inputs of the pipe+ required_variables.remove(self.batch_params.input_item_stuff_name)+ required_variables.add(self.batch_params.input_list_stuff_name)return required_variables@override@@ -81,9 +85,15 @@ class PipeBatch(PipeController):@overridedef _validate_inputs_in_memory(self, working_memory: WorkingMemory) -> None:- if not self.batch_params:- raise PipeDefinitionError(message=f"PipeBatch '{self.code}' must have a batch_params", pipe_code=self.code)- required_concept_code = self.inputs.get_required_input_requirement(variable_name=self.batch_params.input_item_stuff_name).concept.code+ try:+ required_concept_code = self.inputs.get_required_input_requirement(variable_name=self.batch_params.input_list_stuff_name).concept.code+ except PipeInputNotFoundError as exc:+ msg = (+ f"Batch input list named '{self.batch_params.input_list_stuff_name}' is not in "+ f"PipeBatch '{self.code}' input requirements: {self.inputs}"+ )+ raise PipeInputError(message=msg, pipe_code=self.code, variable_name=self.batch_params.input_list_stuff_name, concept_code=None) from exc+required_stuff_name = self.batch_params.input_list_stuff_nametry:working_memory.get_stuff(required_stuff_name)@@ -103,11 +113,12 @@ class PipeBatch(PipeController):"""Common logic for running or dry-running a pipe in batch mode."""batch_params = pipe_run_params.batch_params or self.batch_params or BatchParams.make_default()input_item_stuff_name = batch_params.input_item_stuff_name+ input_list_stuff_name = batch_params.input_list_stuff_nametry:- input_item_concept_code = self.inputs.get_required_input_requirement(input_item_stuff_name)+ input_requirement = self.inputs.get_required_input_requirement(input_list_stuff_name)except PipeInputNotFoundError as exc:- msg = f"Batch input item stuff named '{input_item_stuff_name}' is not in this PipeBatch '{self.code}' input spec: {self.inputs}"- raise PipeInputError(message=msg, pipe_code=self.code, variable_name=input_item_stuff_name, concept_code=None) from exc+ msg = f"Batch input item list named '{input_list_stuff_name}' is not in this PipeBatch '{self.code}' input requirements: {self.inputs}"+ raise PipeInputError(message=msg, pipe_code=self.code, variable_name=input_list_stuff_name, concept_code=None) from excif pipe_run_params.final_stuff_code:method_name = "dry_run_pipe" if pipe_run_params.run_mode == PipeRunMode.DRY else "_run_controller_pipe"@@ -125,7 +136,10 @@ class PipeBatch(PipeController):input_stuff_code = input_stuff.stuff_codeinput_content = input_stuff.contentif not isinstance(input_content, ListContent):- msg = f"Input of PipeBatch must be ListContent, got {input_stuff.stuff_name or 'unnamed'} = {type(input_content)}. stuff: {input_stuff}"+ msg = (+ f"Input of PipeBatch '{self.code}' must be ListContent, "+ f"got {input_stuff.stuff_name or 'unnamed'} = {type(input_content)}. stuff: {input_stuff}"+ )raise PipeInputError(message=msg, pipe_code=self.code, variable_name=batch_params.input_list_stuff_name, concept_code=None)input_content = cast("ListContent[StuffContent]", input_content)@@ -146,7 +160,7 @@ class PipeBatch(PipeController):branch_input_item_code = f"{input_stuff_code}-branch-{branch_index}"item_input_stuff = StuffFactory.make_stuff(code=branch_input_item_code,- concept=input_item_concept_code.concept,+ concept=input_requirement.concept,content=item,name=input_item_stuff_name,)diff --git a/pipelex/pipe_controllers/batch/pipe_batch_blueprint.py b/pipelex/pipe_controllers/batch/pipe_batch_blueprint.pyindex e65090aac..2c537a4d0 100644--- a/pipelex/pipe_controllers/batch/pipe_batch_blueprint.py+++ b/pipelex/pipe_controllers/batch/pipe_batch_blueprint.py@@ -9,8 +9,8 @@ class PipeBatchBlueprint(PipeBlueprint):type: Literal["PipeBatch"] = "PipeBatch"pipe_category: Literal["PipeController"] = "PipeController"branch_pipe_code: str- input_list_name: str | None = None- input_item_name: str | None = None+ input_list_name: str+ input_item_name: str@property@overridediff --git a/pipelex/pipe_controllers/batch/pipe_batch_factory.py b/pipelex/pipe_controllers/batch/pipe_batch_factory.pyindex a58b6ef48..b48ee8ca1 100644--- a/pipelex/pipe_controllers/batch/pipe_batch_factory.py+++ b/pipelex/pipe_controllers/batch/pipe_batch_factory.py@@ -44,7 +44,7 @@ class PipeBatchFactory(PipeFactoryProtocol[PipeBatchBlueprint, PipeBatch]):),),branch_pipe_code=blueprint.branch_pipe_code,- batch_params=BatchParams.make_optional_batch_params(+ batch_params=BatchParams.make_batch_params(input_list_name=blueprint.input_list_name,input_item_name=blueprint.input_item_name,),diff --git a/pipelex/pipe_controllers/condition/pipe_condition.py b/pipelex/pipe_controllers/condition/pipe_condition.pyindex 216df76e6..d5a637dfb 100644--- a/pipelex/pipe_controllers/condition/pipe_condition.py+++ b/pipelex/pipe_controllers/condition/pipe_condition.py@@ -67,6 +67,7 @@ class PipeCondition(PipeController):if self.output.concept_string not in (pipe.output.concept_string,NativeConceptCode.DYNAMIC.concept_string,+ NativeConceptCode.ANYTHING.concept_string,):msg = (f"The output concept code '{self.output.concept_string}' of the pipe '{self.code}' is "@@ -293,8 +294,13 @@ class PipeCondition(PipeController):# Handle continue caseif SpecialOutcome.is_continue(outcome):+ log.dev(f"PipeCondition '{self.code}' continued with outcome: {outcome}. Evaluated expression: {evaluated_expression}")return PipeOutput(working_memory=working_memory)+ if SpecialOutcome.is_fail(outcome):+ msg = f"PipeCondition '{self.code}' failed with outcome: {outcome}. Evaluated expression: {evaluated_expression}"+ raise PipeConditionError(message=msg)+chosen_pipe = get_required_pipe(pipe_code=outcome)# Create condition details for trackingdiff --git a/pipelex/pipe_controllers/condition/special_outcome.py b/pipelex/pipe_controllers/condition/special_outcome.pyindex 8660e464b..5c7b0fdc9 100644--- a/pipelex/pipe_controllers/condition/special_outcome.py+++ b/pipelex/pipe_controllers/condition/special_outcome.py@@ -25,3 +25,16 @@ class SpecialOutcome(StrEnum):return True# case SpecificPipeCodesEnum.BREAK: # Uncomment when BREAK is implemented# return False++ @classmethod+ def is_fail(cls, outcome: str) -> bool:+ try:+ enum_value = SpecialOutcome(outcome)+ except ValueError:+ return False++ match enum_value:+ case SpecialOutcome.FAIL:+ return True+ case SpecialOutcome.CONTINUE:+ return Falsediff --git a/pipelex/pipe_controllers/parallel/pipe_parallel.py b/pipelex/pipe_controllers/parallel/pipe_parallel.pyindex dcda4d2e4..060e4777d 100644--- a/pipelex/pipe_controllers/parallel/pipe_parallel.py+++ b/pipelex/pipe_controllers/parallel/pipe_parallel.py@@ -13,7 +13,14 @@ from pipelex.core.pipes.input_requirements import InputRequirementsfrom pipelex.core.pipes.input_requirements_factory import InputRequirementsFactoryfrom pipelex.core.pipes.pipe_output import PipeOutputfrom pipelex.core.stuffs.stuff_factory import StuffFactory-from pipelex.exceptions import DryRunMissingInputsError, PipeRunParamsError, StaticValidationError, StaticValidationErrorType+from pipelex.exceptions import (+ DryRunMissingInputsError,+ PipeInputError,+ PipeInputNotFoundError,+ PipeRunParamsError,+ StaticValidationError,+ StaticValidationErrorType,+)from pipelex.hub import get_pipeline_tracker, get_required_pipefrom pipelex.pipe_controllers.pipe_controller import PipeControllerfrom pipelex.pipe_controllers.sub_pipe import SubPipe@@ -76,9 +83,19 @@ class PipeParallel(PipeController):# Use the centralized recursion detectionpipe_needed_inputs = pipe.needed_inputs(visited_pipes_with_current)if sub_pipe.batch_params:+ try:+ requirement = pipe_needed_inputs.get_required_input_requirement(variable_name=sub_pipe.batch_params.input_item_stuff_name)+ except PipeInputNotFoundError as exc:+ msg = (+ f"Batch input item named '{sub_pipe.batch_params.input_item_stuff_name}' is not "+ f"in this Parallel Pipe '{self.code}' input requirements: {pipe_needed_inputs}"+ )+ raise PipeInputError(+ message=msg, pipe_code=self.code, variable_name=sub_pipe.batch_params.input_item_stuff_name, concept_code=None+ ) from excneeded_inputs.add_requirement(variable_name=sub_pipe.batch_params.input_list_stuff_name,- concept=pipe_needed_inputs.get_required_input_requirement(variable_name=sub_pipe.batch_params.input_item_stuff_name).concept,+ concept=requirement.concept,multiplicity=True,)for input_name, requirement in pipe_needed_inputs.items:diff --git a/pipelex/pipe_controllers/sequence/pipe_sequence.py b/pipelex/pipe_controllers/sequence/pipe_sequence.pyindex 4916b181d..abeb6ee5b 100644--- a/pipelex/pipe_controllers/sequence/pipe_sequence.py+++ b/pipelex/pipe_controllers/sequence/pipe_sequence.py@@ -11,6 +11,8 @@ from pipelex.core.pipes.input_requirements_factory import InputRequirementsFactofrom pipelex.core.pipes.pipe_output import PipeOutputfrom pipelex.exceptions import (PipeControllerOutputConceptMismatchError,+ PipeInputError,+ PipeInputNotFoundError,PipeRunParamsError,StaticValidationError,StaticValidationErrorType,@@ -55,11 +57,21 @@ class PipeSequence(PipeController):if sequential_sub_pipe.batch_params:if sequential_sub_pipe.batch_params.input_list_stuff_name not in generated_outputs:+ try:+ requirement = sub_pipe_needed_inputs.get_required_input_requirement(+ variable_name=sequential_sub_pipe.batch_params.input_item_stuff_name+ )+ except PipeInputNotFoundError as exc:+ msg = (+ f"Batch input item named '{sequential_sub_pipe.batch_params.input_item_stuff_name}' is not "+ f"in this PipeSequence '{self.code}' input requirements: {sub_pipe_needed_inputs}"+ )+ raise PipeInputError(+ message=msg, pipe_code=self.code, variable_name=sequential_sub_pipe.batch_params.input_item_stuff_name, concept_code=None+ ) from excneeded_inputs.add_requirement(variable_name=sequential_sub_pipe.batch_params.input_list_stuff_name,- concept=sub_pipe_needed_inputs.get_required_input_requirement(- variable_name=sequential_sub_pipe.batch_params.input_item_stuff_name,- ).concept,+ concept=requirement.concept,multiplicity=True,)for input_name, requirement in sub_pipe_needed_inputs.items:diff --git a/pipelex/pipe_controllers/sub_pipe.py b/pipelex/pipe_controllers/sub_pipe.pyindex 42666bb07..76eae772e 100644--- a/pipelex/pipe_controllers/sub_pipe.py+++ b/pipelex/pipe_controllers/sub_pipe.py@@ -5,7 +5,7 @@ from pipelex.core.memory.working_memory import WorkingMemoryfrom pipelex.core.pipes.pipe_output import PipeOutputfrom pipelex.core.pipes.variable_multiplicity import VariableMultiplicityfrom pipelex.core.stuffs.list_content import ListContent-from pipelex.exceptions import PipeInputError, WorkingMemoryStuffNotFoundError+from pipelex.exceptions import PipeInputError, PipeInputNotFoundError, WorkingMemoryStuffNotFoundErrorfrom pipelex.hub import get_pipeline_tracker, get_required_pipefrom pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprintfrom pipelex.pipe_controllers.batch.pipe_batch_factory import PipeBatchFactory@@ -48,7 +48,16 @@ class SubPipe(BaseModel):message=msg, pipe_code=self.pipe_code, variable_name=batch_params.input_list_stuff_name, concept_code=None) from exc- item_stuff_requirement = sub_pipe.inputs.get_required_input_requirement(variable_name=batch_params.input_item_stuff_name)+ try:+ item_stuff_requirement = sub_pipe.inputs.get_required_input_requirement(variable_name=batch_params.input_item_stuff_name)+ except PipeInputNotFoundError as exc:+ msg = (+ f"Batch input item named '{batch_params.input_item_stuff_name}' from '{calling_pipe_code}' is not "+ f"in SubPipe '{self.pipe_code}' input requirements: {sub_pipe.inputs}"+ )+ raise PipeInputError(+ message=msg, pipe_code=self.pipe_code, variable_name=batch_params.input_item_stuff_name, concept_code=None+ ) from excpipe_batch_blueprint = PipeBatchBlueprint(description=f"Batch processing for {self.pipe_code}",branch_pipe_code=self.pipe_code,@@ -56,7 +65,7 @@ class SubPipe(BaseModel):input_list_name=batch_params.input_list_stuff_name,input_item_name=batch_params.input_item_stuff_name,inputs={- batch_params.input_item_stuff_name: item_stuff_requirement.concept.concept_string,+ batch_params.input_list_stuff_name: item_stuff_requirement.concept.concept_string,},)@@ -83,7 +92,7 @@ class SubPipe(BaseModel):else:# Case 3: Normal processingrequired_variables = sub_pipe.required_variables()- required_stuff_names = {rv for rv in required_variables if not rv.startswith("_")}+ required_stuff_names = {req_var for req_var in required_variables if not req_var.startswith("_")}try:required_stuffs = working_memory.get_stuffs(names=required_stuff_names)except WorkingMemoryStuffNotFoundError as exc:diff --git a/pipelex/pipe_controllers/sub_pipe_factory.py b/pipelex/pipe_controllers/sub_pipe_factory.pyindex 023d63160..00657fcc2 100644--- a/pipelex/pipe_controllers/sub_pipe_factory.py+++ b/pipelex/pipe_controllers/sub_pipe_factory.py@@ -16,10 +16,14 @@ class SubPipeFactory:nb_items=blueprint.nb_output,multiple_items=blueprint.multiple_output,)- batch_params = BatchParams.make_optional_batch_params(- input_list_name=blueprint.batch_over,- input_item_name=blueprint.batch_as,- )+ batch_params: BatchParams | None = None+ if blueprint.batch_over and blueprint.batch_as:+ batch_params = BatchParams.make_batch_params(+ input_list_name=blueprint.batch_over,+ input_item_name=blueprint.batch_as,+ )+ else:+ batch_params = Nonereturn SubPipe(pipe_code=blueprint.pipe,output_name=blueprint.result,diff --git a/pipelex/pipe_run/pipe_run_params.py b/pipelex/pipe_run/pipe_run_params.pyindex 3cb8f6972..f0ce75719 100644--- a/pipelex/pipe_run/pipe_run_params.py+++ b/pipelex/pipe_run/pipe_run_params.py@@ -7,7 +7,6 @@ from pydantic import BaseModel, Field, field_validatorfrom pipelex import logfrom pipelex.core.memory.working_memory import BATCH_ITEM_STUFF_NAME, MAIN_STUFF_NAMEfrom pipelex.core.pipes.variable_multiplicity import VariableMultiplicity, VariableMultiplicityResolution-from pipelex.exceptions import BatchParamsErrorfrom pipelex.pipe_run.pipe_run_mode import PipeRunModefrom pipelex.types import Self, StrEnum@@ -112,22 +111,15 @@ class BatchParams(BaseModel):input_item_stuff_name: str@classmethod- def make_optional_batch_params(+ def make_batch_params(cls,- input_list_name: str | None,- input_item_name: str | None,- ) -> BatchParams | None:- if input_list_name:- input_item_stuff_name = input_item_name or BATCH_ITEM_STUFF_NAME- return BatchParams(- input_list_stuff_name=input_list_name,- input_item_stuff_name=input_item_stuff_name,- )- elif input_item_name:- msg = "input_item_name is required when input_list_name is not provided"- raise BatchParamsError(msg)- else:- return None+ input_list_name: str,+ input_item_name: str,+ ) -> BatchParams:+ return BatchParams(+ input_list_stuff_name=input_list_name,+ input_item_stuff_name=input_item_name,+ )@classmethoddef make_default(cls) -> BatchParams:diff --git a/pipelex/plugins/openai/vertexai_factory.py b/pipelex/plugins/openai/vertexai_factory.pyindex d0954c493..0ece3bd9b 100644--- a/pipelex/plugins/openai/vertexai_factory.py+++ b/pipelex/plugins/openai/vertexai_factory.py@@ -64,7 +64,7 @@ class VertexAIFactory(ConfigModel):lib_name = "google-auth-oauthlib"lib_extra_name = "google"msg = (- "The google-auth-oauthlib SDK is required to use Google connection. "+ "The google-auth-oauthlib SDK is required in order to use Google connection. ""You can install it with 'pip install pipelex[google]', or use this model via another provider ""(such as Azure OpenAI, OpenAI, anthropic or bedrock).")diff --git a/pyproject.toml b/pyproject.tomlindex 5e1831c24..c1ffc4f00 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -1,6 +1,6 @@[project]name = "pipelex"-version = "0.14.1"+version = "0.14.2"description = "The open standard for repeatable AI workflows. Write business logic, not API calls."authors = [{ name = "Evotis S.A.S.", email = "[email protected]" }]maintainers = [{ name = "Pipelex staff", email = "[email protected]" }]@@ -194,7 +194,6 @@ reportUnusedFunction = "error"reportUnusedImport = "none"reportUnusedVariable = "error"reportWildcardImportFromLibrary = "error"-reportUnusedParameter = "information"strictDictionaryInference = truestrictListInference = truestrictParameterNoneValue = truediff --git a/tests/unit/builder/pipe/pipe_controller/pipe_batch/test_data.py b/tests/unit/builder/pipe/pipe_controller/pipe_batch/test_data.pyindex 34f2cf5ed..c0f05dbde 100644--- a/tests/unit/builder/pipe/pipe_controller/pipe_batch/test_data.py+++ b/tests/unit/builder/pipe/pipe_controller/pipe_batch/test_data.py@@ -5,27 +5,6 @@ from pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBluepriclass PipeBatchTestCases:- SIMPLE_BATCH = (- "simple_batch",- PipeBatchSpec(- pipe_code="batch_processor",- description="Process items in batch",- inputs={"items": "ItemList"},- output="ProcessedItems",- branch_pipe_code="process_item",- ),- PipeBatchBlueprint(- description="Process items in batch",- inputs={"items": "ItemList"},- output="ProcessedItems",- type="PipeBatch",- pipe_category="PipeController",- branch_pipe_code="process_item",- input_list_name=None,- input_item_name=None,- ),- )-BATCH_WITH_NAMES = ("batch_with_names",PipeBatchSpec(@@ -50,6 +29,5 @@ class PipeBatchTestCases:)TEST_CASES: ClassVar[list[tuple[str, PipeBatchSpec, PipeBatchBlueprint]]] = [- SIMPLE_BATCH,BATCH_WITH_NAMES,]diff --git a/tests/unit/builder/pipe/pipe_controller/pipe_sequence/test_data.py b/tests/unit/builder/pipe/pipe_controller/pipe_sequence/test_data.pyindex b7d69220f..fb597ec92 100644--- a/tests/unit/builder/pipe/pipe_controller/pipe_sequence/test_data.py+++ b/tests/unit/builder/pipe/pipe_controller/pipe_sequence/test_data.py@@ -34,42 +34,6 @@ class PipeSequenceTestCases:),)- SEQUENCE_WITH_BATCH = (- "sequence_with_batch",- PipeSequenceSpec(- pipe_code="batch_sequence",- description="Sequence with batch",- inputs={"items": "ItemList"},- output="ProcessedItems",- steps=[- SubPipeSpec(pipe_code="prepare", result="prepared_items"),- SubPipeSpec(- pipe_code="process_item",- result="processed_items",- batch_over="prepared_items",- batch_as="current_item",- ),- ],- ),- PipeSequenceBlueprint(- description="Sequence with batch",- inputs={"items": "ItemList"},- output="ProcessedItems",- type="PipeSequence",- pipe_category="PipeController",- steps=[- SubPipeBlueprint(pipe="prepare", result="prepared_items"),- SubPipeBlueprint(- pipe="process_item",- result="processed_items",- batch_over="prepared_items",- batch_as="current_item",- ),- ],- ),- )-TEST_CASES: ClassVar[list[tuple[str, PipeSequenceSpec, PipeSequenceBlueprint]]] = [SIMPLE_SEQUENCE,- SEQUENCE_WITH_BATCH,]diff --git a/tests/unit/builder/pipe/test_data_sub_pipe.py b/tests/unit/builder/pipe/test_data_sub_pipe.pyindex 297bded4e..67a933f5d 100644--- a/tests/unit/builder/pipe/test_data_sub_pipe.py+++ b/tests/unit/builder/pipe/test_data_sub_pipe.py@@ -11,13 +11,6 @@ class SubPipeTestCases:SubPipeBlueprint(pipe="process_data", result="processed_data"),)- SUB_PIPE_WITH_BATCH = (- "sub_pipe_with_batch",- SubPipeSpec(pipe_code="process_item", result="processed_items", batch_over="input_list", batch_as="current_item"),- SubPipeBlueprint(pipe="process_item", result="processed_items", batch_over="input_list", batch_as="current_item"),- )-TEST_CASES: ClassVar[list[tuple[str, SubPipeSpec, SubPipeBlueprint]]] = [SIMPLE_SUB_PIPE,- SUB_PIPE_WITH_BATCH,]diff --git a/tests/unit/core/bundles/test_data_pipe_sorter.py b/tests/unit/core/bundles/test_data_pipe_sorter.pyindex 6a33e8d26..bb40da0c9 100644--- a/tests/unit/core/bundles/test_data_pipe_sorter.py+++ b/tests/unit/core/bundles/test_data_pipe_sorter.py@@ -122,6 +122,8 @@ class PipeSorterTestCases:inputs={},output="Text",branch_pipe_code="process_item",+ input_list_name="items",+ input_item_name="item",),"process_item": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="Process", inputs={}, output="Text"),}diff --git a/tests/unit/pipe_controllers/batch/data.py b/tests/unit/pipe_controllers/batch/data.pyindex f5ec2791e..56a943333 100644--- a/tests/unit/pipe_controllers/batch/data.py+++ b/tests/unit/pipe_controllers/batch/data.py@@ -19,27 +19,6 @@ class PipeBatchInputTestCases:),)- VALID_WITHOUT_EXPLICIT_NAMES: ClassVar[tuple[str, PipeBatchBlueprint]] = (- "valid_without_explicit_names",- PipeBatchBlueprint(- description="Test case: valid_without_explicit_names",- inputs={"data_list": "native.Text"},- output="native.Text",- branch_pipe_code="process_data",- ),- )-- VALID_WITH_INPUT_LIST_NAME_ONLY: ClassVar[tuple[str, PipeBatchBlueprint]] = (- "valid_with_input_list_name_only",- PipeBatchBlueprint(- description="Test case: valid_with_input_list_name_only",- inputs={"records": "native.Text"},- output="native.Text",- branch_pipe_code="process_record",- input_list_name="records",- ),- )-VALID_MULTIPLE_INPUTS: ClassVar[tuple[str, PipeBatchBlueprint]] = ("valid_multiple_inputs",PipeBatchBlueprint(@@ -54,7 +33,5 @@ class PipeBatchInputTestCases:VALID_CASES: ClassVar[list[tuple[str, PipeBatchBlueprint]]] = [VALID_SIMPLE_BATCH,- VALID_WITHOUT_EXPLICIT_NAMES,- VALID_WITH_INPUT_LIST_NAME_ONLY,VALID_MULTIPLE_INPUTS,]diff --git a/uv.lock b/uv.lockindex 3039c9598..2e6a41fcd 100644--- a/uv.lock+++ b/uv.lock@@ -63,7 +63,7 @@ wheels = [[[package]]name = "aiohttp"-version = "3.13.1"+version = "3.13.2"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "aiohappyeyeballs" },@@ -75,110 +75,110 @@ dependencies = [{ name = "propcache" },{ name = "yarl" },]-sdist = { url = "https://files.pythonhosted.org/packages/ba/fa/3ae643cd525cf6844d3dc810481e5748107368eb49563c15a5fb9f680750/aiohttp-3.13.1.tar.gz", hash = "sha256:4b7ee9c355015813a6aa085170b96ec22315dabc3d866fd77d147927000e9464", size = 7835344, upload-time = "2025-10-17T14:03:29.337Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/e6/34/5097441cc3047eccc2e0bfed3760ed068489b8392545d3aec0d8fbfab2b5/aiohttp-3.13.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2349a6b642020bf20116a8a5c83bae8ba071acf1461c7cbe45fc7fafd552e7e2", size = 735069, upload-time = "2025-10-17T13:58:56.602Z" },- { url = "https://files.pythonhosted.org/packages/8c/2b/726466b4b4b16271a3db2a8a914d754d6cb9cee7bebde1f3ac6043e4e030/aiohttp-3.13.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2a8434ca31c093a90edb94d7d70e98706ce4d912d7f7a39f56e1af26287f4bb7", size = 492575, upload-time = "2025-10-17T13:58:58.696Z" },- { url = "https://files.pythonhosted.org/packages/82/1f/364e64292c95bb6c9e2823b0afa1ad3f06524c573d45df82294be572489d/aiohttp-3.13.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0bd610a7e87431741021a9a6ab775e769ea8c01bf01766d481282bfb17df597f", size = 487862, upload-time = "2025-10-17T13:59:00.315Z" },- { url = "https://files.pythonhosted.org/packages/23/b0/c5a774b3125ac854987b8ca45a6d995829987d01ece4525d3fc369a9ca88/aiohttp-3.13.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:777ec887264b629395b528af59b8523bf3164d4c6738cd8989485ff3eda002e2", size = 1666761, upload-time = "2025-10-17T13:59:02.224Z" },- { url = "https://files.pythonhosted.org/packages/29/be/32c6c1d3a6c69e594b855bbf4014bea4c42008b0daac8c6e5c9f03207b89/aiohttp-3.13.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ac1892f56e2c445aca5ba28f3bf8e16b26dfc05f3c969867b7ef553b74cb4ebe", size = 1634627, upload-time = "2025-10-17T13:59:03.829Z" },- { url = "https://files.pythonhosted.org/packages/73/8d/fde3a8f4801b14e0b9490f5bc86c5106cb7d96bd60ff2aaee53749c72fe1/aiohttp-3.13.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:499a047d1c5e490c31d16c033e2e47d1358f0e15175c7a1329afc6dfeb04bc09", size = 1726564, upload-time = "2025-10-17T13:59:05.997Z" },- { url = "https://files.pythonhosted.org/packages/52/b2/8290556f1f6b17b1af976a9abb17f9b54dc7218e11bbf6abbebaa7cc70fb/aiohttp-3.13.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:610be925f89501938c770f1e28ca9dd62e9b308592c81bd5d223ce92434c0089", size = 1814413, upload-time = "2025-10-17T13:59:08.975Z" },- { url = "https://files.pythonhosted.org/packages/ef/6b/4b657e9fa72479df38117609d4ec8e4b07e8110b872df3872f9c6a96e26b/aiohttp-3.13.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90eb902c06c6ac85d6b80fa9f2bd681f25b1ebf73433d428b3d182a507242711", size = 1667964, upload-time = "2025-10-17T13:59:10.606Z" },- { url = "https://files.pythonhosted.org/packages/ee/ed/563de175d01fa26459a60a7c82dbf69d20e356d459476a7526329091b4c3/aiohttp-3.13.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ab8ac3224b2beb46266c094b3869d68d5f96f35dba98e03dea0acbd055eefa03", size = 1553917, upload-time = "2025-10-17T13:59:12.312Z" },- { url = "https://files.pythonhosted.org/packages/39/26/48a4b5681eada16eb5b39cae277765aed1644b03610c43eadb8b331ccfea/aiohttp-3.13.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:79ac65b6e2731558aad1e4c1a655d2aa2a77845b62acecf5898b0d4fe8c76618", size = 1637730, upload-time = "2025-10-17T13:59:14.395Z" },- { url = "https://files.pythonhosted.org/packages/c1/43/57b137af37344e03c7f6b28ddf38a4af820b53c1fa9ce13f668fe468d2e2/aiohttp-3.13.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:4dadbd858ed8c04d1aa7a2a91ad65f8e1fbd253ae762ef5be8111e763d576c3c", size = 1644088, upload-time = "2025-10-17T13:59:16.749Z" },- { url = "https://files.pythonhosted.org/packages/0d/c4/e49bafa4babef09929b10968a6b6efe3707fbaa5c5bb7c8db7f810232269/aiohttp-3.13.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:e0b2ccd331bc77149e88e919aa95c228a011e03e1168fd938e6aeb1a317d7a8a", size = 1696215, upload-time = "2025-10-17T13:59:18.711Z" },- { url = "https://files.pythonhosted.org/packages/15/e4/8414be434b3e50f9089ffa7c4d5130ba6ff0d1c6fa9f55cd760b088abbe0/aiohttp-3.13.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:fba3c85fb24fe204e73f3c92f09f4f5cfa55fa7e54b34d59d91b7c5a258d0f6a", size = 1540617, upload-time = "2025-10-17T13:59:20.46Z" },- { url = "https://files.pythonhosted.org/packages/bd/8b/31cb6725f819b74a9c0b0055c500187294e73aea40708b6a5aa7b328ea4c/aiohttp-3.13.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8d5011e4e741d2635cda18f2997a56e8e1d1b94591dc8732f2ef1d3e1bfc5f45", size = 1713509, upload-time = "2025-10-17T13:59:22.61Z" },- { url = "https://files.pythonhosted.org/packages/24/ac/49a79c2711423cfa091e265c46e58617de31258c64502b890f25421cb742/aiohttp-3.13.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c5fe2728a89c82574bd3132d59237c3b5fb83e2e00a320e928d05d74d1ae895f", size = 1654702, upload-time = "2025-10-17T13:59:24.396Z" },- { url = "https://files.pythonhosted.org/packages/30/52/1cf23cffeda1f079f20cd9c72174a76e8b0c6595def6803892e37ee35c8a/aiohttp-3.13.1-cp310-cp310-win32.whl", hash = "sha256:add14a5e68cbcfc526c89c1ed8ea963f5ff8b9b4b854985b07820c6fbfdb3c3c", size = 430898, upload-time = "2025-10-17T13:59:26.227Z" },- { url = "https://files.pythonhosted.org/packages/0e/13/214a01f2936f4645b1fbd5cba9001331ca5af5c04bbdbe747eed330a8516/aiohttp-3.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:a4cc9d9cfdf75a69ae921c407e02d0c1799ab333b0bc6f7928c175f47c080d6a", size = 453684, upload-time = "2025-10-17T13:59:28.129Z" },- { url = "https://files.pythonhosted.org/packages/be/2c/739d03730ffce57d2093e2e611e1541ac9a4b3bb88288c33275058b9ffc2/aiohttp-3.13.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eefa0a891e85dca56e2d00760945a6325bd76341ec386d3ad4ff72eb97b7e64", size = 742004, upload-time = "2025-10-17T13:59:29.73Z" },- { url = "https://files.pythonhosted.org/packages/fc/f8/7f5b7f7184d7c80e421dbaecbd13e0b2a0bb8663fd0406864f9a167a438c/aiohttp-3.13.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6c20eb646371a5a57a97de67e52aac6c47badb1564e719b3601bbb557a2e8fd0", size = 495601, upload-time = "2025-10-17T13:59:31.312Z" },- { url = "https://files.pythonhosted.org/packages/3e/af/fb78d028b9642dd33ff127d9a6a151586f33daff631b05250fecd0ab23f8/aiohttp-3.13.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bfc28038cd86fb1deed5cc75c8fda45c6b0f5c51dfd76f8c63d3d22dc1ab3d1b", size = 491790, upload-time = "2025-10-17T13:59:33.304Z" },- { url = "https://files.pythonhosted.org/packages/1e/ae/e40e422ee995e4f91f7f087b86304e3dd622d3a5b9ca902a1e94ebf9a117/aiohttp-3.13.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b22eeffca2e522451990c31a36fe0e71079e6112159f39a4391f1c1e259a795", size = 1746350, upload-time = "2025-10-17T13:59:35.158Z" },- { url = "https://files.pythonhosted.org/packages/28/a5/fe6022bb869bf2d2633b155ed8348d76358c22d5ff9692a15016b2d1019f/aiohttp-3.13.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:65782b2977c05ebd78787e3c834abe499313bf69d6b8be4ff9c340901ee7541f", size = 1703046, upload-time = "2025-10-17T13:59:37.077Z" },- { url = "https://files.pythonhosted.org/packages/5a/a5/c4ef3617d7cdc49f2d5af077f19794946f0f2d94b93c631ace79047361a2/aiohttp-3.13.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dacba54f9be3702eb866b0b9966754b475e1e39996e29e442c3cd7f1117b43a9", size = 1806161, upload-time = "2025-10-17T13:59:38.837Z" },- { url = "https://files.pythonhosted.org/packages/ad/45/b87d2430aee7e7d00b24e3dff2c5bd69f21017f6edb19cfd91e514664fc8/aiohttp-3.13.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:aa878da718e8235302c365e376b768035add36b55177706d784a122cb822a6a4", size = 1894546, upload-time = "2025-10-17T13:59:40.741Z" },- { url = "https://files.pythonhosted.org/packages/e8/a2/79eb466786a7f11a0292c353a8a9b95e88268c48c389239d7531d66dbb48/aiohttp-3.13.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0e4b4e607fbd4964d65945a7b9d1e7f98b0d5545736ea613f77d5a2a37ff1e46", size = 1745683, upload-time = "2025-10-17T13:59:42.59Z" },- { url = "https://files.pythonhosted.org/packages/93/1a/153b0ad694f377e94eacc85338efe03ed4776a396c8bb47bd9227135792a/aiohttp-3.13.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0c3db2d0e5477ad561bf7ba978c3ae5f8f78afda70daa05020179f759578754f", size = 1605418, upload-time = "2025-10-17T13:59:45.229Z" },- { url = "https://files.pythonhosted.org/packages/3f/4e/18605b1bfeb4b00d3396d833647cdb213118e2a96862e5aebee62ad065b4/aiohttp-3.13.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9739d34506fdf59bf2c092560d502aa728b8cdb33f34ba15fb5e2852c35dd829", size = 1722379, upload-time = "2025-10-17T13:59:46.969Z" },- { url = "https://files.pythonhosted.org/packages/72/13/0a38ad385d547fb283e0e1fe1ff1dff8899bd4ed0aaceeb13ec14abbf136/aiohttp-3.13.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:b902e30a268a85d50197b4997edc6e78842c14c0703450f632c2d82f17577845", size = 1716693, upload-time = "2025-10-17T13:59:49.217Z" },- { url = "https://files.pythonhosted.org/packages/55/65/7029d7573ab9009adde380052c6130d02c8db52195fda112db35e914fe7b/aiohttp-3.13.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1bbfc04c8de7def6504cce0a97f9885a5c805fd2395a0634bc10f9d6ecb42524", size = 1784174, upload-time = "2025-10-17T13:59:51.439Z" },- { url = "https://files.pythonhosted.org/packages/2d/36/fd46e39cb85418e45b0e4a8bfc39651ee0b8f08ea006adf217a221cdb269/aiohttp-3.13.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:6941853405a38a5eeb7d9776db77698df373ff7fa8c765cb81ea14a344fccbeb", size = 1593716, upload-time = "2025-10-17T13:59:53.367Z" },- { url = "https://files.pythonhosted.org/packages/85/b8/188e0cb1be37b4408373171070fda17c3bf9c67c0d3d4fd5ee5b1fa108e1/aiohttp-3.13.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:7764adcd2dc8bd21c8228a53dda2005428498dc4d165f41b6086f0ac1c65b1c9", size = 1799254, upload-time = "2025-10-17T13:59:55.352Z" },- { url = "https://files.pythonhosted.org/packages/67/ff/fdf768764eb427b0cc9ebb2cebddf990f94d98b430679f8383c35aa114be/aiohttp-3.13.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c09e08d38586fa59e5a2f9626505a0326fadb8e9c45550f029feeb92097a0afc", size = 1738122, upload-time = "2025-10-17T13:59:57.263Z" },- { url = "https://files.pythonhosted.org/packages/94/84/fce7a4d575943394d7c0e632273838eb6f39de8edf25386017bf5f0de23b/aiohttp-3.13.1-cp311-cp311-win32.whl", hash = "sha256:ce1371675e74f6cf271d0b5530defb44cce713fd0ab733713562b3a2b870815c", size = 430491, upload-time = "2025-10-17T13:59:59.466Z" },- { url = "https://files.pythonhosted.org/packages/ac/d2/d21b8ab6315a5d588c550ab285b4f02ae363edf012920e597904c5a56608/aiohttp-3.13.1-cp311-cp311-win_amd64.whl", hash = "sha256:77a2f5cc28cf4704cc157be135c6a6cfb38c9dea478004f1c0fd7449cf445c28", size = 454808, upload-time = "2025-10-17T14:00:01.247Z" },- { url = "https://files.pythonhosted.org/packages/1a/72/d463a10bf29871f6e3f63bcf3c91362dc4d72ed5917a8271f96672c415ad/aiohttp-3.13.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0760bd9a28efe188d77b7c3fe666e6ef74320d0f5b105f2e931c7a7e884c8230", size = 736218, upload-time = "2025-10-17T14:00:03.51Z" },- { url = "https://files.pythonhosted.org/packages/26/13/f7bccedbe52ea5a6eef1e4ebb686a8d7765319dfd0a5939f4238cb6e79e6/aiohttp-3.13.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7129a424b441c3fe018a414401bf1b9e1d49492445f5676a3aecf4f74f67fcdb", size = 491251, upload-time = "2025-10-17T14:00:05.756Z" },- { url = "https://files.pythonhosted.org/packages/0c/7c/7ea51b5aed6cc69c873f62548da8345032aa3416336f2d26869d4d37b4a2/aiohttp-3.13.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e1cb04ae64a594f6ddf5cbb024aba6b4773895ab6ecbc579d60414f8115e9e26", size = 490394, upload-time = "2025-10-17T14:00:07.504Z" },- { url = "https://files.pythonhosted.org/packages/31/05/1172cc4af4557f6522efdee6eb2b9f900e1e320a97e25dffd3c5a6af651b/aiohttp-3.13.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:782d656a641e755decd6bd98d61d2a8ea062fd45fd3ff8d4173605dd0d2b56a1", size = 1737455, upload-time = "2025-10-17T14:00:09.403Z" },- { url = "https://files.pythonhosted.org/packages/24/3d/ce6e4eca42f797d6b1cd3053cf3b0a22032eef3e4d1e71b9e93c92a3f201/aiohttp-3.13.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:f92ad8169767429a6d2237331726c03ccc5f245222f9373aa045510976af2b35", size = 1699176, upload-time = "2025-10-17T14:00:11.314Z" },- { url = "https://files.pythonhosted.org/packages/25/04/7127ba55653e04da51477372566b16ae786ef854e06222a1c96b4ba6c8ef/aiohttp-3.13.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0e778f634ca50ec005eefa2253856921c429581422d887be050f2c1c92e5ce12", size = 1767216, upload-time = "2025-10-17T14:00:13.668Z" },- { url = "https://files.pythonhosted.org/packages/b8/3b/43bca1e75847e600f40df829a6b2f0f4e1d4c70fb6c4818fdc09a462afd5/aiohttp-3.13.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9bc36b41cf4aab5d3b34d22934a696ab83516603d1bc1f3e4ff9930fe7d245e5", size = 1865870, upload-time = "2025-10-17T14:00:15.852Z" },- { url = "https://files.pythonhosted.org/packages/9e/69/b204e5d43384197a614c88c1717c324319f5b4e7d0a1b5118da583028d40/aiohttp-3.13.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3fd4570ea696aee27204dd524f287127ed0966d14d309dc8cc440f474e3e7dbd", size = 1751021, upload-time = "2025-10-17T14:00:18.297Z" },- { url = "https://files.pythonhosted.org/packages/1c/af/845dc6b6fdf378791d720364bf5150f80d22c990f7e3a42331d93b337cc7/aiohttp-3.13.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7bda795f08b8a620836ebfb0926f7973972a4bf8c74fdf9145e489f88c416811", size = 1561448, upload-time = "2025-10-17T14:00:20.152Z" },- { url = "https://files.pythonhosted.org/packages/7a/91/d2ab08cd77ed76a49e4106b1cfb60bce2768242dd0c4f9ec0cb01e2cbf94/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:055a51d90e351aae53dcf324d0eafb2abe5b576d3ea1ec03827d920cf81a1c15", size = 1698196, upload-time = "2025-10-17T14:00:22.131Z" },- { url = "https://files.pythonhosted.org/packages/5e/d1/082f0620dc428ecb8f21c08a191a4694915cd50f14791c74a24d9161cc50/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:d4131df864cbcc09bb16d3612a682af0db52f10736e71312574d90f16406a867", size = 1719252, upload-time = "2025-10-17T14:00:24.453Z" },- { url = "https://files.pythonhosted.org/packages/fc/78/2af2f44491be7b08e43945b72d2b4fd76f0a14ba850ba9e41d28a7ce716a/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:163d3226e043f79bf47c87f8dfc89c496cc7bc9128cb7055ce026e435d551720", size = 1736529, upload-time = "2025-10-17T14:00:26.567Z" },- { url = "https://files.pythonhosted.org/packages/b0/34/3e919ecdc93edaea8d140138049a0d9126141072e519535e2efa38eb7a02/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a2370986a3b75c1a5f3d6f6d763fc6be4b430226577b0ed16a7c13a75bf43d8f", size = 1553723, upload-time = "2025-10-17T14:00:28.592Z" },- { url = "https://files.pythonhosted.org/packages/21/4b/d8003aeda2f67f359b37e70a5a4b53fee336d8e89511ac307ff62aeefcdb/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d7c14de0c7c9f1e6e785ce6cbe0ed817282c2af0012e674f45b4e58c6d4ea030", size = 1763394, upload-time = "2025-10-17T14:00:31.051Z" },- { url = "https://files.pythonhosted.org/packages/4c/7b/1dbe6a39e33af9baaafc3fc016a280663684af47ba9f0e5d44249c1f72ec/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb611489cf0db10b99beeb7280bd39e0ef72bc3eb6d8c0f0a16d8a56075d1eb7", size = 1718104, upload-time = "2025-10-17T14:00:33.407Z" },- { url = "https://files.pythonhosted.org/packages/5c/88/bd1b38687257cce67681b9b0fa0b16437be03383fa1be4d1a45b168bef25/aiohttp-3.13.1-cp312-cp312-win32.whl", hash = "sha256:f90fe0ee75590f7428f7c8b5479389d985d83c949ea10f662ab928a5ed5cf5e6", size = 425303, upload-time = "2025-10-17T14:00:35.829Z" },- { url = "https://files.pythonhosted.org/packages/0e/e3/4481f50dd6f27e9e58c19a60cff44029641640237e35d32b04aaee8cf95f/aiohttp-3.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:3461919a9dca272c183055f2aab8e6af0adc810a1b386cce28da11eb00c859d9", size = 452071, upload-time = "2025-10-17T14:00:37.764Z" },- { url = "https://files.pythonhosted.org/packages/16/6d/d267b132342e1080f4c1bb7e1b4e96b168b3cbce931ec45780bff693ff95/aiohttp-3.13.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:55785a7f8f13df0c9ca30b5243d9909bd59f48b274262a8fe78cee0828306e5d", size = 730727, upload-time = "2025-10-17T14:00:39.681Z" },- { url = "https://files.pythonhosted.org/packages/92/c8/1cf495bac85cf71b80fad5f6d7693e84894f11b9fe876b64b0a1e7cbf32f/aiohttp-3.13.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4bef5b83296cebb8167707b4f8d06c1805db0af632f7a72d7c5288a84667e7c3", size = 488678, upload-time = "2025-10-17T14:00:41.541Z" },- { url = "https://files.pythonhosted.org/packages/a8/19/23c6b81cca587ec96943d977a58d11d05a82837022e65cd5502d665a7d11/aiohttp-3.13.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:27af0619c33f9ca52f06069ec05de1a357033449ab101836f431768ecfa63ff5", size = 487637, upload-time = "2025-10-17T14:00:43.527Z" },- { url = "https://files.pythonhosted.org/packages/48/58/8f9464afb88b3eed145ad7c665293739b3a6f91589694a2bb7e5778cbc72/aiohttp-3.13.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a47fe43229a8efd3764ef7728a5c1158f31cdf2a12151fe99fde81c9ac87019c", size = 1718975, upload-time = "2025-10-17T14:00:45.496Z" },- { url = "https://files.pythonhosted.org/packages/e1/8b/c3da064ca392b2702f53949fd7c403afa38d9ee10bf52c6ad59a42537103/aiohttp-3.13.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6e68e126de5b46e8b2bee73cab086b5d791e7dc192056916077aa1e2e2b04437", size = 1686905, upload-time = "2025-10-17T14:00:47.707Z" },- { url = "https://files.pythonhosted.org/packages/0a/a4/9c8a3843ecf526daee6010af1a66eb62579be1531d2d5af48ea6f405ad3c/aiohttp-3.13.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e65ef49dd22514329c55970d39079618a8abf856bae7147913bb774a3ab3c02f", size = 1754907, upload-time = "2025-10-17T14:00:49.702Z" },- { url = "https://files.pythonhosted.org/packages/a4/80/1f470ed93e06436e3fc2659a9fc329c192fa893fb7ed4e884d399dbfb2a8/aiohttp-3.13.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e425a7e0511648b3376839dcc9190098671a47f21a36e815b97762eb7d556b0", size = 1857129, upload-time = "2025-10-17T14:00:51.822Z" },- { url = "https://files.pythonhosted.org/packages/cc/e6/33d305e6cce0a8daeb79c7d8d6547d6e5f27f4e35fa4883fc9c9eb638596/aiohttp-3.13.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:010dc9b7110f055006acd3648d5d5955bb6473b37c3663ec42a1b4cba7413e6b", size = 1738189, upload-time = "2025-10-17T14:00:53.976Z" },- { url = "https://files.pythonhosted.org/packages/ac/42/8df03367e5a64327fe0c39291080697795430c438fc1139c7cc1831aa1df/aiohttp-3.13.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b5c722d0ca5f57d61066b5dfa96cdb87111e2519156b35c1f8dd17c703bee7a", size = 1553608, upload-time = "2025-10-17T14:00:56.144Z" },- { url = "https://files.pythonhosted.org/packages/96/17/6d5c73cd862f1cf29fddcbb54aac147037ff70a043a2829d03a379e95742/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:93029f0e9b77b714904a281b5aa578cdc8aa8ba018d78c04e51e1c3d8471b8ec", size = 1681809, upload-time = "2025-10-17T14:00:58.603Z" },- { url = "https://files.pythonhosted.org/packages/be/31/8926c8ab18533f6076ce28d2c329a203b58c6861681906e2d73b9c397588/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:d1824c7d08d8ddfc8cb10c847f696942e5aadbd16fd974dfde8bd2c3c08a9fa1", size = 1711161, upload-time = "2025-10-17T14:01:01.744Z" },- { url = "https://files.pythonhosted.org/packages/f2/36/2f83e1ca730b1e0a8cf1c8ab9559834c5eec9f5da86e77ac71f0d16b521d/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:8f47d0ff5b3eb9c1278a2f56ea48fda667da8ebf28bd2cb378b7c453936ce003", size = 1731999, upload-time = "2025-10-17T14:01:04.626Z" },- { url = "https://files.pythonhosted.org/packages/b9/ec/1f818cc368dfd4d5ab4e9efc8f2f6f283bfc31e1c06d3e848bcc862d4591/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8a396b1da9b51ded79806ac3b57a598f84e0769eaa1ba300655d8b5e17b70c7b", size = 1548684, upload-time = "2025-10-17T14:01:06.828Z" },- { url = "https://files.pythonhosted.org/packages/d3/ad/33d36efd16e4fefee91b09a22a3a0e1b830f65471c3567ac5a8041fac812/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d9c52a65f54796e066b5d674e33b53178014752d28bca555c479c2c25ffcec5b", size = 1756676, upload-time = "2025-10-17T14:01:09.517Z" },- { url = "https://files.pythonhosted.org/packages/3c/c4/4a526d84e77d464437713ca909364988ed2e0cd0cdad2c06cb065ece9e08/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a89da72d18d6c95a653470b78d8ee5aa3c4b37212004c103403d0776cbea6ff0", size = 1715577, upload-time = "2025-10-17T14:01:11.958Z" },- { url = "https://files.pythonhosted.org/packages/a2/21/e39638b7d9c7f1362c4113a91870f89287e60a7ea2d037e258b81e8b37d5/aiohttp-3.13.1-cp313-cp313-win32.whl", hash = "sha256:02e0258b7585ddf5d01c79c716ddd674386bfbf3041fbbfe7bdf9c7c32eb4a9b", size = 424468, upload-time = "2025-10-17T14:01:14.344Z" },- { url = "https://files.pythonhosted.org/packages/cc/00/f3a92c592a845ebb2f47d102a67f35f0925cb854c5e7386f1a3a1fdff2ab/aiohttp-3.13.1-cp313-cp313-win_amd64.whl", hash = "sha256:ef56ffe60e8d97baac123272bde1ab889ee07d3419606fae823c80c2b86c403e", size = 450806, upload-time = "2025-10-17T14:01:16.437Z" },- { url = "https://files.pythonhosted.org/packages/97/be/0f6c41d2fd0aab0af133c509cabaf5b1d78eab882cb0ceb872e87ceeabf7/aiohttp-3.13.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:77f83b3dc5870a2ea79a0fcfdcc3fc398187ec1675ff61ec2ceccad27ecbd303", size = 733828, upload-time = "2025-10-17T14:01:18.58Z" },- { url = "https://files.pythonhosted.org/packages/75/14/24e2ac5efa76ae30e05813e0f50737005fd52da8ddffee474d4a5e7f38a6/aiohttp-3.13.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:9cafd2609ebb755e47323306c7666283fbba6cf82b5f19982ea627db907df23a", size = 489320, upload-time = "2025-10-17T14:01:20.644Z" },- { url = "https://files.pythonhosted.org/packages/da/5a/4cbe599358d05ea7db4869aff44707b57d13f01724d48123dc68b3288d5a/aiohttp-3.13.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9c489309a2ca548d5f11131cfb4092f61d67954f930bba7e413bcdbbb82d7fae", size = 489899, upload-time = "2025-10-17T14:01:22.638Z" },- { url = "https://files.pythonhosted.org/packages/67/96/3aec9d9cfc723273d4386328a1e2562cf23629d2f57d137047c49adb2afb/aiohttp-3.13.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79ac15fe5fdbf3c186aa74b656cd436d9a1e492ba036db8901c75717055a5b1c", size = 1716556, upload-time = "2025-10-17T14:01:25.406Z" },- { url = "https://files.pythonhosted.org/packages/b9/99/39a3d250595b5c8172843831221fa5662884f63f8005b00b4034f2a7a836/aiohttp-3.13.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:095414be94fce3bc080684b4cd50fb70d439bc4662b2a1984f45f3bf9ede08aa", size = 1665814, upload-time = "2025-10-17T14:01:27.683Z" },- { url = "https://files.pythonhosted.org/packages/3b/96/8319e7060a85db14a9c178bc7b3cf17fad458db32ba6d2910de3ca71452d/aiohttp-3.13.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c68172e1a2dca65fa1272c85ca72e802d78b67812b22827df01017a15c5089fa", size = 1755767, upload-time = "2025-10-17T14:01:29.914Z" },- { url = "https://files.pythonhosted.org/packages/1c/c6/0a2b3d886b40aa740fa2294cd34ed46d2e8108696748492be722e23082a7/aiohttp-3.13.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3751f9212bcd119944d4ea9de6a3f0fee288c177b8ca55442a2cdff0c8201eb3", size = 1836591, upload-time = "2025-10-17T14:01:32.28Z" },- { url = "https://files.pythonhosted.org/packages/fb/34/8ab5904b3331c91a58507234a1e2f662f837e193741609ee5832eb436251/aiohttp-3.13.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8619dca57d98a8353abdc7a1eeb415548952b39d6676def70d9ce76d41a046a9", size = 1714915, upload-time = "2025-10-17T14:01:35.138Z" },- { url = "https://files.pythonhosted.org/packages/b5/d3/d36077ca5f447649112189074ac6c192a666bf68165b693e48c23b0d008c/aiohttp-3.13.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:97795a0cb0a5f8a843759620e9cbd8889f8079551f5dcf1ccd99ed2f056d9632", size = 1546579, upload-time = "2025-10-17T14:01:38.237Z" },- { url = "https://files.pythonhosted.org/packages/a8/14/dbc426a1bb1305c4fc78ce69323498c9e7c699983366ef676aa5d3f949fa/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1060e058da8f9f28a7026cdfca9fc886e45e551a658f6a5c631188f72a3736d2", size = 1680633, upload-time = "2025-10-17T14:01:40.902Z" },- { url = "https://files.pythonhosted.org/packages/29/83/1e68e519aff9f3ef6d4acb6cdda7b5f592ef5c67c8f095dc0d8e06ce1c3e/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f48a2c26333659101ef214907d29a76fe22ad7e912aa1e40aeffdff5e8180977", size = 1678675, upload-time = "2025-10-17T14:01:43.779Z" },- { url = "https://files.pythonhosted.org/packages/38/b9/7f3e32a81c08b6d29ea15060c377e1f038ad96cd9923a85f30e817afff22/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f1dfad638b9c91ff225162b2824db0e99ae2d1abe0dc7272b5919701f0a1e685", size = 1726829, upload-time = "2025-10-17T14:01:46.546Z" },- { url = "https://files.pythonhosted.org/packages/23/ce/610b1f77525a0a46639aea91377b12348e9f9412cc5ddcb17502aa4681c7/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:8fa09ab6dd567cb105db4e8ac4d60f377a7a94f67cf669cac79982f626360f32", size = 1542985, upload-time = "2025-10-17T14:01:49.082Z" },- { url = "https://files.pythonhosted.org/packages/53/39/3ac8dfdad5de38c401846fa071fcd24cb3b88ccfb024854df6cbd9b4a07e/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4159fae827f9b5f655538a4f99b7cbc3a2187e5ca2eee82f876ef1da802ccfa9", size = 1741556, upload-time = "2025-10-17T14:01:51.846Z" },- { url = "https://files.pythonhosted.org/packages/2a/48/b1948b74fea7930b0f29595d1956842324336de200593d49a51a40607fdc/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ad671118c19e9cfafe81a7a05c294449fe0ebb0d0c6d5bb445cd2190023f5cef", size = 1696175, upload-time = "2025-10-17T14:01:54.232Z" },- { url = "https://files.pythonhosted.org/packages/96/26/063bba38e4b27b640f56cc89fe83cc3546a7ae162c2e30ca345f0ccdc3d1/aiohttp-3.13.1-cp314-cp314-win32.whl", hash = "sha256:c5c970c148c48cf6acb65224ca3c87a47f74436362dde75c27bc44155ccf7dfc", size = 430254, upload-time = "2025-10-17T14:01:56.451Z" },- { url = "https://files.pythonhosted.org/packages/88/aa/25fd764384dc4eab714023112d3548a8dd69a058840d61d816ea736097a2/aiohttp-3.13.1-cp314-cp314-win_amd64.whl", hash = "sha256:748a00167b7a88385756fa615417d24081cba7e58c8727d2e28817068b97c18c", size = 456256, upload-time = "2025-10-17T14:01:58.752Z" },- { url = "https://files.pythonhosted.org/packages/d4/9f/9ba6059de4bad25c71cd88e3da53f93e9618ea369cf875c9f924b1c167e2/aiohttp-3.13.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:390b73e99d7a1f0f658b3f626ba345b76382f3edc65f49d6385e326e777ed00e", size = 765956, upload-time = "2025-10-17T14:02:01.515Z" },- { url = "https://files.pythonhosted.org/packages/1f/30/b86da68b494447d3060f45c7ebb461347535dab4af9162a9267d9d86ca31/aiohttp-3.13.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:27e83abb330e687e019173d8fc1fd6a1cf471769624cf89b1bb49131198a810a", size = 503206, upload-time = "2025-10-17T14:02:03.818Z" },- { url = "https://files.pythonhosted.org/packages/c1/21/d27a506552843ff9eeb9fcc2d45f943b09eefdfdf205aab044f4f1f39f6a/aiohttp-3.13.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2b20eed07131adbf3e873e009c2869b16a579b236e9d4b2f211bf174d8bef44a", size = 507719, upload-time = "2025-10-17T14:02:05.947Z" },- { url = "https://files.pythonhosted.org/packages/58/23/4042230ec7e4edc7ba43d0342b5a3d2fe0222ca046933c4251a35aaf17f5/aiohttp-3.13.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:58fee9ef8477fd69e823b92cfd1f590ee388521b5ff8f97f3497e62ee0656212", size = 1862758, upload-time = "2025-10-17T14:02:08.469Z" },- { url = "https://files.pythonhosted.org/packages/df/88/525c45bea7cbb9f65df42cadb4ff69f6a0dbf95931b0ff7d1fdc40a1cb5f/aiohttp-3.13.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1f62608fcb7b3d034d5e9496bea52d94064b7b62b06edba82cd38191336bbeda", size = 1717790, upload-time = "2025-10-17T14:02:11.37Z" },- { url = "https://files.pythonhosted.org/packages/1d/80/21e9b5eb77df352a5788713f37359b570a793f0473f3a72db2e46df379b9/aiohttp-3.13.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fdc4d81c3dfc999437f23e36d197e8b557a3f779625cd13efe563a9cfc2ce712", size = 1842088, upload-time = "2025-10-17T14:02:13.872Z" },- { url = "https://files.pythonhosted.org/packages/d2/bf/d1738f6d63fe8b2a0ad49533911b3347f4953cd001bf3223cb7b61f18dff/aiohttp-3.13.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:601d7ec812f746fd80ff8af38eeb3f196e1bab4a4d39816ccbc94c222d23f1d0", size = 1934292, upload-time = "2025-10-17T14:02:16.624Z" },- { url = "https://files.pythonhosted.org/packages/04/e6/26cab509b42610ca49573f2fc2867810f72bd6a2070182256c31b14f2e98/aiohttp-3.13.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47c3f21c469b840d9609089435c0d9918ae89f41289bf7cc4afe5ff7af5458db", size = 1791328, upload-time = "2025-10-17T14:02:19.051Z" },- { url = "https://files.pythonhosted.org/packages/8a/6d/baf7b462852475c9d045bee8418d9cdf280efb687752b553e82d0c58bcc2/aiohttp-3.13.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d6c6cdc0750db88520332d4aaa352221732b0cafe89fd0e42feec7cb1b5dc236", size = 1622663, upload-time = "2025-10-17T14:02:21.397Z" },- { url = "https://files.pythonhosted.org/packages/c8/48/396a97318af9b5f4ca8b3dc14a67976f71c6400a9609c622f96da341453f/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:58a12299eeb1fca2414ee2bc345ac69b0f765c20b82c3ab2a75d91310d95a9f6", size = 1787791, upload-time = "2025-10-17T14:02:24.212Z" },- { url = "https://files.pythonhosted.org/packages/a8/e2/6925f6784134ce3ff3ce1a8502ab366432a3b5605387618c1a939ce778d9/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:0989cbfc195a4de1bb48f08454ef1cb47424b937e53ed069d08404b9d3c7aea1", size = 1775459, upload-time = "2025-10-17T14:02:26.971Z" },- { url = "https://files.pythonhosted.org/packages/c3/e3/b372047ba739fc39f199b99290c4cc5578ce5fd125f69168c967dac44021/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:feb5ee664300e2435e0d1bc3443a98925013dfaf2cae9699c1f3606b88544898", size = 1789250, upload-time = "2025-10-17T14:02:29.686Z" },- { url = "https://files.pythonhosted.org/packages/02/8c/9f48b93d7d57fc9ef2ad4adace62e4663ea1ce1753806c4872fb36b54c39/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:58a6f8702da0c3606fb5cf2e669cce0ca681d072fe830968673bb4c69eb89e88", size = 1616139, upload-time = "2025-10-17T14:02:32.151Z" },- { url = "https://files.pythonhosted.org/packages/5c/c6/c64e39d61aaa33d7de1be5206c0af3ead4b369bf975dac9fdf907a4291c1/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a417ceb433b9d280e2368ffea22d4bc6e3e0d894c4bc7768915124d57d0964b6", size = 1815829, upload-time = "2025-10-17T14:02:34.635Z" },- { url = "https://files.pythonhosted.org/packages/22/75/e19e93965ea675f1151753b409af97a14f1d888588a555e53af1e62b83eb/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8ac8854f7b0466c5d6a9ea49249b3f6176013859ac8f4bb2522ad8ed6b94ded2", size = 1760923, upload-time = "2025-10-17T14:02:37.364Z" },- { url = "https://files.pythonhosted.org/packages/6c/a4/06ed38f1dabd98ea136fd116cba1d02c9b51af5a37d513b6850a9a567d86/aiohttp-3.13.1-cp314-cp314t-win32.whl", hash = "sha256:be697a5aeff42179ed13b332a411e674994bcd406c81642d014ace90bf4bb968", size = 463318, upload-time = "2025-10-17T14:02:39.924Z" },- { url = "https://files.pythonhosted.org/packages/04/0f/27e4fdde899e1e90e35eeff56b54ed63826435ad6cdb06b09ed312d1b3fa/aiohttp-3.13.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f1d6aa90546a4e8f20c3500cb68ab14679cd91f927fa52970035fd3207dfb3da", size = 496721, upload-time = "2025-10-17T14:02:42.199Z" },+sdist = { url = "https://files.pythonhosted.org/packages/1c/ce/3b83ebba6b3207a7135e5fcaba49706f8a4b6008153b4e30540c982fae26/aiohttp-3.13.2.tar.gz", hash = "sha256:40176a52c186aefef6eb3cad2cdd30cd06e3afbe88fe8ab2af9c0b90f228daca", size = 7837994, upload-time = "2025-10-28T20:59:39.937Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/6d/34/939730e66b716b76046dedfe0842995842fa906ccc4964bba414ff69e429/aiohttp-3.13.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2372b15a5f62ed37789a6b383ff7344fc5b9f243999b0cd9b629d8bc5f5b4155", size = 736471, upload-time = "2025-10-28T20:55:27.924Z" },+ { url = "https://files.pythonhosted.org/packages/fd/cf/dcbdf2df7f6ca72b0bb4c0b4509701f2d8942cf54e29ca197389c214c07f/aiohttp-3.13.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e7f8659a48995edee7229522984bd1009c1213929c769c2daa80b40fe49a180c", size = 493985, upload-time = "2025-10-28T20:55:29.456Z" },+ { url = "https://files.pythonhosted.org/packages/9d/87/71c8867e0a1d0882dcbc94af767784c3cb381c1c4db0943ab4aae4fed65e/aiohttp-3.13.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:939ced4a7add92296b0ad38892ce62b98c619288a081170695c6babe4f50e636", size = 489274, upload-time = "2025-10-28T20:55:31.134Z" },+ { url = "https://files.pythonhosted.org/packages/38/0f/46c24e8dae237295eaadd113edd56dee96ef6462adf19b88592d44891dc5/aiohttp-3.13.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6315fb6977f1d0dd41a107c527fee2ed5ab0550b7d885bc15fee20ccb17891da", size = 1668171, upload-time = "2025-10-28T20:55:36.065Z" },+ { url = "https://files.pythonhosted.org/packages/eb/c6/4cdfb4440d0e28483681a48f69841fa5e39366347d66ef808cbdadddb20e/aiohttp-3.13.2-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6e7352512f763f760baaed2637055c49134fd1d35b37c2dedfac35bfe5cf8725", size = 1636036, upload-time = "2025-10-28T20:55:37.576Z" },+ { url = "https://files.pythonhosted.org/packages/84/37/8708cf678628216fb678ab327a4e1711c576d6673998f4f43e86e9ae90dd/aiohttp-3.13.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e09a0a06348a2dd73e7213353c90d709502d9786219f69b731f6caa0efeb46f5", size = 1727975, upload-time = "2025-10-28T20:55:39.457Z" },+ { url = "https://files.pythonhosted.org/packages/e6/2e/3ebfe12fdcb9b5f66e8a0a42dffcd7636844c8a018f261efb2419f68220b/aiohttp-3.13.2-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a09a6d073fb5789456545bdee2474d14395792faa0527887f2f4ec1a486a59d3", size = 1815823, upload-time = "2025-10-28T20:55:40.958Z" },+ { url = "https://files.pythonhosted.org/packages/a1/4f/ca2ef819488cbb41844c6cf92ca6dd15b9441e6207c58e5ae0e0fc8d70ad/aiohttp-3.13.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b59d13c443f8e049d9e94099c7e412e34610f1f49be0f230ec656a10692a5802", size = 1669374, upload-time = "2025-10-28T20:55:42.745Z" },+ { url = "https://files.pythonhosted.org/packages/f8/fe/1fe2e1179a0d91ce09c99069684aab619bf2ccde9b20bd6ca44f8837203e/aiohttp-3.13.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:20db2d67985d71ca033443a1ba2001c4b5693fe09b0e29f6d9358a99d4d62a8a", size = 1555315, upload-time = "2025-10-28T20:55:44.264Z" },+ { url = "https://files.pythonhosted.org/packages/5a/2b/f3781899b81c45d7cbc7140cddb8a3481c195e7cbff8e36374759d2ab5a5/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:960c2fc686ba27b535f9fd2b52d87ecd7e4fd1cf877f6a5cba8afb5b4a8bd204", size = 1639140, upload-time = "2025-10-28T20:55:46.626Z" },+ { url = "https://files.pythonhosted.org/packages/72/27/c37e85cd3ece6f6c772e549bd5a253d0c122557b25855fb274224811e4f2/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:6c00dbcf5f0d88796151e264a8eab23de2997c9303dd7c0bf622e23b24d3ce22", size = 1645496, upload-time = "2025-10-28T20:55:48.933Z" },+ { url = "https://files.pythonhosted.org/packages/66/20/3af1ab663151bd3780b123e907761cdb86ec2c4e44b2d9b195ebc91fbe37/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fed38a5edb7945f4d1bcabe2fcd05db4f6ec7e0e82560088b754f7e08d93772d", size = 1697625, upload-time = "2025-10-28T20:55:50.377Z" },+ { url = "https://files.pythonhosted.org/packages/95/eb/ae5cab15efa365e13d56b31b0d085a62600298bf398a7986f8388f73b598/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:b395bbca716c38bef3c764f187860e88c724b342c26275bc03e906142fc5964f", size = 1542025, upload-time = "2025-10-28T20:55:51.861Z" },+ { url = "https://files.pythonhosted.org/packages/e9/2d/1683e8d67ec72d911397fe4e575688d2a9b8f6a6e03c8fdc9f3fd3d4c03f/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:204ffff2426c25dfda401ba08da85f9c59525cdc42bda26660463dd1cbcfec6f", size = 1714918, upload-time = "2025-10-28T20:55:53.515Z" },+ { url = "https://files.pythonhosted.org/packages/99/a2/ffe8e0e1c57c5e542d47ffa1fcf95ef2b3ea573bf7c4d2ee877252431efc/aiohttp-3.13.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:05c4dd3c48fb5f15db31f57eb35374cb0c09afdde532e7fb70a75aede0ed30f6", size = 1656113, upload-time = "2025-10-28T20:55:55.438Z" },+ { url = "https://files.pythonhosted.org/packages/0d/42/d511aff5c3a2b06c09d7d214f508a4ad8ac7799817f7c3d23e7336b5e896/aiohttp-3.13.2-cp310-cp310-win32.whl", hash = "sha256:e574a7d61cf10351d734bcddabbe15ede0eaa8a02070d85446875dc11189a251", size = 432290, upload-time = "2025-10-28T20:55:56.96Z" },+ { url = "https://files.pythonhosted.org/packages/8b/ea/1c2eb7098b5bad4532994f2b7a8228d27674035c9b3234fe02c37469ef14/aiohttp-3.13.2-cp310-cp310-win_amd64.whl", hash = "sha256:364f55663085d658b8462a1c3f17b2b84a5c2e1ba858e1b79bff7b2e24ad1514", size = 455075, upload-time = "2025-10-28T20:55:58.373Z" },+ { url = "https://files.pythonhosted.org/packages/35/74/b321e7d7ca762638cdf8cdeceb39755d9c745aff7a64c8789be96ddf6e96/aiohttp-3.13.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4647d02df098f6434bafd7f32ad14942f05a9caa06c7016fdcc816f343997dd0", size = 743409, upload-time = "2025-10-28T20:56:00.354Z" },+ { url = "https://files.pythonhosted.org/packages/99/3d/91524b905ec473beaf35158d17f82ef5a38033e5809fe8742e3657cdbb97/aiohttp-3.13.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e3403f24bcb9c3b29113611c3c16a2a447c3953ecf86b79775e7be06f7ae7ccb", size = 497006, upload-time = "2025-10-28T20:56:01.85Z" },+ { url = "https://files.pythonhosted.org/packages/eb/d3/7f68bc02a67716fe80f063e19adbd80a642e30682ce74071269e17d2dba1/aiohttp-3.13.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:43dff14e35aba17e3d6d5ba628858fb8cb51e30f44724a2d2f0c75be492c55e9", size = 493195, upload-time = "2025-10-28T20:56:03.314Z" },+ { url = "https://files.pythonhosted.org/packages/98/31/913f774a4708775433b7375c4f867d58ba58ead833af96c8af3621a0d243/aiohttp-3.13.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e2a9ea08e8c58bb17655630198833109227dea914cd20be660f52215f6de5613", size = 1747759, upload-time = "2025-10-28T20:56:04.904Z" },+ { url = "https://files.pythonhosted.org/packages/e8/63/04efe156f4326f31c7c4a97144f82132c3bb21859b7bb84748d452ccc17c/aiohttp-3.13.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53b07472f235eb80e826ad038c9d106c2f653584753f3ddab907c83f49eedead", size = 1704456, upload-time = "2025-10-28T20:56:06.986Z" },+ { url = "https://files.pythonhosted.org/packages/8e/02/4e16154d8e0a9cf4ae76f692941fd52543bbb148f02f098ca73cab9b1c1b/aiohttp-3.13.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e736c93e9c274fce6419af4aac199984d866e55f8a4cec9114671d0ea9688780", size = 1807572, upload-time = "2025-10-28T20:56:08.558Z" },+ { url = "https://files.pythonhosted.org/packages/34/58/b0583defb38689e7f06798f0285b1ffb3a6fb371f38363ce5fd772112724/aiohttp-3.13.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ff5e771f5dcbc81c64898c597a434f7682f2259e0cd666932a913d53d1341d1a", size = 1895954, upload-time = "2025-10-28T20:56:10.545Z" },+ { url = "https://files.pythonhosted.org/packages/6b/f3/083907ee3437425b4e376aa58b2c915eb1a33703ec0dc30040f7ae3368c6/aiohttp-3.13.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3b6fb0c207cc661fa0bf8c66d8d9b657331ccc814f4719468af61034b478592", size = 1747092, upload-time = "2025-10-28T20:56:12.118Z" },+ { url = "https://files.pythonhosted.org/packages/ac/61/98a47319b4e425cc134e05e5f3fc512bf9a04bf65aafd9fdcda5d57ec693/aiohttp-3.13.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:97a0895a8e840ab3520e2288db7cace3a1981300d48babeb50e7425609e2e0ab", size = 1606815, upload-time = "2025-10-28T20:56:14.191Z" },+ { url = "https://files.pythonhosted.org/packages/97/4b/e78b854d82f66bb974189135d31fce265dee0f5344f64dd0d345158a5973/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9e8f8afb552297aca127c90cb840e9a1d4bfd6a10d7d8f2d9176e1acc69bad30", size = 1723789, upload-time = "2025-10-28T20:56:16.101Z" },+ { url = "https://files.pythonhosted.org/packages/ed/fc/9d2ccc794fc9b9acd1379d625c3a8c64a45508b5091c546dea273a41929e/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ed2f9c7216e53c3df02264f25d824b079cc5914f9e2deba94155190ef648ee40", size = 1718104, upload-time = "2025-10-28T20:56:17.655Z" },+ { url = "https://files.pythonhosted.org/packages/66/65/34564b8765ea5c7d79d23c9113135d1dd3609173da13084830f1507d56cf/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:99c5280a329d5fa18ef30fd10c793a190d996567667908bef8a7f81f8202b948", size = 1785584, upload-time = "2025-10-28T20:56:19.238Z" },+ { url = "https://files.pythonhosted.org/packages/30/be/f6a7a426e02fc82781afd62016417b3948e2207426d90a0e478790d1c8a4/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:2ca6ffef405fc9c09a746cb5d019c1672cd7f402542e379afc66b370833170cf", size = 1595126, upload-time = "2025-10-28T20:56:20.836Z" },+ { url = "https://files.pythonhosted.org/packages/e5/c7/8e22d5d28f94f67d2af496f14a83b3c155d915d1fe53d94b66d425ec5b42/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:47f438b1a28e926c37632bff3c44df7d27c9b57aaf4e34b1def3c07111fdb782", size = 1800665, upload-time = "2025-10-28T20:56:22.922Z" },+ { url = "https://files.pythonhosted.org/packages/d1/11/91133c8b68b1da9fc16555706aa7276fdf781ae2bb0876c838dd86b8116e/aiohttp-3.13.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9acda8604a57bb60544e4646a4615c1866ee6c04a8edef9b8ee6fd1d8fa2ddc8", size = 1739532, upload-time = "2025-10-28T20:56:25.924Z" },+ { url = "https://files.pythonhosted.org/packages/17/6b/3747644d26a998774b21a616016620293ddefa4d63af6286f389aedac844/aiohttp-3.13.2-cp311-cp311-win32.whl", hash = "sha256:868e195e39b24aaa930b063c08bb0c17924899c16c672a28a65afded9c46c6ec", size = 431876, upload-time = "2025-10-28T20:56:27.524Z" },+ { url = "https://files.pythonhosted.org/packages/c3/63/688462108c1a00eb9f05765331c107f95ae86f6b197b865d29e930b7e462/aiohttp-3.13.2-cp311-cp311-win_amd64.whl", hash = "sha256:7fd19df530c292542636c2a9a85854fab93474396a52f1695e799186bbd7f24c", size = 456205, upload-time = "2025-10-28T20:56:29.062Z" },+ { url = "https://files.pythonhosted.org/packages/29/9b/01f00e9856d0a73260e86dd8ed0c2234a466c5c1712ce1c281548df39777/aiohttp-3.13.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b1e56bab2e12b2b9ed300218c351ee2a3d8c8fdab5b1ec6193e11a817767e47b", size = 737623, upload-time = "2025-10-28T20:56:30.797Z" },+ { url = "https://files.pythonhosted.org/packages/5a/1b/4be39c445e2b2bd0aab4ba736deb649fabf14f6757f405f0c9685019b9e9/aiohttp-3.13.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:364e25edaabd3d37b1db1f0cbcee8c73c9a3727bfa262b83e5e4cf3489a2a9dc", size = 492664, upload-time = "2025-10-28T20:56:32.708Z" },+ { url = "https://files.pythonhosted.org/packages/28/66/d35dcfea8050e131cdd731dff36434390479b4045a8d0b9d7111b0a968f1/aiohttp-3.13.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c5c94825f744694c4b8db20b71dba9a257cd2ba8e010a803042123f3a25d50d7", size = 491808, upload-time = "2025-10-28T20:56:34.57Z" },+ { url = "https://files.pythonhosted.org/packages/00/29/8e4609b93e10a853b65f8291e64985de66d4f5848c5637cddc70e98f01f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba2715d842ffa787be87cbfce150d5e88c87a98e0b62e0f5aa489169a393dbbb", size = 1738863, upload-time = "2025-10-28T20:56:36.377Z" },+ { url = "https://files.pythonhosted.org/packages/9d/fa/4ebdf4adcc0def75ced1a0d2d227577cd7b1b85beb7edad85fcc87693c75/aiohttp-3.13.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:585542825c4bc662221fb257889e011a5aa00f1ae4d75d1d246a5225289183e3", size = 1700586, upload-time = "2025-10-28T20:56:38.034Z" },+ { url = "https://files.pythonhosted.org/packages/da/04/73f5f02ff348a3558763ff6abe99c223381b0bace05cd4530a0258e52597/aiohttp-3.13.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:39d02cb6025fe1aabca329c5632f48c9532a3dabccd859e7e2f110668972331f", size = 1768625, upload-time = "2025-10-28T20:56:39.75Z" },+ { url = "https://files.pythonhosted.org/packages/f8/49/a825b79ffec124317265ca7d2344a86bcffeb960743487cb11988ffb3494/aiohttp-3.13.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e67446b19e014d37342f7195f592a2a948141d15a312fe0e700c2fd2f03124f6", size = 1867281, upload-time = "2025-10-28T20:56:41.471Z" },+ { url = "https://files.pythonhosted.org/packages/b9/48/adf56e05f81eac31edcfae45c90928f4ad50ef2e3ea72cb8376162a368f8/aiohttp-3.13.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4356474ad6333e41ccefd39eae869ba15a6c5299c9c01dfdcfdd5c107be4363e", size = 1752431, upload-time = "2025-10-28T20:56:43.162Z" },+ { url = "https://files.pythonhosted.org/packages/30/ab/593855356eead019a74e862f21523db09c27f12fd24af72dbc3555b9bfd9/aiohttp-3.13.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eeacf451c99b4525f700f078becff32c32ec327b10dcf31306a8a52d78166de7", size = 1562846, upload-time = "2025-10-28T20:56:44.85Z" },+ { url = "https://files.pythonhosted.org/packages/39/0f/9f3d32271aa8dc35036e9668e31870a9d3b9542dd6b3e2c8a30931cb27ae/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8a9b889aeabd7a4e9af0b7f4ab5ad94d42e7ff679aaec6d0db21e3b639ad58d", size = 1699606, upload-time = "2025-10-28T20:56:46.519Z" },+ { url = "https://files.pythonhosted.org/packages/2c/3c/52d2658c5699b6ef7692a3f7128b2d2d4d9775f2a68093f74bca06cf01e1/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:fa89cb11bc71a63b69568d5b8a25c3ca25b6d54c15f907ca1c130d72f320b76b", size = 1720663, upload-time = "2025-10-28T20:56:48.528Z" },+ { url = "https://files.pythonhosted.org/packages/9b/d4/8f8f3ff1fb7fb9e3f04fcad4e89d8a1cd8fc7d05de67e3de5b15b33008ff/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8aa7c807df234f693fed0ecd507192fc97692e61fee5702cdc11155d2e5cadc8", size = 1737939, upload-time = "2025-10-28T20:56:50.77Z" },+ { url = "https://files.pythonhosted.org/packages/03/d3/ddd348f8a27a634daae39a1b8e291ff19c77867af438af844bf8b7e3231b/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9eb3e33fdbe43f88c3c75fa608c25e7c47bbd80f48d012763cb67c47f39a7e16", size = 1555132, upload-time = "2025-10-28T20:56:52.568Z" },+ { url = "https://files.pythonhosted.org/packages/39/b8/46790692dc46218406f94374903ba47552f2f9f90dad554eed61bfb7b64c/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9434bc0d80076138ea986833156c5a48c9c7a8abb0c96039ddbb4afc93184169", size = 1764802, upload-time = "2025-10-28T20:56:54.292Z" },+ { url = "https://files.pythonhosted.org/packages/ba/e4/19ce547b58ab2a385e5f0b8aa3db38674785085abcf79b6e0edd1632b12f/aiohttp-3.13.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ff15c147b2ad66da1f2cbb0622313f2242d8e6e8f9b79b5206c84523a4473248", size = 1719512, upload-time = "2025-10-28T20:56:56.428Z" },+ { url = "https://files.pythonhosted.org/packages/70/30/6355a737fed29dcb6dfdd48682d5790cb5eab050f7b4e01f49b121d3acad/aiohttp-3.13.2-cp312-cp312-win32.whl", hash = "sha256:27e569eb9d9e95dbd55c0fc3ec3a9335defbf1d8bc1d20171a49f3c4c607b93e", size = 426690, upload-time = "2025-10-28T20:56:58.736Z" },+ { url = "https://files.pythonhosted.org/packages/0a/0d/b10ac09069973d112de6ef980c1f6bb31cb7dcd0bc363acbdad58f927873/aiohttp-3.13.2-cp312-cp312-win_amd64.whl", hash = "sha256:8709a0f05d59a71f33fd05c17fc11fcb8c30140506e13c2f5e8ee1b8964e1b45", size = 453465, upload-time = "2025-10-28T20:57:00.795Z" },+ { url = "https://files.pythonhosted.org/packages/bf/78/7e90ca79e5aa39f9694dcfd74f4720782d3c6828113bb1f3197f7e7c4a56/aiohttp-3.13.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7519bdc7dfc1940d201651b52bf5e03f5503bda45ad6eacf64dda98be5b2b6be", size = 732139, upload-time = "2025-10-28T20:57:02.455Z" },+ { url = "https://files.pythonhosted.org/packages/db/ed/1f59215ab6853fbaa5c8495fa6cbc39edfc93553426152b75d82a5f32b76/aiohttp-3.13.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:088912a78b4d4f547a1f19c099d5a506df17eacec3c6f4375e2831ec1d995742", size = 490082, upload-time = "2025-10-28T20:57:04.784Z" },+ { url = "https://files.pythonhosted.org/packages/68/7b/fe0fe0f5e05e13629d893c760465173a15ad0039c0a5b0d0040995c8075e/aiohttp-3.13.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5276807b9de9092af38ed23ce120539ab0ac955547b38563a9ba4f5b07b95293", size = 489035, upload-time = "2025-10-28T20:57:06.894Z" },+ { url = "https://files.pythonhosted.org/packages/d2/04/db5279e38471b7ac801d7d36a57d1230feeee130bbe2a74f72731b23c2b1/aiohttp-3.13.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1237c1375eaef0db4dcd7c2559f42e8af7b87ea7d295b118c60c36a6e61cb811", size = 1720387, upload-time = "2025-10-28T20:57:08.685Z" },+ { url = "https://files.pythonhosted.org/packages/31/07/8ea4326bd7dae2bd59828f69d7fdc6e04523caa55e4a70f4a8725a7e4ed2/aiohttp-3.13.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:96581619c57419c3d7d78703d5b78c1e5e5fc0172d60f555bdebaced82ded19a", size = 1688314, upload-time = "2025-10-28T20:57:10.693Z" },+ { url = "https://files.pythonhosted.org/packages/48/ab/3d98007b5b87ffd519d065225438cc3b668b2f245572a8cb53da5dd2b1bc/aiohttp-3.13.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a2713a95b47374169409d18103366de1050fe0ea73db358fc7a7acb2880422d4", size = 1756317, upload-time = "2025-10-28T20:57:12.563Z" },+ { url = "https://files.pythonhosted.org/packages/97/3d/801ca172b3d857fafb7b50c7c03f91b72b867a13abca982ed6b3081774ef/aiohttp-3.13.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:228a1cd556b3caca590e9511a89444925da87d35219a49ab5da0c36d2d943a6a", size = 1858539, upload-time = "2025-10-28T20:57:14.623Z" },+ { url = "https://files.pythonhosted.org/packages/f7/0d/4764669bdf47bd472899b3d3db91fffbe925c8e3038ec591a2fd2ad6a14d/aiohttp-3.13.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ac6cde5fba8d7d8c6ac963dbb0256a9854e9fafff52fbcc58fdf819357892c3e", size = 1739597, upload-time = "2025-10-28T20:57:16.399Z" },+ { url = "https://files.pythonhosted.org/packages/c4/52/7bd3c6693da58ba16e657eb904a5b6decfc48ecd06e9ac098591653b1566/aiohttp-3.13.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2bef8237544f4e42878c61cef4e2839fee6346dc60f5739f876a9c50be7fcdb", size = 1555006, upload-time = "2025-10-28T20:57:18.288Z" },+ { url = "https://files.pythonhosted.org/packages/48/30/9586667acec5993b6f41d2ebcf96e97a1255a85f62f3c653110a5de4d346/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:16f15a4eac3bc2d76c45f7ebdd48a65d41b242eb6c31c2245463b40b34584ded", size = 1683220, upload-time = "2025-10-28T20:57:20.241Z" },+ { url = "https://files.pythonhosted.org/packages/71/01/3afe4c96854cfd7b30d78333852e8e851dceaec1c40fd00fec90c6402dd2/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:bb7fb776645af5cc58ab804c58d7eba545a97e047254a52ce89c157b5af6cd0b", size = 1712570, upload-time = "2025-10-28T20:57:22.253Z" },+ { url = "https://files.pythonhosted.org/packages/11/2c/22799d8e720f4697a9e66fd9c02479e40a49de3de2f0bbe7f9f78a987808/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e1b4951125ec10c70802f2cb09736c895861cd39fd9dcb35107b4dc8ae6220b8", size = 1733407, upload-time = "2025-10-28T20:57:24.37Z" },+ { url = "https://files.pythonhosted.org/packages/34/cb/90f15dd029f07cebbd91f8238a8b363978b530cd128488085b5703683594/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:550bf765101ae721ee1d37d8095f47b1f220650f85fe1af37a90ce75bab89d04", size = 1550093, upload-time = "2025-10-28T20:57:26.257Z" },+ { url = "https://files.pythonhosted.org/packages/69/46/12dce9be9d3303ecbf4d30ad45a7683dc63d90733c2d9fe512be6716cd40/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fe91b87fc295973096251e2d25a811388e7d8adf3bd2b97ef6ae78bc4ac6c476", size = 1758084, upload-time = "2025-10-28T20:57:28.349Z" },+ { url = "https://files.pythonhosted.org/packages/f9/c8/0932b558da0c302ffd639fc6362a313b98fdf235dc417bc2493da8394df7/aiohttp-3.13.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0c8e31cfcc4592cb200160344b2fb6ae0f9e4effe06c644b5a125d4ae5ebe23", size = 1716987, upload-time = "2025-10-28T20:57:30.233Z" },+ { url = "https://files.pythonhosted.org/packages/5d/8b/f5bd1a75003daed099baec373aed678f2e9b34f2ad40d85baa1368556396/aiohttp-3.13.2-cp313-cp313-win32.whl", hash = "sha256:0740f31a60848d6edb296a0df827473eede90c689b8f9f2a4cdde74889eb2254", size = 425859, upload-time = "2025-10-28T20:57:32.105Z" },+ { url = "https://files.pythonhosted.org/packages/5d/28/a8a9fc6957b2cee8902414e41816b5ab5536ecf43c3b1843c10e82c559b2/aiohttp-3.13.2-cp313-cp313-win_amd64.whl", hash = "sha256:a88d13e7ca367394908f8a276b89d04a3652044612b9a408a0bb22a5ed976a1a", size = 452192, upload-time = "2025-10-28T20:57:34.166Z" },+ { url = "https://files.pythonhosted.org/packages/9b/36/e2abae1bd815f01c957cbf7be817b3043304e1c87bad526292a0410fdcf9/aiohttp-3.13.2-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2475391c29230e063ef53a66669b7b691c9bfc3f1426a0f7bcdf1216bdbac38b", size = 735234, upload-time = "2025-10-28T20:57:36.415Z" },+ { url = "https://files.pythonhosted.org/packages/ca/e3/1ee62dde9b335e4ed41db6bba02613295a0d5b41f74a783c142745a12763/aiohttp-3.13.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:f33c8748abef4d8717bb20e8fb1b3e07c6adacb7fd6beaae971a764cf5f30d61", size = 490733, upload-time = "2025-10-28T20:57:38.205Z" },+ { url = "https://files.pythonhosted.org/packages/1a/aa/7a451b1d6a04e8d15a362af3e9b897de71d86feac3babf8894545d08d537/aiohttp-3.13.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ae32f24bbfb7dbb485a24b30b1149e2f200be94777232aeadba3eecece4d0aa4", size = 491303, upload-time = "2025-10-28T20:57:40.122Z" },+ { url = "https://files.pythonhosted.org/packages/57/1e/209958dbb9b01174870f6a7538cd1f3f28274fdbc88a750c238e2c456295/aiohttp-3.13.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d7f02042c1f009ffb70067326ef183a047425bb2ff3bc434ead4dd4a4a66a2b", size = 1717965, upload-time = "2025-10-28T20:57:42.28Z" },+ { url = "https://files.pythonhosted.org/packages/08/aa/6a01848d6432f241416bc4866cae8dc03f05a5a884d2311280f6a09c73d6/aiohttp-3.13.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93655083005d71cd6c072cdab54c886e6570ad2c4592139c3fb967bfc19e4694", size = 1667221, upload-time = "2025-10-28T20:57:44.869Z" },+ { url = "https://files.pythonhosted.org/packages/87/4f/36c1992432d31bbc789fa0b93c768d2e9047ec8c7177e5cd84ea85155f36/aiohttp-3.13.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0db1e24b852f5f664cd728db140cf11ea0e82450471232a394b3d1a540b0f906", size = 1757178, upload-time = "2025-10-28T20:57:47.216Z" },+ { url = "https://files.pythonhosted.org/packages/ac/b4/8e940dfb03b7e0f68a82b88fd182b9be0a65cb3f35612fe38c038c3112cf/aiohttp-3.13.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b009194665bcd128e23eaddef362e745601afa4641930848af4c8559e88f18f9", size = 1838001, upload-time = "2025-10-28T20:57:49.337Z" },+ { url = "https://files.pythonhosted.org/packages/d7/ef/39f3448795499c440ab66084a9db7d20ca7662e94305f175a80f5b7e0072/aiohttp-3.13.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c038a8fdc8103cd51dbd986ecdce141473ffd9775a7a8057a6ed9c3653478011", size = 1716325, upload-time = "2025-10-28T20:57:51.327Z" },+ { url = "https://files.pythonhosted.org/packages/d7/51/b311500ffc860b181c05d91c59a1313bdd05c82960fdd4035a15740d431e/aiohttp-3.13.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66bac29b95a00db411cd758fea0e4b9bdba6d549dfe333f9a945430f5f2cc5a6", size = 1547978, upload-time = "2025-10-28T20:57:53.554Z" },+ { url = "https://files.pythonhosted.org/packages/31/64/b9d733296ef79815226dab8c586ff9e3df41c6aff2e16c06697b2d2e6775/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4ebf9cfc9ba24a74cf0718f04aac2a3bbe745902cc7c5ebc55c0f3b5777ef213", size = 1682042, upload-time = "2025-10-28T20:57:55.617Z" },+ { url = "https://files.pythonhosted.org/packages/3f/30/43d3e0f9d6473a6db7d472104c4eff4417b1e9df01774cb930338806d36b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a4b88ebe35ce54205c7074f7302bd08a4cb83256a3e0870c72d6f68a3aaf8e49", size = 1680085, upload-time = "2025-10-28T20:57:57.59Z" },+ { url = "https://files.pythonhosted.org/packages/16/51/c709f352c911b1864cfd1087577760ced64b3e5bee2aa88b8c0c8e2e4972/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:98c4fb90bb82b70a4ed79ca35f656f4281885be076f3f970ce315402b53099ae", size = 1728238, upload-time = "2025-10-28T20:57:59.525Z" },+ { url = "https://files.pythonhosted.org/packages/19/e2/19bd4c547092b773caeb48ff5ae4b1ae86756a0ee76c16727fcfd281404b/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:ec7534e63ae0f3759df3a1ed4fa6bc8f75082a924b590619c0dd2f76d7043caa", size = 1544395, upload-time = "2025-10-28T20:58:01.914Z" },+ { url = "https://files.pythonhosted.org/packages/cf/87/860f2803b27dfc5ed7be532832a3498e4919da61299b4a1f8eb89b8ff44d/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5b927cf9b935a13e33644cbed6c8c4b2d0f25b713d838743f8fe7191b33829c4", size = 1742965, upload-time = "2025-10-28T20:58:03.972Z" },+ { url = "https://files.pythonhosted.org/packages/67/7f/db2fc7618925e8c7a601094d5cbe539f732df4fb570740be88ed9e40e99a/aiohttp-3.13.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:88d6c017966a78c5265d996c19cdb79235be5e6412268d7e2ce7dee339471b7a", size = 1697585, upload-time = "2025-10-28T20:58:06.189Z" },+ { url = "https://files.pythonhosted.org/packages/0c/07/9127916cb09bb38284db5036036042b7b2c514c8ebaeee79da550c43a6d6/aiohttp-3.13.2-cp314-cp314-win32.whl", hash = "sha256:f7c183e786e299b5d6c49fb43a769f8eb8e04a2726a2bd5887b98b5cc2d67940", size = 431621, upload-time = "2025-10-28T20:58:08.636Z" },+ { url = "https://files.pythonhosted.org/packages/fb/41/554a8a380df6d3a2bba8a7726429a23f4ac62aaf38de43bb6d6cde7b4d4d/aiohttp-3.13.2-cp314-cp314-win_amd64.whl", hash = "sha256:fe242cd381e0fb65758faf5ad96c2e460df6ee5b2de1072fe97e4127927e00b4", size = 457627, upload-time = "2025-10-28T20:58:11Z" },+ { url = "https://files.pythonhosted.org/packages/c7/8e/3824ef98c039d3951cb65b9205a96dd2b20f22241ee17d89c5701557c826/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:f10d9c0b0188fe85398c61147bbd2a657d616c876863bfeff43376e0e3134673", size = 767360, upload-time = "2025-10-28T20:58:13.358Z" },+ { url = "https://files.pythonhosted.org/packages/a4/0f/6a03e3fc7595421274fa34122c973bde2d89344f8a881b728fa8c774e4f1/aiohttp-3.13.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e7c952aefdf2460f4ae55c5e9c3e80aa72f706a6317e06020f80e96253b1accd", size = 504616, upload-time = "2025-10-28T20:58:15.339Z" },+ { url = "https://files.pythonhosted.org/packages/c6/aa/ed341b670f1bc8a6f2c6a718353d13b9546e2cef3544f573c6a1ff0da711/aiohttp-3.13.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c20423ce14771d98353d2e25e83591fa75dfa90a3c1848f3d7c68243b4fbded3", size = 509131, upload-time = "2025-10-28T20:58:17.693Z" },+ { url = "https://files.pythonhosted.org/packages/7f/f0/c68dac234189dae5c4bbccc0f96ce0cc16b76632cfc3a08fff180045cfa4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e96eb1a34396e9430c19d8338d2ec33015e4a87ef2b4449db94c22412e25ccdf", size = 1864168, upload-time = "2025-10-28T20:58:20.113Z" },+ { url = "https://files.pythonhosted.org/packages/8f/65/75a9a76db8364b5d0e52a0c20eabc5d52297385d9af9c35335b924fafdee/aiohttp-3.13.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:23fb0783bc1a33640036465019d3bba069942616a6a2353c6907d7fe1ccdaf4e", size = 1719200, upload-time = "2025-10-28T20:58:22.583Z" },+ { url = "https://files.pythonhosted.org/packages/f5/55/8df2ed78d7f41d232f6bd3ff866b6f617026551aa1d07e2f03458f964575/aiohttp-3.13.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2e1a9bea6244a1d05a4e57c295d69e159a5c50d8ef16aa390948ee873478d9a5", size = 1843497, upload-time = "2025-10-28T20:58:24.672Z" },+ { url = "https://files.pythonhosted.org/packages/e9/e0/94d7215e405c5a02ccb6a35c7a3a6cfff242f457a00196496935f700cde5/aiohttp-3.13.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0a3d54e822688b56e9f6b5816fb3de3a3a64660efac64e4c2dc435230ad23bad", size = 1935703, upload-time = "2025-10-28T20:58:26.758Z" },+ { url = "https://files.pythonhosted.org/packages/0b/78/1eeb63c3f9b2d1015a4c02788fb543141aad0a03ae3f7a7b669b2483f8d4/aiohttp-3.13.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a653d872afe9f33497215745da7a943d1dc15b728a9c8da1c3ac423af35178e", size = 1792738, upload-time = "2025-10-28T20:58:29.787Z" },+ { url = "https://files.pythonhosted.org/packages/41/75/aaf1eea4c188e51538c04cc568040e3082db263a57086ea74a7d38c39e42/aiohttp-3.13.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:56d36e80d2003fa3fc0207fac644216d8532e9504a785ef9a8fd013f84a42c61", size = 1624061, upload-time = "2025-10-28T20:58:32.529Z" },+ { url = "https://files.pythonhosted.org/packages/9b/c2/3b6034de81fbcc43de8aeb209073a2286dfb50b86e927b4efd81cf848197/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:78cd586d8331fb8e241c2dd6b2f4061778cc69e150514b39a9e28dd050475661", size = 1789201, upload-time = "2025-10-28T20:58:34.618Z" },+ { url = "https://files.pythonhosted.org/packages/c9/38/c15dcf6d4d890217dae79d7213988f4e5fe6183d43893a9cf2fe9e84ca8d/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:20b10bbfbff766294fe99987f7bb3b74fdd2f1a2905f2562132641ad434dcf98", size = 1776868, upload-time = "2025-10-28T20:58:38.835Z" },+ { url = "https://files.pythonhosted.org/packages/04/75/f74fd178ac81adf4f283a74847807ade5150e48feda6aef024403716c30c/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9ec49dff7e2b3c85cdeaa412e9d438f0ecd71676fde61ec57027dd392f00c693", size = 1790660, upload-time = "2025-10-28T20:58:41.507Z" },+ { url = "https://files.pythonhosted.org/packages/e7/80/7368bd0d06b16b3aba358c16b919e9c46cf11587dc572091031b0e9e3ef0/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:94f05348c4406450f9d73d38efb41d669ad6cd90c7ee194810d0eefbfa875a7a", size = 1617548, upload-time = "2025-10-28T20:58:43.674Z" },+ { url = "https://files.pythonhosted.org/packages/7d/4b/a6212790c50483cb3212e507378fbe26b5086d73941e1ec4b56a30439688/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:fa4dcb605c6f82a80c7f95713c2b11c3b8e9893b3ebd2bc9bde93165ed6107be", size = 1817240, upload-time = "2025-10-28T20:58:45.787Z" },+ { url = "https://files.pythonhosted.org/packages/ff/f7/ba5f0ba4ea8d8f3c32850912944532b933acbf0f3a75546b89269b9b7dde/aiohttp-3.13.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cf00e5db968c3f67eccd2778574cf64d8b27d95b237770aa32400bd7a1ca4f6c", size = 1762334, upload-time = "2025-10-28T20:58:47.936Z" },+ { url = "https://files.pythonhosted.org/packages/7e/83/1a5a1856574588b1cad63609ea9ad75b32a8353ac995d830bf5da9357364/aiohttp-3.13.2-cp314-cp314t-win32.whl", hash = "sha256:d23b5fe492b0805a50d3371e8a728a9134d8de5447dce4c885f5587294750734", size = 464685, upload-time = "2025-10-28T20:58:50.642Z" },+ { url = "https://files.pythonhosted.org/packages/9f/4d/d22668674122c08f4d56972297c51a624e64b3ed1efaa40187607a7cb66e/aiohttp-3.13.2-cp314-cp314t-win_amd64.whl", hash = "sha256:ff0a7b0a82a7ab905cbda74006318d1b12e37c797eb1b0d4eb3e316cf47f658f", size = 498093, upload-time = "2025-10-28T20:58:52.782Z" },][[package]]@@ -214,7 +214,7 @@ wheels = [[[package]]name = "anthropic"-version = "0.71.0"+version = "0.72.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "anyio" },@@ -226,9 +226,9 @@ dependencies = [{ name = "sniffio" },{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/82/4f/70682b068d897841f43223df82d96ec1d617435a8b759c4a2d901a50158b/anthropic-0.71.0.tar.gz", hash = "sha256:eb8e6fa86d049061b3ef26eb4cbae0174ebbff21affa6de7b3098da857d8de6a", size = 489102, upload-time = "2025-10-16T15:54:40.08Z" }+sdist = { url = "https://files.pythonhosted.org/packages/49/07/61f3ca8e69c5dcdaec31b36b79a53ea21c5b4ca5e93c7df58c71f43bf8d8/anthropic-0.72.0.tar.gz", hash = "sha256:8971fe76dcffc644f74ac3883069beb1527641115ae0d6eb8fa21c1ce4082f7a", size = 493721, upload-time = "2025-10-28T19:13:01.755Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/5d/77/073e8ac488f335aec7001952825275582fb8f433737e90f24eeef9d878f6/anthropic-0.71.0-py3-none-any.whl", hash = "sha256:85c5015fcdbdc728390f11b17642a65a4365d03b12b799b18b6cc57e71fdb327", size = 355035, upload-time = "2025-10-16T15:54:38.238Z" },+ { url = "https://files.pythonhosted.org/packages/7b/b7/160d4fb30080395b4143f1d1a4f6c646ba9105561108d2a434b606c03579/anthropic-0.72.0-py3-none-any.whl", hash = "sha256:0e9f5a7582f038cab8efbb4c959e49ef654a56bfc7ba2da51b5a7b8a84de2e4d", size = 357464, upload-time = "2025-10-28T19:13:00.215Z" },][[package]]@@ -342,16 +342,16 @@ wheels = [[[package]]name = "boto3-stubs"-version = "1.40.60"+version = "1.40.61"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "botocore-stubs" },{ name = "types-s3transfer" },{ name = "typing-extensions", marker = "python_full_version < '3.12'" },]-sdist = { url = "https://files.pythonhosted.org/packages/39/23/342e5fbec4652316fd2ae55c49a0ea9166fadab3c0adb6e7d610613693ac/boto3_stubs-1.40.60.tar.gz", hash = "sha256:4fac3c882867ba6c8153b8853b43903e129f9e5a890b18e4bea9a88192e23ffd", size = 100986, upload-time = "2025-10-27T19:49:13.329Z" }+sdist = { url = "https://files.pythonhosted.org/packages/5f/d2/86697de17c884b95e4d2bb7691e08c32c463cef4ffaf6f6dd034b9f224d8/boto3_stubs-1.40.61.tar.gz", hash = "sha256:1837e1c29d79d7a8d096d60235cb89cff9f4142466d9ee310cc1f8562da340ee", size = 99653, upload-time = "2025-10-28T19:49:02.066Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/83/8a/d14e63701c4e869f1d37ba5657f9821961616b98a30074f20b559c071fb6/boto3_stubs-1.40.60-py3-none-any.whl", hash = "sha256:1ea7f9dbabc7f9ac8477646c12cc51ef49af6b24d53cc2ae8cf6fa6bed6a995a", size = 69746, upload-time = "2025-10-27T19:49:05.619Z" },+ { url = "https://files.pythonhosted.org/packages/ac/2b/93170eca862678017bf117cd087576a14af3102477ecfc685ae30bff1460/boto3_stubs-1.40.61-py3-none-any.whl", hash = "sha256:fd6e73f15b8688c2d3dc1d19c139dd8c853cbcd33c306f7649e7f1c06bf70118", size = 69068, upload-time = "2025-10-28T19:48:51.889Z" },][[package]]@@ -370,14 +370,14 @@ wheels = [[[package]]name = "botocore-stubs"-version = "1.40.60"+version = "1.40.61"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "types-awscrt" },]-sdist = { url = "https://files.pythonhosted.org/packages/ac/e9/b9ca290cc0dca5a641512427e9bc057bbee175aa7f0ba069ad2f3aff3d15/botocore_stubs-1.40.60.tar.gz", hash = "sha256:5394af28f43eaf5c598a7b440b0d4ef5026fe9096f81cb509075ee92de5b645a", size = 42226, upload-time = "2025-10-27T20:26:07.199Z" }+sdist = { url = "https://files.pythonhosted.org/packages/28/b0/ad2eafc5736b6f32de0a7d49e42b6940f1ff69e179d199cdcafbe119a414/botocore_stubs-1.40.61.tar.gz", hash = "sha256:c208d9066613d6990cca3eb6dd3a2fcbef1ef02368e5df6701c5e35735527fe4", size = 42238, upload-time = "2025-10-28T20:28:55.933Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/3e/66/629958de671fa14f804bc45ff41a585c9c709869808074496ac37df25d79/botocore_stubs-1.40.60-py3-none-any.whl", hash = "sha256:399e3004e5e496500fe4e8c2ed677211b40c1d23f2304368eb1282100b1b2a58", size = 66541, upload-time = "2025-10-27T20:26:04.351Z" },+ { url = "https://files.pythonhosted.org/packages/cd/b5/3429fd3ea14d9bd0236e5bcc036cf7a51900fe1c46f34642e5316366f0c2/botocore_stubs-1.40.61-py3-none-any.whl", hash = "sha256:71cbdbc3b277bfeb2c98e2c65c985ad42f18ad33a54a53d524a396482a86092a", size = 66542, upload-time = "2025-10-28T20:28:53.751Z" },][[package]]@@ -847,16 +847,16 @@ wheels = [[[package]]name = "google-auth"-version = "2.41.1"+version = "2.42.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "cachetools" },{ name = "pyasn1-modules" },{ name = "rsa" },]-sdist = { url = "https://files.pythonhosted.org/packages/a8/af/5129ce5b2f9688d2fa49b463e544972a7c82b0fdb50980dafee92e121d9f/google_auth-2.41.1.tar.gz", hash = "sha256:b76b7b1f9e61f0cb7e88870d14f6a94aeef248959ef6992670efee37709cbfd2", size = 292284, upload-time = "2025-09-30T22:51:26.363Z" }+sdist = { url = "https://files.pythonhosted.org/packages/11/75/28881e9d7de9b3d61939bc9624bd8fa594eb787a00567aba87173c790f09/google_auth-2.42.0.tar.gz", hash = "sha256:9bbbeef3442586effb124d1ca032cfb8fb7acd8754ab79b55facd2b8f3ab2802", size = 295400, upload-time = "2025-10-28T17:38:08.599Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/be/a4/7319a2a8add4cc352be9e3efeff5e2aacee917c85ca2fa1647e29089983c/google_auth-2.41.1-py2.py3-none-any.whl", hash = "sha256:754843be95575b9a19c604a848a41be03f7f2afd8c019f716dc1f51ee41c639d", size = 221302, upload-time = "2025-09-30T22:51:24.212Z" },+ { url = "https://files.pythonhosted.org/packages/87/24/ec82aee6ba1a076288818fe5cc5125f4d93fffdc68bb7b381c68286c8aaa/google_auth-2.42.0-py2.py3-none-any.whl", hash = "sha256:f8f944bcb9723339b0ef58a73840f3c61bc91b69bf7368464906120b55804473", size = 222550, upload-time = "2025-10-28T17:38:05.496Z" },][[package]]@@ -1894,7 +1894,7 @@ wheels = [[[package]]name = "pipelex"-version = "0.14.1"+version = "0.14.2"source = { editable = "." }dependencies = [{ name = "aiofiles" },@@ -2062,7 +2062,7 @@ wheels = [[[package]]name = "posthog"-version = "6.7.10"+version = "6.7.11"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "backoff" },@@ -2072,9 +2072,9 @@ dependencies = [{ name = "six" },{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/9f/28/b81f52830efa1eb3e22b7b8c39ef60cf964dfc49b3d64ec060691b0d6df5/posthog-6.7.10.tar.gz", hash = "sha256:212512af756e7641e398bf36131ad589790a08cfa80c267895f46e0ec943e547", size = 120427, upload-time = "2025-10-24T13:50:50.565Z" }+sdist = { url = "https://files.pythonhosted.org/packages/cb/32/3668d5e0f8b852fad81770743ee17893854fd8e5f7cea897a0a9199b0370/posthog-6.7.11.tar.gz", hash = "sha256:62db3e97cbd95351fe081c1ea8805393293de6fabad6d2e9024bf940aca4ddbf", size = 120407, upload-time = "2025-10-28T13:06:18.335Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/af/c7/fdcd03a3eb71d968c6e8c20f0e011895086aac5d1502ae30b4c1345f8152/posthog-6.7.10-py3-none-any.whl", hash = "sha256:dc0a8dd8ddfa6f721f0066a4e3fb0062c2e19dce3b3ae8875d2a0984f9fd5d59", size = 138703, upload-time = "2025-10-24T13:50:49.285Z" },+ { url = "https://files.pythonhosted.org/packages/8c/00/bf284e0aae5dec7c217c176f291867cfac2f7bfd5692c9ce041e80986fa7/posthog-6.7.11-py3-none-any.whl", hash = "sha256:31421a88437cef2ce20f60c14ee8d298b2e765a6de0617cb95d1fcef54170749", size = 138713, upload-time = "2025-10-28T13:06:17.018Z" },][[package]]