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/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.py
index 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.py
index 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 SkipJsonSchema
from typing_extensions import override
from 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 PipeConditionBlueprint
class PipeConditionSpec(PipeSpec):
@@ -31,7 +31,6 @@ class PipeConditionSpec(PipeSpec):
@override
def 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.py
index 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 Literal
import shortuuid
-from pydantic import field_validator, model_validator
+from pydantic import model_validator
from typing_extensions import override
from pipelex import log
@@ -9,7 +9,6 @@ from pipelex.config import StaticValidationReaction, get_config
from pipelex.core.concepts.concept_factory import ConceptFactory
from pipelex.core.concepts.concept_native import NATIVE_CONCEPTS_DATA, NativeConceptEnum, NativeConceptManager
from pipelex.core.memory.working_memory import WorkingMemory
-from pipelex.core.pipes.pipe_abstract import PipeAbstract
from pipelex.core.pipes.pipe_input import PipeInputSpec
from pipelex.core.pipes.pipe_input_blueprint import InputRequirementBlueprint
from 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_provider
from pipelex.pipe_controllers.condition.pipe_condition_details import PipeConditionDetails, PipeConditionPipeMap
from pipelex.pipe_controllers.pipe_controller import PipeController
from pipelex.pipe_works.pipe_job_factory import PipeJobFactory
@@ -41,11 +40,17 @@ class PipeCondition(PipeController):
type: Literal["PipeCondition"] = "PipeCondition"
expression_template: str | None = None
expression: str | None = None
- # TODO: rething this pipe_map.
- pipe_map: list[PipeConditionPipeMap]
+ pipe_map: PipeConditionPipeMap
default_pipe_code: str | None = None
add_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 self
def _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):
@override
def 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 evaluation
Returns:
- A tuple of (evaluated_expression, chosen_pipe_code)
+ The evaluated expression
Raises:
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_PROMPT
evaluated_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 expression
if 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
@override
async 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 tracking
condition_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.py
index 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 Field
from 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 = None
expression: str | None = None
- pipe_map: PipeConditionPipeMapBlueprint = Field(default_factory=PipeConditionPipeMapBlueprint)
+ pipe_map: dict[str, str] = Field(default_factory=dict)
default_pipe_code: str | None = None
add_alias_from_expression_to: str | None = None
diff --git a/pipelex/pipe_controllers/condition/pipe_condition_details.py b/pipelex/pipe_controllers/condition/pipe_condition_details.py
index 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: str
test_expression: str
- pipe_map: list[PipeConditionPipeMap]
+ pipe_map: dict[str, str]
default_pipe_code: str | None = None
evaluated_expression: str
chosen_pipe_code: str
diff --git a/pipelex/pipe_controllers/condition/pipe_condition_factory.py b/pipelex/pipe_controllers/condition/pipe_condition_factory.py
index 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 PipeFactoryProtocol
from pipelex.core.pipes.pipe_input_factory import PipeInputSpecFactory
from pipelex.hub import get_concept_provider
from 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 PipeConditionBlueprint
class 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
@override
def 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.py
index 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, PipeParalle
parallel_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.py
index 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 InputRequirementBlueprint
from pipelex.core.pipes.pipe_run_params import PipeRunMode
from pipelex.core.pipes.pipe_run_params_factory import PipeRunParamsFactory
from pipelex.exceptions import DryRunError
-from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint, PipeConditionPipeMapBlueprint
+from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint
from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactory
from pipelex.pipeline.job_metadata import JobMetadata
from 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.py
index 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 TextContent
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.exceptions import DryRunError
from 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 PipeConditionBlueprint
from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactory
from pipelex.pipe_works.pipe_job_factory import PipeJobFactory
from 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.py
index 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, ConceptFactory
from pipelex.core.pipes.pipe_input_blueprint import InputRequirementBlueprint
from 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 PipeConditionBlueprint
from 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.py
index 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 PipeConditionBlueprint
PIPE_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.py
index 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 ClassVar
from pipelex.core.pipes.pipe_input_blueprint import InputRequirementBlueprint
from 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 PipeConditionBlueprint
class 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,
),