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.
Feature/check is initialized (#441)
Louis Choquelb348eabaf7cc
diff --git a/.pipelex/inference/deck/base_deck.toml b/.pipelex/inference/deck/base_deck.tomlindex 12f516755..07dcb3b6f 100644--- a/.pipelex/inference/deck/base_deck.toml+++ b/.pipelex/inference/deck/base_deck.toml@@ -60,7 +60,7 @@ smart_llm_for_structured = ["claude-4-sonnet","gpt-4o", # we use gpt-4o here rather than gpt-5 until we handle reasoning parameters]-+llm_for_creativity = ["claude-4.1-opus", "gemini-2.5-pro", "gpt-4o"]llm_for_large_codebase = ["gemini-2.5-pro","claude-4.5-sonnet",@@ -81,6 +81,12 @@ cheap_llm_for_vision = ["claude-3-haiku",]cheap_llm_for_structured = ["gpt-4o-mini", "mistral-small", "claude-3-haiku"]+cheap_llm_for_creativity = [+ "gemini-2.5-flash",+ "grok-3-mini",+ "gpt-4o-mini",+ "claude-4.5-haiku",+]##################################################################################################### LLM Presetsdiff --git a/docs/home/2-get-started/pipe-builder.md b/docs/home/2-get-started/pipe-builder.mdindex 063a32819..124498de1 100644--- a/docs/home/2-get-started/pipe-builder.md+++ b/docs/home/2-get-started/pipe-builder.md@@ -27,12 +27,15 @@ The fastest way to create production-ready AI workflows is with the Pipe Builderpipelex build pipe "Take a CV and Job offer in PDF, analyze if they match and generate 5 questions for the interview"```-The pipe builder generates a complete production-ready script in our Pipelex language, saved as a `.plx` file including domain definition, concepts, and the multiple _pipe_ steps to take to achieve the goal. It has also generated a file `inputs.json`, describing the form of the **mandatory** inputs for running the pipe.+The pipe builder generates three files in a numbered directory (e.g., `results/pipeline_01/`):++1. **`bundle.plx`** - Complete production-ready script in our Pipelex language with domain definition, concepts, and pipe steps+2. **`inputs.json`** - Template describing the **mandatory** inputs for running the pipe+3. **`run_{pipe_code}.py`** - Ready-to-run Python script that you can customize and execute!!! tip "Pipe Builder Requirements"For now, the pipe builder requires access to **Claude 4.5 Sonnet**, either through Pipelex Inference, or using your own key through Anthropic, Amazon Bedrock or BlackboxAI. Don't hesitate to join our [Discord](https://go.pipelex.com/discord) to get a key, otherwise, you can also create the workflows yourself, following our [documentation guide](./write-workflows-manually.md).-## Run your pipeline**Option 1: CLI**diff --git a/docs/home/6-build-reliable-ai-workflows/pipe-builder.md b/docs/home/6-build-reliable-ai-workflows/pipe-builder.mdindex e7bc7301d..364cbce44 100644--- a/docs/home/6-build-reliable-ai-workflows/pipe-builder.md+++ b/docs/home/6-build-reliable-ai-workflows/pipe-builder.md@@ -21,24 +21,39 @@ This command runs a validation/fix loop to ensure the generated pipeline is corr**What Gets Generated:**-The build command creates two essential files:+By default, the build command creates a numbered directory with three files:-1. **`.plx` file** - Your complete pipeline definition with concepts and pipes-2. **`inputs.json` template** - A pre-filled template showing the inputs your pipeline expects+1. **`bundle.plx`** - Your complete pipeline definition with domain, concepts, and pipes+2. **`inputs.json`** - A pre-filled template showing the inputs your pipeline expects+3. **`run_{pipe_code}.py`** - A ready-to-run Python script you can customize and executeAfter generation, you can fill in the `inputs.json` template with your actual data and run the pipeline. For detailed guidance on preparing and formatting inputs, see [Providing Inputs to Pipelines](./pipes/provide-inputs.md).-**Example:**+**Examples:**```bash+# Default: creates results/pipeline_01/ with all three files+pipelex build pipe "Take a photo as input, and render the opposite of the photo"++# Custom name: creates results/photo_inverter_01/ with all three files+pipelex build pipe "Take a photo as input, and render the opposite of the photo" \+ -o photo_inverter++# Single file only: creates results/photo_inverter_01.plx+pipelex build pipe "Take a photo as input, and render the opposite of the photo" \+ -o photo_inverter --no-extras++# Custom directory: creates custom_dir/pipeline_01/pipelex build pipe "Take a photo as input, and render the opposite of the photo" \- -o results/photo_inverter.plx+ --output-dir custom_dir```**Options:**-- `--output, -o`: Output path for generated PLX file-- `--no-output`: Skip saving the pipeline to file+- `-o, --output-name`: Base name for the generated file or directory (without extension)+- `--output-dir`: Directory where files will be generated (default: `results`)+- `--no-extras`: Skip generating `inputs.json` and runner, only generate the `.plx` bundle+- `--no-output`: Build the pipeline but don't save any files## Quick Start Examplediff --git a/pipelex/builder/builder_loop.py b/pipelex/builder/builder_loop.pyindex a8be0004b..cd7318a71 100644--- a/pipelex/builder/builder_loop.py+++ b/pipelex/builder/builder_loop.py@@ -43,7 +43,6 @@ class BuilderLoop:console = Console(stderr=True)console.print_exception()raise PipeBuilderError(message=msg) from exc- pretty_print(pipe_output, title="Pipe Output")if is_save_working_memory_enabled:working_memory_path = get_incremental_file_path(@@ -58,7 +57,6 @@ class BuilderLoop:except WorkingMemoryStuffNotFoundError as exc:msg = f"Builder loop: Failed to get pipelex bundle spec: {exc}."raise PipeBuilderError(message=msg, working_memory=pipe_output.working_memory) from exc- pretty_print(pipelex_bundle_spec, title="Pipelex Bundle Spec • 1st iteration")plx_content = PlxFactory.make_plx_content(blueprint=pipelex_bundle_spec.to_blueprint())if is_save_first_iteration_enabled:diff --git a/pipelex/builder/bundle_header_spec.py b/pipelex/builder/bundle_header_spec.pyindex 47f8ddeb7..39fa49fca 100644--- a/pipelex/builder/bundle_header_spec.py+++ b/pipelex/builder/bundle_header_spec.py@@ -1,6 +1,10 @@from pydantic import Field+from rich.console import Group+from rich.text import Text+from typing_extensions import overridefrom pipelex.core.stuffs.structured_content import StructuredContent+from pipelex.tools.misc.pretty import PrettyPrintableclass BundleHeaderSpec(StructuredContent):@@ -8,3 +12,16 @@ class BundleHeaderSpec(StructuredContent):description: str = Field(description="Definition of the domain of the knowledge work.")system_prompt: str | None = Field(description="System prompt for the domain.")main_pipe: str = Field(description="The main pipe of the domain.")++ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ bundle_group = Group()+ if title:+ bundle_group.renderables.append(Text(title, style="bold"))+ bundle_group.renderables.append(Text.from_markup(f"Domain: [yellow]{self.domain}[/yellow]\n", style="bold"))+ bundle_group.renderables.append(Text.from_markup(f"Description: [italic]{self.description}[/italic]\n"))+ bundle_group.renderables.append(Text.from_markup(f"Main Pipe: [red]{self.main_pipe}[/red]\n"))+ if self.system_prompt:+ bundle_group.renderables.append(Text(f"System Prompt: {self.system_prompt}", style="dim"))++ return bundle_groupdiff --git a/pipelex/builder/bundle_spec.py b/pipelex/builder/bundle_spec.pyindex 1b1958648..f0dc950c0 100644--- a/pipelex/builder/bundle_spec.py+++ b/pipelex/builder/bundle_spec.py@@ -1,4 +1,8 @@from pydantic import ConfigDict, Field, ValidationError, field_validator, model_validator+from rich.console import Group+from rich.table import Table+from rich.text import Text+from typing_extensions import overridefrom pipelex.builder.builder_errors import (ConceptFailure,@@ -15,6 +19,7 @@ from pipelex.core.bundles.pipelex_bundle_blueprint import PipeBlueprintUnion, Pifrom pipelex.core.concepts.concept_blueprint import ConceptBlueprintfrom pipelex.core.domains.domain_blueprint import DomainBlueprintfrom pipelex.core.stuffs.structured_content import StructuredContent+from pipelex.tools.misc.pretty import PrettyPrintablefrom pipelex.tools.typing.pydantic_utils import format_pydantic_validation_error@@ -118,3 +123,49 @@ class PipelexBundleSpec(StructuredContent):pipe=pipe,concept=concept,)++ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ bundle_group = Group()++ # Bundle header info+ if title:+ bundle_group.renderables.append(Text(title, style="bold"))+ bundle_group.renderables.append(Text.from_markup(f"Domain: [yellow]{self.domain}[/yellow]\n", style="bold"))+ if self.description:+ bundle_group.renderables.append(Text.from_markup(f"Description: [italic]{self.description}[/italic]\n"))+ bundle_group.renderables.append(Text.from_markup(f"Main Pipe: [red]{self.main_pipe}[/red]\n"))+ if self.system_prompt:+ bundle_group.renderables.append(Text(f"System Prompt: {self.system_prompt}\n", style="dim"))++ # Concepts table+ if self.concept:+ bundle_group.renderables.append(Text("\n"))+ concepts_table = Table(+ title="Concepts", title_style="bold green", show_header=False, show_edge=True, show_lines=True, border_style="green"+ )+ concepts_table.add_column("Concept", style="white")++ for concept_code, concept_spec_or_name in self.concept.items():+ if isinstance(concept_spec_or_name, ConceptSpec):+ concept_rendered = concept_spec_or_name.rendered_for_rich()+ concepts_table.add_row(concept_rendered)+ else:+ # Simple string concept reference+ concepts_table.add_row(Text.from_markup(f"[green]{concept_code}[/green]: {concept_spec_or_name}"))++ bundle_group.renderables.append(concepts_table)++ # Pipes table+ if self.pipe:+ bundle_group.renderables.append(Text("\n"))+ pipes_table = Table(title="Pipes", title_style="bold red", show_header=False, show_edge=True, show_lines=True, border_style="red")+ pipes_table.add_column("Pipe", style="white")++ for pipe_spec in self.pipe.values():+ pipe_rendered = pipe_spec.rendered_for_rich()+ pipes_table.add_row(pipe_rendered)++ bundle_group.renderables.append(pipes_table)++ return bundle_groupdiff --git a/pipelex/builder/concept/concept_spec.py b/pipelex/builder/concept/concept_spec.pyindex d4266d058..2fbd7f1d0 100644--- a/pipelex/builder/concept/concept_spec.py+++ b/pipelex/builder/concept/concept_spec.py@@ -3,9 +3,12 @@ from datetime import datetimefrom typing import Anyfrom pydantic import ConfigDict, Field, field_validator, model_validator+from rich.console import Group+from rich.table import Table+from rich.text import Textfrom typing_extensions import override-from pipelex import log, pretty_print+from pipelex import logfrom pipelex.core.concepts.concept_blueprint import (ConceptBlueprint,ConceptBlueprintError,@@ -17,7 +20,7 @@ from pipelex.core.concepts.concept_native import NativeConceptCodefrom pipelex.core.concepts.exceptions import ConceptCodeError, ConceptStringOrConceptCodeErrorfrom pipelex.core.domains.domain_blueprint import DomainBlueprintfrom pipelex.core.stuffs.structured_content import StructuredContent-from pipelex.tools.misc.json_utils import remove_none_values_from_dict+from pipelex.tools.misc.pretty import PrettyPrintablefrom pipelex.tools.misc.string_utils import is_pascal_case, normalize_to_ascii, snake_to_pascal_casefrom pipelex.types import Self, StrEnum@@ -262,22 +265,41 @@ class ConceptSpec(StructuredContent):return ConceptBlueprint(description=self.description, structure=converted_structure, refines=self.refines)@override- def pretty_print_content(self, title: str | None = None, number: int | None = None) -> None:- the_dict: dict[str, Any] = self.smart_dump()- the_dict = remove_none_values_from_dict(data=the_dict)- if number:- title = f"Concept #{number}: {self.the_concept_code}"- else:- title = f"Concept: {self.the_concept_code}"+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ concept_group = Group()+ if title:+ concept_group.renderables.append(Text(title, style="bold"))+ concept_group.renderables.append(Text.from_markup(f"Concept: [green]{self.the_concept_code}[/green]", style="bold"))if self.refines:- title += f" • Refines {self.refines}"- the_dict.pop("refines")-- description = self.description- the_dict.pop("the_concept_code")- the_dict.pop("description")+ concept_group.renderables.append(Text.from_markup(f"Refines: [green]{self.refines}[/green]"))+ concept_group.renderables.append(Text.from_markup(f"\nDescription: [italic]{self.description}[/italic]\n"))if self.structure:- structure = the_dict.pop("structure")- pretty_print(structure, title=title, subtitle=description)- else:- pretty_print(description, title=title)+ # Check if any field has a default value+ has_default_values = any(field_spec.default_value is not None for field_spec in self.structure.values())++ structure_table = Table(+ title="Structure:",+ title_style="not italic",+ title_justify="left",+ show_header=True,+ header_style="dim",+ show_edge=True,+ show_lines=True,+ border_style="dim",+ )+ structure_table.add_column("Field", style="blue")+ structure_table.add_column("Description", style="white italic")+ structure_table.add_column("Type", style="white")+ structure_table.add_column("Required", style="white")+ if has_default_values:+ structure_table.add_column("Default Value", style="white")++ for field_name, field_spec in self.structure.items():+ required_text = "Yes" if field_spec.required else "No"+ row_data = [field_name, field_spec.description, field_spec.type.value, required_text]+ if has_default_values:+ row_data.append(str(field_spec.default_value) if field_spec.default_value is not None else "")+ structure_table.add_row(*row_data)+ concept_group.renderables.append(structure_table)++ return concept_groupdiff --git a/pipelex/builder/pipe/pipe_batch_spec.py b/pipelex/builder/pipe/pipe_batch_spec.pyindex 24132f7f7..48d430d72 100644--- a/pipelex/builder/pipe/pipe_batch_spec.py+++ b/pipelex/builder/pipe/pipe_batch_spec.py@@ -1,10 +1,13 @@from typing import Literalfrom pydantic import Field+from rich.console import Group+from rich.text import Textfrom typing_extensions import overridefrom pipelex.builder.pipe.pipe_spec import PipeSpecfrom pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprint+from pipelex.tools.misc.pretty import PrettyPrintableclass PipeBatchSpec(PipeSpec):@@ -33,6 +36,23 @@ class PipeBatchSpec(PipeSpec):description="Name assigned to individual items within each execution branch. This is how the branch pipe accesses its specific input item.",)+ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ # Get base pipe information from parent+ base_group = super().rendered_for_rich(title=title, number=number)++ # Create a group combining base info with batch-specific details+ batch_group = Group()+ batch_group.renderables.append(base_group)++ # Add batch-specific information+ batch_group.renderables.append(Text()) # Blank line+ batch_group.renderables.append(Text.from_markup(f"Branch Pipe: [red]{self.branch_pipe_code}[/red]"))+ batch_group.renderables.append(Text.from_markup(f"Iterate Over: [bold cyan]{self.input_list_name}[/bold cyan]"))+ batch_group.renderables.append(Text.from_markup(f"Item Name: [cyan]{self.input_item_name}[/cyan]"))++ return batch_group+@overridedef to_blueprint(self) -> PipeBatchBlueprint:base_blueprint = super().to_blueprint()diff --git a/pipelex/builder/pipe/pipe_compose_spec.py b/pipelex/builder/pipe/pipe_compose_spec.pyindex e341b66db..27a4ab352 100644--- a/pipelex/builder/pipe/pipe_compose_spec.py+++ b/pipelex/builder/pipe/pipe_compose_spec.py@@ -2,6 +2,9 @@ from typing import Literalfrom pydantic import Field, field_validatorfrom pydantic.json_schema import SkipJsonSchema+from rich.console import Group+from rich.panel import Panel+from rich.text import Textfrom typing_extensions import overridefrom pipelex.builder.pipe.pipe_spec import PipeSpec@@ -9,6 +12,7 @@ from pipelex.cogt.templating.template_blueprint import TemplateBlueprintfrom pipelex.cogt.templating.template_category import TemplateCategoryfrom pipelex.cogt.templating.templating_style import TagStyle, TemplatingStyle, TextFormatfrom pipelex.pipe_operators.compose.pipe_compose_blueprint import PipeComposeBlueprint+from pipelex.tools.misc.pretty import PrettyPrintablefrom pipelex.types import StrEnum@@ -86,6 +90,32 @@ class PipeComposeSpec(PipeSpec):def validate_target_format(cls, target_format_value: str) -> TargetFormat:return TargetFormat(target_format_value)+ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ # Get base pipe information from parent+ base_group = super().rendered_for_rich(title=title, number=number)++ # Create a group combining base info with compose-specific details+ compose_group = Group()+ compose_group.renderables.append(base_group)++ # Add target format+ compose_group.renderables.append(Text()) # Blank line+ compose_group.renderables.append(Text.from_markup(f"Target Format: [bold yellow]{self.target_format}[/bold yellow]"))++ # Add template in a panel+ compose_group.renderables.append(Text()) # Blank line+ template_panel = Panel(+ self.template,+ title="Template",+ title_align="left",+ border_style="green",+ padding=(0, 1),+ )+ compose_group.renderables.append(template_panel)++ return compose_group+@overridedef to_blueprint(self) -> PipeComposeBlueprint:base_blueprint = super().to_blueprint()diff --git a/pipelex/builder/pipe/pipe_condition_spec.py b/pipelex/builder/pipe/pipe_condition_spec.pyindex e48e4dcea..065dcfd7e 100644--- a/pipelex/builder/pipe/pipe_condition_spec.py+++ b/pipelex/builder/pipe/pipe_condition_spec.py@@ -2,11 +2,16 @@ from typing import Literalfrom pydantic import Fieldfrom pydantic.json_schema import SkipJsonSchema+from rich.console import Group+from rich.panel import Panel+from rich.table import Table+from rich.text import Textfrom typing_extensions import overridefrom pipelex.builder.pipe.pipe_spec import PipeSpecfrom pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprintfrom pipelex.pipe_controllers.condition.special_outcome import SpecialOutcome+from pipelex.tools.misc.pretty import PrettyPrintableclass PipeConditionSpec(PipeSpec):@@ -26,6 +31,52 @@ class PipeConditionSpec(PipeSpec):outcomes: dict[str, str] = Field(..., description="Mapping `dict[str, str]` of condition to outcomes.")default_outcome: str | SpecialOutcome = Field(description="The fallback outcome if the expression result does not match any key in outcome map.")+ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ # Get base pipe information from parent+ base_group = super().rendered_for_rich(title=title, number=number)++ # Create a group combining base info with condition-specific details+ condition_group = Group()+ condition_group.renderables.append(base_group)++ # Add expression template in a panel+ condition_group.renderables.append(Text()) # Blank line+ expression_panel = Panel(+ self.jinja2_expression_template,+ title="Expression Template",+ title_align="left",+ border_style="yellow",+ padding=(0, 1),+ )+ condition_group.renderables.append(expression_panel)++ # Add outcomes as a table+ condition_group.renderables.append(Text()) # Blank line+ outcomes_table = Table(+ title="Outcomes:",+ title_justify="left",+ title_style="not italic",+ show_header=True,+ header_style="dim",+ show_edge=True,+ show_lines=True,+ border_style="dim",+ )+ outcomes_table.add_column("Condition", style="yellow")+ outcomes_table.add_column("Pipe", style="cyan")++ for condition, pipe in self.outcomes.items():+ outcomes_table.add_row(condition, pipe)++ condition_group.renderables.append(outcomes_table)++ # Add default outcome+ condition_group.renderables.append(Text()) # Blank line+ condition_group.renderables.append(Text.from_markup(f"Default Outcome: [bold red]{self.default_outcome}[/bold red]"))++ return condition_group+@overridedef to_blueprint(self) -> PipeConditionBlueprint:base_blueprint = super().to_blueprint()diff --git a/pipelex/builder/pipe/pipe_extract_spec.py b/pipelex/builder/pipe/pipe_extract_spec.pyindex 4e3e36f31..2722cbf7e 100644--- a/pipelex/builder/pipe/pipe_extract_spec.py+++ b/pipelex/builder/pipe/pipe_extract_spec.py@@ -2,11 +2,14 @@ from typing import TYPE_CHECKING, Literalfrom pydantic import Field, field_validatorfrom pydantic.json_schema import SkipJsonSchema+from rich.console import Group+from rich.text import Textfrom typing_extensions import overridefrom pipelex.builder.pipe.pipe_spec import PipeSpecfrom pipelex.builder.pipe.pipe_spec_exceptions import PipeExtractSpecErrorfrom pipelex.pipe_operators.extract.pipe_extract_blueprint import PipeExtractBlueprint+from pipelex.tools.misc.pretty import PrettyPrintablefrom pipelex.types import StrEnumif TYPE_CHECKING:@@ -59,6 +62,29 @@ class PipeExtractSpec(PipeSpec):raise PipeExtractSpecError(msg)return inputs_value+ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ # Get base pipe information from parent+ base_group = super().rendered_for_rich(title=title, number=number)++ # Create a group combining base info with extract-specific details+ extract_group = Group()+ extract_group.renderables.append(base_group)++ # Add extract specific information+ extract_group.renderables.append(Text()) # Blank line+ extract_group.renderables.append(Text.from_markup(f"Extract Skill: [bold yellow]{self.extract_skill}[/bold yellow]"))++ # Add optional extraction settings if they are set+ if self.page_images is not None:+ extract_group.renderables.append(Text.from_markup(f"Include Page Images: [bold magenta]{self.page_images}[/bold magenta]"))+ if self.page_image_captions is not None:+ extract_group.renderables.append(Text.from_markup(f"Generate Image Captions: [bold magenta]{self.page_image_captions}[/bold magenta]"))+ if self.page_views is not None:+ extract_group.renderables.append(Text.from_markup(f"Include Page Views: [bold magenta]{self.page_views}[/bold magenta]"))++ return extract_group+@overridedef to_blueprint(self) -> PipeExtractBlueprint:base_blueprint = super().to_blueprint()diff --git a/pipelex/builder/pipe/pipe_func_spec.py b/pipelex/builder/pipe/pipe_func_spec.pyindex 0cb0da548..dead94644 100644--- a/pipelex/builder/pipe/pipe_func_spec.py+++ b/pipelex/builder/pipe/pipe_func_spec.py@@ -2,10 +2,13 @@ from typing import Literalfrom pydantic import Fieldfrom pydantic.json_schema import SkipJsonSchema+from rich.console import Group+from rich.text import Textfrom typing_extensions import overridefrom pipelex.builder.pipe.pipe_spec import PipeSpecfrom pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprint+from pipelex.tools.misc.pretty import PrettyPrintableclass PipeFuncSpec(PipeSpec):@@ -15,6 +18,21 @@ class PipeFuncSpec(PipeSpec):pipe_category: SkipJsonSchema[Literal["PipeOperator"]] = "PipeOperator"function_name: str = Field(description="The name of the function to call.")+ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ # Get base pipe information from parent+ base_group = super().rendered_for_rich(title=title, number=number)++ # Create a group combining base info with func-specific details+ func_group = Group()+ func_group.renderables.append(base_group)++ # Add function specific information+ func_group.renderables.append(Text()) # Blank line+ func_group.renderables.append(Text.from_markup(f"Function Name: [bold cyan]{self.function_name}[/bold cyan]"))++ return func_group+@overridedef to_blueprint(self) -> PipeFuncBlueprint:base_blueprint = super().to_blueprint()diff --git a/pipelex/builder/pipe/pipe_img_gen_spec.py b/pipelex/builder/pipe/pipe_img_gen_spec.pyindex 9f3a0d2b4..f6169b0b8 100644--- a/pipelex/builder/pipe/pipe_img_gen_spec.py+++ b/pipelex/builder/pipe/pipe_img_gen_spec.py@@ -1,10 +1,13 @@from typing import TYPE_CHECKING, Literalfrom pydantic import Field, field_validator+from rich.console import Group+from rich.text import Textfrom typing_extensions import overridefrom pipelex.builder.pipe.pipe_spec import PipeSpecfrom pipelex.pipe_operators.img_gen.pipe_img_gen_blueprint import PipeImgGenBlueprint+from pipelex.tools.misc.pretty import PrettyPrintablefrom pipelex.types import StrEnumif TYPE_CHECKING:@@ -42,6 +45,21 @@ class PipeImgGenSpec(PipeSpec):else:return ImgGenSkill(img_gen_skill_value)+ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ # Get base pipe information from parent+ base_group = super().rendered_for_rich(title=title, number=number)++ # Create a group combining base info with img_gen-specific details+ img_gen_group = Group()+ img_gen_group.renderables.append(base_group)++ # Add image generation specific information+ img_gen_group.renderables.append(Text()) # Blank line+ img_gen_group.renderables.append(Text.from_markup(f"Image Generation Skill: [bold yellow]{self.img_gen_skill}[/bold yellow]"))++ return img_gen_group+@overridedef to_blueprint(self) -> PipeImgGenBlueprint:"""Convert this PipeImgGenBlueprint to the core PipeImgGenBlueprint."""diff --git a/pipelex/builder/pipe/pipe_llm_spec.py b/pipelex/builder/pipe/pipe_llm_spec.pyindex 4d2fce330..582115b34 100644--- a/pipelex/builder/pipe/pipe_llm_spec.py+++ b/pipelex/builder/pipe/pipe_llm_spec.py@@ -2,10 +2,14 @@ from typing import TYPE_CHECKING, Literalfrom pydantic import Field, field_validatorfrom pydantic.json_schema import SkipJsonSchema+from rich.console import Group+from rich.panel import Panel+from rich.text import Textfrom typing_extensions import overridefrom pipelex.builder.pipe.pipe_spec import PipeSpecfrom pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint+from pipelex.tools.misc.pretty import PrettyPrintablefrom pipelex.types import StrEnumif TYPE_CHECKING:@@ -20,7 +24,7 @@ class LLMSkill(StrEnum):LLM_FOR_WRITING_CHEAP = "llm_for_writing_cheap"LLM_FOR_IMG_TO_TEXT_CHEAP = "llm_for_img_to_text_cheap"- LLM_FOR_VISUAL_DESIGN = "llm_for_visual_design"+ LLM_FOR_VISUAL_DESIGN = "cheap_llm_for_creativity"LLM_FOR_CREATIVE_WRITING = "llm_for_creative_writing"LLM_TO_CODE = "llm_to_code"LLM_TO_ANALYZE_LARGE_CODEBASE = "llm_to_analyze_large_codebase"@@ -68,6 +72,45 @@ So, don't have to write a bullet-list of all the attributes definitions yourselfdef validate_llm(cls, llm_value: str) -> LLMSkill:return LLMSkill(llm_value)+ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ # Get base pipe information from parent+ base_group = super().rendered_for_rich(title=title, number=number)++ # Create a group combining base info with LLM-specific details+ llm_group = Group()+ llm_group.renderables.append(base_group)++ # Add LLM-specific information+ llm_group.renderables.append(Text()) # Blank line+ llm_group.renderables.append(Text.from_markup(f"LLM Skill: [bold yellow]{self.llm_skill}[/bold yellow]"))++ # Add system prompt if present+ if self.system_prompt:+ system_prompt_panel = Panel(+ self.system_prompt,+ title="System Prompt",+ title_align="left",+ border_style="blue",+ padding=(0, 1),+ )+ llm_group.renderables.append(Text()) # Blank line+ llm_group.renderables.append(system_prompt_panel)++ # Add prompt if present+ if self.prompt:+ prompt_panel = Panel(+ self.prompt,+ title="Prompt",+ title_align="left",+ border_style="green",+ padding=(0, 1),+ )+ llm_group.renderables.append(Text()) # Blank line+ llm_group.renderables.append(prompt_panel)++ return llm_group+@overridedef to_blueprint(self) -> PipeLLMBlueprint:base_blueprint = super().to_blueprint()diff --git a/pipelex/builder/pipe/pipe_parallel_spec.py b/pipelex/builder/pipe/pipe_parallel_spec.pyindex a70d0e632..7f0cf570f 100644--- a/pipelex/builder/pipe/pipe_parallel_spec.py+++ b/pipelex/builder/pipe/pipe_parallel_spec.py@@ -1,6 +1,9 @@from typing import Literalfrom pydantic import Field, field_validator, model_validator+from rich.console import Group+from rich.table import Table+from rich.text import Textfrom typing_extensions import overridefrom pipelex.builder.concept.concept_spec import ConceptSpec@@ -8,6 +11,7 @@ from pipelex.builder.pipe.pipe_spec import PipeSpecfrom pipelex.builder.pipe.pipe_spec_exceptions import PipeParallelSpecErrorfrom pipelex.builder.pipe.sub_pipe_spec import SubPipeSpecfrom pipelex.pipe_controllers.parallel.pipe_parallel_blueprint import PipeParallelBlueprint+from pipelex.tools.misc.pretty import PrettyPrintablefrom pipelex.types import Self@@ -53,6 +57,44 @@ class PipeParallelSpec(PipeSpec):)return self+ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ # Get base pipe information from parent+ base_group = super().rendered_for_rich(title=title, number=number)++ # Create a group combining base info with parallel-specific details+ parallel_group = Group()+ parallel_group.renderables.append(base_group)++ # Add parallel configuration+ parallel_group.renderables.append(Text()) # Blank line+ parallel_group.renderables.append(Text.from_markup(f"Add Each Output: [bold yellow]{self.add_each_output}[/bold yellow]"))+ if self.combined_output:+ parallel_group.renderables.append(Text.from_markup(f"Combined Output: [bold green]{self.combined_output}[/bold green]"))++ # Add parallel branches as a table+ parallel_group.renderables.append(Text()) # Blank line+ parallels_table = Table(+ title="Parallel Branches:",+ title_justify="left",+ title_style="not italic",+ show_header=True,+ header_style="dim",+ show_edge=True,+ show_lines=True,+ border_style="dim",+ )+ parallels_table.add_column("Branch", style="dim", width=6, justify="right")+ parallels_table.add_column("Pipe", style="red")+ parallels_table.add_column("Result name", style="cyan")++ for idx, parallel in enumerate(self.parallels, start=1):+ parallels_table.add_row(str(idx), parallel.pipe_code, parallel.result)++ parallel_group.renderables.append(parallels_table)++ return parallel_group+@overridedef to_blueprint(self) -> PipeParallelBlueprint:base_blueprint = super().to_blueprint()diff --git a/pipelex/builder/pipe/pipe_sequence_spec.py b/pipelex/builder/pipe/pipe_sequence_spec.pyindex cc137d522..915a55b81 100644--- a/pipelex/builder/pipe/pipe_sequence_spec.py+++ b/pipelex/builder/pipe/pipe_sequence_spec.py@@ -2,11 +2,15 @@ from typing import Literalfrom pydantic import Fieldfrom pydantic.json_schema import SkipJsonSchema+from rich.console import Group+from rich.table import Table+from rich.text import Textfrom typing_extensions import overridefrom pipelex.builder.pipe.pipe_spec import PipeSpecfrom pipelex.builder.pipe.sub_pipe_spec import SubPipeSpecfrom pipelex.pipe_controllers.sequence.pipe_sequence_blueprint import PipeSequenceBlueprint+from pipelex.tools.misc.pretty import PrettyPrintableclass PipeSequenceSpec(PipeSpec):@@ -21,6 +25,38 @@ class PipeSequenceSpec(PipeSpec):description=("List of SubPipeSpec instances to execute sequentially. Each step runs after the previous one completes."))+ @override+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ # Get base pipe information from parent+ base_group = super().rendered_for_rich(title=title, number=number)++ # Create a group combining base info with sequence-specific details+ sequence_group = Group()+ sequence_group.renderables.append(base_group)++ # Add sequence steps as a table+ sequence_group.renderables.append(Text()) # Blank line+ steps_table = Table(+ title="Sequence Steps:",+ title_justify="left",+ title_style="not italic",+ show_header=True,+ header_style="dim",+ show_edge=True,+ show_lines=True,+ border_style="dim",+ )+ steps_table.add_column("Step", style="dim", width=4, justify="right")+ steps_table.add_column("Pipe", style="red")+ steps_table.add_column("Result name", style="cyan")++ for idx, step in enumerate(self.steps, start=1):+ steps_table.add_row(str(idx), step.pipe_code, step.result)++ sequence_group.renderables.append(steps_table)++ return sequence_group+@overridedef to_blueprint(self) -> PipeSequenceBlueprint:base_blueprint = super().to_blueprint()diff --git a/pipelex/builder/pipe/pipe_signature.py b/pipelex/builder/pipe/pipe_signature.pyindex ad122b243..5f0f87f4a 100644--- a/pipelex/builder/pipe/pipe_signature.py+++ b/pipelex/builder/pipe/pipe_signature.py@@ -2,13 +2,15 @@ from typing import Anyfrom pydantic import Field, field_validator, model_validatorfrom pydantic.json_schema import SkipJsonSchema+from rich.console import Group+from rich.table import Table+from rich.text import Textfrom typing_extensions import override-from pipelex import pretty_printfrom pipelex.core.pipes.exceptions import PipeBlueprintErrorfrom pipelex.core.pipes.pipe_blueprint import AllowedPipeCategories, AllowedPipeTypesfrom pipelex.core.stuffs.structured_content import StructuredContent-from pipelex.tools.misc.json_utils import remove_none_values_from_dict+from pipelex.tools.misc.pretty import PrettyPrintableclass PipeSignature(StructuredContent):@@ -67,18 +69,45 @@ class PipeSignature(StructuredContent):return AllowedPipeTypes(type_value)@override- def pretty_print_content(self, title: str | None = None, number: int | None = None) -> None:- the_dict: dict[str, Any] = self.smart_dump()- the_dict = remove_none_values_from_dict(data=the_dict)- if number:- title = f"Pipe signature #{number}: {self.code}"+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ pipe_group = Group()+ if title:+ pipe_group.renderables.append(Text(title, style="bold"))+ pipe_group.renderables.append(Text.from_markup(f"Pipe Signature: [red]{self.code}[/red]\n", style="bold"))+ pipe_type = self.type.value if isinstance(self.type, AllowedPipeTypes) else str(self.type)+ pipe_group.renderables.append(Text.from_markup(f"Type: [bold magenta]{pipe_type}[/bold magenta] ({self.pipe_category.value})\n"))+ pipe_group.renderables.append(Text.from_markup(f"Description: [italic]{self.description}[/italic]\n"))++ # Create inputs section+ if not self.inputs:+ pipe_group.renderables.append(Text.from_markup("\nNo inputs"))+ elif len(self.inputs) == 1:+ # Single input: display as a simple line of text+ input_name, concept_spec = next(iter(self.inputs.items()))+ pipe_group.renderables.append(Text.from_markup(f"\nInput: [cyan]{input_name}[/cyan] ([bold green]{concept_spec}[/bold green])"))else:- title = f"Pipe signature: {self.code}"- title += f" • {self.type} -> {self.result}"- subtitle = self.description- the_dict.pop("code")- the_dict.pop("description")- the_dict.pop("type")- the_dict.pop("pipe_category")- the_dict.pop("result")- pretty_print(the_dict, title=title, subtitle=subtitle)+ # Multiple inputs: display as a table+ inputs_table = Table(+ title="Inputs:",+ title_justify="left",+ title_style="not italic",+ show_header=False,+ show_edge=True,+ show_lines=True,+ border_style="dim",+ )+ inputs_table.add_column("Variable Name", style="cyan")+ inputs_table.add_column("Concept", style="bold green")+ for input_name, concept_spec in self.inputs.items():+ inputs_table.add_row(input_name, concept_spec)+ pipe_group.renderables.append(inputs_table)++ # Show output and result+ pipe_group.renderables.append(Text.from_markup(f"\nOutput concept: [bold green]{self.output}[/bold green]"))+ pipe_group.renderables.append(Text.from_markup(f"\nOutput name: [cyan]{self.result}[/cyan]"))++ # Show dependencies if any+ if self.pipe_dependencies:+ pipe_group.renderables.append(Text.from_markup(f"\nDependencies: [red]{', '.join(self.pipe_dependencies)}[/red]"))++ return pipe_groupdiff --git a/pipelex/builder/pipe/pipe_spec.py b/pipelex/builder/pipe/pipe_spec.pyindex 4bac8f6ce..f33f246b0 100644--- a/pipelex/builder/pipe/pipe_spec.py+++ b/pipelex/builder/pipe/pipe_spec.py@@ -2,15 +2,18 @@ import refrom typing import Anyfrom pydantic import Field, field_validator+from rich.console import Group+from rich.table import Table+from rich.text import Textfrom typing_extensions import override-from pipelex import log, pretty_print+from pipelex import logfrom pipelex.builder.concept.concept_spec import ConceptSpecfrom pipelex.core.pipes.exceptions import PipeBlueprintErrorfrom pipelex.core.pipes.pipe_blueprint import AllowedPipeCategories, AllowedPipeTypes, PipeBlueprintfrom pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicityfrom pipelex.core.stuffs.structured_content import StructuredContent-from pipelex.tools.misc.json_utils import remove_none_values_from_dict+from pipelex.tools.misc.pretty import PrettyPrintablefrom pipelex.tools.misc.string_utils import is_snake_case, normalize_to_ascii@@ -133,17 +136,40 @@ class PipeSpec(StructuredContent):)@override- def pretty_print_content(self, title: str | None = None, number: int | None = None) -> None:- the_dict: dict[str, Any] = self.smart_dump()- the_dict = remove_none_values_from_dict(data=the_dict)- if number:- title = f"Pipe #{number}: {self.pipe_code}"+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ pipe_group = Group()+ if title:+ pipe_group.renderables.append(Text(title, style="bold"))+ pipe_group.renderables.append(Text.from_markup(f"Pipe: [bold red]{self.pipe_code}[/bold red]\n"))+ pipe_group.renderables.append(Text.from_markup(f"Type: [bold magenta]{self.type}[/bold magenta] ({self.pipe_category})\n"))+ if self.description:+ pipe_group.renderables.append(Text.from_markup(f"Description: [italic]{self.description}[/italic]\n"))++ # Create inputs section+ if not self.inputs:+ pipe_group.renderables.append(Text.from_markup("\nNo inputs"))+ elif len(self.inputs) == 1:+ # Single input: display as a simple line of text+ input_name, concept_spec = next(iter(self.inputs.items()))+ pipe_group.renderables.append(Text.from_markup(f"\nInput: [cyan]{input_name}[/cyan] ([bold green]{concept_spec}[/bold green])"))else:- title = f"Pipe: {self.pipe_code}"- title += f" • {self.type}"- subtitle = self.description- the_dict.pop("pipe_code")- the_dict.pop("description")- the_dict.pop("type")- the_dict.pop("pipe_category")- pretty_print(the_dict, title=title, subtitle=subtitle)+ # Multiple inputs: display as a table+ inputs_table = Table(+ title="Inputs:",+ title_justify="left",+ title_style="not italic",+ show_header=False,+ show_edge=True,+ show_lines=True,+ border_style="dim",+ )+ inputs_table.add_column("Variable Name", style="cyan")+ inputs_table.add_column("Concept", style="bold green")+ for input_name, concept_spec in self.inputs.items():+ inputs_table.add_row(input_name, concept_spec)+ pipe_group.renderables.append(inputs_table)++ # Show output+ pipe_group.renderables.append(Text.from_markup(f"\nOutput: [bold green]{self.output}[/bold green]"))++ return pipe_groupdiff --git a/pipelex/cli/_cli.py b/pipelex/cli/_cli.pyindex ed131e5c6..5bd23183e 100644--- a/pipelex/cli/_cli.py+++ b/pipelex/cli/_cli.py@@ -14,6 +14,7 @@ from pipelex.cli.commands.kit_cmd import kit_appfrom pipelex.cli.commands.run_cmd import run_cmdfrom pipelex.cli.commands.show_cmd import show_appfrom pipelex.cli.commands.validate_cmd import validate_cmd+from pipelex.cli.readiness import check_readinessfrom pipelex.tools.misc.package_utils import get_package_version@@ -69,6 +70,9 @@ def app_callback(ctx: typer.Context) -> None:if ctx.invoked_subcommand is None or ctx.invoked_subcommand in ("init", "doctor"):return+ # Check system readiness (dependencies and venv for dev installs)+ check_readiness()+init_cmd(silent=True)diff --git a/pipelex/cli/commands/build_cmd.py b/pipelex/cli/commands/build_cmd.pyindex 7c66ac744..cbbed3f5c 100644--- a/pipelex/cli/commands/build_cmd.py+++ b/pipelex/cli/commands/build_cmd.py@@ -1,4 +1,5 @@import asyncio+import osimport timefrom typing import TYPE_CHECKING, Annotated@@ -19,6 +20,7 @@ from pipelex.cli.error_handlers import (handle_validation_error,)from pipelex.cogt.exceptions import ModelDeckPresetValidatonError+from pipelex.config import get_configfrom pipelex.exceptions import (LibraryLoadingError,PipeInputError,@@ -32,7 +34,12 @@ from pipelex.pipelex import PACKAGE_VERSION, Pipelexfrom pipelex.pipeline.execute import execute_pipelinefrom pipelex.system.runtime import IntegrationModefrom pipelex.system.telemetry.events import EventProperty-from pipelex.tools.misc.file_utils import ensure_directory_for_file_path, get_incremental_file_path, save_text_to_path+from pipelex.tools.misc.file_utils import (+ ensure_directory_for_file_path,+ get_incremental_directory_path,+ get_incremental_file_path,+ save_text_to_path,+)from pipelex.tools.misc.json_utils import load_json_dict_from_path, save_as_json_to_pathif TYPE_CHECKING:@@ -48,7 +55,7 @@ pipelex build pipe "Imagine a cute animal mascot for a startup based on its elevinclude 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+ at the end we want the rendered image" -o mascotpipelex 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"@@ -87,14 +94,22 @@ def build_pipe_cmd(str,typer.Option("--builder-pipe", help="Builder pipe to use for generating the pipeline"),] = "pipe_builder",- output_path: Annotated[- str,- typer.Option("--output", "-o", help="Path to save the generated PLX file"),- ] = "./results/generated_pipeline.plx",+ output_name: Annotated[+ str | None,+ typer.Option("--output-name", "-o", help="Base name for the generated file or directory (without extension)"),+ ] = None,+ output_dir: Annotated[+ str | None,+ typer.Option("--output-dir", help="Directory where files will be generated"),+ ] = None,no_output: Annotated[bool,typer.Option("--no-output", help="Skip saving the pipeline to file"),] = False,+ no_extras: Annotated[+ bool,+ typer.Option("--no-extras", help="Skip generating inputs.json and runner.py, only generate the PLX file"),+ ] = False,) -> None:try:pipelex_instance = Pipelex.make(integration_mode=IntegrationMode.CLI)@@ -106,27 +121,22 @@ def build_pipe_cmd(typer.secho("🔥 Starting pipe builder... 🚀\n", fg=typer.colors.GREEN)async def run_pipeline():+ # Get builder config+ builder_config = get_config().pipelex.builder_config++ # Case 1: --no-output flag → Don't save anythingif no_output:typer.secho("\n⚠️ Pipeline will not be saved to file (--no-output specified)", fg=typer.colors.YELLOW)- elif not output_path:- typer.secho("\n🛑 Cannot save a pipeline to an empty file name", fg=typer.colors.RED)- raise typer.Exit(1)- else:- ensure_directory_for_file_path(file_path=output_path)+ # Build the pipelinebuilder_loop = BuilderLoop()- # Save to file unless explicitly disabled with --no-output- if no_output:- typer.secho("\n⚠️ Pipeline not saved to file (--no-output specified)", fg=typer.colors.YELLOW)- return-try:pipelex_bundle_spec = await builder_loop.build_and_fix(pipe_code=builder_pipe, inputs={"brief": prompt})except PipeBuilderError as exc:msg = f"Builder loop: Failed to execute pipeline: {exc}."if exc.working_memory:failure_memory_path = get_incremental_file_path(- base_path="results",+ base_path=builder_config.default_output_dir,base_name="failure_memory",extension="json",)@@ -137,24 +147,64 @@ def build_pipe_cmd(typer.secho(f"❌ {msg}", fg=typer.colors.RED)typer.secho("❌ No failure memory available", fg=typer.colors.RED)raise typer.Exit(1) from exc- plx_content = PlxFactory.make_plx_content(blueprint=pipelex_bundle_spec.to_blueprint())- 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)+ # Return early if no output requested+ if no_output:+ return++ # Determine base output directory+ base_dir = output_dir or builder_config.default_output_dir++ # Determine output path and whether to generate extras+ bundle_file_name = f"{builder_config.default_bundle_file_name}.plx"++ if no_extras:+ # Generate single file: {base_dir}/{name}_01.plx+ name = output_name or builder_config.default_bundle_file_name+ plx_file_path = get_incremental_file_path(+ base_path=base_dir,+ base_name=name,+ extension="plx",+ )+ extras_output_dir = "" # Not used in no_extras mode+ else:+ # Generate directory with extras: {base_dir}/{name}_01/bundle.plx + extras+ dir_name = output_name or builder_config.default_directory_base_name+ extras_output_dir = get_incremental_directory_path(+ base_path=base_dir,+ base_name=dir_name,+ )+ plx_file_path = os.path.join(extras_output_dir, bundle_file_name)++ # Save the PLX file+ ensure_directory_for_file_path(file_path=plx_file_path)+ plx_content = PlxFactory.make_plx_content(blueprint=pipelex_bundle_spec.to_blueprint())+ save_text_to_path(text=plx_content, path=plx_file_path)+ typer.secho(f"✅ Bundle saved to: {plx_file_path}", fg=typer.colors.GREEN)++ # Generate extras (inputs and runner) if requested+ if not no_extras:+ 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(plx_file_path)+ pipe = get_required_pipe(pipe_code=main_pipe_code)++ # Generate inputs.json+ inputs_json_str = generate_input_memory_json_string(pipe.inputs, indent=2)+ inputs_json_path = os.path.join(extras_output_dir, "inputs.json")+ save_text_to_path(text=inputs_json_str, path=inputs_json_path)+ typer.secho(f"✅ Inputs saved to: {inputs_json_path}", fg=typer.colors.GREEN)++ # Generate runner.py+ runner_code = generate_runner_code(pipe)+ runner_path = os.path.join(extras_output_dir, f"run_{main_pipe_code}.py")+ save_text_to_path(text=runner_code, path=runner_path)+ typer.secho(f"✅ Runner saved to: {runner_path}", fg=typer.colors.GREEN)++ except Exception as exc:+ typer.secho(f"⚠️ Warning: Could not generate extras: {exc}", fg=typer.colors.YELLOW)try:with get_telemetry_manager().telemetry_context():diff --git a/pipelex/cli/commands/init/config_files.py b/pipelex/cli/commands/init/config_files.pyindex c565bbd86..09794f620 100644--- a/pipelex/cli/commands/init/config_files.py+++ b/pipelex/cli/commands/init/config_files.py@@ -12,7 +12,7 @@ from pipelex.system.telemetry.telemetry_config import TELEMETRY_CONFIG_FILE_NAMEdef init_config(reset: bool = False, dry_run: bool = False) -> int:- """Initialize pipelex configuration in the .pipelex directory. Does not install telemetry, just the main config dans inference backends.+ """Initialize pipelex configuration in the .pipelex directory. Does not install telemetry, just the main config and inference backends.Args:reset: Whether to overwrite existing files.diff --git a/pipelex/cli/readiness.py b/pipelex/cli/readiness.pynew file mode 100644index 000000000..509c01c63--- /dev/null+++ b/pipelex/cli/readiness.py@@ -0,0 +1,103 @@+"""System readiness checks for Pipelex CLI."""++from __future__ import annotations++import os+import sys+from pathlib import Path++from rich.console import Console++import pipelex+from pipelex.exceptions import ReadinessCheckError+++def _is_in_virtual_environment() -> bool:+ """Check if the current Python process is running inside a virtual environment.++ Returns:+ True if running in a virtual environment, False otherwise+ """+ # Check if we're in a venv (sys.prefix != sys.base_prefix)+ # or in a conda environment (CONDA_DEFAULT_ENV env var is set)+ return sys.prefix != sys.base_prefix or os.environ.get("CONDA_DEFAULT_ENV") is not None or os.environ.get("VIRTUAL_ENV") is not None+++def _find_venv_directories() -> list[str]:+ """Find common virtual environment directories in the current project.++ Returns:+ List of found venv directory names+ """+ common_venv_names = [".venv", "venv", "env", ".env"]+ found_venvs: list[str] = []++ # Check current directory and parent directories (up to 3 levels)+ current_path = Path.cwd()+ for _ in range(3):+ for venv_name in common_venv_names:+ venv_path = current_path / venv_name+ if venv_path.is_dir() and (venv_path / "bin" / "python").exists():+ found_venvs.append(venv_name)+ if current_path.parent == current_path:+ break+ current_path = current_path.parent++ return found_venvs+++def _is_development_install() -> bool:+ """Check if Pipelex is installed in development/editable mode.++ Returns:+ True if running from a development install (has .git directory in parent paths)+ """+ try:+ pipelex_path = Path(pipelex.__file__).parent+ current = pipelex_path+ for _ in range(5): # Check up to 5 levels up+ if (current / ".git").exists():+ return True+ if current.parent == current:+ break+ current = current.parent+ except (AttributeError, OSError):+ # If pipelex.__file__ doesn't exist or path operations fail, not a dev install+ return False+ return False+++def check_readiness() -> None:+ """For development installs, enforces virtual environment activation++ Raises:+ ReadinessCheckError: if development install without virtual environment+ """+ # Then check virtual environment requirement for development installs+ if _is_development_install() and not _is_in_virtual_environment():+ console = Console(stderr=True)+ console.print("\n[bold red]❌ Virtual Environment Required (Development Mode)[/bold red]\n")+ console.print("[yellow]Pipelex is running in development mode but no virtual environment is active.[/yellow]\n")++ # Try to find venv directories and provide specific activation instructions+ found_venvs = _find_venv_directories()+ if found_venvs:+ console.print("[bold cyan]Found virtual environment(s) in your project:[/bold cyan]")+ for venv_name in found_venvs:+ console.print(f" • [green]{venv_name}[/green]")+ console.print()+ console.print("[bold green]To activate your virtual environment:[/bold green]")+ venv_example = found_venvs[0]+ console.print(f" [cyan]source {venv_example}/bin/activate[/cyan] [dim]# On macOS/Linux[/dim]")+ console.print(f" [cyan]{venv_example}\\Scripts\\activate[/cyan] [dim]# On Windows[/dim]\n")+ else:+ console.print("[bold green]To create and activate a virtual environment:[/bold green]")+ console.print(" [cyan]python -m venv .venv[/cyan]")+ console.print(" [cyan]source .venv/bin/activate[/cyan] [dim]# On macOS/Linux[/dim]")+ console.print(" [cyan].venv\\Scripts\\activate[/cyan] [dim]# On Windows[/dim]\n")++ console.print("[bold yellow]Why is this required?[/bold yellow]")+ console.print("Development mode requires a virtual environment to avoid conflicts\nwith system packages and ensure reproducible builds.\n")++ msg = "Development install detected but no virtual environment is active. Please activate your virtual environment and try again."+ raise ReadinessCheckError(msg)diff --git a/pipelex/cogt/llm/llm_worker_internal_abstract.py b/pipelex/cogt/llm/llm_worker_internal_abstract.pyindex e9207af5e..4fe3174ee 100644--- a/pipelex/cogt/llm/llm_worker_internal_abstract.py+++ b/pipelex/cogt/llm/llm_worker_internal_abstract.py@@ -49,7 +49,7 @@ class LLMWorkerInternalAbstract(LLMWorkerAbstract):self,llm_job: LLMJob,):- log.info(f"✨ {self.desc} ✨")+ log.dev(f"✨ {self.desc} ✨")await super()._before_job(llm_job=llm_job)llm_job.llm_job_before_start(inference_model=self.inference_model)if get_config().cogt.llm_config.is_dump_text_prompts_enabled:diff --git a/pipelex/config.py b/pipelex/config.pyindex 4937bb4ca..d2fed92d4 100644--- a/pipelex/config.py+++ b/pipelex/config.py@@ -122,6 +122,12 @@ class ScanConfig(ConfigModel):return frozenset(value)+class BuilderConfig(ConfigModel):+ default_output_dir: str+ default_bundle_file_name: str+ default_directory_base_name: str++class Pipelex(ConfigModel):feature_config: FeatureConfiglog_config: LogConfig@@ -138,6 +144,7 @@ class Pipelex(ConfigModel):reporting_config: ReportingConfigobserver_config: ObserverConfigscan_config: ScanConfig+ builder_config: BuilderConfigclass MigrationConfig(ConfigModel):diff --git a/pipelex/core/pipes/pipe_abstract.py b/pipelex/core/pipes/pipe_abstract.pyindex 44bc6e0e5..0d1e03d31 100644--- a/pipelex/core/pipes/pipe_abstract.py+++ b/pipelex/core/pipes/pipe_abstract.py@@ -10,6 +10,7 @@ from pipelex.core.pipes.input_requirements import InputRequirementsfrom pipelex.core.pipes.pipe_blueprint import PipeBlueprintfrom pipelex.core.pipes.pipe_output import PipeOutputfrom pipelex.exceptions import PipeOperatorModelChoiceError, PipeStackOverflowError+from pipelex.pipe_run.pipe_run_mode import PipeRunModefrom pipelex.pipe_run.pipe_run_params import PipeRunParamsfrom pipelex.pipeline.job_metadata import JobMetadata@@ -112,5 +113,21 @@ class PipeAbstract(ABC, BaseModel):msg = f"Exceeded pipe stack limit of {limit}. You can raise that limit in the config. Stack:\n{pipe_stack}"raise PipeStackOverflowError(message=msg, limit=limit, pipe_stack=pipe_stack)+ def _format_pipe_run_info(self, pipe_run_params: PipeRunParams) -> str:+ indent_level = len(pipe_run_params.pipe_stack) - 1+ indent = " " * indent_level+ if indent_level > 0:+ indent = f"{indent}[yellow]↳[/yellow] "+ pipe_type_label = f"[white]{self.pipe_type}:[/white]"+ match pipe_run_params.run_mode:+ case PipeRunMode.LIVE:+ pass+ case PipeRunMode.DRY:+ pipe_type_label = f"[dim]Dry run:[/dim] {pipe_type_label}"+ pipe_code_label = f"[red]{self.code}[/red]"+ concept_code_label = f"[bold green]{self.output.code}[/bold green]"+ arrow = "[yellow]→[/yellow]"+ return f"{indent}{pipe_type_label} {pipe_code_label} {arrow} {concept_code_label}"+PipeAbstractType = type[PipeAbstract]diff --git a/pipelex/core/stuffs/list_content.py b/pipelex/core/stuffs/list_content.pyindex 06faf471c..bf6df0268 100644--- a/pipelex/core/stuffs/list_content.py+++ b/pipelex/core/stuffs/list_content.py@@ -1,10 +1,12 @@from typing import Any, Genericfrom json2html import json2html+from rich.table import Tablefrom typing_extensions import overridefrom pipelex.cogt.templating.templating_style import TextFormatfrom pipelex.core.stuffs.stuff_content import StuffContent, StuffContentType+from pipelex.tools.misc.pretty import PrettyPrintable, pretty_widthclass ListContent(StuffContent, Generic[StuffContentType]):@@ -80,12 +82,14 @@ class ListContent(StuffContent, Generic[StuffContentType]):return rendered@override- def pretty_print_content(self, title: str | None = None, number: int | None = None) -> None:+ def rendered_for_rich(self, title: str | None = None, number: int | None = None) -> PrettyPrintable:+ table = Table(title=title, show_header=False, show_edge=False, show_lines=True, border_style="white", width=pretty_width(factor=0.8))+ table.add_column("No.", style="yellow", justify="center", width=6)+ table.add_column("Content", style="white")+for item_index, item in enumerate(self.items):- item_number = item_index + 1- if title:- item_title = f"{title} • Item #{item_number}"- else:- item_title = f"Item #{item_index + 1}"- item.pretty_print_content(title=item_title, number=item_number)- print()+ item_number = str(item_index + 1)+ item_content = item.rendered_for_rich()+ table.add_row(item_number, item_content)++ return tablediff --git a/pipelex/core/stuffs/stuff.py b/pipelex/core/stuffs/stuff.pyindex 112871d66..0cda69dc2 100644--- a/pipelex/core/stuffs/stuff.py+++ b/pipelex/core/stuffs/stuff.py@@ -194,7 +194,7 @@ Forbidden fields are: 'stuff_name', 'content_class', 'concept_code', 'stuff_codereturn self.content_as(MermaidContent)def pretty_print_stuff(self, title: str | None = None) -> None:- title = title or f"{self.stuff_name} ({self.concept.code})"+ title = title or f"[cyan]{self.stuff_name}[/cyan] ([bold green]{self.concept.code}[/bold green])"self.content.pretty_print_content(title=title)diff --git a/pipelex/core/stuffs/stuff_content.py b/pipelex/core/stuffs/stuff_content.pyindex 962532aa1..39018ac9d 100644--- a/pipelex/core/stuffs/stuff_content.py+++ b/pipelex/core/stuffs/stuff_content.py@@ -2,11 +2,12 @@ from abc import ABCfrom typing import Any, TypeVarfrom kajson import kajson+from rich.json import JSONfrom typing_extensions import overridefrom pipelex.cogt.templating.templating_style import TextFormatfrom pipelex.tools.misc.json_utils import remove_none_values-from pipelex.tools.misc.pretty import pretty_print+from pipelex.tools.misc.pretty import PrettyPrintable, pretty_print, pretty_widthfrom pipelex.tools.typing.pydantic_utils import CustomBaseModelStuffContentType = TypeVar("StuffContentType", bound="StuffContent")@@ -54,6 +55,9 @@ class StuffContent(ABC, CustomBaseModel):def rendered_json(self) -> str:return kajson.dumps(self.smart_dump(), indent=4)- def pretty_print_content(self, title: str | None = None, number: int | None = None) -> None: # noqa: ARG002+ def rendered_for_rich(self) -> PrettyPrintable:json_content = remove_none_values(json_content=self.smart_dump())- pretty_print(json_content, title=title)+ return JSON.from_data(json_content, indent=4)++ def pretty_print_content(self, title: str | None = None, number: int | None = None) -> None: # noqa: ARG002+ pretty_print(self.rendered_for_rich(), title=title, width=pretty_width())diff --git a/pipelex/core/stuffs/text_content.py b/pipelex/core/stuffs/text_content.pyindex 9140de146..3fa630459 100644--- a/pipelex/core/stuffs/text_content.py+++ b/pipelex/core/stuffs/text_content.py@@ -4,6 +4,7 @@ from typing import Anyimport markdownfrom typing_extensions import override+from pipelex import pretty_print_mdfrom pipelex.core.stuffs.stuff_content import StuffContentfrom pipelex.tools.misc.file_utils import ensure_directory_exists, save_text_to_path@@ -45,3 +46,7 @@ class TextContent(StuffContent):ensure_directory_exists(directory)filename = "text_content.txt"save_text_to_path(text=self.text, path=f"{directory}/{filename}")++ @override+ def pretty_print_content(self, title: str | None = None, number: int | None = None) -> None:+ pretty_print_md(self.text, title=title)diff --git a/pipelex/exceptions.py b/pipelex/exceptions.pyindex ac98bb825..b10ed11be 100644--- a/pipelex/exceptions.py+++ b/pipelex/exceptions.py@@ -111,6 +111,14 @@ class PipelexCLIError(PipelexException, ClickException):"""Raised when there's an error in CLI usage or operation."""+class VirtualEnvironmentError(PipelexCLIError):+ """Raised when the CLI is run outside the required virtual environment."""+++class ReadinessCheckError(PipelexCLIError):+ """Raised when readiness checks fail (missing dependencies or dev mode without venv)."""++class PipelexConfigError(PipelexException):passdiff --git a/pipelex/kit/configs/inference/deck/base_deck.toml b/pipelex/kit/configs/inference/deck/base_deck.tomlindex 12f516755..07dcb3b6f 100644--- a/pipelex/kit/configs/inference/deck/base_deck.toml+++ b/pipelex/kit/configs/inference/deck/base_deck.toml@@ -60,7 +60,7 @@ smart_llm_for_structured = ["claude-4-sonnet","gpt-4o", # we use gpt-4o here rather than gpt-5 until we handle reasoning parameters]-+llm_for_creativity = ["claude-4.1-opus", "gemini-2.5-pro", "gpt-4o"]llm_for_large_codebase = ["gemini-2.5-pro","claude-4.5-sonnet",@@ -81,6 +81,12 @@ cheap_llm_for_vision = ["claude-3-haiku",]cheap_llm_for_structured = ["gpt-4o-mini", "mistral-small", "claude-3-haiku"]+cheap_llm_for_creativity = [+ "gemini-2.5-flash",+ "grok-3-mini",+ "gpt-4o-mini",+ "claude-4.5-haiku",+]##################################################################################################### LLM Presetsdiff --git a/pipelex/kit/configs/pipelex.toml b/pipelex/kit/configs/pipelex.tomlindex a1faa165f..4eca807ed 100644--- a/pipelex/kit/configs/pipelex.toml+++ b/pipelex/kit/configs/pipelex.toml@@ -43,6 +43,11 @@ excluded_dirs = ["results",]+[pipelex.builder_config]+default_output_dir = "results"+default_bundle_file_name = "bundle"+default_directory_base_name = "pipeline"+[pipelex.log_config]default_log_level = "INFO"diff --git a/pipelex/pipe_controllers/pipe_controller.py b/pipelex/pipe_controllers/pipe_controller.pyindex 0fe00ca94..f50088c8f 100644--- a/pipelex/pipe_controllers/pipe_controller.py+++ b/pipelex/pipe_controllers/pipe_controller.py@@ -53,14 +53,10 @@ class PipeController(PipeAbstract):# check we have the required inputs in the working memoryself._validate_inputs_in_memory(working_memory=working_memory)+ pipe_run_info = self._format_pipe_run_info(pipe_run_params=pipe_run_params)+ log.info(pipe_run_info)match pipe_run_params.run_mode:case PipeRunMode.LIVE:- indent_level = len(pipe_run_params.pipe_stack) - 1- indent = " " * indent_level- label = (- f"{indent}{'[yellow]↳[/yellow]' if indent_level > 0 else ''} Running [blue]{self.class_name}[/blue] → [green]{self.code}[/green]"- )- log.info(f"{label} → [red]{self.output.code}[/red]")pipe_output = await self._run_controller_pipe(job_metadata=job_metadata,working_memory=working_memory,@@ -68,11 +64,6 @@ class PipeController(PipeAbstract):output_name=output_name,)case PipeRunMode.DRY:- name = f"Dry running [blue]{self.class_name}[/blue]"- indent_level = len(pipe_run_params.pipe_stack) - 1- indent = " " * indent_level- label = f"{indent}{'[yellow]↳[/yellow]' if indent_level > 0 else ''} {name}: [green]{self.code}[/green]"- log.info(f"{label} → [red]{self.output.code}[/red]")pipe_output = await self._dry_run_controller_pipe(job_metadata=job_metadata,working_memory=working_memory,diff --git a/pipelex/pipe_operators/pipe_operator.py b/pipelex/pipe_operators/pipe_operator.pyindex 67aa04255..5fb9653a5 100644--- a/pipelex/pipe_operators/pipe_operator.py+++ b/pipelex/pipe_operators/pipe_operator.py@@ -1,19 +1,21 @@from abc import abstractmethod-from typing import Generic, Literal, TypeVar+from typing import TYPE_CHECKING, Generic, Literal, TypeVarfrom typing_extensions import override-from pipelex import log, pretty_print_md+from pipelex import logfrom pipelex.cogt.exceptions import ModelNotFoundError, ModelWaterfallErrorfrom pipelex.core.memory.working_memory import WorkingMemoryfrom pipelex.core.pipes.pipe_abstract import PipeAbstractfrom pipelex.core.pipes.pipe_output import PipeOutput-from pipelex.core.stuffs.text_content import TextContentfrom pipelex.exceptions import PipeOperatorModelAvailabilityErrorfrom pipelex.pipe_run.pipe_run_mode import PipeRunModefrom pipelex.pipe_run.pipe_run_params import PipeRunParamsfrom pipelex.pipeline.job_metadata import JobMetadata+if TYPE_CHECKING:+ from pipelex.core.stuffs.list_content import ListContent+ from pipelex.core.stuffs.stuff_content import StuffContentPipeOperatorOutputType = TypeVar("PipeOperatorOutputType", bound=PipeOutput)@@ -41,35 +43,27 @@ class PipeOperator(PipeAbstract, Generic[PipeOperatorOutputType]):)job_metadata.update(updated_metadata=updated_metadata)+ pipe_run_info = self._format_pipe_run_info(pipe_run_params=pipe_run_params)+ log.info(pipe_run_info)try:match pipe_run_params.run_mode:case PipeRunMode.LIVE:- if self.class_name not in ["PipeCompose", "PipeLLMPrompt"]:- name = f"Running [cyan]{self.class_name}[/cyan]"- indent_level = len(pipe_run_params.pipe_stack) - 1- indent = " " * indent_level- label = f"{indent}{'[yellow]↳[/yellow]' if indent_level > 0 else ''} {name} → [green]{self.code}[/green]"- log.info(f"{label} → [red]{self.output.code}[/red]")pipe_output = await self._run_operator_pipe(job_metadata=job_metadata,working_memory=working_memory,pipe_run_params=pipe_run_params,output_name=output_name,)- if isinstance(pipe_output.main_stuff.content, TextContent):- print()- pretty_print_md(pipe_output.main_stuff_as_str, title=f"PipeOutput of pipe {self.code}")- print()- else:- print()- pipe_output.main_stuff.pretty_print_stuff(title=f"PipeOutput of pipe {self.code}: {self.output.code}")- print()+ main_stuff = pipe_output.main_stuff+ output_concept_code = self.output.code+ output_concept_with_multiplicity = f"[bold green]{output_concept_code}[/bold green]"+ if main_stuff.is_list:+ list_content: ListContent[StuffContent] = main_stuff.as_list_content() # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]+ nb_items = len(list_content.items)+ output_concept_with_multiplicity = f" ({nb_items} items)"+ title = f"Output of pipe [red]{self.code}[/red]: {output_concept_with_multiplicity}"+ main_stuff.pretty_print_stuff(title=title)case PipeRunMode.DRY:- name = f"Dry run [cyan]{self.class_name}[/cyan]"- indent_level = len(pipe_run_params.pipe_stack) - 1- indent = " " * indent_level- label = f"{indent}{'[yellow]↳[/yellow]' if indent_level > 0 else ''} {name}: [green]{self.code}[/green]"- log.info(f"{label} → [red]{self.output.code}[/red]")pipe_output = await self._dry_run_operator_pipe(job_metadata=job_metadata,working_memory=working_memory,diff --git a/pipelex/pipe_run/dry_run.py b/pipelex/pipe_run/dry_run.pyindex e0c0971aa..650ee9320 100644--- a/pipelex/pipe_run/dry_run.py+++ b/pipelex/pipe_run/dry_run.py@@ -66,7 +66,7 @@ async def dry_run_pipe(pipe: PipeAbstract, raise_on_failure: bool = False) -> Drerror_message = f"Dry run failed for pipe '{pipe.code}': {exc}"return DryRunOutput(pipe_code=pipe.code, status=DryRunStatus.FAILURE, error_message=error_message)- log.info(f"✅ Pipe '{pipe.code}' dry run completed successfully")+ log.dev(f"✅ Pipe '{pipe.code}' dry run completed successfully")return DryRunOutput(pipe_code=pipe.code, status=DryRunStatus.SUCCESS)@@ -137,7 +137,7 @@ async def dry_run_pipes(pipes: list[PipeAbstract], run_in_parallel: bool = True,unexpected_failures = {pipe_code: results[pipe_code] for pipe_code in failed_pipes if pipe_code not in allowed_to_fail_pipes}- log.info(+ log.dev(f"Dry run completed: {len(successful_pipes)} successful, {len(failed_pipes)} failed, "f"{len(allowed_to_fail_pipes)} allowed to fail, in {time.time() - start_time:.2f} seconds",)diff --git a/pipelex/pipelex.py b/pipelex/pipelex.pyindex f5145b725..8529641ed 100644--- a/pipelex/pipelex.py+++ b/pipelex/pipelex.py@@ -53,9 +53,19 @@ from pipelex.system.environment import get_optional_envfrom pipelex.system.registries.func_registry import func_registryfrom pipelex.system.runtime import IntegrationMode, runtime_managerfrom pipelex.system.telemetry.observer_telemetry import ObserverTelemetry-from pipelex.system.telemetry.telemetry_config import TELEMETRY_CONFIG_FILE_NAME, TelemetryConfig, TelemetryMode-from pipelex.system.telemetry.telemetry_manager import DO_NOT_TRACK_ENV_VAR_KEY, TelemetryManager-from pipelex.system.telemetry.telemetry_manager_abstract import TelemetryManagerAbstract, TelemetryManagerNoOp+from pipelex.system.telemetry.telemetry_config import (+ TELEMETRY_CONFIG_FILE_NAME,+ TelemetryConfig,+ TelemetryMode,+)+from pipelex.system.telemetry.telemetry_manager import (+ DO_NOT_TRACK_ENV_VAR_KEY,+ TelemetryManager,+)+from pipelex.system.telemetry.telemetry_manager_abstract import (+ TelemetryManagerAbstract,+ TelemetryManagerNoOp,+)from pipelex.test_extras.registry_test_models import TestRegistryModelsfrom pipelex.tools.misc.package_utils import get_package_infofrom pipelex.tools.misc.toml_utils import load_toml_from_path@@ -207,15 +217,15 @@ If you need help, drop by our Discord: we're happy to assist: {URLs.discord}.backend_name = credentials_exc.backend_namevar_name = credentials_exc.key_nameerror_msg: str- if secrets_provider:+ if isinstance(secrets_provider, EnvSecretsProvider):error_msg = (- f"Could not get credentials for inference backend '{backend_name}':\n{credentials_exc},"- f"\ncheck that secret '{var_name}' is available from your secrets provider."+ f"Could not get credentials for inference backend '{backend_name}':\n{credentials_exc},\n"+ f"you need to add '{var_name}' to your environment variables or to your .env file.")else:error_msg = (f"Could not get credentials for inference backend '{backend_name}':\n{credentials_exc},\n"- f"you need to add '{var_name}' to your environment variables or to your .env file."+ f"check that secret '{var_name}' is available from your secrets provider.")if credentials_exc.backend_name == "pipelex_inference":error_msg += (diff --git a/pipelex/pipelex.toml b/pipelex/pipelex.tomlindex ed8b85fb2..443ce0900 100644--- a/pipelex/pipelex.toml+++ b/pipelex/pipelex.toml@@ -21,6 +21,11 @@ excluded_dirs = ["results",]+[pipelex.builder_config]+default_output_dir = "results"+default_bundle_file_name = "bundle"+default_directory_base_name = "pipeline"+[pipelex.feature_config]# WIP/Experimental feature flagsis_pipeline_tracking_enabled = falsediff --git a/pipelex/system/configuration/config_check.py b/pipelex/system/configuration/config_check.pynew file mode 100644index 000000000..d2ce7d298--- /dev/null+++ b/pipelex/system/configuration/config_check.py@@ -0,0 +1,57 @@+from rich.console import Console+from rich.panel import Panel++from pipelex.cli.commands.init.config_files import init_config+from pipelex.config import ConfigPaths+from pipelex.tools.misc.file_utils import path_exists+from pipelex.urls import URLs+++def check_is_initialized(print_warning_if_not: bool = True) -> bool:+ backends_toml_path = ConfigPaths.BACKENDS_FILE_PATH+ routing_profiles_toml_path = ConfigPaths.ROUTING_PROFILES_FILE_PATH++ # Check critical files+ config_exists = init_config(reset=False, dry_run=True) == 0+ backends_exists = path_exists(backends_toml_path)+ routing_exists = path_exists(routing_profiles_toml_path)++ is_initialized = config_exists and backends_exists and routing_exists++ if not is_initialized and print_warning_if_not:+ console = Console()++ # Build a descriptive message about what's missing+ issues: list[str] = []+ if not config_exists:+ issues.append("[yellow]•[/yellow] Configuration files not configured")+ if not backends_exists:+ issues.append("[yellow]•[/yellow] Inference backends not configured")+ if not routing_exists:+ issues.append("[yellow]•[/yellow] Routing profiles not configured")++ issues_text = "\n".join(issues) if issues else "[yellow]•[/yellow] Configuration incomplete"++ message = f"""[bold red]⚠️ Pipelex is not initialized[/bold red]++{issues_text}++[bold cyan]To initialize Pipelex, run:[/bold cyan]++[bold green]pipelex init[/bold green]++This will set up all required configuration files and guide you through+selecting inference backends and routing profiles.++[dim]Need help? Visit our Discord: {URLs.discord}[/dim]"""++ panel = Panel(+ message,+ border_style="red",+ padding=(1, 2),+ )++ console.print()+ console.print(panel)+ console.print()+ return is_initializeddiff --git a/pipelex/tools/misc/pretty.py b/pipelex/tools/misc/pretty.pyindex 42a9e4d19..4815bfad0 100644--- a/pipelex/tools/misc/pretty.py+++ b/pipelex/tools/misc/pretty.py@@ -1,11 +1,15 @@import shutilfrom typing import Any, ClassVar+from kajson import kajsonfrom rich import print as rich_print+from rich.console import Group+from rich.json import JSONfrom rich.markdown import Markdownfrom rich.panel import Panelfrom rich.pretty import Prettyfrom rich.style import StyleType+from rich.syntax import Syntaxfrom rich.table import Tablefrom rich.text import Text, TextType@@ -16,24 +20,41 @@ TEXT_COLOR = TerminalColor.WHITETITLE_COLOR = TerminalColor.CYANBORDER_COLOR = TerminalColor.YELLOW+PRETTY_WIDTH_MIN = 125++PrettyPrintable = Markdown | Text | JSON | Table | Group+++def pretty_width(width: int | None = None, factor: float | None = None) -> int:+ terminal_width = shutil.get_terminal_size().columns+ absolute_width = width or min(max(PRETTY_WIDTH_MIN, int(terminal_width / 2)), terminal_width)+ if factor:+ return int(absolute_width * factor)+ return absolute_width+def pretty_print(content: str | Any,title: TextType | None = None,subtitle: TextType | None = None,+ inner_title: str | None = None,border_style: StyleType | None = None,+ width: int | None = None,):- PrettyPrinter.pretty_print(content=content, title=title, subtitle=subtitle, border_style=border_style)+ PrettyPrinter.pretty_print(content=content, title=title, subtitle=subtitle, inner_title=inner_title, border_style=border_style, width=width)def pretty_print_md(content: str,title: TextType | None = None,subtitle: TextType | None = None,+ inner_title: str | None = None,border_style: StyleType | None = None,+ width: int | None = None,):+ width = width or pretty_width()md_content = Markdown(content)- PrettyPrinter.pretty_print(content=md_content, title=title, subtitle=subtitle, border_style=border_style)+ PrettyPrinter.pretty_print(content=md_content, title=title, subtitle=subtitle, inner_title=inner_title, border_style=border_style, width=width)class PrettyPrintMode(StrEnum):@@ -50,13 +71,22 @@ class PrettyPrinter:content: str | Any,title: TextType | None = None,subtitle: TextType | None = None,+ inner_title: str | None = None,border_style: StyleType | None = None,+ width: int | None = None,):match cls.mode:case PrettyPrintMode.RICH:- cls.pretty_print_using_rich(content=content, title=title, subtitle=subtitle, border_style=border_style)+ cls.pretty_print_using_rich(+ content=content,+ title=title,+ subtitle=subtitle,+ inner_title=inner_title,+ border_style=border_style,+ width=width,+ )case PrettyPrintMode.POOR:- cls.pretty_print_without_rich(content=content, title=title, subtitle=subtitle)+ cls.pretty_print_without_rich(content=content, title=title, subtitle=subtitle, inner_title=inner_title)@classmethoddef pretty_print_using_rich(@@ -64,26 +94,30 @@ class PrettyPrinter:content: str | Any,title: TextType | None = None,subtitle: TextType | None = None,+ inner_title: str | None = None,border_style: StyleType | None = None,+ width: int | None = None,):if isinstance(content, str):if content.startswith(("http://", "https://")):content = Text(content, style="link " + content, no_wrap=True)else:content = Text(str(content)) # Treat all other strings as plain text- elif isinstance(content, Table):- # For tables, print directly without a panel- if title:- rich_print(f"\n[bold blue]{title}[/]\n")- rich_print(content)- rich_print("\n")- if subtitle:- rich_print(f"\n[dim]{subtitle}[/]")- return- elif isinstance(content, Markdown):- print("\n")+ elif isinstance(content, (Pretty, JSON, Table, Markdown, Group)):+ pass+ elif isinstance(content, dict):+ try:+ content = JSON.from_data(content, indent=4)+ except TypeError:+ json_string = kajson.dumps(content, indent=4)+ content = Syntax(json_string, "json", theme="monokai")else:content = Pretty(content)++ if inner_title:+ inner_title_text = Text(str(inner_title), style="dim")+ content = Group(inner_title_text, content)+ rich_print()panel = Panel(content,title=title,@@ -91,10 +125,13 @@ class PrettyPrinter:expand=False,title_align="left",subtitle_align="right",- padding=(0, 1),+ padding=(1, 1),border_style=border_style or "",+ highlight=True,+ width=width,)rich_print(panel)+ rich_print()@classmethoddef pretty_print_without_rich(@@ -102,16 +139,25 @@ class PrettyPrinter:content: str | Any,title: TextType | None = None,subtitle: TextType | None = None,+ inner_title: str | None = None,):if isinstance(content, str) and content.startswith(("http://", "https://")):cls.pretty_print_url_without_rich(content=content, title=title, subtitle=subtitle)return- title = title or ""+ title_str = str(title) if title else ""if subtitle:- title += f" ({subtitle})"+ title_str += f"\n{subtitle!s}"+ if inner_title:+ title_str += f"\n{inner_title}"terminal_width = shutil.get_terminal_size().columnscontent_str = f"{content}"- max_content_width = terminal_width - len(title) - 8 # Accounting for frame and padding++ # Split title into lines if it contains newlines+ title_lines = title_str.splitlines() if title_str else []++ # Calculate max content width based on longest title line+ max_title_len = max(len(line) for line in title_lines) if title_lines else 0+ max_content_width = terminal_width - max_title_len - 8 # Accounting for frame and paddingwrapped_lines: list[str] = []for line in content_str.splitlines():while len(line) > max_content_width:@@ -122,13 +168,18 @@ class PrettyPrinter:if not wrapped_lines:wrapped_lines.append("")- frame_width = max(len(title) + 6, max(len(line) for line in wrapped_lines) + 6)+ # Calculate frame width based on longest title line and content lines+ max_title_width = max((len(line) for line in title_lines), default=0)+ max_content_line_width = max(len(line) for line in wrapped_lines)+ frame_width = max(max_title_width + 6, max_content_line_width + 6)top_border = "╭" + "─" * (frame_width - 2) + "╮"bottom_border = "╰" + "─" * (frame_width - 2) + "╯"print(f"{BORDER_COLOR}{top_border}{RESET_FONT}")- if title:- print(f"{BORDER_COLOR}│ {BOLD_FONT}{TITLE_COLOR}{title}{RESET_FONT}:{' ' * (frame_width - len(title) - 4)}{BORDER_COLOR}│{RESET_FONT}")+ # Print each title line separately+ for title_line in title_lines:+ padding = " " * (frame_width - len(title_line) - 4)+ print(f"{BORDER_COLOR}│ {BOLD_FONT}{TITLE_COLOR}{title_line}{RESET_FONT}:{padding}{BORDER_COLOR}│{RESET_FONT}")for line in wrapped_lines:padding = " " * (frame_width - len(line) - 3)print(f"{BORDER_COLOR}│ {TEXT_COLOR}{line}{RESET_FONT}{padding}{BORDER_COLOR}│{RESET_FONT}")diff --git a/tests/unit/builder/pipe/pipe_operator/pipe_extract/test_extract_skill_presets.py b/tests/unit/builder/pipe/pipe_operator/pipe_extract/test_extract_skill_presets.pynew file mode 100644index 000000000..b69dca574--- /dev/null+++ b/tests/unit/builder/pipe/pipe_operator/pipe_extract/test_extract_skill_presets.py@@ -0,0 +1,45 @@+import pytest++from pipelex.builder.pipe.pipe_extract_spec import ExtractSkill+from pipelex.cogt.exceptions import ModelChoiceNotFoundError+from pipelex.cogt.models.model_deck_check import check_extract_choice_with_deck+++class TestExtractSkill:+ """Test that all ExtractSkill enum values are valid ExtractModelChoice values in the model deck."""++ def test_all_extract_skills_are_valid_extract_choices(self):+ """Verify that every ExtractSkill enum value can be resolved as a valid ExtractModelChoice.++ This ensures that all skill-based extraction choices referenced in code are actually+ configured in the model deck (as presets, waterfalls, aliases, or direct model names)+ and available at runtime.+ """+ # Get all Extract skill values+ all_extract_skills = [skill.value for skill in ExtractSkill]++ # Act & Assert+ invalid_choices: list[str] = []+ for skill_value in all_extract_skills:+ try:+ # Use check_extract_choice_with_deck to validate - this checks both presets and handles+ check_extract_choice_with_deck(skill_value)+ except ModelChoiceNotFoundError:+ invalid_choices.append(skill_value)++ # Provide clear error message if any choices are invalid+ assert not invalid_choices, (+ f"The following ExtractSkill values are not valid extraction choices in the model deck: "+ f"{', '.join(invalid_choices)}. "+ f"Please add them as presets, waterfalls, aliases, or ensure they exist as direct model names "+ f"in .pipelex/inference/deck/base_deck.toml or overrides.toml"+ )++ def test_individual_extract_skills_are_valid(self):+ """Test each ExtractSkill value individually for better error reporting."""+ for skill in ExtractSkill:+ try:+ # Use check_extract_choice_with_deck to validate - this checks both presets and handles+ check_extract_choice_with_deck(skill.value)+ except ModelChoiceNotFoundError as e:+ pytest.fail(f"ExtractSkill.{skill.name} ('{skill.value}') is not a valid extraction choice in the model deck. Error: {e}")diff --git a/tests/unit/builder/pipe/pipe_operator/pipe_img_gen/test_img_gen_skill_presets.py b/tests/unit/builder/pipe/pipe_operator/pipe_img_gen/test_img_gen_skill_presets.pynew file mode 100644index 000000000..e4975b397--- /dev/null+++ b/tests/unit/builder/pipe/pipe_operator/pipe_img_gen/test_img_gen_skill_presets.py@@ -0,0 +1,45 @@+import pytest++from pipelex.builder.pipe.pipe_img_gen_spec import ImgGenSkill+from pipelex.cogt.exceptions import ModelChoiceNotFoundError+from pipelex.cogt.models.model_deck_check import check_img_gen_choice_with_deck+++class TestImgGenSkill:+ """Test that all ImgGenSkill enum values are valid ImgGenModelChoice values in the model deck."""++ def test_all_img_gen_skills_are_valid_img_gen_choices(self):+ """Verify that every ImgGenSkill enum value can be resolved as a valid ImgGenModelChoice.++ This ensures that all skill-based image generation choices referenced in code are actually+ configured in the model deck (as presets, waterfalls, aliases, or direct model names)+ and available at runtime.+ """+ # Get all ImgGen skill values+ all_img_gen_skills = [skill.value for skill in ImgGenSkill]++ # Act & Assert+ invalid_choices: list[str] = []+ for skill_value in all_img_gen_skills:+ try:+ # Use check_img_gen_choice_with_deck to validate - this checks both presets and handles+ check_img_gen_choice_with_deck(skill_value)+ except ModelChoiceNotFoundError:+ invalid_choices.append(skill_value)++ # Provide clear error message if any choices are invalid+ assert not invalid_choices, (+ f"The following ImgGenSkill values are not valid image generation choices in the model deck: "+ f"{', '.join(invalid_choices)}. "+ f"Please add them as presets, waterfalls, aliases, or ensure they exist as direct model names "+ f"in .pipelex/inference/deck/base_deck.toml or overrides.toml"+ )++ def test_individual_img_gen_skills_are_valid(self):+ """Test each ImgGenSkill value individually for better error reporting."""+ for skill in ImgGenSkill:+ try:+ # Use check_img_gen_choice_with_deck to validate - this checks both presets and handles+ check_img_gen_choice_with_deck(skill.value)+ except ModelChoiceNotFoundError as e:+ pytest.fail(f"ImgGenSkill.{skill.name} ('{skill.value}') is not a valid image generation choice in the model deck. Error: {e}")diff --git a/tests/unit/builder/pipe/pipe_operator/pipe_llm/test_llm_skill_presets.py b/tests/unit/builder/pipe/pipe_operator/pipe_llm/test_llm_skill_presets.pynew file mode 100644index 000000000..bf418f7ef--- /dev/null+++ b/tests/unit/builder/pipe/pipe_operator/pipe_llm/test_llm_skill_presets.py@@ -0,0 +1,45 @@+import pytest++from pipelex.builder.pipe.pipe_llm_spec import LLMSkill+from pipelex.cogt.exceptions import ModelChoiceNotFoundError+from pipelex.cogt.models.model_deck_check import check_llm_choice_with_deck+++class TestLLMSkill:+ """Test that all LLMSkill enum values are valid LLMModelChoice values in the model deck."""++ def test_all_llm_skills_are_valid_llm_choices(self):+ """Verify that every LLMSkill enum value can be resolved as a valid LLMModelChoice.++ This ensures that all skill-based LLM choices referenced in code are actually+ configured in the model deck (as presets, waterfalls, aliases, or direct model names)+ and available at runtime.+ """+ # Get all LLM skill values+ all_llm_skills = [skill.value for skill in LLMSkill]++ # Act & Assert+ invalid_choices: list[str] = []+ for skill_value in all_llm_skills:+ try:+ # Use check_llm_choice_with_deck to validate - this checks both presets and handles (including waterfalls)+ check_llm_choice_with_deck(skill_value)+ except ModelChoiceNotFoundError:+ invalid_choices.append(skill_value)++ # Provide clear error message if any choices are invalid+ assert not invalid_choices, (+ f"The following LLMSkill values are not valid LLM choices in the model deck: "+ f"{', '.join(invalid_choices)}. "+ f"Please add them as presets, waterfalls, aliases, or ensure they exist as direct model names "+ f"in .pipelex/inference/deck/base_deck.toml or overrides.toml"+ )++ def test_individual_llm_skills_are_valid(self):+ """Test each LLMSkill value individually for better error reporting."""+ for skill in LLMSkill:+ try:+ # Use check_llm_choice_with_deck to validate - this checks both presets and handles (including waterfalls)+ check_llm_choice_with_deck(skill.value)+ except ModelChoiceNotFoundError as e:+ pytest.fail(f"LLMSkill.{skill.name} ('{skill.value}') is not a valid LLM choice in the model deck. Error: {e}")diff --git a/tests/unit/test_pipelex_check_initialization.py b/tests/unit/test_pipelex_check_initialization.pynew file mode 100644index 000000000..a8eb96e8e--- /dev/null+++ b/tests/unit/test_pipelex_check_initialization.py@@ -0,0 +1,177 @@+from __future__ import annotations++from typing import TYPE_CHECKING++if TYPE_CHECKING:+ from pathlib import Path++ from pytest_mock import MockerFixture++from pipelex.config import ConfigPaths+from pipelex.system.configuration.config_check import check_is_initialized+++class TestPipelexCheckInitialization:+ """Test the check_is_initialized function from config_check module."""++ def test_check_is_initialized_returns_true_when_all_files_exist(self, tmp_path: Path, mocker: MockerFixture) -> None:+ """Test that check_is_initialized returns True when all required files exist."""+ # Setup test directories+ config_dir = tmp_path / ".pipelex" / "inference"+ config_dir.mkdir(parents=True)+ backends_file = config_dir / "backends.toml"+ routing_file = config_dir / "routing_profiles.toml"+ backends_file.write_text("[backends]\nconfig = 'value'")+ routing_file.write_text("[routing]\nconfig = 'value'")++ # Mock ConfigPaths to point to temp directory+ mocker.patch.object(ConfigPaths, "BACKENDS_FILE_PATH", str(backends_file))+ mocker.patch.object(ConfigPaths, "ROUTING_PROFILES_FILE_PATH", str(routing_file))++ # Test+ result = check_is_initialized()++ # Verify+ assert result is True++ def test_check_is_initialized_returns_false_when_backends_missing(self, tmp_path: Path, mocker: MockerFixture) -> None:+ """Test that check_is_initialized returns False when backends.toml is missing."""+ # Setup test directories - only routing file exists+ config_dir = tmp_path / ".pipelex" / "inference"+ config_dir.mkdir(parents=True)+ backends_file = config_dir / "backends.toml"+ routing_file = config_dir / "routing_profiles.toml"+ routing_file.write_text("[routing]\nconfig = 'value'")++ # Mock ConfigPaths to point to temp directory+ mocker.patch.object(ConfigPaths, "BACKENDS_FILE_PATH", str(backends_file))+ mocker.patch.object(ConfigPaths, "ROUTING_PROFILES_FILE_PATH", str(routing_file))++ # Test+ result = check_is_initialized(print_warning_if_not=False)++ # Verify+ assert result is False++ def test_check_is_initialized_returns_false_when_routing_missing(self, tmp_path: Path, mocker: MockerFixture) -> None:+ """Test that check_is_initialized returns False when routing_profiles.toml is missing."""+ # Setup test directories - only backends file exists+ config_dir = tmp_path / ".pipelex" / "inference"+ config_dir.mkdir(parents=True)+ backends_file = config_dir / "backends.toml"+ routing_file = config_dir / "routing_profiles.toml"+ backends_file.write_text("[backends]\nconfig = 'value'")++ # Mock ConfigPaths to point to temp directory+ mocker.patch.object(ConfigPaths, "BACKENDS_FILE_PATH", str(backends_file))+ mocker.patch.object(ConfigPaths, "ROUTING_PROFILES_FILE_PATH", str(routing_file))++ # Test+ result = check_is_initialized(print_warning_if_not=False)++ # Verify+ assert result is False++ def test_check_is_initialized_returns_false_when_all_files_missing(self, tmp_path: Path, mocker: MockerFixture) -> None:+ """Test that check_is_initialized returns False when both required files are missing."""+ # Setup test directories - no files exist+ config_dir = tmp_path / ".pipelex" / "inference"+ config_dir.mkdir(parents=True)+ backends_file = config_dir / "backends.toml"+ routing_file = config_dir / "routing_profiles.toml"++ # Mock ConfigPaths to point to temp directory+ mocker.patch.object(ConfigPaths, "BACKENDS_FILE_PATH", str(backends_file))+ mocker.patch.object(ConfigPaths, "ROUTING_PROFILES_FILE_PATH", str(routing_file))++ # Test+ result = check_is_initialized(print_warning_if_not=False)++ # Verify+ assert result is False++ def test_check_is_initialized_prints_warning_when_not_initialized(self, tmp_path: Path, mocker: MockerFixture) -> None:+ """Test that check_is_initialized prints warning and returns False when not initialized and print_warning_if_not is True."""+ # Setup test directories - no files exist+ config_dir = tmp_path / ".pipelex" / "inference"+ config_dir.mkdir(parents=True)+ backends_file = config_dir / "backends.toml"+ routing_file = config_dir / "routing_profiles.toml"++ # Mock ConfigPaths to point to temp directory+ mocker.patch.object(ConfigPaths, "BACKENDS_FILE_PATH", str(backends_file))+ mocker.patch.object(ConfigPaths, "ROUTING_PROFILES_FILE_PATH", str(routing_file))++ # Mock console.print to suppress output during test+ mock_console_print = mocker.patch("pipelex.system.configuration.config_check.Console.print")++ # Test - should print warning and return False+ result = check_is_initialized(print_warning_if_not=True)++ # Verify+ assert result is False+ assert mock_console_print.called++ def test_check_is_initialized_returns_true_when_initialized_with_print_warning(self, tmp_path: Path, mocker: MockerFixture) -> None:+ """Test that check_is_initialized returns True when initialized with print_warning_if_not=True."""+ # Setup test directories - all files exist+ config_dir = tmp_path / ".pipelex" / "inference"+ config_dir.mkdir(parents=True)+ backends_file = config_dir / "backends.toml"+ routing_file = config_dir / "routing_profiles.toml"+ backends_file.write_text("[backends]\nconfig = 'value'")+ routing_file.write_text("[routing]\nconfig = 'value'")++ # Mock ConfigPaths to point to temp directory+ mocker.patch.object(ConfigPaths, "BACKENDS_FILE_PATH", str(backends_file))+ mocker.patch.object(ConfigPaths, "ROUTING_PROFILES_FILE_PATH", str(routing_file))++ # Test+ result = check_is_initialized(print_warning_if_not=True)++ # Verify+ assert result is True++ def test_check_is_initialized_returns_false_with_only_backends_missing(self, tmp_path: Path, mocker: MockerFixture) -> None:+ """Test that check_is_initialized returns False when only backends file is missing."""+ # Setup test directories - only routing file exists+ config_dir = tmp_path / ".pipelex" / "inference"+ config_dir.mkdir(parents=True)+ backends_file = config_dir / "backends.toml"+ routing_file = config_dir / "routing_profiles.toml"+ routing_file.write_text("[routing]\nconfig = 'value'")++ # Mock ConfigPaths to point to temp directory+ mocker.patch.object(ConfigPaths, "BACKENDS_FILE_PATH", str(backends_file))+ mocker.patch.object(ConfigPaths, "ROUTING_PROFILES_FILE_PATH", str(routing_file))++ # Mock console.print to suppress output during test+ mocker.patch("pipelex.system.configuration.config_check.Console.print")++ # Test+ result = check_is_initialized(print_warning_if_not=True)++ # Verify+ assert result is False++ def test_check_is_initialized_returns_false_with_only_routing_missing(self, tmp_path: Path, mocker: MockerFixture) -> None:+ """Test that check_is_initialized returns False when only routing file is missing."""+ # Setup test directories - only backends file exists+ config_dir = tmp_path / ".pipelex" / "inference"+ config_dir.mkdir(parents=True)+ backends_file = config_dir / "backends.toml"+ routing_file = config_dir / "routing_profiles.toml"+ backends_file.write_text("[backends]\nconfig = 'value'")++ # Mock ConfigPaths to point to temp directory+ mocker.patch.object(ConfigPaths, "BACKENDS_FILE_PATH", str(backends_file))+ mocker.patch.object(ConfigPaths, "ROUTING_PROFILES_FILE_PATH", str(routing_file))++ # Mock console.print to suppress output during test+ mocker.patch("pipelex.system.configuration.config_check.Console.print")++ # Test+ result = check_is_initialized(print_warning_if_not=True)++ # Verify+ assert result is Falsediff --git a/tests/unit/tools/misc/test_pretty.py b/tests/unit/tools/misc/test_pretty.pyindex 31c91172f..0839fbc6c 100644--- a/tests/unit/tools/misc/test_pretty.py+++ b/tests/unit/tools/misc/test_pretty.py@@ -42,9 +42,13 @@ class TestPrettyPrint:captured = capsys.readouterr()output = remove_ansi_escape_codes(captured.out)expected_output = textwrap.dedent("""\+╭─ title ─────────╮+ │ ││ Optional[float] │+ │ │╰─────────────────╯+""")assert output == expected_output, f"Output did not match expected:\n{output}"@@ -56,9 +60,13 @@ class TestPrettyPrint:output = remove_ansi_escape_codes(captured.out)expected_output = textwrap.dedent("""\+╭─ title ──────────────────────────────────────────────╮+ │ ││ SomethingBeforeBracketsAnd[SomethingBetweenBrackets] │+ │ │╰──────────────────────────────────────────────────────╯+""")assert output == expected_output, f"Output did not match expected:\n{output}"@@ -70,9 +78,13 @@ class TestPrettyPrint:output = remove_ansi_escape_codes(captured.out)expected_output = textwrap.dedent("""\+╭─ title ─────────────╮+ │ ││ List[Optional[int]] │+ │ │╰─────────────────────╯+""")assert output == expected_output, f"Output did not match expected:\n{output}"@@ -84,9 +96,13 @@ class TestPrettyPrint:output = remove_ansi_escape_codes(captured.out)expected_output = textwrap.dedent("""\+╭─ title ───────────────────────────────╮+ │ ││ Union[str, List[int], Dict[str, Any]] │+ │ │╰───────────────────────────────────────╯+""")assert output == expected_output, f"Output did not match expected:\n{output}"@@ -98,9 +114,13 @@ class TestPrettyPrint:output = remove_ansi_escape_codes(captured.out)expected_output = textwrap.dedent("""\+╭─ title ─────────────────────╮+ │ ││ @decorator[*args, **kwargs] │+ │ │╰─────────────────────────────╯+""")assert output == expected_output, f"Output did not match expected:\n{output}"@@ -112,9 +132,13 @@ class TestPrettyPrint:output = remove_ansi_escape_codes(captured.out)expected_output = textwrap.dedent("""\+╭─ title ─╮+ │ ││ List[] │+ │ │╰─────────╯+""")assert output == expected_output, f"Output did not match expected:\n{output}"@@ -126,9 +150,13 @@ class TestPrettyPrint:output = remove_ansi_escape_codes(captured.out)expected_output = textwrap.dedent("""\+╭─ title ───────────╮+ │ ││ Unmatched[bracket │+ │ │╰───────────────────╯+""")assert output == expected_output, f"Output did not match expected:\n{output}"@@ -140,9 +168,13 @@ class TestPrettyPrint:output = remove_ansi_escape_codes(captured.out)expected_output = textwrap.dedent("""\+╭─ title ────────────╮+ │ ││ 🐍Python[版本3.11] │+ │ │╰────────────────────╯+""")assert output == expected_output, f"Output did not match expected:\n{output}"@@ -218,10 +250,11 @@ class TestPrettyPrintInSandbox:output = remove_ansi_escape_codes(captured.out)expected_output = textwrap.dedent("""\- ╭────────────────────╮- │ title (subtitle): │- │ None │- ╰────────────────────╯+ ╭────────────╮+ │ title: │+ │ subtitle: │+ │ None │+ ╰────────────╯""")assert output == expected_output, f"Output did not match expected:\n{output}"diff --git a/uv.lock b/uv.lockindex 5b454f5eb..083c80325 100644--- a/uv.lock+++ b/uv.lock@@ -307,16 +307,16 @@ wheels = [[[package]]name = "boto3-stubs"-version = "1.40.64"+version = "1.40.69"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/ab/af/362ed100e01551b36558da328dfdd4c3307a112915cef92a18cf3af7c8db/boto3_stubs-1.40.64.tar.gz", hash = "sha256:af4a7fb67bda0c1277afcd45a25065605567d260a8afd34bbdf1799d2492334f", size = 99647, upload-time = "2025-10-31T19:47:34.613Z" }+sdist = { url = "https://files.pythonhosted.org/packages/e3/f7/10c3314c273fcd74bbf588c521cd30cba5784c492ba14858014bdd295af3/boto3_stubs-1.40.69.tar.gz", hash = "sha256:244121672c614b58426f1630f5685a821f4a8cff49deed59a287d9d91c7a4d64", size = 99409, upload-time = "2025-11-08T08:35:02.954Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/c0/92/45cc1db83ebaaa26d2e4f200436aafbcddf8fb29a8c2b1d296921d9aa722/boto3_stubs-1.40.64-py3-none-any.whl", hash = "sha256:c0c0dd70c02b08550ca596e8799586b3669e9352844db22401e76556b05d71a3", size = 69067, upload-time = "2025-10-31T19:47:25.89Z" },+ { url = "https://files.pythonhosted.org/packages/ed/54/1f5d5db7812524809656baadc63669f4456a88bc65f1b30b576f3d2309f9/boto3_stubs-1.40.69-py3-none-any.whl", hash = "sha256:004e9647c310dcaec45145645dfa9aec73fb233f2649900eeaa976894378d57c", size = 68982, upload-time = "2025-11-08T08:34:57.269Z" },][[package]]@@ -335,14 +335,14 @@ wheels = [[[package]]name = "botocore-stubs"-version = "1.40.68"+version = "1.40.69"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "types-awscrt" },]-sdist = { url = "https://files.pythonhosted.org/packages/7f/30/588ab9ca87ba6a7ef307cd9941fb7c95abb5820d02bb3f2b818fe5eab4fd/botocore_stubs-1.40.68.tar.gz", hash = "sha256:47c8e99e30b1d65ca78be51e6dea994c06c3da9b35521891f8910e641da2b95b", size = 42253, upload-time = "2025-11-06T21:22:40.312Z" }+sdist = { url = "https://files.pythonhosted.org/packages/2a/57/da68248f3b5fcd41f47dd4dfad6b6ba5fdcdedfa86e04d2b9822d5788dfd/botocore_stubs-1.40.69.tar.gz", hash = "sha256:31d1bb9a5140df9ba83d6d4d66b68998767279850de50e28caade315244b0a78", size = 42235, upload-time = "2025-11-07T21:18:47.479Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/f8/e3/d94acada07e82af6a26baf03d0db8daeaae969c09635417281193810c1b1/botocore_stubs-1.40.68-py3-none-any.whl", hash = "sha256:4eb9bc8127e65b5a84df280eaa80e8626e98f296c46dc9b8579d6c5efbf008b2", size = 66543, upload-time = "2025-11-06T21:22:37.631Z" },+ { url = "https://files.pythonhosted.org/packages/b1/19/0f822401c3fda8de004be0d9ed9195ea63f76bde2b1d12c81e9138cd94b3/botocore_stubs-1.40.69-py3-none-any.whl", hash = "sha256:79837e22d89c65cb09484aede593aca5b5027ec6a535c34498aebca693c3b856", size = 66542, upload-time = "2025-11-07T21:18:44.688Z" },][[package]]@@ -459,75 +459,75 @@ wheels = [[[package]]name = "coverage"-version = "7.11.1"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/89/12/3e2d2ec71796e0913178478e693a06af6a3bc9f7f9cb899bf85a426d8370/coverage-7.11.1.tar.gz", hash = "sha256:b4b3a072559578129a9e863082a2972a2abd8975bc0e2ec57da96afcd6580a8a", size = 814037, upload-time = "2025-11-07T10:52:41.067Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/aa/15/6d7162366ed0508686dd68a716260bb3e2686fbce9e1acb6a42fa07cbc19/coverage-7.11.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:057c0aedcade895c0d25c06daff00fb381dea8089434ec916e59b051e5dead68", size = 216603, upload-time = "2025-11-07T10:49:45.154Z" },- { url = "https://files.pythonhosted.org/packages/74/87/37ad9c35a3e5376f437c20a0fb01e20c4841afbf75328eb37d66dd87242d/coverage-7.11.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ea73d4b5a489ea60ebce592ea516089d2bee8b299fb465fdd295264da98b2480", size = 217120, upload-time = "2025-11-07T10:49:47.95Z" },- { url = "https://files.pythonhosted.org/packages/ea/d9/4a1f7f679018c189c97a48f215275fe9e31e6a4db0135aac755c08224310/coverage-7.11.1-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:63f837e043f7f0788c2ce8fc6bbbcc3579f123af9cb284e1334099969222ceab", size = 243865, upload-time = "2025-11-07T10:49:49.716Z" },- { url = "https://files.pythonhosted.org/packages/38/3f/5678792f90d4c8467531a4db9b66a8929cee0c9f28a8f5fed0e94d7e1d3e/coverage-7.11.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:086764f9fa6f4fa57035ed1c2387501c57092f2159bf1be0f090f85f9042ccf2", size = 245693, upload-time = "2025-11-07T10:49:51.273Z" },- { url = "https://files.pythonhosted.org/packages/4e/27/0e6d9d3ec92307b67eb735b451cbead5d0307dc43f6ef1faf3f280abd68b/coverage-7.11.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1a30a6ba3b668227d5a6f9f6ac2d875117af20f260ddc01619487174036a5583", size = 247552, upload-time = "2025-11-07T10:49:53.826Z" },- { url = "https://files.pythonhosted.org/packages/98/d4/5600ae43bfeb9cea2b7ea2cd6a3c5a064533cdb53696a35b7bd8e288396b/coverage-7.11.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2663b19df42932a2cd66e62783f4bbbca047853ede893d48f3271c5e12c89246", size = 244515, upload-time = "2025-11-07T10:49:55.632Z" },- { url = "https://files.pythonhosted.org/packages/1a/b3/73a5033b46d8193b775ed6768f05c63dc4f9402834c56d6f456cc92175bb/coverage-7.11.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8c6570122b2eafaa5f4b54700b6f17ee10e23c5cf4292fa9b5a00e9dc279a74", size = 245596, upload-time = "2025-11-07T10:49:58.138Z" },- { url = "https://files.pythonhosted.org/packages/72/57/40abaeacf2a78c22983183e0d44145ef64256ab12d35635d89fe08337475/coverage-7.11.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:2cf57b5be59d36d133c06103f50c72bfdba7c7624d68b443b16a2d2d4eb40424", size = 243605, upload-time = "2025-11-07T10:49:59.73Z" },- { url = "https://files.pythonhosted.org/packages/ad/a5/796f3a21bdde952568e0cadf825269c74c33ae82966e46283075e3babb80/coverage-7.11.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f3f3eb204cbe221ef9209e34341b3d0bc32f4cf3c7c4f150db571e20b9963ecd", size = 243867, upload-time = "2025-11-07T10:50:01.164Z" },- { url = "https://files.pythonhosted.org/packages/36/0d/2071cb65945737f5d82eebcdfb7b869c56c0f521e1af4af6f6b0a80cfe62/coverage-7.11.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:57d36cb40ad55fe443bb2390c759c61b9fa3afc68d5446a2aaed1ad18fc92752", size = 244485, upload-time = "2025-11-07T10:50:03.086Z" },- { url = "https://files.pythonhosted.org/packages/45/c5/599efe919c50d4069029fa59696f7ec106a70eb0e92b8a2f7a5f8afd0980/coverage-7.11.1-cp310-cp310-win32.whl", hash = "sha256:999a82a2dec9e31df7cb49a17e6b564b76fab3f9cd76788280997b5a694b8025", size = 219176, upload-time = "2025-11-07T10:50:04.432Z" },- { url = "https://files.pythonhosted.org/packages/1a/8c/022c91f0f0e08918991bff99bdc961a60b0585397f78e9885414c9e20f0f/coverage-7.11.1-cp310-cp310-win_amd64.whl", hash = "sha256:d47ad0fdc96d5772fcded1a57f042a72dba893a226d3efa5802d0bfa88e3a9a1", size = 220112, upload-time = "2025-11-07T10:50:06.013Z" },- { url = "https://files.pythonhosted.org/packages/5b/09/7d035b041643d4d99c8ea374b7f0363ebb5edf02121ea4bfddaf7f738e08/coverage-7.11.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9f8be6327cb57e73f1933a111b31ca3e8db68eba70921244296cd9541f8405cf", size = 216729, upload-time = "2025-11-07T10:50:07.543Z" },- { url = "https://files.pythonhosted.org/packages/2b/d0/3b31528bb14c2dc498c09804ee4bfe3e17ca28b1de6c2e3e850c99ed2b39/coverage-7.11.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3386b3d974eea5b8fbc31388c2847d5b3ce783aa001048c7c13ad0e0f9f97284", size = 217232, upload-time = "2025-11-07T10:50:09.064Z" },- { url = "https://files.pythonhosted.org/packages/b8/1c/713bd524fec4d3d1d2813de0fad233d4ff9e3bbd9bf8f8052bb0359e0f3f/coverage-7.11.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dd5a0e53989aa0d2b94871ac9a990f7b6247c3afe49af77f8750d7bcf1e66efa", size = 247628, upload-time = "2025-11-07T10:50:10.609Z" },- { url = "https://files.pythonhosted.org/packages/b2/05/2887d76a5e160eb1b62dc99b1f177052799c37134d38e8b208e01bd4d712/coverage-7.11.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e17d99e4a9989ccc52d672543ed9d8741d90730ba331d452793be5733b4fee58", size = 249545, upload-time = "2025-11-07T10:50:12.187Z" },- { url = "https://files.pythonhosted.org/packages/6f/7e/bb95b8396a7c8deb0426a1261d62851b28a380a849546f730a8ee36471f7/coverage-7.11.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2ece0ace8d8fc20cc29e2108d4031517c03d9e08883f10c1df16bef84d469110", size = 251658, upload-time = "2025-11-07T10:50:14.23Z" },- { url = "https://files.pythonhosted.org/packages/bc/96/1397eaee431b43dbe2ec683401c8341d65993434d69f3a36087c5c280fb1/coverage-7.11.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:54bf4a13bfcf6f07c4b7d83970074dc2fa8b5782e8dee962f5eb4dfbc3a275ef", size = 247742, upload-time = "2025-11-07T10:50:16.001Z" },- { url = "https://files.pythonhosted.org/packages/b5/ea/b71c504fe7fd58495ccabe1cd4afd7e5685d563e2019ae4865cb0b44f652/coverage-7.11.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b48e85160795648323fc3a9d8efe11be65a033b564e1db28b53866810da6cf35", size = 249351, upload-time = "2025-11-07T10:50:17.852Z" },- { url = "https://files.pythonhosted.org/packages/10/35/e44cb3d633cdeec7c6def511f552494a16bfa4e6cb5e916d9a0d4c98a933/coverage-7.11.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4b77e7bb5765988a7a80463b999085cd66c6515113fc88b46910217f19ee99fe", size = 247423, upload-time = "2025-11-07T10:50:19.439Z" },- { url = "https://files.pythonhosted.org/packages/af/88/c344ab065706a9df03b558fe4bcb9d367f92d5983f6a672c03eeb0905d39/coverage-7.11.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ce345819ddedcbe797d8ba824deeb0d55710037dfd47efd95709ab9e1b841e0c", size = 247150, upload-time = "2025-11-07T10:50:20.919Z" },- { url = "https://files.pythonhosted.org/packages/34/5b/b0b6c986e41c6072d0c57761e648c120a34b1004f7de5b90bda5cb7542eb/coverage-7.11.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:abde2bd52560527124d9e6515daa1f1e3c7e820a37af63d063723867775220aa", size = 248047, upload-time = "2025-11-07T10:50:22.599Z" },- { url = "https://files.pythonhosted.org/packages/06/2b/aa232a409b63422910e180ccd5f7083e6e41d942608f3513e617006c0253/coverage-7.11.1-cp311-cp311-win32.whl", hash = "sha256:049883a469ec823b1c9556050380e61f580d52f8abfc8be2071f3512a2bc3859", size = 219201, upload-time = "2025-11-07T10:50:24.513Z" },- { url = "https://files.pythonhosted.org/packages/41/d4/ec0155c883ddc43b2ff08e3b88fc846a4642a117306f8891188f217bd823/coverage-7.11.1-cp311-cp311-win_amd64.whl", hash = "sha256:784a9fe33335296857db05b97dcb16df811418515a2355fc4811b0c2b029b4be", size = 220134, upload-time = "2025-11-07T10:50:26.035Z" },- { url = "https://files.pythonhosted.org/packages/71/59/96dc2070a2f124e27c9b8d6e45e35d44f01b056b6eaf6793bfff40e84c4a/coverage-7.11.1-cp311-cp311-win_arm64.whl", hash = "sha256:2bcfeb983a53f0d3ee3ebc004827723d8accb619f64bf90aff73b7703dfe14bd", size = 218807, upload-time = "2025-11-07T10:50:27.685Z" },- { url = "https://files.pythonhosted.org/packages/0f/31/04af7e42fdb3681e4d73d37bf3f375f0488aa38d1001ee746c7dbfe09643/coverage-7.11.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:421e2d237dcecdefa9b77cae1aa0dfff5c495f29e053e776172457e289976311", size = 216896, upload-time = "2025-11-07T10:50:31.429Z" },- { url = "https://files.pythonhosted.org/packages/f5/e9/1c3628a1225bdea66295a117cd2bb1d324d9c433c40078b24d50f55448a7/coverage-7.11.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:08ef89c812072ecd52a862b46e131f75596475d23cc7f5a75410394341d4332f", size = 217261, upload-time = "2025-11-07T10:50:33.008Z" },- { url = "https://files.pythonhosted.org/packages/2b/80/4d4f943da23c432b2bba8664f4eada9b19911081852e8cc89776c61d0b94/coverage-7.11.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bc6e0b2d6ed317810b4e435ffabc31b2d517d6ceb4183dfd6af4748c52d170eb", size = 248742, upload-time = "2025-11-07T10:50:34.634Z" },- { url = "https://files.pythonhosted.org/packages/e3/e1/c4b42f02fbb6ce08e05d7a2b26bcf5df11d3e67a3806e40415f7ab9511e7/coverage-7.11.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b59736704df8b1f8b1dafb36b16f2ef8a952e4410465634442459426bd2319ae", size = 251503, upload-time = "2025-11-07T10:50:36.501Z" },- { url = "https://files.pythonhosted.org/packages/31/a8/3df60e88f1dabccae4994c6df4a2f23d4cd0eee27fc3ae8f0bb2e78cb538/coverage-7.11.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:843816452d8bfc4c2be72546b3b382850cb91150feaa963ec7d2b665ec9d4768", size = 252590, upload-time = "2025-11-07T10:50:38.059Z" },- { url = "https://files.pythonhosted.org/packages/06/1c/2b9fae11361b0348c2d3612a8179d2cc8b6b245e8b14d5479c75b9f18613/coverage-7.11.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:19363046125d4a423c25d3d7c90bab3a0230932c16014198f87a6b3960c1b187", size = 249133, upload-time = "2025-11-07T10:50:39.648Z" },- { url = "https://files.pythonhosted.org/packages/b8/2b/e33712a8eede02762a536bdc2f89e736e0ad87bd13b35d724306585aeb54/coverage-7.11.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e37486aed7045c280ebdc207026bdef9267730177d929a5e25250e1f33cc125", size = 250524, upload-time = "2025-11-07T10:50:41.59Z" },- { url = "https://files.pythonhosted.org/packages/84/c9/6181877977a0f6e46b9c93a8382b8c671769fb12df8a15be8d6091541b77/coverage-7.11.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:7c68180e67b4843674bfb1d3ec928ffcfc94081b5da959e616405eca51c23356", size = 248673, upload-time = "2025-11-07T10:50:43.153Z" },- { url = "https://files.pythonhosted.org/packages/9b/d6/ff26c2eb57d4dcd46c6ed136d6b04aceb7f58f48dcc500c77f7194711a6f/coverage-7.11.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cf825b60f94d1706c22d4887310db26cc3117d545ac6ad4229b4a0d718afcf9a", size = 248251, upload-time = "2025-11-07T10:50:45.069Z" },- { url = "https://files.pythonhosted.org/packages/f9/ff/411803f1fcb9efe00afbc96442564cc691f537541a8bde377cf1ac04e695/coverage-7.11.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:437149272ff0440df66044bd6ee87cbc252463754ca43cafa496cfb2f57f56dd", size = 250111, upload-time = "2025-11-07T10:50:46.701Z" },- { url = "https://files.pythonhosted.org/packages/c1/9f/781c045e1e5f8930f8266f224318040413b60837749d2ed11883b7478c81/coverage-7.11.1-cp312-cp312-win32.whl", hash = "sha256:98ea0b8d1addfc333494c2248af367e8ecb27724a99804a18376b801f876da58", size = 219407, upload-time = "2025-11-07T10:50:48.862Z" },- { url = "https://files.pythonhosted.org/packages/26/59/813d8eedc96a781e8a6f9c37f6ecb4326ebbffdafe2e1154ed2def468b76/coverage-7.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:7d49a473799e55a465bcadd19525977ab80031b8b86baaa622241808df4585cd", size = 220220, upload-time = "2025-11-07T10:50:51.576Z" },- { url = "https://files.pythonhosted.org/packages/63/5f/c0905d9159d38194943a21d7d013f1c2f0c43e7d63f680ed56269728418a/coverage-7.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:0c77e5951ab176a6ccb70c6f688fca2a7ac834753ba82ee4eb741be655f30b43", size = 218856, upload-time = "2025-11-07T10:50:53.591Z" },- { url = "https://files.pythonhosted.org/packages/f4/01/0c50c318f5e8f1a482da05d788d0ff06137803ed8fface4a1ba51e04b3ad/coverage-7.11.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:da9930594ca99d66eb6f613d7beba850db2f8dfa86810ee35ae24e4d5f2bb97d", size = 216920, upload-time = "2025-11-07T10:50:55.992Z" },- { url = "https://files.pythonhosted.org/packages/20/11/9f038e6c2baea968c377ab355b0d1d0a46b5f38985691bf51164e1b78c1f/coverage-7.11.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cc47a280dc014220b0fc6e5f55082a3f51854faf08fd9635b8a4f341c46c77d3", size = 217301, upload-time = "2025-11-07T10:50:57.609Z" },- { url = "https://files.pythonhosted.org/packages/68/cd/9dcf93d81d0cddaa0bba90c3b4580e6f1ddf833918b816930d250cc553a4/coverage-7.11.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:74003324321bbf130939146886eddf92e48e616b5910215e79dea6edeb8ee7c8", size = 248277, upload-time = "2025-11-07T10:50:59.442Z" },- { url = "https://files.pythonhosted.org/packages/11/f5/b2c7c494046c9c783d3cac4c812fc24d6104dd36a7a598e7dd6fea3e7927/coverage-7.11.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:211f7996265daab60a8249af4ca6641b3080769cbedcffc42cc4841118f3a305", size = 250871, upload-time = "2025-11-07T10:51:01.094Z" },- { url = "https://files.pythonhosted.org/packages/a5/5a/b359649566954498aa17d7c98093182576d9e435ceb4ea917b3b48d56f86/coverage-7.11.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70619d194d8fea0cb028cb6bb9c85b519c7509c1d1feef1eea635183bc8ecd27", size = 252115, upload-time = "2025-11-07T10:51:03.087Z" },- { url = "https://files.pythonhosted.org/packages/f3/17/3cef1ede3739622950f0737605353b797ec564e70c9d254521b10f4b03ba/coverage-7.11.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e0208bb59d441cfa3321569040f8e455f9261256e0df776c5462a1e5a9b31e13", size = 248442, upload-time = "2025-11-07T10:51:04.888Z" },- { url = "https://files.pythonhosted.org/packages/5f/63/d5854c47ae42d9d18855329db6bc528f5b7f4f874257edb00cf8b483f9f8/coverage-7.11.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:545714d8765bda1c51f8b1c96e0b497886a054471c68211e76ef49dd1468587d", size = 250253, upload-time = "2025-11-07T10:51:06.515Z" },- { url = "https://files.pythonhosted.org/packages/48/e8/c7706f8a5358a59c18b489e7e19e83d6161b7c8bc60771f95920570c94a8/coverage-7.11.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d0a2b02c1e20158dd405054bcca87f91fd5b7605626aee87150819ea616edd67", size = 248217, upload-time = "2025-11-07T10:51:08.405Z" },- { url = "https://files.pythonhosted.org/packages/5b/c9/a2136dfb168eb09e2f6d9d6b6c986243fdc0b3866a9376adb263d3c3378b/coverage-7.11.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0f4aa986a4308a458e0fb572faa3eb3db2ea7ce294604064b25ab32b435a468", size = 248040, upload-time = "2025-11-07T10:51:10.626Z" },- { url = "https://files.pythonhosted.org/packages/18/9a/a63991c0608ddc6adf65e6f43124951aaf36bd79f41937b028120b8268ea/coverage-7.11.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d51cc6687e8bbfd1e041f52baed0f979cd592242cf50bf18399a7e03afc82d88", size = 249801, upload-time = "2025-11-07T10:51:12.63Z" },- { url = "https://files.pythonhosted.org/packages/84/19/947acf7c0c6e90e4ec3abf474133ed36d94407d07e36eafdfd3acb59fee9/coverage-7.11.1-cp313-cp313-win32.whl", hash = "sha256:1b3067db3afe6deeca2b2c9f0ec23820d5f1bd152827acfadf24de145dfc5f66", size = 219430, upload-time = "2025-11-07T10:51:14.329Z" },- { url = "https://files.pythonhosted.org/packages/35/54/36fef7afb3884450c7b6d494fcabe2fab7c669d547c800ca30f41c1dc212/coverage-7.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:39a4c44b0cd40e3c9d89b2b7303ebd6ab9ae8a63f9e9a8c4d65a181a0b33aebe", size = 220239, upload-time = "2025-11-07T10:51:16.418Z" },- { url = "https://files.pythonhosted.org/packages/d3/dc/7d38bb99e8e69200b7dd5de15507226bd90eac102dfc7cc891b9934cdc76/coverage-7.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:a2e3560bf82fa8169a577e054cbbc29888699526063fee26ea59ea2627fd6e73", size = 218868, upload-time = "2025-11-07T10:51:18.186Z" },- { url = "https://files.pythonhosted.org/packages/36/c6/d1ff54fbd6bcad42dbcfd13b417e636ef84aae194353b1ef3361700f2525/coverage-7.11.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:47a4f362a10285897ab3aa7a4b37d28213a4f2626823923613d6d7a3584dd79a", size = 217615, upload-time = "2025-11-07T10:51:21.065Z" },- { url = "https://files.pythonhosted.org/packages/73/f9/6ed59e7cf1488d6f975e5b14ef836f5e537913523e92175135f8518a83ce/coverage-7.11.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0df35fa7419ef571db9dacd50b0517bc54dbfe37eb94043b5fc3540bff276acd", size = 217960, upload-time = "2025-11-07T10:51:22.797Z" },- { url = "https://files.pythonhosted.org/packages/c4/74/2dab1dc2ebe16f074f80ae483b0f45faf278d102be703ac01b32cd85b6c3/coverage-7.11.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e1a2c621d341c9d56f7917e56fbb56be4f73fe0d0e8dae28352fb095060fd467", size = 259262, upload-time = "2025-11-07T10:51:24.467Z" },- { url = "https://files.pythonhosted.org/packages/15/49/eccfe039663e29a50a54b0c2c8d076acd174d7ac50d018ef8a5b1c37c8dc/coverage-7.11.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6c354b111be9b2234d9573d75dd30ca4e414b7659c730e477e89be4f620b3fb5", size = 261326, upload-time = "2025-11-07T10:51:26.232Z" },- { url = "https://files.pythonhosted.org/packages/f0/bb/2b829aa23fd5ee8318e33cc02a606eb09900921291497963adc3f06af8bb/coverage-7.11.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4589bd44698728f600233fb2881014c9b8ec86637ef454c00939e779661dbe7e", size = 263758, upload-time = "2025-11-07T10:51:27.912Z" },- { url = "https://files.pythonhosted.org/packages/ac/03/d44c3d70e5da275caf2cad2071da6b425412fbcb1d1d5a81f1f89b45e3f1/coverage-7.11.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c6956fc8754f2309131230272a7213a483a32ecbe29e2b9316d808a28f2f8ea1", size = 258444, upload-time = "2025-11-07T10:51:30.107Z" },- { url = "https://files.pythonhosted.org/packages/a9/c1/cf61d9f46ae088774c65dd3387a15dfbc72de90c1f6e105025e9eda19b42/coverage-7.11.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:63926a97ed89dc6a087369b92dcb8b9a94cead46c08b33a7f1f4818cd8b6a3c3", size = 261335, upload-time = "2025-11-07T10:51:31.814Z" },- { url = "https://files.pythonhosted.org/packages/95/9a/b3299bb14f11f2364d78a2b9704491b15395e757af6116694731ce4e5834/coverage-7.11.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:f5311ba00c53a7fb2b293fdc1f478b7286fe2a845a7ba9cda053f6e98178f0b4", size = 258951, upload-time = "2025-11-07T10:51:33.925Z" },- { url = "https://files.pythonhosted.org/packages/3f/a3/73cb2763e59f14ba6d8d6444b1f640a9be2242bfb59b7e50581c695db7ff/coverage-7.11.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:31bf5ffad84c974f9e72ac53493350f36b6fa396109159ec704210698f12860b", size = 257840, upload-time = "2025-11-07T10:51:36.092Z" },- { url = "https://files.pythonhosted.org/packages/85/db/482e72589a952027e238ffa3a15f192c552e0685fd0c5220ad05b5f17d56/coverage-7.11.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:227ee59fbc4a8c57a7383a1d7af6ca94a78ae3beee4045f38684548a8479a65b", size = 260040, upload-time = "2025-11-07T10:51:38.277Z" },- { url = "https://files.pythonhosted.org/packages/18/a1/b931d3ee099c2dca8e9ea56c07ae84c0f91562f7bbbcccab8c91b3474ef1/coverage-7.11.1-cp313-cp313t-win32.whl", hash = "sha256:a447d97b3ce680bb1da2e6bd822ebb71be6a1fb77ce2c2ad2fe4bd8aacec3058", size = 220102, upload-time = "2025-11-07T10:51:40.017Z" },- { url = "https://files.pythonhosted.org/packages/9a/53/b553b7bfa6207def4918f0cb72884c844fa4c3f1566e58fbb4f34e54cdc5/coverage-7.11.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d6d11180437c67bde2248563a42b8e5bbf85c8df78fae13bf818ad17bfb15f02", size = 221166, upload-time = "2025-11-07T10:51:41.921Z" },- { url = "https://files.pythonhosted.org/packages/6b/45/1c1d58b3ed585598764bd2fe41fcf60ccafe15973ad621c322ba52e22d32/coverage-7.11.1-cp313-cp313t-win_arm64.whl", hash = "sha256:1e19a4c43d612760c6f7190411fb157e2d8a6dde00c91b941d43203bd3b17f6f", size = 219439, upload-time = "2025-11-07T10:51:43.753Z" },- { url = "https://files.pythonhosted.org/packages/76/32/bd9f48c28e23b2f08946f8e83983617b00619f5538dbd7e1045fa7e88c00/coverage-7.11.1-py3-none-any.whl", hash = "sha256:0fa848acb5f1da24765cee840e1afe9232ac98a8f9431c6112c15b34e880b9e8", size = 208689, upload-time = "2025-11-07T10:52:38.646Z" },+version = "7.11.2"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/32/e6/7c4006cf689ed7a4aa75dcf1f14acbc04e585714c220b5cc6d231096685a/coverage-7.11.2.tar.gz", hash = "sha256:ae43149b7732df15c3ca9879b310c48b71d08cd8a7ba77fda7f9108f78499e93", size = 814849, upload-time = "2025-11-08T20:26:33.011Z" }+wheels = [+ { url = "https://files.pythonhosted.org/packages/83/5b/d943b719938467d313973fd83af9c810e248fcec33165d5ab0148ab1c602/coverage-7.11.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:004bdc5985b86f565772af627925e368256ee2172623db10a0d78a3b53f20ef1", size = 216802, upload-time = "2025-11-08T20:23:47.186Z" },+ { url = "https://files.pythonhosted.org/packages/8b/f7/d3c096ca6a6212e8a536ae2144406d28b43e7528ff05a0bf6a5336319d0d/coverage-7.11.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3aa8c62460499e10ceac5ea61cc09c4f7ddcd8a68c6313cf08785ad353dfd311", size = 217317, upload-time = "2025-11-08T20:23:50.255Z" },+ { url = "https://files.pythonhosted.org/packages/10/46/d0dbafbd3604293b73a44ae9c88e339921c13f309138b31ec60b451895b9/coverage-7.11.2-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d73da4893125e0671f762e408dea9957b2bda0036c9589c2fd258a6b870acbdb", size = 244068, upload-time = "2025-11-08T20:23:51.63Z" },+ { url = "https://files.pythonhosted.org/packages/3d/16/ef8aba300f7224167c556d15852bf35d42c7af93b68f3ef82323737515e8/coverage-7.11.2-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:805efa416085999da918f15f81b26636d8e79863e1fbac1495664686d1e6a6e9", size = 245896, upload-time = "2025-11-08T20:23:53.1Z" },+ { url = "https://files.pythonhosted.org/packages/7f/ea/02fa537e61bc61fd111d5d9611184a354dd26bbc31e58ccd922f76404723/coverage-7.11.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c65f4291aec39692a3bfbe1d92ae5bea58c16b5553fdf021de61c655d987233f", size = 247755, upload-time = "2025-11-08T20:23:54.88Z" },+ { url = "https://files.pythonhosted.org/packages/41/3b/6cc19074059c030e489fd5ff934aa49521a75ba6236d27badb3b4270b21c/coverage-7.11.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b7658f3d4f728092368c091c18efcfb679be9b612c93bfdf345f33635a325188", size = 244714, upload-time = "2025-11-08T20:23:56.655Z" },+ { url = "https://files.pythonhosted.org/packages/a6/d5/b3480a0fd9c45fad37884c38ee943788ef43b64abf156b3f8e6af096c62e/coverage-7.11.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9f5f6ee021b3b25e748a9a053f3a8dd61a62b6689efd6425cb47e27360994903", size = 245800, upload-time = "2025-11-08T20:23:58.06Z" },+ { url = "https://files.pythonhosted.org/packages/07/2a/34f1476db9c58c410193f8f0cbecdfd9931912ed07de628fdffe0dae216d/coverage-7.11.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9a95b7a6043b221ec1a0d4d5481e424272b37028353265fbe5fcd3768d652eb7", size = 243808, upload-time = "2025-11-08T20:23:59.756Z" },+ { url = "https://files.pythonhosted.org/packages/73/fd/b43a0a4f6306a486d31cdd4166afd4dc0b08a8f072d7ab2ccc23893b6d19/coverage-7.11.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:94ced4a29a6987af99faaa49a513bf8d0458e8af004c54174e05dd7a8a31c7d9", size = 244070, upload-time = "2025-11-08T20:24:01.281Z" },+ { url = "https://files.pythonhosted.org/packages/cc/8c/bcbe2c9cb81ef008d05b04ebc37a3a1c65d61b61c9cf772f0ae473ddc56b/coverage-7.11.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8014a28a37ffabf7da7107f4f154d68c6b89672f27fef835a0574591c5cd140b", size = 244688, upload-time = "2025-11-08T20:24:02.641Z" },+ { url = "https://files.pythonhosted.org/packages/6b/f7/c6c276f6663a1d7e29f8cc4a5a8c76dbf834ecb74017936187146adbce9e/coverage-7.11.2-cp310-cp310-win32.whl", hash = "sha256:43ecf9dca4fcb3baf8a886019dd5ce663c95a5e1c5172719c414f0ebd9eeb785", size = 219382, upload-time = "2025-11-08T20:24:04.476Z" },+ { url = "https://files.pythonhosted.org/packages/4f/aa/0d07b2d567f1d005088b4afad533b4a6af48ec75f3f9071afbe5f7076cab/coverage-7.11.2-cp310-cp310-win_amd64.whl", hash = "sha256:230317450af65a37c1fdbdd3546f7277e0c1c1b65e0d57409248e5dd0fa13493", size = 220319, upload-time = "2025-11-08T20:24:06.464Z" },+ { url = "https://files.pythonhosted.org/packages/89/39/326336c0adc6dc624be0edb5143dec90a9da2626335e83f6d09da120922f/coverage-7.11.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:36c41bf2ee6f6062de8177e249fee17cd5c9662cd373f7a41e6468a34c5b9c0f", size = 216927, upload-time = "2025-11-08T20:24:08.167Z" },+ { url = "https://files.pythonhosted.org/packages/b7/68/cd1d3422fc9525827cddf62b2385f78356b88e745e90e8e512fefcc05f8f/coverage-7.11.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:397778cf6d50df59c890bd3ac10acb5bf413388ff6a013305134f1403d5db648", size = 217429, upload-time = "2025-11-08T20:24:09.939Z" },+ { url = "https://files.pythonhosted.org/packages/36/73/3f384dd79d6bbdf7fbceda3c7e0db33e148559bc18c49022c9c0c5e512c1/coverage-7.11.2-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c85f44ed4260221e46a4e9e8e8df4b359ab6c0a742c79e85d649779bcf77b534", size = 247832, upload-time = "2025-11-08T20:24:11.897Z" },+ { url = "https://files.pythonhosted.org/packages/45/3c/27839b6f343998e82f3e470397c058566c953dc71fe37e0abb953133a341/coverage-7.11.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cbffd1d5c5bf4c576ca247bf77646cdad4dced82928337eeb0b85e2b3be4d64b", size = 249749, upload-time = "2025-11-08T20:24:13.705Z" },+ { url = "https://files.pythonhosted.org/packages/6e/51/011102c7f6902084e632128ac0f42cd3345acc543a7c9f8ce5e1a94397ef/coverage-7.11.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ea10a57568af7cf082a7a4d98a699f993652c2ffbdd5a6c9d63c9ca10b693b4d", size = 251860, upload-time = "2025-11-08T20:24:15.113Z" },+ { url = "https://files.pythonhosted.org/packages/bb/4c/4622eb7aac98c2552ed8a176a6015ea8cf36a2ec75cbcfb5f2ccf100bbd6/coverage-7.11.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c4b1bea4c707f4c09f682fe0e646a114dfd068f627880d4a208850d01f8164ad", size = 247942, upload-time = "2025-11-08T20:24:16.637Z" },+ { url = "https://files.pythonhosted.org/packages/95/94/42ba12fc827fb504f8f8ec5313e46cf5582cdb9d4823e76d70ed22e88bdf/coverage-7.11.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1ac3f647ecf25d883051ef42d38d823016e715b9f289f8c1768be5117075d1bd", size = 249553, upload-time = "2025-11-08T20:24:18.153Z" },+ { url = "https://files.pythonhosted.org/packages/a3/47/2cd8014c872a3e469ffe50fbc692d02c7460e20cd701a0d6366fbef759e3/coverage-7.11.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:d423991415f73a70c0a5f3e0a226cf4ab374dd0da7409978069b844df3d31582", size = 247627, upload-time = "2025-11-08T20:24:19.644Z" },+ { url = "https://files.pythonhosted.org/packages/a9/31/e722f2c7f0f16954d13e6441a24d841174bcb1ff2421c6504c024c09c7af/coverage-7.11.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0f4a958ff286038ac870f836351e9fb8912f1614d1cdbda200fc899235f7dc9b", size = 247353, upload-time = "2025-11-08T20:24:21.28Z" },+ { url = "https://files.pythonhosted.org/packages/0a/dd/d4fd26be0ce7993f0013df9788e52cd83a1adf5cfb9887bfd1b38722380e/coverage-7.11.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4d1ff4b87ad438148976f2215141a490ae000e878536370d53f8da8c59a175a6", size = 248251, upload-time = "2025-11-08T20:24:22.724Z" },+ { url = "https://files.pythonhosted.org/packages/1c/33/003f7b5f10fae2ad7390e57a1520c46a24bd46e374b197e97050ae47751f/coverage-7.11.2-cp311-cp311-win32.whl", hash = "sha256:e448ceee2fb880427eafc9a3f8e6162b2ac7cc3e9b30b85d6511f25cc8a11820", size = 219410, upload-time = "2025-11-08T20:24:24.15Z" },+ { url = "https://files.pythonhosted.org/packages/22/e8/5db102c57143f33a9229ecdc8d7976ad0c5d103fcd26f2b939db96789990/coverage-7.11.2-cp311-cp311-win_amd64.whl", hash = "sha256:bc65e32fe5bb942f0f5247e1500e355cbbdf326181198f5e27e3bb3ddb81e203", size = 220342, upload-time = "2025-11-08T20:24:25.947Z" },+ { url = "https://files.pythonhosted.org/packages/bf/b2/9908f6b4b979045c01e02a069ae5f73c16dff022c296a5e1fd756c602c6c/coverage-7.11.2-cp311-cp311-win_arm64.whl", hash = "sha256:e8eb6cbd7d3b238335b5da0f3ce281102435afb503be4d7bdd69eea3c700a952", size = 219014, upload-time = "2025-11-08T20:24:27.382Z" },+ { url = "https://files.pythonhosted.org/packages/4f/98/aef630a13bc974333aeb83d69765eb513f790bf4bd5b79b8036ec176de8e/coverage-7.11.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:eaa2a5eeb82fa7a6a9cd65c4f968ee2a53839d451b4e88e060c67d87a0a40732", size = 217103, upload-time = "2025-11-08T20:24:28.938Z" },+ { url = "https://files.pythonhosted.org/packages/f9/1f/41f144dc49c07043230ad79126a9c79236724579c43175e476e0731ddc2a/coverage-7.11.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:07e14a4050525fd98bf3d793f229eb8b3ae81678f4031e38e6a18a068bd59fd4", size = 217467, upload-time = "2025-11-08T20:24:30.758Z" },+ { url = "https://files.pythonhosted.org/packages/a1/fa/6fc4b47c7c8323b0326c57786858b6185668f008edc2ea626bc35fb53e28/coverage-7.11.2-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:03e7e7dc31a7deaebf121c3c3bd3c6442b7fbf50aca72aae2a1d08aa30ca2a20", size = 248947, upload-time = "2025-11-08T20:24:32.559Z" },+ { url = "https://files.pythonhosted.org/packages/22/38/03bb7b3d991259ef8d483b83560f87eb4c6d5e8889ad836d212e010d08b3/coverage-7.11.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d752a8e398a19e2fb24781e4c73089bfeb417b6ac55f96c2c42cfe5bdb21cc18", size = 251707, upload-time = "2025-11-08T20:24:34.371Z" },+ { url = "https://files.pythonhosted.org/packages/83/6c/c32c7c76c8373978bf68bcfd87a1d265ace9c973ed9a007cada37f25948a/coverage-7.11.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a02818ec44803e325d66bd022828212df934739b894d1699c9a05b9105d30f2", size = 252793, upload-time = "2025-11-08T20:24:35.921Z" },+ { url = "https://files.pythonhosted.org/packages/60/16/86582ab283bad8e137f76e97c5b75a81f547174bca9bb2eba8b7be33d8b6/coverage-7.11.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d30a717493583c2a83c99f195e934c073be7f4291b32b7352c246d52e43f6893", size = 249331, upload-time = "2025-11-08T20:24:37.462Z" },+ { url = "https://files.pythonhosted.org/packages/9e/8a/24449d3e2a84bd38c1903757265cd45b6c9021ecf013f27e33155dba5ada/coverage-7.11.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:55ae008253df6000bc885a780c1b0e939bd8c932f41e16df1cfe19a00428a98a", size = 250728, upload-time = "2025-11-08T20:24:38.936Z" },+ { url = "https://files.pythonhosted.org/packages/86/bc/fcfe9bdda15f48ef6d78a8524837216752fe82474965d42310e6296c8bde/coverage-7.11.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:17047fb65fcd1ce8a2f97dd2247c2b59cb4bc8848b3911db02dcb05856f91b71", size = 248877, upload-time = "2025-11-08T20:24:40.444Z" },+ { url = "https://files.pythonhosted.org/packages/51/27/58db09afcb155f41739330c521258782eefc12fe18f70d3b8e5dbc61857b/coverage-7.11.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:5f72a49504e1f35443b157d97997c9259a017384373eab52fd09b8ade2ae4674", size = 248455, upload-time = "2025-11-08T20:24:42.479Z" },+ { url = "https://files.pythonhosted.org/packages/24/6b/1eba5fa2b01b1aa727aa2a1c480c5f475fccecf32decae95b890cef7ee68/coverage-7.11.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5c31cdbb95ab0f4a60224a04efc43cfb406ce904f0b60fb6b2a72f37718ea5cb", size = 250316, upload-time = "2025-11-08T20:24:44.029Z" },+ { url = "https://files.pythonhosted.org/packages/08/58/46d3dcb99366c74b0478f2a58fd97e82419871a50989937e08578f9a5c5c/coverage-7.11.2-cp312-cp312-win32.whl", hash = "sha256:632904d126ca97e5d4ecf7e51ae8b20f086b6f002c6075adcfd4ff3a28574527", size = 219617, upload-time = "2025-11-08T20:24:46.086Z" },+ { url = "https://files.pythonhosted.org/packages/94/19/ab26b96a5c6fd0b5d644524997b60523b3ccbe7473a069e1385a272be238/coverage-7.11.2-cp312-cp312-win_amd64.whl", hash = "sha256:c7ea5dec77d79dabb7b5fc712c59361aac52e459cd22028480625c3c743323d0", size = 220427, upload-time = "2025-11-08T20:24:47.809Z" },+ { url = "https://files.pythonhosted.org/packages/5b/c5/948b268909f04eb2b0a55e22f1e4b3ffd472a8a398d05ebcf95c36d8b1eb/coverage-7.11.2-cp312-cp312-win_arm64.whl", hash = "sha256:ed6ba9f1777fdd1c8e5650c7d123211fa484a187c61af4d82948dc5ee3c0afcc", size = 219068, upload-time = "2025-11-08T20:24:49.813Z" },+ { url = "https://files.pythonhosted.org/packages/ec/00/57f3f8adaced9e4c74f482932e093176df7e400b4bb95dc1f3cd499511b5/coverage-7.11.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:38a5509fe7fabb6fb3161059b947641753b6529150ef483fc01c4516a546f2ad", size = 217125, upload-time = "2025-11-08T20:24:51.368Z" },+ { url = "https://files.pythonhosted.org/packages/fc/2a/ff1a55673161608c895080950cdfbb6485c95e6fa57a92d2cd1e463717b3/coverage-7.11.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7e01ab8d69b6cffa2463e78a4d760a6b69dfebe5bf21837eabcc273655c7e7b3", size = 217499, upload-time = "2025-11-08T20:24:53.238Z" },+ { url = "https://files.pythonhosted.org/packages/73/e3/eaac01709ffbef291a12ca2526b6247f55ab17724e2297cc70921cd9a81f/coverage-7.11.2-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:b4776c6555a9f378f37fa06408f2e1cc1d06e4c4e06adb3d157a4926b549efbe", size = 248479, upload-time = "2025-11-08T20:24:54.825Z" },+ { url = "https://files.pythonhosted.org/packages/75/25/d846d2d08d182eeb30d1eba839fabdd9a3e6c710a1f187657b9c697bab23/coverage-7.11.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6f70fa1ef17cba5dada94e144ea1b6e117d4f174666842d1da3aaf765d6eb477", size = 251074, upload-time = "2025-11-08T20:24:56.442Z" },+ { url = "https://files.pythonhosted.org/packages/2e/7a/34c9402ad12bce609be4be1146a7d22a7fae8e9d752684b6315cce552a65/coverage-7.11.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:811bff1f93566a8556a9aeb078bd82573e37f4d802a185fba4cbe75468615050", size = 252318, upload-time = "2025-11-08T20:24:57.987Z" },+ { url = "https://files.pythonhosted.org/packages/cf/2f/292fe3cea4cc1c4b8fb060fa60e565ab1b3bfc67bda74bedefb24b4a2407/coverage-7.11.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d0e80c9946da61cc0bf55dfd90d65707acc1aa5bdcb551d4285ea8906255bb33", size = 248641, upload-time = "2025-11-08T20:24:59.642Z" },+ { url = "https://files.pythonhosted.org/packages/c5/af/33ccb2aa2f43bbc330a1fccf84a396b90f2e61c00dccb7b72b2993a3c795/coverage-7.11.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:10f10c9acf584ef82bfaaa7296163bd11c7487237f1670e81fc2fa7e972be67b", size = 250457, upload-time = "2025-11-08T20:25:01.358Z" },+ { url = "https://files.pythonhosted.org/packages/bd/91/4b5b58f34e0587fbc5c1a28d644d9c20c13349c1072aea507b6e372c8f20/coverage-7.11.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:fd3f7cc6cb999e3eff91a2998a70c662b0fcd3c123d875766147c530ca0d3248", size = 248421, upload-time = "2025-11-08T20:25:02.895Z" },+ { url = "https://files.pythonhosted.org/packages/d5/d5/5c5ed220b15f490717522d241629c522fa22275549a6ccfbc96a3654b009/coverage-7.11.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e52a028a56889d3ad036c0420e866e4a69417d3203e2fc5f03dcb8841274b64c", size = 248244, upload-time = "2025-11-08T20:25:04.742Z" },+ { url = "https://files.pythonhosted.org/packages/1e/27/504088aba40735132db838711d966e1314931ff9bddcd0e2ea6bc7e345a7/coverage-7.11.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f6f985e175dfa1fb8c0a01f47186720ae25d5e20c181cc5f3b9eba95589b8148", size = 250004, upload-time = "2025-11-08T20:25:06.633Z" },+ { url = "https://files.pythonhosted.org/packages/ea/89/4d61c0ad0d39656bd5e73fe41a93a34b063c90333258e6307aadcfcdbb97/coverage-7.11.2-cp313-cp313-win32.whl", hash = "sha256:e48b95abe2983be98cdf52900e07127eb7fe7067c87a700851f4f1f53d2b00e6", size = 219639, upload-time = "2025-11-08T20:25:08.27Z" },+ { url = "https://files.pythonhosted.org/packages/e0/a7/a298afa025ebe7a2afd6657871a1ac2d9c49666ce00f9a35ee9df61a3bd8/coverage-7.11.2-cp313-cp313-win_amd64.whl", hash = "sha256:ea910cc737ee8553c81ad5c104bc5b135106ebb36f88be506c3493e001b4c733", size = 220445, upload-time = "2025-11-08T20:25:09.906Z" },+ { url = "https://files.pythonhosted.org/packages/7e/a1/1825f5eadc0a0a6ea1c6e678827e1ec8c0494dbd23270016fccfc3358fbf/coverage-7.11.2-cp313-cp313-win_arm64.whl", hash = "sha256:ef2d3081562cd83f97984a96e02e7a294efa28f58d5e7f4e28920f59fd752b41", size = 219077, upload-time = "2025-11-08T20:25:11.777Z" },+ { url = "https://files.pythonhosted.org/packages/c0/61/98336c6f4545690b482e805c3a1a83fb2db4c19076307b187db3d421b5b3/coverage-7.11.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:87d7c7b0b2279e174f36d276e2afb7bf16c9ea04e824d4fa277eea1854f4cfd4", size = 217818, upload-time = "2025-11-08T20:25:13.697Z" },+ { url = "https://files.pythonhosted.org/packages/57/ee/6dca6e5f1a4affba8d3224996d0e9145e6d67817da753cc436e48bb8d0e6/coverage-7.11.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:940d195f4c8ba3ec6e7c302c9f546cdbe63e57289ed535452bc52089b1634f1c", size = 218170, upload-time = "2025-11-08T20:25:15.284Z" },+ { url = "https://files.pythonhosted.org/packages/ec/17/9c9ca3ef09d3576027e77cf580eb599d8d655f9ca2456a26ca50c53e07e3/coverage-7.11.2-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e3b92e10ca996b5421232dd6629b9933f97eb57ce374bca800ab56681fbeda2b", size = 259466, upload-time = "2025-11-08T20:25:17.373Z" },+ { url = "https://files.pythonhosted.org/packages/53/96/2001a596827a0b91ba5f627f21b5ce998fa1f27d861a8f6d909f5ea663ff/coverage-7.11.2-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:61d6a7cc1e7a7a761ac59dcc88cee54219fd4231face52bd1257cfd3df29ae9f", size = 261530, upload-time = "2025-11-08T20:25:19.085Z" },+ { url = "https://files.pythonhosted.org/packages/4d/bb/fea7007035fdc3c40fcca0ab740da549ff9d38fa50b0d37cd808fbbf9683/coverage-7.11.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bee1911c44c52cad6b51d436aa8c6ff5ca5d414fa089c7444592df9e7b890be9", size = 263963, upload-time = "2025-11-08T20:25:21.168Z" },+ { url = "https://files.pythonhosted.org/packages/d2/b3/7452071353441b632ebea42f6ad328a7ab592e4bc50a31f9921b41667017/coverage-7.11.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4c4423ea9c28749080b41e18ec74d658e6c9f148a6b47e719f3d7f56197f8227", size = 258644, upload-time = "2025-11-08T20:25:22.928Z" },+ { url = "https://files.pythonhosted.org/packages/e6/05/6e56b1c2b3308f587508ad4b0a4cb76c8d6179fea2df148e071979b3eb77/coverage-7.11.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:689d3b4dd0d4c912ed8bfd7a1b5ff2c5ecb1fa16571840573174704ff5437862", size = 261539, upload-time = "2025-11-08T20:25:25.277Z" },+ { url = "https://files.pythonhosted.org/packages/91/15/7afeeac2a49f651318e4a83f1d5f4d3d4f4092f1d451ac4aec8069cddbdb/coverage-7.11.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:75ef769be19d69ea71b0417d7fbf090032c444792579cdf9b166346a340987d5", size = 259153, upload-time = "2025-11-08T20:25:28.098Z" },+ { url = "https://files.pythonhosted.org/packages/1e/77/08f3b5c7500b2031cee74e8a01f9a5bc407f781ff6a826707563bb9dd5b7/coverage-7.11.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:6681164bc697b93676945c8c814b76ac72204c395e11b71ba796a93b33331c24", size = 258043, upload-time = "2025-11-08T20:25:30.087Z" },+ { url = "https://files.pythonhosted.org/packages/ca/49/8e080e7622bd7c82df0f8324bbe0461ed1032a638b80046f1a53a88ea3a8/coverage-7.11.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4aa799c61869318d2b86c0d3c413d6805546aec42069f009cbb27df2eefb2790", size = 260243, upload-time = "2025-11-08T20:25:31.722Z" },+ { url = "https://files.pythonhosted.org/packages/dc/75/da033d8589661527b4a6d30c414005467e48fbccc0f3c10898af183e14e1/coverage-7.11.2-cp313-cp313t-win32.whl", hash = "sha256:9a6468e1a3a40d3d1f9120a9ff221d3eacef4540a6f819fff58868fe0bd44fa9", size = 220309, upload-time = "2025-11-08T20:25:33.9Z" },+ { url = "https://files.pythonhosted.org/packages/29/ef/8a477d41dbcde1f1179c13c43c9f77ee926b793fe3e5f1cf5d868a494679/coverage-7.11.2-cp313-cp313t-win_amd64.whl", hash = "sha256:30c437e8b51ce081fe3903c9e368e85c9a803b093fd062c49215f3bf4fd1df37", size = 221374, upload-time = "2025-11-08T20:25:35.88Z" },+ { url = "https://files.pythonhosted.org/packages/0d/a3/4c3cdd737ed1f630b821430004c2d5f1088b9bc0a7115aa5ad7c40d7d5cb/coverage-7.11.2-cp313-cp313t-win_arm64.whl", hash = "sha256:a35701fe0b5ee9d4b67d31aa76555237af32a36b0cf8dd33f8a74470cf7cd2f5", size = 219648, upload-time = "2025-11-08T20:25:37.572Z" },+ { url = "https://files.pythonhosted.org/packages/05/7a/99766a75c88e576f47c2d9a06416ff5d95be9b42faca5c37e1ab77c4cd1a/coverage-7.11.2-py3-none-any.whl", hash = "sha256:2442afabe9e83b881be083238bb7cf5afd4a10e47f29b6094470338d2336b33c", size = 208891, upload-time = "2025-11-08T20:26:30.739Z" },][package.optional-dependencies]@@ -615,15 +615,15 @@ wheels = [[[package]]name = "fal-client"-version = "0.8.1"+version = "0.9.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "httpx" },{ name = "httpx-sse" },]-sdist = { url = "https://files.pythonhosted.org/packages/15/21/6a199b0e5933a93ecb69ca919aa58e62682ff4619e5cdf9e5b17becebeeb/fal_client-0.8.1.tar.gz", hash = "sha256:2c12cb0b0a327f4aa9c24fc7952722acf7aa059a1421a1c53283466f3bc07353", size = 15795, upload-time = "2025-10-15T19:33:09.608Z" }+sdist = { url = "https://files.pythonhosted.org/packages/bb/5e/3d1e10041c20db96abbc21a4d9d4594e05e4643b8ef5d775c28ff28b2826/fal_client-0.9.0.tar.gz", hash = "sha256:c8602e540db23ea19d30f3efc932137119515e3f7f9dfbfd63044332fbd74e86", size = 16483, upload-time = "2025-11-09T14:14:59.855Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/45/dc/0012b95c05448264329ba71ad568e440f12b7f5acdf2ddc09fa1aec42e0d/fal_client-0.8.1-py3-none-any.whl", hash = "sha256:ab37063f2b35ca6fad06f75fe45b05b72c774ad7590e0f93d47a8f6ad5e1f9db", size = 10912, upload-time = "2025-10-15T19:33:07.797Z" },+ { url = "https://files.pythonhosted.org/packages/60/e1/7f468aeb695950d737971308e223a90c83436606107906ba7ecb43e10406/fal_client-0.9.0-py3-none-any.whl", hash = "sha256:91280ece00211fd36977b1a1b74bc9638c56f8617705bb0c8e9292efa175c293", size = 11000, upload-time = "2025-11-09T14:14:58.649Z" },][[package]]