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/pipe condition trying to get continue like a pipe (#316)
Louis Choquel0b44f10812d9
diff --git a/pipelex/core/pipes/specific_pipe.py b/pipelex/core/pipes/specific_pipe.pyindex 963c2ea56..036360c8a 100644--- a/pipelex/core/pipes/specific_pipe.py+++ b/pipelex/core/pipes/specific_pipe.py@@ -7,8 +7,8 @@ class SpecificPipeCodesEnum(StrEnum):# BREAK = "break"@classmethod- def value_list(cls) -> list[str]:- return list(cls)+ def value_list(cls) -> set[str]:+ return set(cls)# TODO: Rethink this class. They are not pipes really.diff --git a/pipelex/libraries/pipelines/builder/pipe/pipe_condition_spec.py b/pipelex/libraries/pipelines/builder/pipe/pipe_condition_spec.pyindex 694af011d..c0396403a 100644--- a/pipelex/libraries/pipelines/builder/pipe/pipe_condition_spec.py+++ b/pipelex/libraries/pipelines/builder/pipe/pipe_condition_spec.py@@ -5,7 +5,7 @@ from pydantic.json_schema import SkipJsonSchemafrom typing_extensions import overridefrom pipelex.libraries.pipelines.builder.pipe.pipe_signature import PipeSpec-from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint, PipeConditionPipeMapBlueprint+from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprintclass PipeConditionSpec(PipeSpec):@@ -31,7 +31,6 @@ class PipeConditionSpec(PipeSpec):@overridedef to_blueprint(self) -> PipeConditionBlueprint:base_blueprint = super().to_blueprint()- pipe_map_blueprint = PipeConditionPipeMapBlueprint(root=dict(self.pipe_map))return PipeConditionBlueprint(description=base_blueprint.description,inputs=base_blueprint.inputs,@@ -40,7 +39,7 @@ class PipeConditionSpec(PipeSpec):category=self.category,expression_template=self.jinja2_expression_template,expression=None,- pipe_map=pipe_map_blueprint,+ pipe_map=self.pipe_map,default_pipe_code=self.default_pipe_code,add_alias_from_expression_to=None,)diff --git a/pipelex/pipe_controllers/condition/pipe_condition.py b/pipelex/pipe_controllers/condition/pipe_condition.pyindex 1a38a5675..4ac2a4441 100644--- a/pipelex/pipe_controllers/condition/pipe_condition.py+++ b/pipelex/pipe_controllers/condition/pipe_condition.py@@ -1,7 +1,7 @@from typing import Literalimport shortuuid-from pydantic import field_validator, model_validator+from pydantic import model_validatorfrom typing_extensions import overridefrom pipelex import log@@ -9,7 +9,6 @@ from pipelex.config import StaticValidationReaction, get_configfrom pipelex.core.concepts.concept_factory import ConceptFactoryfrom pipelex.core.concepts.concept_native import NATIVE_CONCEPTS_DATA, NativeConceptEnum, NativeConceptManagerfrom pipelex.core.memory.working_memory import WorkingMemory-from pipelex.core.pipes.pipe_abstract import PipeAbstractfrom pipelex.core.pipes.pipe_input import PipeInputSpecfrom pipelex.core.pipes.pipe_input_blueprint import InputRequirementBlueprintfrom pipelex.core.pipes.pipe_input_factory import PipeInputSpecFactory@@ -26,7 +25,7 @@ from pipelex.exceptions import (StaticValidationErrorType,WorkingMemoryStuffNotFoundError,)-from pipelex.hub import get_content_generator, get_pipe_router, get_pipeline_tracker, get_required_pipe, get_template_provider+from pipelex.hub import get_content_generator, get_optional_pipe, get_pipe_router, get_pipeline_tracker, get_required_pipe, get_template_providerfrom pipelex.pipe_controllers.condition.pipe_condition_details import PipeConditionDetails, PipeConditionPipeMapfrom pipelex.pipe_controllers.pipe_controller import PipeControllerfrom pipelex.pipe_works.pipe_job_factory import PipeJobFactory@@ -41,11 +40,17 @@ class PipeCondition(PipeController):type: Literal["PipeCondition"] = "PipeCondition"expression_template: str | None = Noneexpression: str | None = None- # TODO: rething this pipe_map.- pipe_map: list[PipeConditionPipeMap]+ pipe_map: PipeConditionPipeMapdefault_pipe_code: str | None = Noneadd_alias_from_expression_to: str | None = None+ @property+ def mapped_pipe_codes(self) -> set[str]:+ codes = set(self.pipe_map.values())+ if self.default_pipe_code:+ codes.add(self.default_pipe_code)+ return codes - set(SpecificPipeCodesEnum.value_list())+########################################################################################## Validation#########################################################################################@@ -54,51 +59,23 @@ class PipeCondition(PipeController):"""Validate the output for the pipe condition.The output of the pipe condition should match the output of all the conditional pipes, and the default pipe."""- # This pipe CONTINUE enables to leave a PipeCondition and continue the sequence.- # This system though has to be rethink. It might not be the best solution- for pipe_condition_pipe_map in self.pipe_map:- if not SpecificPipe.is_continue(pipe_condition_pipe_map.pipe_code):- pipe = get_required_pipe(pipe_code=pipe_condition_pipe_map.pipe_code)- if self.output.concept_string not in (- pipe.output.concept_string,- NativeConceptManager.get_native_concept_string(NativeConceptEnum.DYNAMIC),- ):- msg = (- f"The output concept code '{self.output.concept_string}' of the pipe '{self.code}' is "- f"not matching the output concept code '{pipe.output.concept_string}' of the pipe '{pipe_condition_pipe_map.pipe_code}'"- )- raise PipeConditionError(msg)- if self.default_pipe_code and self.default_pipe_code not in SpecificPipeCodesEnum.value_list():- default_pipe = get_required_pipe(pipe_code=self.default_pipe_code)+ for pipe_code in self.mapped_pipe_codes:+ pipe = get_required_pipe(pipe_code=pipe_code)if self.output.concept_string not in (- default_pipe.output.concept_string,+ pipe.output.concept_string,NativeConceptManager.get_native_concept_string(NativeConceptEnum.DYNAMIC),):msg = (f"The output concept code '{self.output.concept_string}' of the pipe '{self.code}' is "- f"not matching the output concept code '{default_pipe.output.concept_string}' of the default pipe '{self.default_pipe_code}'"+ f"not matching the output concept code '{pipe.output.concept_string}' of the pipe '{pipe_code}'")raise PipeConditionError(msg)- @field_validator("pipe_map")- @classmethod- def validate_pipe_map(cls, pipe_map: list[PipeConditionPipeMap]) -> list[PipeConditionPipeMap]:- # Validate that the expressions and pipe_code are UNIQUE- expression_results = [pipe_condition_pipe_map.expression_result for pipe_condition_pipe_map in pipe_map]- pipe_codes = [pipe_condition_pipe_map.pipe_code for pipe_condition_pipe_map in pipe_map]- if len(expression_results) != len(set(expression_results)):- msg = f"PipeCondition '{cls.code}' must have a unique expression result for each pipe in pipe_map in pipe_map: {pipe_map}"- raise PipeDefinitionError(msg)- if len(pipe_codes) != len(set(pipe_codes)):- msg = f"PipeCondition '{cls.code}' must have a unique pipe code for each expression result in pipe_map in pipe_map: {pipe_map}"- raise PipeDefinitionError(msg)- return pipe_map-@model_validator(mode="after")def validate_expression(self) -> Self:if not has_exactly_one_among_attributes_from_list(self, attributes_list=["expression_template", "expression"]):msg = "PipeCondition should have exactly one of expression_template or expression"- raise PipeDefinitionError(msg)+ raise PipeDefinitionError(message=msg, domain_code=self.domain, pipe_code=self.code, description=self.description)return selfdef _make_pipe_condition_details(self, evaluated_expression: str, chosen_pipe_code: str) -> PipeConditionDetails:@@ -146,7 +123,7 @@ class PipeCondition(PipeController):for required_variable_name in self.required_variables():if required_variable_name not in self.inputs.variables:msg = f"Required variable '{required_variable_name}' is not in the inputs of pipe {self.code}"- raise PipeDefinitionError(msg)+ raise PipeDefinitionError(message=msg, domain_code=self.domain, pipe_code=self.code, description=self.description)return self@override@@ -183,14 +160,13 @@ class PipeCondition(PipeController):)# 2. Add the inputs needed by all possible target pipes- for pipe_condition_pipe_map in self.pipe_map:- if not SpecificPipe.is_continue(pipe_condition_pipe_map.pipe_code):- pipe = get_required_pipe(pipe_code=pipe_condition_pipe_map.pipe_code)- # Use the centralized recursion detection- pipe_needed_inputs = pipe.needed_inputs(visited_pipes_with_current)+ for pipe_code in self.mapped_pipe_codes:+ pipe = get_required_pipe(pipe_code=pipe_code)+ # Use the centralized recursion detection+ pipe_needed_inputs = pipe.needed_inputs(visited_pipes_with_current)- for input_name, requirement in pipe_needed_inputs.items:- needed_inputs.add_requirement(variable_name=input_name, concept=requirement.concept)+ for input_name, requirement in pipe_needed_inputs.items:+ needed_inputs.add_requirement(variable_name=input_name, concept=requirement.concept)return needed_inputs@@ -198,7 +174,7 @@ class PipeCondition(PipeController):def validate_inputs(self) -> Self:if not self.pipe_map:msg = f"Pipe'{self.code}'(PipeCondition) must have at least one mapping in pipe_map"- raise ValueError(msg)+ raise PipeDefinitionError(message=msg, domain_code=self.domain, pipe_code=self.code, description=self.description)# Skip validation during model creation - it will be done in validate_with_libraries()return self@@ -255,26 +231,19 @@ class PipeCondition(PipeController):@overridedef pipe_dependencies(self) -> set[str]:- pipe_codes = [- pipe_condition_pipe_map.pipe_code- for pipe_condition_pipe_map in self.pipe_map- if not SpecificPipe.is_continue(pipe_condition_pipe_map.pipe_code)- ]- if self.default_pipe_code and self.default_pipe_code not in SpecificPipeCodesEnum.value_list():- pipe_codes.append(self.default_pipe_code)- return set(pipe_codes)-- async def _evaluate_expression_and_select_pipe(+ return self.mapped_pipe_codes++ async def _evaluate_expression(self,working_memory: WorkingMemory,- ) -> PipeAbstract:+ ) -> str:"""Evaluate the conditional expression and select the appropriate pipe.Args:working_memory: The working memory context for evaluationReturns:- A tuple of (evaluated_expression, chosen_pipe_code)+ The evaluated expressionRaises:PipeConditionError: If expression evaluation fails or no matching pipe is found@@ -282,6 +251,7 @@ class PipeCondition(PipeController):content_generator = get_content_generator()# Evaluate the expression using Jinja2 templating+ # TODO: create a proper category instead of using Jinja2TemplateCategory.LLM_PROMPTevaluated_expression = await content_generator.make_jinja2_text(context=working_memory.generate_jinja2_context(),jinja2=self.applied_expression_template,@@ -290,7 +260,7 @@ class PipeCondition(PipeController):# Validate the evaluated expressionif not evaluated_expression or evaluated_expression == "None":- error_msg = f"Conditional expression returned an empty string in pipe {self.code}:"+ error_msg = f"Conditional expression returned no result in pipe {self.code}:"error_msg += f"\n\nExpression: {self.applied_expression_template}"raise PipeConditionError(error_msg)log.debug(f"evaluated_expression: '{evaluated_expression}'")@@ -303,23 +273,7 @@ class PipeCondition(PipeController):target=self.add_alias_from_expression_to,)- # Select the pipe based on the evaluated expression- chosen_pipe_code = next(- (- pipe_condition_pipe_map.pipe_code- for pipe_condition_pipe_map in self.pipe_map- if pipe_condition_pipe_map.expression_result == evaluated_expression- ),- self.default_pipe_code,- )- # Validate that a pipe was found- if not chosen_pipe_code:- error_msg = f"No pipe code found for evaluated expression '{evaluated_expression}' in pipe {self.code}:"- error_msg += f"\n\nExpression: {self.applied_expression_template}"- error_msg += f"\n\nPipe map: {self.pipe_map}"- raise PipeConditionError(error_msg)-- return get_required_pipe(pipe_code=chosen_pipe_code)+ return evaluated_expression@overrideasync def _run_controller_pipe(@@ -342,12 +296,24 @@ class PipeCondition(PipeController):multiplicity=requirement.multiplicity,)- chosen_pipe = await self._evaluate_expression_and_select_pipe(working_memory=working_memory)+ evaluated_expression = await self._evaluate_expression(working_memory=working_memory)++ # Select the pipe based on the evaluated expression+ chosen_pipe_code = self.pipe_map.get(evaluated_expression, self.default_pipe_code)++ # Validate that a pipe code was found+ if not chosen_pipe_code:+ error_msg = f"No pipe code found for evaluated expression '{evaluated_expression}' in pipe {self.code}:"+ error_msg += f"\n\nExpression: {self.applied_expression_template}"+ error_msg += f"\n\nPipe map: {self.pipe_map}"+ raise PipeConditionError(error_msg)# Handle continue case- if SpecificPipe.is_continue(chosen_pipe.code):+ if SpecificPipe.is_continue(chosen_pipe_code):return PipeOutput(working_memory=working_memory)+ chosen_pipe = get_required_pipe(pipe_code=chosen_pipe_code)+# Create condition details for trackingcondition_details = self._make_pipe_condition_details(evaluated_expression=self.applied_expression_template,@@ -448,35 +414,22 @@ class PipeCondition(PipeController):) from exc# 3. Validate that all pipes in the pipe_map exist- all_pipe_codes = {pipe_condition_pipe_map.pipe_code for pipe_condition_pipe_map in self.pipe_map}+ all_pipe_codes = set(self.pipe_map.values())if self.default_pipe_code:all_pipe_codes.add(self.default_pipe_code)+ all_pipe_codes -= set(SpecificPipeCodesEnum.value_list())- missing_pipes: list[str] = []- for pipe_code in all_pipe_codes:- if pipe_code in SpecificPipeCodesEnum.value_list():- continue- try:- get_required_pipe(pipe_code=pipe_code)- log.debug(f"Pipe '{pipe_code}' exists and is accessible")- except Exception as exc:- log.error(f"Dry run failed: pipe '{pipe_code}' not found: {exc}")- missing_pipes.append(pipe_code)+ missing_pipes = [pipe_code for pipe_code in all_pipe_codes if not get_optional_pipe(pipe_code=pipe_code)]if missing_pipes:error_msg = (- f"Dry run failed for pipe '{self.code}' (PipeCondition): missing pipes: {', '.join(missing_pipes)}. "+ f"Dry run failed for PipeCondition '{self.code}': missing pipes: {', '.join(missing_pipes)}. "f"Pipe map: {self.pipe_map}, default: {self.default_pipe_code}")- raise DryRunError(- message=error_msg,- missing_inputs=[],- pipe_code=self.code,- )+ raise DryRunError(message=error_msg, pipe_code=self.code)# Here, it should launch the dry run of all the pipes in the pipe_map- for pipe_condition_pipe_map in self.pipe_map:- pipe_code = pipe_condition_pipe_map.pipe_code+ for pipe_code in self.mapped_pipe_codes:pipe = get_required_pipe(pipe_code=pipe_code)await pipe.run_pipe(job_metadata=job_metadata,diff --git a/pipelex/pipe_controllers/condition/pipe_condition_blueprint.py b/pipelex/pipe_controllers/condition/pipe_condition_blueprint.pyindex fa5ed48a4..744b77413 100644--- a/pipelex/pipe_controllers/condition/pipe_condition_blueprint.py+++ b/pipelex/pipe_controllers/condition/pipe_condition_blueprint.py@@ -1,21 +1,15 @@from typing import Literal-from pydantic import Field, RootModel+from pydantic import Fieldfrom pipelex.core.pipes.pipe_blueprint import PipeBlueprint-PipeConditionPipeMapRoot = dict[str, str]---class PipeConditionPipeMapBlueprint(RootModel[PipeConditionPipeMapRoot]):- root: PipeConditionPipeMapRoot = Field(default_factory=dict)-class PipeConditionBlueprint(PipeBlueprint):type: Literal["PipeCondition"] = "PipeCondition"category: Literal["PipeController"] = "PipeController"expression_template: str | None = Noneexpression: str | None = None- pipe_map: PipeConditionPipeMapBlueprint = Field(default_factory=PipeConditionPipeMapBlueprint)+ pipe_map: dict[str, str] = Field(default_factory=dict)default_pipe_code: str | None = Noneadd_alias_from_expression_to: str | None = Nonediff --git a/pipelex/pipe_controllers/condition/pipe_condition_details.py b/pipelex/pipe_controllers/condition/pipe_condition_details.pyindex c97f513b2..7b9de0632 100644--- a/pipelex/pipe_controllers/condition/pipe_condition_details.py+++ b/pipelex/pipe_controllers/condition/pipe_condition_details.py@@ -1,15 +1,12 @@from pydantic import BaseModel--class PipeConditionPipeMap(BaseModel):- expression_result: str- pipe_code: str+PipeConditionPipeMap = dict[str, str]class PipeConditionDetails(BaseModel):code: strtest_expression: str- pipe_map: list[PipeConditionPipeMap]+ pipe_map: dict[str, str]default_pipe_code: str | None = Noneevaluated_expression: strchosen_pipe_code: strdiff --git a/pipelex/pipe_controllers/condition/pipe_condition_factory.py b/pipelex/pipe_controllers/condition/pipe_condition_factory.pyindex 8f0de26c4..97c560a54 100644--- a/pipelex/pipe_controllers/condition/pipe_condition_factory.py+++ b/pipelex/pipe_controllers/condition/pipe_condition_factory.py@@ -5,17 +5,10 @@ from pipelex.core.pipes.pipe_factory import PipeFactoryProtocolfrom pipelex.core.pipes.pipe_input_factory import PipeInputSpecFactoryfrom pipelex.hub import get_concept_providerfrom pipelex.pipe_controllers.condition.pipe_condition import PipeCondition-from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint, PipeConditionPipeMapBlueprint-from pipelex.pipe_controllers.condition.pipe_condition_details import PipeConditionPipeMap+from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprintclass PipeConditionFactory(PipeFactoryProtocol[PipeConditionBlueprint, PipeCondition]):- @classmethod- def make_pipe_condition_pipe_map(cls, pipe_map: PipeConditionPipeMapBlueprint) -> list[PipeConditionPipeMap]:- return [- PipeConditionPipeMap(expression_result=expression_result, pipe_code=pipe_code) for expression_result, pipe_code in pipe_map.root.items()- ]-@classmethod@overridedef make_from_blueprint(@@ -47,7 +40,7 @@ class PipeConditionFactory(PipeFactoryProtocol[PipeConditionBlueprint, PipeCondi),expression_template=blueprint.expression_template,expression=blueprint.expression,- pipe_map=cls.make_pipe_condition_pipe_map(pipe_map=blueprint.pipe_map),+ pipe_map=blueprint.pipe_map,default_pipe_code=blueprint.default_pipe_code,add_alias_from_expression_to=blueprint.add_alias_from_expression_to,)diff --git a/pipelex/pipe_controllers/parallel/pipe_parallel_factory.py b/pipelex/pipe_controllers/parallel/pipe_parallel_factory.pyindex 4f4215234..4f6b7b266 100644--- a/pipelex/pipe_controllers/parallel/pipe_parallel_factory.py+++ b/pipelex/pipe_controllers/parallel/pipe_parallel_factory.py@@ -28,7 +28,7 @@ class PipeParallelFactory(PipeFactoryProtocol[PipeParallelBlueprint, PipeParalleparallel_sub_pipes: list[SubPipe] = []for sub_pipe_blueprint in blueprint.parallels:if not sub_pipe_blueprint.result:- msg = "Unexpected error in pipe '{pipe_code}': PipeParallel requires a result specified for each parallel sub pipe"+ msg = f"Unexpected error in pipe '{pipe_code}': PipeParallel requires a result specified for each parallel sub pipe"raise PipeDefinitionError(message=msg, domain_code=domain, pipe_code=pipe_code, description=blueprint.description, source=blueprint.source)diff --git a/tests/e2e/pipelex/pipes/pipe_controller/pipe_condition/test_pipe_condition_simple.py b/tests/e2e/pipelex/pipes/pipe_controller/pipe_condition/test_pipe_condition_simple.pyindex 0acbf2b7b..d9312bae2 100644--- a/tests/e2e/pipelex/pipes/pipe_controller/pipe_condition/test_pipe_condition_simple.py+++ b/tests/e2e/pipelex/pipes/pipe_controller/pipe_condition/test_pipe_condition_simple.py@@ -12,7 +12,7 @@ from pipelex.core.pipes.pipe_input_blueprint import InputRequirementBlueprintfrom pipelex.core.pipes.pipe_run_params import PipeRunModefrom pipelex.core.pipes.pipe_run_params_factory import PipeRunParamsFactoryfrom pipelex.exceptions import DryRunError-from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint, PipeConditionPipeMapBlueprint+from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprintfrom pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactoryfrom pipelex.pipeline.job_metadata import JobMetadatafrom tests.test_pipelines.pipe_controllers.pipe_condition.pipe_condition import CategoryInput@@ -30,7 +30,7 @@ class TestPipeConditionSimple:inputs={"user_category": InputRequirementBlueprint(concept="test_pipe_condition.CategoryInput")},output=f"{SpecialDomain.NATIVE}.{NativeConceptEnum.TEXT}",expression_template="{{ user_category.category }}",- pipe_map=PipeConditionPipeMapBlueprint(root={"small": "process_small", "medium": "process_medium", "large": "process_large"}),+ pipe_map={"small": "process_small", "medium": "process_medium", "large": "process_large"},default_pipe_code="process_small",)@@ -64,7 +64,7 @@ class TestPipeConditionSimple:inputs={"user_status": InputRequirementBlueprint(concept="test_pipe_condition.CategoryInput")},output=f"{SpecialDomain.NATIVE}.{NativeConceptEnum.TEXT}",expression_template="{{ user_status.category }}",- pipe_map=PipeConditionPipeMapBlueprint(root={"active": "process_small", "inactive": "process_medium", "pending": "process_large"}),+ pipe_map={"active": "process_small", "inactive": "process_medium", "pending": "process_large"},default_pipe_code="process_small",)diff --git a/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_simple.py b/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_simple.pyindex 75ba3bfc2..2aa5461da 100644--- a/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_simple.py+++ b/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_simple.py@@ -17,7 +17,7 @@ from pipelex.core.stuffs.stuff_content import TextContentfrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.exceptions import DryRunErrorfrom pipelex.hub import get_pipe_router, get_required_pipe-from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint, PipeConditionPipeMapBlueprint+from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprintfrom pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactoryfrom pipelex.pipe_works.pipe_job_factory import PipeJobFactoryfrom pipelex.pipeline.job_metadata import JobMetadata@@ -35,7 +35,7 @@ class TestPipeConditionSimple:inputs={"input_text": InputRequirementBlueprint(concept=f"{SpecialDomain.NATIVE}.{NativeConceptEnum.TEXT}")},output=f"{SpecialDomain.NATIVE}.{NativeConceptEnum.TEXT}",expression_template="{% if input_text.text|length > 5 %}long{% else %}short{% endif %}",- pipe_map=PipeConditionPipeMapBlueprint(root={"long": "capitalize_long_text", "short": "add_prefix_short_text"}),+ pipe_map={"long": "capitalize_long_text", "short": "add_prefix_short_text"},)pipe_condition = PipeConditionFactory.make_from_blueprint(@@ -53,10 +53,7 @@ class TestPipeConditionSimple:assert pipe_condition.domain == "test_integration"assert pipe_condition.code == "text_length_condition"- assert pipe_condition.pipe_map[0].expression_result == "long"- assert pipe_condition.pipe_map[0].pipe_code == "capitalize_long_text"- assert pipe_condition.pipe_map[1].expression_result == "short"- assert pipe_condition.pipe_map[1].pipe_code == "add_prefix_short_text"+ assert pipe_condition.pipe_map == {"long": "capitalize_long_text", "short": "add_prefix_short_text"}input_text = working_memory.get_stuff("input_text")assert input_text is not None@@ -107,7 +104,7 @@ class TestPipeConditionSimple:inputs={"input_text": InputRequirementBlueprint(concept=f"{SpecialDomain.NATIVE}.{NativeConceptEnum.TEXT}")},output=f"{SpecialDomain.NATIVE}.{NativeConceptEnum.TEXT}",expression_template="{% if input_text.text|length > 5 %}long{% else %}short{% endif %}",- pipe_map=PipeConditionPipeMapBlueprint(root={"long": "capitalize_long_text", "short": "add_prefix_short_text"}),+ pipe_map={"long": "capitalize_long_text", "short": "add_prefix_short_text"},)pipe_condition = PipeConditionFactory.make_from_blueprint(diff --git a/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_validation.py b/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_validation.pyindex b64043e5d..88bd48627 100644--- a/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_validation.py+++ b/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_validation.py@@ -1,7 +1,7 @@from pipelex.core.concepts.concept_factory import ConceptBlueprint, ConceptFactoryfrom pipelex.core.pipes.pipe_input_blueprint import InputRequirementBlueprintfrom pipelex.hub import get_concept_provider-from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint, PipeConditionPipeMapBlueprint+from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprintfrom pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactory@@ -31,7 +31,7 @@ class TestPipeConditionValidation:inputs={"input_var": InputRequirementBlueprint(concept=concept_1.concept_string)},output=concept_2.concept_string,expression="input_var",- pipe_map=PipeConditionPipeMapBlueprint(root={"value1": "pipe_a", "value2": "pipe_b"}),+ pipe_map={"value1": "pipe_a", "value2": "pipe_b"},default_pipe_code="default_pipe",)@@ -73,7 +73,7 @@ class TestPipeConditionValidation:inputs={"var": InputRequirementBlueprint(concept=concept_1.concept_string)},output=concept_2.concept_string,expression_template="{{ var }}",- pipe_map=PipeConditionPipeMapBlueprint(root={"value": "target_pipe"}),+ pipe_map={"value": "target_pipe"},)pipe_condition_template = PipeConditionFactory.make_from_blueprint(@@ -88,7 +88,7 @@ class TestPipeConditionValidation:inputs={"var": InputRequirementBlueprint(concept=concept_1.concept_string)},output=concept_2.concept_string,expression="var",- pipe_map=PipeConditionPipeMapBlueprint(root={"value": "target_pipe"}),+ pipe_map={"value": "target_pipe"},)pipe_condition_expr = PipeConditionFactory.make_from_blueprint(diff --git a/tests/unit/pipelex/core/test_data/pipes/controllers/condition/pipe_condition.py b/tests/unit/pipelex/core/test_data/pipes/controllers/condition/pipe_condition.pyindex a50784f9d..9c8478218 100644--- a/tests/unit/pipelex/core/test_data/pipes/controllers/condition/pipe_condition.py+++ b/tests/unit/pipelex/core/test_data/pipes/controllers/condition/pipe_condition.py@@ -1,5 +1,5 @@from pipelex.core.bundles.pipelex_bundle_blueprint import PipelexBundleBlueprint-from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint, PipeConditionPipeMapBlueprint+from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprintPIPE_CONDITION = ("pipe_condition",@@ -22,12 +22,10 @@ pipe_map = { small = "process_small", large = "process_large" }description="Process based on condition",output="ProcessedData",expression="input_data.category",- pipe_map=PipeConditionPipeMapBlueprint(- {- "small": "process_small",- "large": "process_large",- },- ),+ pipe_map={+ "small": "process_small",+ "large": "process_large",+ },),},),diff --git a/tests/unit/pipelex/libraries/pipelines/builder/pipe/pipe_controllers/pipe_condition/test_data.py b/tests/unit/pipelex/libraries/pipelines/builder/pipe/pipe_controllers/pipe_condition/test_data.pyindex 303b10e19..7fa77e3fc 100644--- a/tests/unit/pipelex/libraries/pipelines/builder/pipe/pipe_controllers/pipe_condition/test_data.py+++ b/tests/unit/pipelex/libraries/pipelines/builder/pipe/pipe_controllers/pipe_condition/test_data.py@@ -2,7 +2,7 @@ from typing import ClassVarfrom pipelex.core.pipes.pipe_input_blueprint import InputRequirementBlueprintfrom pipelex.libraries.pipelines.builder.pipe.pipe_condition_spec import PipeConditionSpec-from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint, PipeConditionPipeMapBlueprint+from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprintclass PipeConditionTestCases:@@ -29,13 +29,11 @@ class PipeConditionTestCases:category="PipeController",expression=None,expression_template="{{ item.category }}",- pipe_map=PipeConditionPipeMapBlueprint(- root={- "A": "process_a",- "B": "process_b",- "C": "process_c",- },- ),+ pipe_map={+ "A": "process_a",+ "B": "process_b",+ "C": "process_c",+ },default_pipe_code="process_default",add_alias_from_expression_to=None,),