Skip to content

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.

Fix PipeLLM bug for generating text. improve builder to output ConceptSpec

Louis Choquele3e07850a1ce
diff --git a/pipelex/cogt/content_generation/content_generator.py b/pipelex/cogt/content_generation/content_generator.py
index 0280a4ef8..575f3636e 100644
--- a/pipelex/cogt/content_generation/content_generator.py
+++ b/pipelex/cogt/content_generation/content_generator.py
@@ -257,9 +257,7 @@ class ContentGenerator(ContentGeneratorProtocol):
prompting_style=prompting_style,
template_category=template_category,
)
- jinja2_text = await jinja2_gen_text(jinja2_assignment=jinja2_assignment)
- log.dev(f"{self.__class__.__name__} jinja2: {jinja2_text}")
- return jinja2_text
+ return await jinja2_gen_text(jinja2_assignment=jinja2_assignment)
@override
async def make_ocr_extract_pages(
diff --git a/pipelex/core/pipes/pipe_run_params.py b/pipelex/core/pipes/pipe_run_params.py
index 34c0ac93e..741ca076a 100644
--- a/pipelex/core/pipes/pipe_run_params.py
+++ b/pipelex/core/pipes/pipe_run_params.py
@@ -34,7 +34,7 @@ class OutputMultiplicityResolution(BaseModel):
resolved_multiplicity: PipeOutputMultiplicity | None = Field(description="The final multiplicity value to use after resolution")
- enable_multiple_outputs: bool = Field(description="Whether multiple outputs should be generated")
+ is_multiple_outputs_enabled: bool = Field(description="Whether multiple outputs should be generated")
specific_output_count: int | None = Field(default=None, description="Exact number of outputs to generate, if specified")
@@ -126,19 +126,21 @@ def output_multiplicity_to_apply(
log.debug("base_multiplicity is bool")
return OutputMultiplicityResolution(
resolved_multiplicity=base_multiplicity,
- enable_multiple_outputs=base_multiplicity,
+ is_multiple_outputs_enabled=base_multiplicity,
specific_output_count=None,
)
elif isinstance(base_multiplicity, int):
log.debug("base_multiplicity is int")
return OutputMultiplicityResolution(
resolved_multiplicity=base_multiplicity,
- enable_multiple_outputs=True,
+ is_multiple_outputs_enabled=True,
specific_output_count=base_multiplicity,
)
else:
log.debug("base_multiplicity is None")
- return OutputMultiplicityResolution(resolved_multiplicity=base_multiplicity, enable_multiple_outputs=False, specific_output_count=None)
+ return OutputMultiplicityResolution(
+ resolved_multiplicity=base_multiplicity, is_multiple_outputs_enabled=False, specific_output_count=None
+ )
# Case 2: Override is a boolean
elif isinstance(override_multiplicity, bool):
@@ -149,24 +151,24 @@ def output_multiplicity_to_apply(
if isinstance(base_multiplicity, bool):
log.debug("base_multiplicity is bool - disregarding base, using True")
- return OutputMultiplicityResolution(resolved_multiplicity=True, enable_multiple_outputs=True, specific_output_count=None)
+ return OutputMultiplicityResolution(resolved_multiplicity=True, is_multiple_outputs_enabled=True, specific_output_count=None)
else:
log.debug("base_multiplicity is int or None - preserving base value")
return OutputMultiplicityResolution(
resolved_multiplicity=base_multiplicity,
- enable_multiple_outputs=True,
+ is_multiple_outputs_enabled=True,
specific_output_count=base_multiplicity if isinstance(base_multiplicity, int) else None,
)
else:
log.debug("override_multiplicity is False - forcing single output")
- return OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None)
+ return OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None)
else:
# Case 3: Override is an integer
log.debug("override_multiplicity is int - using override value")
return OutputMultiplicityResolution(
resolved_multiplicity=override_multiplicity,
- enable_multiple_outputs=True,
+ is_multiple_outputs_enabled=True,
specific_output_count=override_multiplicity,
)
diff --git a/pipelex/libraries/pipelines/builder/builder.plx b/pipelex/libraries/pipelines/builder/builder.plx
index 290beda6a..a9f2a237c 100644
--- a/pipelex/libraries/pipelines/builder/builder.plx
+++ b/pipelex/libraries/pipelines/builder/builder.plx
@@ -20,10 +20,10 @@ description = "This pipe is going to be the entry point for the builder. It will
inputs = { brief = "UserBrief" }
output = "Dynamic"
steps = [
- { pipe = "draft_planning_text", result = "plan_draft" },
- { pipe = "draft_to_conceptspecs_text", result = "concept_spec_drafts_text" },
+ { pipe = "draft_the_plan", result = "plan_draft" },
+ { pipe = "draft_the_concepts", result = "concept_drafts" },
+ { pipe = "structure_concepts", result = "concept_specs" },
# { pipe = "draft_to_pipesignatures_text", result = "pipe_signatures_text" },
- # { pipe = "materialize_concept_spec_drafts", result = "concept_spec_drafts" },
# { pipe = "materialize_pipe_signatures", result = "pipe_signatures" },
# { pipe = "pipe_builder_domain_information", result = "domain_information" },
# { pipe = "build_concept_spec", batch_over = "concept_spec_drafts", batch_as = "concept_spec_draft", result = "concept_specs" },
@@ -38,21 +38,16 @@ description = "Turn the brief into a DomainInformation object."
inputs = { brief = "UserBrief" }
output = "DomainInformation"
prompt_template = """
-Based on the brief output the "domain" of this pipe, and a definition of what it would represent.
-
-Brief:
+Name and define the domain of this process:
@brief
-For example, if the pipe is about generating a compliance matrix out of a RFP, the domain would be "rfp_compliance_matrix"...
-It should be not more than 4 words, in snake_case.
-For the definition, i would like to see a short description of what the bundle would represent.
+For example, if the brief is about generating and analyzing a compliance matrix out of a RFP,
+the domain would be "rfp_compliance" and the definition would be "Generating and analyzing compliance related to RFPs".
+The domain name should be not more than 4 words, in snake_case.
+For the definition, be concise.
"""
-# ────────────────────────────────────────────────────────────────────────────────
-# STAGE 1 — plan (natural language pseudo-code, but explicit about IO + sequencing)
-# ────────────────────────────────────────────────────────────────────────────────
-
-[pipe.draft_planning_text]
+[pipe.draft_the_plan]
type = "PipeLLM"
description = "Turn the brief into a pseudo-code plan describing controllers, pipes, their inputs/outputs."
inputs = { brief = "UserBrief" }
@@ -95,17 +90,14 @@ Keep your style concise, no need to write tags such as "Description:", just writ
@brief
"""
-# ────────────────────────────────────────────────────────────────────────────────
-# STAGE 2 — textual specs (still TEXT, not structured objects yet)
-# ────────────────────────────────────────────────────────────────────────────────
-[pipe.draft_to_conceptspecs_text]
+[pipe.draft_the_concepts]
type = "PipeLLM"
description = "Interpret the draft of a plan to create an AI pipeline, and define the needed concepts."
inputs = { plan_draft = "PlanDraft", brief = "UserBrief" }
output = "ConceptDrafts"
llm = "llm_to_engineer"
prompt_template = """
-We are working on writing an AI pipeleine to answer this brief:
+We are working on writing an AI pipeleine to fulfill this brief:
@brief
We have already written a plan for the pipeline. It's built using pipes, each with its own inputs (one or more) and output (single).
@@ -140,6 +132,22 @@ DO NOT redefine native concepts such as: Text, Image, PDF, Number, Page. if you
@plan_draft
"""
+[pipe.structure_concepts]
+type = "PipeLLM"
+description = "Structure the concept definitions."
+inputs = { concept_drafts = "ConceptDrafts", brief = "UserBrief" }
+output = "concept.ConceptSpec"
+multiple_output = true
+llm = "llm_to_engineer"
+prompt_template = """
+Structure the concept drafts.
+
+@concept_drafts
+"""
+
+
+
+
[pipe.draft_to_pipesignatures_text]
type = "PipeLLM"
description = "Write the pipe signatures for the plan."
@@ -224,30 +232,6 @@ Brief:
No more than 10 PipeSignatures
"""
-# ────────────────────────────────────────────────────────────────────────────────
-# STAGE 3 — materialize: TEXT → real objects (ConceptSpec[], PipeSignature[])
-# ────────────────────────────────────────────────────────────────────────────────
-
-[pipe.materialize_concept_spec_drafts]
-type = "PipeLLM"
-description = "Turn ConceptSpecsText into ConceptSpec objects."
-inputs = { concept_spec_drafts_text = "Text", brief = "UserBrief" }
-output = "concept.ConceptSpecDraft"
-multiple_output = true
-llm = "llm_to_engineer"
-prompt_template = """
-Materialize ConceptSpec objects from the ConceptSpecsText.
-Do not change the information in the input. Just organize the information
-
-ConceptSpecs:
-@concept_spec_drafts_text
-
-Brief:
-@brief
-
-LIMIT TO A MAXIMUM OF 5 fields for now
-"""
-
[pipe.materialize_pipe_signatures]
type = "PipeLLM"
description = "Turn PipeSignaturesText into PipeSignature objects that reference the ConceptSpec objects."
diff --git a/pipelex/libraries/pipelines/builder/builder.py b/pipelex/libraries/pipelines/builder/builder.py
index 4493cf68d..3f934808a 100644
--- a/pipelex/libraries/pipelines/builder/builder.py
+++ b/pipelex/libraries/pipelines/builder/builder.py
@@ -25,8 +25,8 @@ from pipelex.types import StrEnum
class DomainInformation(StructuredContent):
- domain: str = Field(description="The domain of the pipeline library.")
- definition: str = Field(description="The definition of the pipeline library.")
+ domain: str = Field(description="Name of the domain of the knowledge work.")
+ definition: str = Field(description="Definition of the domain of the knowledge work.")
class PipeBuilderError(Exception):
diff --git a/pipelex/libraries/pipelines/builder/concept/concept_spec.py b/pipelex/libraries/pipelines/builder/concept/concept_spec.py
index 406baaec8..00e3827ec 100644
--- a/pipelex/libraries/pipelines/builder/concept/concept_spec.py
+++ b/pipelex/libraries/pipelines/builder/concept/concept_spec.py
@@ -118,7 +118,7 @@ class ConceptSpecDraft(StructuredContent):
the_concept_code: str = Field(description="Concept code. Must be PascalCase.")
definition: str = Field(description="Description of the concept, in natural language.")
structure: str = Field(
- description="A description of a dict with fieldnames as keys, and values being a dict with: definition, type, required, default_value",
+ description="Description of a dict with fieldnames as keys, and values being a dict with: definition, type, required, default_value",
)
refines: str | None = Field(
default=None,
@@ -128,22 +128,7 @@ class ConceptSpecDraft(StructuredContent):
class ConceptSpec(StructuredContent):
- """Spec defining a concept that can be used in the Pipelex framework.
-
- A concept represents a structured data type that can either define its own structure
- or refine an existing native concept. Concepts are fundamental building blocks in
- Pipelex workflows for data validation and transformation.
-
- Attributes:
- the_concept_code: Concept code. Must be PascalCase.
- definition: Natural language description of what the concept represents and its purpose.
- structure: The concept's field structure. Can be either:
- - A string referring to another concept
- - A dictionary where keys are field names (in snake_case) and values are
- either strings (concept references) or ConceptStructureBlueprint instances
- Cannot be used together with 'refines'.
- refines: The native concept this concept extends (Text, Image, PDF, TextAndImages,
- Number, Page) in PascalCase format. Cannot be used together with 'structure'.
+ """Spec structuring a concept: a conceptual data type that can either define its own structure or refine an existing native concept.
Validation Rules:
1. Mutual exclusivity: A concept must have either 'structure' or 'refines', but not both.
@@ -153,17 +138,25 @@ class ConceptSpec(StructuredContent):
4. Concept strings: Format is "domain.ConceptCode" where domain is lowercase and
ConceptCode is PascalCase.
5. Native concepts: When refining, must be one of the valid native concepts.
- 6. Structure values: In structure dict, values must be either valid concept strings
+ 6. Structure values: In structure attribute, values must be either valid concept strings
or ConceptStructureBlueprint instances.
-
"""
model_config = ConfigDict(extra="forbid")
the_concept_code: str = Field(description="Concept code. Must be PascalCase.")
- definition: str
- structure: str | dict[str, str | ConceptStructureSpec] | None = None
- refines: str | None = None
+ definition: str = Field(description="Description of the concept, in natural language.")
+ structure: str | dict[str, str | ConceptStructureSpec] | None = Field(
+ default=None,
+ description=("Definition of the concept's structure. Each attribute (snake_case) specifies: definition, type, required, default_value"),
+ )
+ refines: str | None = Field(
+ default=None,
+ description=(
+ "If applicable: the native concept this concept extends (Text, Image, PDF, TextAndImages, Number, Page) "
+ "in PascalCase format. Cannot be used together with 'structure'."
+ ),
+ )
@classmethod
def is_native_concept_code(cls, concept_code: str) -> bool:
diff --git a/pipelex/pipe_operators/llm/pipe_llm.py b/pipelex/pipe_operators/llm/pipe_llm.py
index e7478f5fe..fa2d4c4a5 100644
--- a/pipelex/pipe_operators/llm/pipe_llm.py
+++ b/pipelex/pipe_operators/llm/pipe_llm.py
@@ -255,8 +255,9 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):
base_multiplicity=self.output_multiplicity,
override_multiplicity=pipe_run_params.output_multiplicity,
)
+ log.debug(f"multiplicity_resolution: {multiplicity_resolution}")
applied_output_multiplicity = multiplicity_resolution.resolved_multiplicity
- is_multiple_output = multiplicity_resolution.enable_multiple_outputs
+ is_multiple_output = multiplicity_resolution.is_multiple_outputs_enabled
fixed_nb_output = multiplicity_resolution.specific_output_count
# Collect what LLM settings we have for this particular PipeLLM
@@ -299,32 +300,31 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):
log.verbose(
f"is_with_preliminary_text: {is_with_preliminary_text} for pipe {self.code} because the structuring_method is {self.structuring_method}",
)
- # Append output structure prompt if needed
- output_structure_prompt: str | None = PipeLLM.get_output_structure_prompt(
- concept_string=pipe_run_params.dynamic_output_concept_code or output_concept.concept_string,
- is_with_preliminary_text=is_with_preliminary_text,
- )
llm_prompt_run_params = PipeRunParams.copy_by_injecting_multiplicity(
pipe_run_params=pipe_run_params,
applied_output_multiplicity=applied_output_multiplicity,
is_with_preliminary_text=is_with_preliminary_text,
)
+
# TODO: we need a better solution for structuring_method (text then object), meanwhile,
# we acknowledge the code here with llm_prompt_1 and llm_prompt_2 is overly complex and should be refactored.
- llm_prompt_1 = await self.llm_prompt_spec.make_llm_prompt(
- output_concept_string=output_concept.concept_string,
- context_provider=working_memory,
- output_structure_prompt=output_structure_prompt,
- extra_params=llm_prompt_run_params.params,
- )
the_content: StuffContent
- if output_concept.structure_class_name == NativeConceptEnum.TEXT and not is_multiple_output:
+ log.debug(f"output_concept.structure_class_name: {output_concept.structure_class_name}")
+ log.debug(f"TextContent.__class__.__name__: {TextContent.__class__.__name__}")
+ log.debug(f"is_multiple_output: {is_multiple_output}")
+ if output_concept.structure_class_name == "TextContent" and not is_multiple_output:
log.debug(f"PipeLLM generating a single text output: {self.class_name}_gen_text")
+ llm_prompt_1_for_text = await self.llm_prompt_spec.make_llm_prompt(
+ output_concept_string=output_concept.concept_string,
+ context_provider=working_memory,
+ output_structure_prompt=None,
+ extra_params=llm_prompt_run_params.params,
+ )
generated_text: str = await content_generator.make_llm_text(
job_metadata=job_metadata,
- llm_prompt_for_text=llm_prompt_1,
+ llm_prompt_for_text=llm_prompt_1_for_text,
llm_setting_main=llm_setting_main,
)
@@ -335,7 +335,7 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):
if is_multiple_output:
log.debug(f"PipeLLM generating {fixed_nb_output} output(s)" if fixed_nb_output else "PipeLLM generating a list of output(s)")
else:
- log.debug("PipeLLM generating a single output")
+ log.debug(f"PipeLLM generating a single object output, class name: '{output_concept.structure_class_name}'")
# TODO: we need a better solution for structuring_method (text then object), meanwhile,
# we acknowledge the code here with llm_prompt_1 and llm_prompt_2 is overly complex and should be refactored.
@@ -388,6 +388,16 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):
else:
llm_prompt_2_factory = None
+ output_structure_prompt: str | None = PipeLLM.get_output_structure_prompt(
+ concept_string=pipe_run_params.dynamic_output_concept_code or output_concept.concept_string,
+ is_with_preliminary_text=is_with_preliminary_text,
+ )
+ llm_prompt_1_for_object = await self.llm_prompt_spec.make_llm_prompt(
+ output_concept_string=output_concept.concept_string,
+ context_provider=working_memory,
+ output_structure_prompt=output_structure_prompt,
+ extra_params=llm_prompt_run_params.params,
+ )
the_content = await self._llm_gen_object_stuff_content(
job_metadata=job_metadata,
is_multiple_output=is_multiple_output,
@@ -395,7 +405,7 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):
output_class_name=output_concept.structure_class_name,
llm_setting_main=llm_setting_main,
llm_setting_for_object=llm_setting_for_object,
- llm_prompt_1=llm_prompt_1,
+ llm_prompt_1=llm_prompt_1_for_object,
llm_prompt_2_factory=llm_prompt_2_factory,
content_generator=content_generator,
)
@@ -517,17 +527,19 @@ class PipeLLM(PipeOperator[PipeLLMOutput]):
)
@staticmethod
- def get_output_structure_prompt(concept_string: str, is_with_preliminary_text: bool) -> str:
+ def get_output_structure_prompt(concept_string: str, is_with_preliminary_text: bool) -> str | None:
concept = get_required_concept(concept_string=concept_string)
class_name = concept.structure_class_name
output_class = get_class_registry().get_class(class_name)
+ log.debug(f"get_output_structure_prompt for {concept_string} with {is_with_preliminary_text=}")
+ log.debug(f"output_class: {output_class}")
if not output_class:
- return ""
+ return None
class_structure = StructurePrinter().get_type_structure(tp=output_class, base_class=StuffContent)
if not class_structure:
- return ""
+ return None
class_structure_str = "\n".join(class_structure)
# TODO: use proper prompt templating for this
diff --git a/tests/unit/pipelex/core/pipes/data.py b/tests/unit/pipelex/core/pipes/data.py
index 145267a20..85e6ce250 100644
--- a/tests/unit/pipelex/core/pipes/data.py
+++ b/tests/unit/pipelex/core/pipes/data.py
@@ -34,128 +34,128 @@ OUTPUT_MULTIPLICITY_TO_APPLY_TEST_CASES: list[
(
None,
None,
- OutputMultiplicityResolution(resolved_multiplicity=None, enable_multiple_outputs=False, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=None, is_multiple_outputs_enabled=False, specific_output_count=None),
"base=None, override=None",
),
(
True,
None,
- OutputMultiplicityResolution(resolved_multiplicity=True, enable_multiple_outputs=True, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=True, is_multiple_outputs_enabled=True, specific_output_count=None),
"base=True, override=None",
),
(
False,
None,
- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),
"base=False, override=None",
),
- (3, None, OutputMultiplicityResolution(resolved_multiplicity=3, enable_multiple_outputs=True, specific_output_count=3), "base=3, override=None"),
- (5, None, OutputMultiplicityResolution(resolved_multiplicity=5, enable_multiple_outputs=True, specific_output_count=5), "base=5, override=None"),
+ (3, None, OutputMultiplicityResolution(resolved_multiplicity=3, is_multiple_outputs_enabled=True, specific_output_count=3), "base=3, override=None"),
+ (5, None, OutputMultiplicityResolution(resolved_multiplicity=5, is_multiple_outputs_enabled=True, specific_output_count=5), "base=5, override=None"),
# Override is False - force single output regardless of base
(
None,
False,
- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),
"base=None, override=False",
),
(
True,
False,
- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),
"base=True, override=False",
),
(
False,
False,
- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),
"base=False, override=False",
),
(
3,
False,
- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),
"base=3, override=False",
),
(
10,
False,
- OutputMultiplicityResolution(resolved_multiplicity=False, enable_multiple_outputs=False, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=False, is_multiple_outputs_enabled=False, specific_output_count=None),
"base=10, override=False",
),
# Override is True - enable multiple outputs
(
None,
True,
- OutputMultiplicityResolution(resolved_multiplicity=None, enable_multiple_outputs=True, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=None, is_multiple_outputs_enabled=True, specific_output_count=None),
"base=None, override=True",
),
(
True,
True,
- OutputMultiplicityResolution(resolved_multiplicity=True, enable_multiple_outputs=True, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=True, is_multiple_outputs_enabled=True, specific_output_count=None),
"base=True, override=True",
),
(
False,
True,
- OutputMultiplicityResolution(resolved_multiplicity=True, enable_multiple_outputs=True, specific_output_count=None),
+ OutputMultiplicityResolution(resolved_multiplicity=True, is_multiple_outputs_enabled=True, specific_output_count=None),
"base=False, override=True",
),
(
3,
True,
- OutputMultiplicityResolution(resolved_multiplicity=3, enable_multiple_outputs=True, specific_output_count=3),
+ OutputMultiplicityResolution(resolved_multiplicity=3, is_multiple_outputs_enabled=True, specific_output_count=3),
"base=3, override=True - preserve base count",
),
(
7,
True,
- OutputMultiplicityResolution(resolved_multiplicity=7, enable_multiple_outputs=True, specific_output_count=7),
+ OutputMultiplicityResolution(resolved_multiplicity=7, is_multiple_outputs_enabled=True, specific_output_count=7),
"base=7, override=True - preserve base count",
),
# Override is int - use override count, enable multiple outputs
- (None, 2, OutputMultiplicityResolution(resolved_multiplicity=2, enable_multiple_outputs=True, specific_output_count=2), "base=None, override=2"),
- (True, 4, OutputMultiplicityResolution(resolved_multiplicity=4, enable_multiple_outputs=True, specific_output_count=4), "base=True, override=4"),
+ (None, 2, OutputMultiplicityResolution(resolved_multiplicity=2, is_multiple_outputs_enabled=True, specific_output_count=2), "base=None, override=2"),
+ (True, 4, OutputMultiplicityResolution(resolved_multiplicity=4, is_multiple_outputs_enabled=True, specific_output_count=4), "base=True, override=4"),
(
False,
6,
- OutputMultiplicityResolution(resolved_multiplicity=6, enable_multiple_outputs=True, specific_output_count=6),
+ OutputMultiplicityResolution(resolved_multiplicity=6, is_multiple_outputs_enabled=True, specific_output_count=6),
"base=False, override=6",
),
(
3,
8,
- OutputMultiplicityResolution(resolved_multiplicity=8, enable_multiple_outputs=True, specific_output_count=8),
+ OutputMultiplicityResolution(resolved_multiplicity=8, is_multiple_outputs_enabled=True, specific_output_count=8),
"base=3, override=8 - override takes precedence",
),
(
5,
1,
- OutputMultiplicityResolution(resolved_multiplicity=1, enable_multiple_outputs=True, specific_output_count=1),
+ OutputMultiplicityResolution(resolved_multiplicity=1, is_multiple_outputs_enabled=True, specific_output_count=1),
"base=5, override=1 - override takes precedence",
),
# Edge cases with negative numbers
(
-1,
None,
- OutputMultiplicityResolution(resolved_multiplicity=-1, enable_multiple_outputs=True, specific_output_count=-1),
+ OutputMultiplicityResolution(resolved_multiplicity=-1, is_multiple_outputs_enabled=True, specific_output_count=-1),
"base=-1, override=None",
),
- (3, -2, OutputMultiplicityResolution(resolved_multiplicity=-2, enable_multiple_outputs=True, specific_output_count=-2), "base=3, override=-2"),
+ (3, -2, OutputMultiplicityResolution(resolved_multiplicity=-2, is_multiple_outputs_enabled=True, specific_output_count=-2), "base=3, override=-2"),
# Edge cases with zero
- (0, None, OutputMultiplicityResolution(resolved_multiplicity=0, enable_multiple_outputs=True, specific_output_count=0), "base=0, override=None"),
- (True, 0, OutputMultiplicityResolution(resolved_multiplicity=0, enable_multiple_outputs=True, specific_output_count=0), "base=True, override=0"),
+ (0, None, OutputMultiplicityResolution(resolved_multiplicity=0, is_multiple_outputs_enabled=True, specific_output_count=0), "base=0, override=None"),
+ (True, 0, OutputMultiplicityResolution(resolved_multiplicity=0, is_multiple_outputs_enabled=True, specific_output_count=0), "base=True, override=0"),
# Large numbers
(
1000,
None,
- OutputMultiplicityResolution(resolved_multiplicity=1000, enable_multiple_outputs=True, specific_output_count=1000),
+ OutputMultiplicityResolution(resolved_multiplicity=1000, is_multiple_outputs_enabled=True, specific_output_count=1000),
"base=1000, override=None",
),
(
100,
999,
- OutputMultiplicityResolution(resolved_multiplicity=999, enable_multiple_outputs=True, specific_output_count=999),
+ OutputMultiplicityResolution(resolved_multiplicity=999, is_multiple_outputs_enabled=True, specific_output_count=999),
"base=100, override=999",
),
]
diff --git a/tests/unit/pipelex/core/pipes/test_pipe_run_params.py b/tests/unit/pipelex/core/pipes/test_pipe_run_params.py
index 3e96e7027..906366bbb 100644
--- a/tests/unit/pipelex/core/pipes/test_pipe_run_params.py
+++ b/tests/unit/pipelex/core/pipes/test_pipe_run_params.py
@@ -120,7 +120,7 @@ class TestOutputMultiplicityToApply:
"""Test output_multiplicity_to_apply with all parameter combinations."""
result = output_multiplicity_to_apply(base, override)
assert result.resolved_multiplicity == expected_result.resolved_multiplicity, f"Failed resolved_multiplicity for case: {description}"
- assert result.enable_multiple_outputs == expected_result.enable_multiple_outputs, f"Failed enable_multiple_outputs for case: {description}"
+ assert result.is_multiple_outputs_enabled == expected_result.is_multiple_outputs_enabled, f"Failed enable_multiple_outputs for case: {description}"
assert result.specific_output_count == expected_result.specific_output_count, f"Failed specific_output_count for case: {description}"
def test_override_none_uses_base(self):
@@ -128,25 +128,25 @@ class TestOutputMultiplicityToApply:
# Base None -> single output
result = output_multiplicity_to_apply(None, None)
assert result.resolved_multiplicity is None
- assert result.enable_multiple_outputs is False
+ assert result.is_multiple_outputs_enabled is False
assert result.specific_output_count is None
# Base True -> multiple output, LLM decides
result = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=None)
assert result.resolved_multiplicity is True
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count is None
# Base int -> multiple output with specific count
result = output_multiplicity_to_apply(base_multiplicity=3, override_multiplicity=None)
assert result.resolved_multiplicity == 3
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 3
# Base False -> single output
result = output_multiplicity_to_apply(base_multiplicity=False, override_multiplicity=None)
assert result.resolved_multiplicity is False
- assert result.enable_multiple_outputs is False
+ assert result.is_multiple_outputs_enabled is False
assert result.specific_output_count is None
def test_override_false_forces_single_output(self):
@@ -157,7 +157,7 @@ class TestOutputMultiplicityToApply:
for base in test_bases:
result = output_multiplicity_to_apply(base_multiplicity=base, override_multiplicity=False)
assert result.resolved_multiplicity is False, f"Failed for base={base}: resolved_multiplicity should be False"
- assert result.enable_multiple_outputs is False, f"Failed for base={base}: enable_multiple_outputs should be False"
+ assert result.is_multiple_outputs_enabled is False, f"Failed for base={base}: enable_multiple_outputs should be False"
assert result.specific_output_count is None, f"Failed for base={base}: specific_output_count should be None"
def test_override_true_enables_multiple_outputs(self):
@@ -165,26 +165,26 @@ class TestOutputMultiplicityToApply:
# Base None -> preserve None but enable multiple
result = output_multiplicity_to_apply(base_multiplicity=None, override_multiplicity=True)
assert result.resolved_multiplicity is None
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count is None
# Base False -> enable multiple, LLM decides count
result = output_multiplicity_to_apply(base_multiplicity=False, override_multiplicity=True)
assert result.resolved_multiplicity is True
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count is None
# Base True -> keep True
result = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=True)
assert result.resolved_multiplicity is True
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count is None
# Base int -> preserve count, enable multiple
for base_int in [1, 3, 5, 10]:
result = output_multiplicity_to_apply(base_multiplicity=base_int, override_multiplicity=True)
assert result.resolved_multiplicity == base_int
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == base_int
def test_override_int_uses_override_count(self):
@@ -195,7 +195,7 @@ class TestOutputMultiplicityToApply:
for base in test_bases:
result = output_multiplicity_to_apply(base_multiplicity=base, override_multiplicity=override_int)
assert result.resolved_multiplicity == override_int, f"Failed for base={base}: resolved_multiplicity should be {override_int}"
- assert result.enable_multiple_outputs is True, f"Failed for base={base}: enable_multiple_outputs should be True"
+ assert result.is_multiple_outputs_enabled is True, f"Failed for base={base}: enable_multiple_outputs should be True"
assert result.specific_output_count == override_int, f"Failed for base={base}: specific_output_count should be {override_int}"
def test_return_basemodel_structure(self):
@@ -205,7 +205,7 @@ class TestOutputMultiplicityToApply:
# Test field types
assert result.resolved_multiplicity is None or isinstance(result.resolved_multiplicity, (bool, int))
- assert isinstance(result.enable_multiple_outputs, bool)
+ assert isinstance(result.is_multiple_outputs_enabled, bool)
assert result.specific_output_count is None or isinstance(result.specific_output_count, int)
def test_edge_cases(self):
@@ -213,29 +213,29 @@ class TestOutputMultiplicityToApply:
# Negative numbers
result = output_multiplicity_to_apply(base_multiplicity=-1, override_multiplicity=None)
assert result.resolved_multiplicity == -1
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == -1
result = output_multiplicity_to_apply(base_multiplicity=3, override_multiplicity=-2)
assert result.resolved_multiplicity == -2
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == -2
# Zero values
result = output_multiplicity_to_apply(base_multiplicity=0, override_multiplicity=None)
assert result.resolved_multiplicity == 0
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 0
result = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=0)
assert result.resolved_multiplicity == 0
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 0
# Large numbers
result = output_multiplicity_to_apply(base_multiplicity=1000, override_multiplicity=None)
assert result.resolved_multiplicity == 1000
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 1000
def test_override_precedence_logic(self):
@@ -243,40 +243,40 @@ class TestOutputMultiplicityToApply:
# Override False beats any base
result = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=False)
assert result.resolved_multiplicity is False
- assert result.enable_multiple_outputs is False
+ assert result.is_multiple_outputs_enabled is False
assert result.specific_output_count is None
result = output_multiplicity_to_apply(base_multiplicity=5, override_multiplicity=False)
assert result.resolved_multiplicity is False
- assert result.enable_multiple_outputs is False
+ assert result.is_multiple_outputs_enabled is False
assert result.specific_output_count is None
# Override int beats any base
result = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=3)
assert result.resolved_multiplicity == 3
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 3
result = output_multiplicity_to_apply(base_multiplicity=7, override_multiplicity=3)
assert result.resolved_multiplicity == 3
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 3
# Override True with int base preserves int
result = output_multiplicity_to_apply(base_multiplicity=5, override_multiplicity=True)
assert result.resolved_multiplicity == 5
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 5
# Override True with bool base becomes True
result = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=True)
assert result.resolved_multiplicity is True
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count is None
result = output_multiplicity_to_apply(base_multiplicity=False, override_multiplicity=True)
assert result.resolved_multiplicity is True
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count is None
def test_complex_scenarios(self):
@@ -284,23 +284,23 @@ class TestOutputMultiplicityToApply:
# Scenario: Pipe has base multiplicity=3, runtime wants to disable it
result = output_multiplicity_to_apply(base_multiplicity=3, override_multiplicity=False)
assert result.resolved_multiplicity is False
- assert result.enable_multiple_outputs is False
+ assert result.is_multiple_outputs_enabled is False
assert result.specific_output_count is None
# Scenario: Pipe has no base multiplicity, runtime wants 5 outputs
result = output_multiplicity_to_apply(base_multiplicity=None, override_multiplicity=5)
assert result.resolved_multiplicity == 5
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 5
# Scenario: Pipe has base True, runtime wants specific count
result = output_multiplicity_to_apply(base_multiplicity=True, override_multiplicity=2)
assert result.resolved_multiplicity == 2
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 2
# Scenario: Pipe has base count, runtime wants to enable but let LLM decide
result = output_multiplicity_to_apply(base_multiplicity=4, override_multiplicity=True)
assert result.resolved_multiplicity == 4 # Preserves base count
- assert result.enable_multiple_outputs is True
+ assert result.is_multiple_outputs_enabled is True
assert result.specific_output_count == 4