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/remove implicit concepts (#483)

Thomas Hebrarde786284f79bf
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 03d725977..fdfd498a0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,10 +8,12 @@
- Modified the GHA `version-check.yml` so that the check of the version is only applying to release branches.
- Removed the `pyproject.toml` file from the build.
+- No more implicit concepts. A concept reference has a domain and a code. If there is no domain, it should be a native concept, or it is declared in the same bundle.
### Refactored
- The `find_files_in_dir` function was coded in 3 different places, now it's in `pipelex/tools/misc/file_utils.py`, and accepts `excluded_dirs`.
+- Refactored the Pipe factories: Centralized everything in the `PipeFactory` class.
## [v0.16.0] - 2025-11-25
diff --git a/pipelex/builder/builder.plx b/pipelex/builder/builder.plx
index 458bff8e7..6a2fe55c8 100644
--- a/pipelex/builder/builder.plx
+++ b/pipelex/builder/builder.plx
@@ -9,12 +9,17 @@ PipelexBundleSpec = "A Pipelex bundle spec."
BundleHeaderSpec = "A domain information object."
FlowDraft = "Draft of the flow of the pipeline."
+## Concepts
+ConceptStructureSpec = "A concept spec with structure but without full implementation."
+ConceptSpec = "A specification for a concept including its code, description, and a structure draft as plain text."
+
+
[pipe]
[pipe.pipe_builder]
type = "PipeSequence"
description = "This pipe is going to be the entry point for the builder. It will take a UserBrief and return a PipelexBundleSpec."
inputs = { brief = "UserBrief" }
-output = "builder.PipelexBundleSpec"
+output = "PipelexBundleSpec"
steps = [
{ pipe = "draft_the_plan", result = "plan_draft" },
{ pipe = "draft_the_concepts", result = "concept_drafts" },
@@ -127,7 +132,7 @@ List the concept drafts in Markdown format with a heading 3 for each, e.g. `###
type = "PipeLLM"
description = "Structure the concept definitions."
inputs = { concept_drafts = "ConceptDrafts" }
-output = "concept.ConceptSpec[]"
+output = "ConceptSpec[]"
model = "llm_to_engineer"
system_prompt = """
You are an expert at data extraction and json formatting.
@@ -140,8 +145,8 @@ prompt = """
[pipe.draft_flow]
type = "PipeLLM"
description = "Draft the flow of the pipeline."
-inputs = { plan_draft = "PlanDraft", brief = "UserBrief", concept_specs = "concept.ConceptSpec" }
-output = "builder.FlowDraft"
+inputs = { plan_draft = "PlanDraft", brief = "UserBrief", concept_specs = "ConceptSpec" }
+output = "FlowDraft"
model = "llm_to_engineer"
system_prompt = """
You are a Senior engineer.
@@ -239,8 +244,8 @@ At the end, recap the list of variables used, with a super concise recap of what
[pipe.review_flow]
type = "PipeLLM"
description = "Review a draft flow and make it consistent."
-inputs = { flow_draft = "builder.FlowDraft", brief = "UserBrief" }
-output = "builder.FlowDraft"
+inputs = { flow_draft = "FlowDraft", brief = "UserBrief" }
+output = "FlowDraft"
model = "llm_to_engineer"
system_prompt = """
You are a Senior engineer.
@@ -268,7 +273,7 @@ Otherwise, state that it was fixed like "The flow has been checked and fixed:" a
[pipe.design_pipe_signatures]
type = "PipeLLM"
description = "Write the pipe signatures for the plan."
-inputs = { prepared_flow = "builder.FlowDraft", brief = "UserBrief" }
+inputs = { prepared_flow = "FlowDraft", brief = "UserBrief" }
output = "pipe_design.PipeSignature[]"
model = "llm_to_engineer"
system_prompt = """
@@ -305,7 +310,7 @@ prompt = """
[pipe.write_bundle_header]
type = "PipeLLM"
description = "Write the bundle header."
-inputs = { brief = "UserBrief", pipe_signatures = "PipeSignature" }
+inputs = { brief = "UserBrief", pipe_signatures = "pipe_design.PipeSignature" }
output = "BundleHeaderSpec"
model = "llm_to_engineer"
prompt = """
@@ -324,7 +329,6 @@ The main pipe is the one that will carry out the main task of the pipeline, it s
[pipe.assemble_pipelex_bundle_spec]
type = "PipeFunc"
description = "Compile the pipelex bundle spec."
-inputs = { pipe_specs = "PipeSpec", concept_specs = "ConceptSpec", bundle_header_spec = "BundleHeaderSpec" }
+inputs = { pipe_specs = "pipe_design.PipeSpec", concept_specs = "ConceptSpec", bundle_header_spec = "BundleHeaderSpec" }
output = "PipelexBundleSpec"
function_name = "assemble_pipelex_bundle_spec"
-
diff --git a/pipelex/builder/concept/concept.plx b/pipelex/builder/concept/concept.plx
deleted file mode 100644
index e34cce392..000000000
--- a/pipelex/builder/concept/concept.plx
+++ /dev/null
@@ -1,6 +0,0 @@
-domain = "concept"
-description = "Build and process concepts for Pipelex bundles from signatures and drafts."
-
-[concept]
-ConceptStructureSpec = "A concept spec with structure but without full implementation."
-ConceptSpec = "A specification for a concept including its code, description, and a structure draft as plain text."
diff --git a/pipelex/builder/pipe/pipe_design.plx b/pipelex/builder/pipe/pipe_design.plx
index ded034e3c..8f372ed1a 100644
--- a/pipelex/builder/pipe/pipe_design.plx
+++ b/pipelex/builder/pipe/pipe_design.plx
@@ -1,5 +1,4 @@
domain = "pipe_design"
-description = "Build and process pipes."
[concept]
PipeSignature = "A pipe contract which says what the pipe does, not how it does it: code (the pipe code in snake_case), type, description, inputs, output."
@@ -22,7 +21,7 @@ PipeFailure = "Details of a single pipe failure during dry run."
[pipe.detail_pipe_spec]
type = "PipeCondition"
description = "Route by signature.type to the correct spec emitter."
-inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }
+inputs = { plan_draft = "builder.PlanDraft", pipe_signature = "PipeSignature", concept_specs = "builder.ConceptSpec" }
output = "Anything"
expression = "pipe_signature.type"
default_outcome = "fail"
@@ -43,8 +42,8 @@ PipeBatch = "detail_pipe_batch"
[pipe.detail_pipe_sequence]
type = "PipeLLM"
description = "Build a PipeSequenceSpec from the signature (children referenced by code)."
-inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }
-output = "pipe_design.PipeSequenceSpec"
+inputs = { plan_draft = "builder.PlanDraft", pipe_signature = "PipeSignature", concept_specs = "builder.ConceptSpec" }
+output = "PipeSequenceSpec"
model = "llm_to_engineer"
prompt = """
# Orchestrate a sequence of pipe steps that will run one after the other.
@@ -67,8 +66,8 @@ Note:
[pipe.detail_pipe_parallel]
type = "PipeLLM"
description = "Build a PipeParallelSpec from the signature."
-inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }
-output = "pipe_design.PipeParallelSpec"
+inputs = { plan_draft = "builder.PlanDraft", pipe_signature = "PipeSignature", concept_specs = "builder.ConceptSpec" }
+output = "PipeParallelSpec"
model = "llm_to_engineer"
prompt = """
Orchestrate a set of independent pipes that will run concurrently.
@@ -88,8 +87,8 @@ Based on the pipe signature, build the PipeParallelSpec.
[pipe.detail_pipe_condition]
type = "PipeLLM"
description = "Build a PipeConditionSpec from the signature (provide expression/outcome consistent with children)."
-inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }
-output = "pipe_design.PipeConditionSpec"
+inputs = { plan_draft = "builder.PlanDraft", pipe_signature = "PipeSignature", concept_specs = "builder.ConceptSpec" }
+output = "PipeConditionSpec"
model = "llm_to_engineer"
prompt = """
Design a PipeConditionSpec to route to the correct pipe based on a conditional expression.
@@ -109,8 +108,8 @@ Based on the pipe signature, build the PipeConditionSpec.
[pipe.detail_pipe_batch]
type = "PipeLLM"
description = "Build a PipeBatchSpec from the signature."
-inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }
-output = "pipe_design.PipeBatchSpec"
+inputs = { plan_draft = "builder.PlanDraft", pipe_signature = "PipeSignature", concept_specs = "builder.ConceptSpec" }
+output = "PipeBatchSpec"
model = "llm_to_engineer"
prompt = """
Design a PipeBatchSpec to run a pipe in batch.
@@ -134,8 +133,8 @@ Based on the pipe signature, build the PipeComposeSpec.
[pipe.detail_pipe_llm]
type = "PipeLLM"
description = "Build a PipeLLMSpec from the signature."
-inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }
-output = "pipe_design.PipeLLMSpec"
+inputs = { plan_draft = "builder.PlanDraft", pipe_signature = "PipeSignature", concept_specs = "builder.ConceptSpec" }
+output = "PipeLLMSpec"
model = "llm_to_engineer"
prompt = """
Design a PipeLLMSpec to use an LLM to generate a text, or a structured object using different kinds of inputs.
@@ -161,8 +160,8 @@ Notes:
[pipe.detail_pipe_extract]
type = "PipeLLM"
description = "Build a PipeExtractSpec from the signature."
-inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }
-output = "pipe_design.PipeExtractSpec"
+inputs = { plan_draft = "builder.PlanDraft", pipe_signature = "PipeSignature", concept_specs = "builder.ConceptSpec" }
+output = "PipeExtractSpec"
model = "llm_to_engineer"
prompt = """
Design a PipeExtractSpec to extract text from an image or a pdf.
@@ -182,8 +181,8 @@ Based on the pipe signature, build the PipeExtractSpec.
[pipe.detail_pipe_img_gen]
type = "PipeLLM"
description = "Build a PipeImgGenSpec from the signature."
-inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }
-output = "pipe_design.PipeImgGenSpec"
+inputs = { plan_draft = "builder.PlanDraft", pipe_signature = "PipeSignature", concept_specs = "builder.ConceptSpec" }
+output = "PipeImgGenSpec"
model = "llm_to_engineer"
prompt = """
Your job is to design a PipeImgGenSpec to generate an image from a text prompt.
@@ -206,8 +205,8 @@ Notes:
[pipe.detail_pipe_compose]
type = "PipeLLM"
description = "Build a PipeComposeSpec from the signature."
-inputs = { plan_draft = "PlanDraft", pipe_signature = "PipeSignature", concept_specs = "concept.ConceptSpec" }
-output = "pipe_design.PipeComposeSpec"
+inputs = { plan_draft = "builder.PlanDraft", pipe_signature = "PipeSignature", concept_specs = "builder.ConceptSpec" }
+output = "PipeComposeSpec"
model = "llm_to_engineer"
prompt = """
Design a PipeComposeSpec to render a jinja2 template.
diff --git a/pipelex/builder/pipe/pipe_llm_spec.py b/pipelex/builder/pipe/pipe_llm_spec.py
index a838afe7b..c3e40b0a6 100644
--- a/pipelex/builder/pipe/pipe_llm_spec.py
+++ b/pipelex/builder/pipe/pipe_llm_spec.py
@@ -119,8 +119,6 @@ So, don't have to write a bullet-list of all the attributes definitions yourself
llm_choice: LLMModelChoice = self.llm_skill
return PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description=base_blueprint.description,
inputs=base_blueprint.inputs,
output=base_blueprint.output,
diff --git a/pipelex/core/concepts/concept.py b/pipelex/core/concepts/concept.py
index 67f26a4bb..4f2f33b6b 100644
--- a/pipelex/core/concepts/concept.py
+++ b/pipelex/core/concepts/concept.py
@@ -9,7 +9,6 @@ from pipelex.base_exceptions import PipelexUnexpectedError
from pipelex.core.concepts.exceptions import ConceptCodeError, ConceptStringError, ConceptValueError
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.concepts.validation import validate_concept_code, validate_concept_string
-from pipelex.core.domains.domain import SpecialDomain
from pipelex.core.domains.exceptions import DomainCodeError
from pipelex.core.domains.validation import validate_domain_code
from pipelex.core.stuffs.image_field_search import search_for_nested_image_fields
@@ -64,15 +63,6 @@ class Concept(BaseModel):
def concept_string(self) -> str:
return f"{self.domain}.{self.code}"
- @classmethod
- def is_implicit_concept(cls, concept_string: str) -> bool:
- try:
- validate_concept_string(concept_string=concept_string)
- except ConceptStringError as exc:
- msg = f"Concept string '{concept_string}' is not a valid concept string for concept '{cls.concept_string}'"
- raise ConceptValueError(msg) from exc
- return concept_string.startswith(SpecialDomain.IMPLICIT)
-
@classmethod
def sentence_from_concept(cls, concept: "Concept") -> str:
return pascal_case_to_sentence(name=concept.code)
diff --git a/pipelex/core/concepts/concept_factory.py b/pipelex/core/concepts/concept_factory.py
index 838ba3e9b..e966c5e8e 100644
--- a/pipelex/core/concepts/concept_factory.py
+++ b/pipelex/core/concepts/concept_factory.py
@@ -51,15 +51,6 @@ class ConceptFactory:
return normalized
- @classmethod
- def make_implicit_concept(cls, concept_code: str) -> Concept:
- return Concept(
- code=concept_code,
- domain=SpecialDomain.IMPLICIT,
- description=concept_code,
- structure_class_name=TextContent.__name__,
- )
-
@classmethod
def make(cls, concept_code: str, domain: str, description: str, structure_class_name: str, refines: str | None = None) -> Concept:
return Concept(
@@ -152,10 +143,12 @@ class ConceptFactory:
@classmethod
def make_domain_and_concept_code_from_concept_string_or_code(
cls,
- domain: str,
concept_string_or_code: str,
- concept_codes_from_the_same_domain: list[str] | None = None,
+ domain: str | None = None,
) -> DomainAndConceptCode:
+ if "." not in concept_string_or_code and not domain:
+ msg = f"Not enough information to make a domain and concept code from '{concept_string_or_code}'"
+ raise ConceptFactoryError(msg)
try:
validate_concept_string_or_code(concept_string_or_code=concept_string_or_code)
except ConceptStringError as exc:
@@ -169,24 +162,21 @@ class ConceptFactory:
if "." in concept_string_or_code:
domain_code, concept_code = concept_string_or_code.rsplit(".")
return DomainAndConceptCode(domain=domain_code, concept_code=concept_code)
- if (
- concept_codes_from_the_same_domain and concept_string_or_code in concept_codes_from_the_same_domain
- ): # Is a concept code from the same domain
+ elif domain:
return DomainAndConceptCode(domain=domain, concept_code=concept_string_or_code)
- return DomainAndConceptCode(domain=SpecialDomain.IMPLICIT, concept_code=concept_string_or_code)
+ else:
+ msg = f"Not enough information to make a domain and concept code from '{concept_string_or_code}'"
+ raise ConceptFactoryError(msg)
@classmethod
def make_concept_string_with_domain(cls, domain: str, concept_code: str) -> str:
return f"{domain}.{concept_code}"
@classmethod
- def make_concept_string_with_domain_from_concept_string_or_code(
- cls, domain: str, concept_sring_or_code: str, concept_codes_from_the_same_domain: list[str] | None = None
- ) -> str:
+ def make_concept_string_with_domain_from_concept_string_or_code(cls, domain: str, concept_sring_or_code: str) -> str:
input_domain_and_code = cls.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
concept_string_or_code=concept_sring_or_code,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
+ domain=domain,
)
return cls.make_concept_string_with_domain(
@@ -219,7 +209,6 @@ class ConceptFactory:
domain: str,
concept_code: str,
concept_blueprint_or_description: ConceptBlueprint | str,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> Concept:
blueprint: ConceptBlueprint
if isinstance(concept_blueprint_or_description, str):
@@ -230,7 +219,6 @@ class ConceptFactory:
domain=domain,
concept_code=concept_code,
blueprint=blueprint,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
)
@classmethod
@@ -239,7 +227,6 @@ class ConceptFactory:
domain: str,
concept_code: str,
blueprint: ConceptBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> Concept:
if not is_concept_code_valid(concept_code=concept_code):
msg = f"Concept code '{concept_code}' is not a valid concept code"
@@ -305,9 +292,8 @@ class ConceptFactory:
structure_class_name = TextContent.__name__
domain_and_concept_code = cls.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
concept_string_or_code=concept_code,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
+ domain=domain,
)
return Concept(
diff --git a/pipelex/core/concepts/helpers.py b/pipelex/core/concepts/helpers.py
new file mode 100644
index 000000000..f4f449233
--- /dev/null
+++ b/pipelex/core/concepts/helpers.py
@@ -0,0 +1,12 @@
+def strip_multiplicity_from_concept_string_or_code(concept_string_or_code: str) -> str:
+ """Strip multiplicity from a concept string or code.
+
+ Args:
+ concept_string_or_code: The concept string or code to strip multiplicity from
+
+ Returns:
+ The concept string or code without multiplicity
+ """
+ if "[" in concept_string_or_code:
+ return concept_string_or_code.split("[")[0]
+ return concept_string_or_code
diff --git a/pipelex/core/domains/domain.py b/pipelex/core/domains/domain.py
index 0f72e0534..116da1c2f 100644
--- a/pipelex/core/domains/domain.py
+++ b/pipelex/core/domains/domain.py
@@ -4,7 +4,6 @@ from pipelex.types import StrEnum
class SpecialDomain(StrEnum):
- IMPLICIT = "implicit"
NATIVE = "native"
@classmethod
@@ -17,8 +16,6 @@ class SpecialDomain(StrEnum):
match enum_value:
case SpecialDomain.NATIVE:
return True
- case SpecialDomain.IMPLICIT:
- return False
class Domain(BaseModel):
diff --git a/pipelex/core/pipes/inputs/input_requirements_factory.py b/pipelex/core/pipes/inputs/input_requirements_factory.py
index ed04bf06a..8501cdde0 100644
--- a/pipelex/core/pipes/inputs/input_requirements_factory.py
+++ b/pipelex/core/pipes/inputs/input_requirements_factory.py
@@ -26,14 +26,12 @@ class InputRequirementsFactory:
cls,
domain: str,
blueprint: dict[str, str],
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> InputRequirements:
input_requirements_dict: dict[str, InputRequirement] = {}
for var_name, requirement_str in blueprint.items():
input_requirement = InputRequirementsFactory.make_from_string(
domain=domain,
requirement_str=requirement_str,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
)
input_requirements_dict[var_name] = input_requirement
return InputRequirements(root=input_requirements_dict)
@@ -43,7 +41,6 @@ class InputRequirementsFactory:
cls,
domain: str,
requirement_str: str,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> InputRequirement:
"""Parse an input requirement string and return an InputRequirement.
@@ -56,8 +53,6 @@ class InputRequirementsFactory:
Args:
domain: The domain to use for resolving concept codes without domain prefix
requirement_str: String in the format "domain.ConceptCode" or "ConceptCode" with optional "[multiplicity]"
- library_id: The library ID to use for resolving concepts
- concept_codes_from_the_same_domain: List of concept codes from the same domain for resolution
Returns:
InputRequirement with the parsed concept and multiplicity
@@ -88,7 +83,6 @@ class InputRequirementsFactory:
concept_string_with_domain = ConceptFactory.make_concept_string_with_domain_from_concept_string_or_code(
domain=domain,
concept_sring_or_code=concept_string_or_code,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
)
# Determine multiplicity
diff --git a/pipelex/core/pipes/pipe_abstract.py b/pipelex/core/pipes/pipe_abstract.py
index b5eaaad7c..5d01b2533 100644
--- a/pipelex/core/pipes/pipe_abstract.py
+++ b/pipelex/core/pipes/pipe_abstract.py
@@ -35,6 +35,24 @@ class PipeAbstract(ABC, BaseModel):
def pipe_type(self) -> str:
return self.__class__.__name__
+ @property
+ def concept_dependencies(self) -> list[Concept]:
+ """Return all unique concept dependencies (output + inputs) without duplicates."""
+ seen_concept_strings: set[str] = set()
+ unique_concepts: list[Concept] = []
+
+ # Add output concept first
+ unique_concepts.append(self.output)
+ seen_concept_strings.add(self.output.concept_string)
+
+ # Add input concepts (avoiding duplicates)
+ for concept in self.inputs.concepts:
+ if concept.concept_string not in seen_concept_strings:
+ unique_concepts.append(concept)
+ seen_concept_strings.add(concept.concept_string)
+
+ return unique_concepts
+
@field_validator("code", mode="before")
@classmethod
def validate_pipe_code_syntax(cls, code: str) -> str:
diff --git a/pipelex/core/pipes/pipe_blueprint.py b/pipelex/core/pipes/pipe_blueprint.py
index 26a1a24f7..95e2a8a52 100644
--- a/pipelex/core/pipes/pipe_blueprint.py
+++ b/pipelex/core/pipes/pipe_blueprint.py
@@ -78,6 +78,7 @@ class PipeType(StrEnum):
class PipeBlueprint(ABC, BaseModel):
model_config = ConfigDict(extra="forbid")
+
source: str | None = None
pipe_category: Any = Field(exclude=True) # Technical field for Union discrimination, not user-facing
type: Any # TODO: Find a better way to handle this.
diff --git a/pipelex/core/pipes/pipe_factory.py b/pipelex/core/pipes/pipe_factory.py
index 5e1a52943..9cda5ca69 100644
--- a/pipelex/core/pipes/pipe_factory.py
+++ b/pipelex/core/pipes/pipe_factory.py
@@ -1,12 +1,23 @@
-from typing import Any, Protocol, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, Protocol, TypeVar
from kajson.exceptions import ClassRegistryInheritanceError, ClassRegistryNotFoundError
from kajson.kajson_manager import KajsonManager
-from typing_extensions import override, runtime_checkable
+from typing_extensions import runtime_checkable
-from pipelex.core.pipes.exceptions import PipeFactoryError
-from pipelex.core.pipes.pipe_abstract import PipeAbstract
-from pipelex.core.pipes.pipe_blueprint import PipeBlueprint
+from pipelex.core.concepts.concept import Concept
+from pipelex.core.concepts.concept_factory import ConceptFactory
+from pipelex.core.concepts.exceptions import ConceptFactoryError
+from pipelex.core.concepts.helpers import strip_multiplicity_from_concept_string_or_code
+from pipelex.core.concepts.native.concept_native import NativeConceptCode
+from pipelex.core.pipes.exceptions import PipeFactoryError, PipeVariableMultiplicityError
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
+from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory
+from pipelex.core.pipes.pipe_blueprint import PipeBlueprint, PipeType
+from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
+from pipelex.hub import get_required_concept
+
+if TYPE_CHECKING:
+ from pipelex.core.pipes.pipe_abstract import PipeAbstract
PipeBlueprintType = TypeVar("PipeBlueprintType", bound="PipeBlueprint", contravariant=True)
PipeAbstractType = TypeVar("PipeAbstractType", bound="PipeAbstract", covariant=True)
@@ -15,27 +26,76 @@ PipeAbstractType = TypeVar("PipeAbstractType", bound="PipeAbstract", covariant=T
@runtime_checkable
class PipeFactoryProtocol(Protocol[PipeBlueprintType, PipeAbstractType]):
@classmethod
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeBlueprintType,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeAbstractType: ...
-class PipeFactory(PipeFactoryProtocol[PipeBlueprint, PipeAbstract]):
+class PipeFactory(Generic[PipeAbstractType]):
@classmethod
- @override
def make_from_blueprint(
cls,
- domain: str,
+ domain_code: str,
pipe_code: str,
blueprint: PipeBlueprint,
concept_codes_from_the_same_domain: list[str] | None = None,
- ) -> PipeAbstract:
+ ) -> PipeAbstractType:
+ if concept_codes_from_the_same_domain is None:
+ concept_codes_from_the_same_domain = []
+
+ # TODO: This test should move to the PipelexBlueprint validation.
+ # Validate that the specified concepts are declared in the bundle, or are natives concepts.
+ if blueprint.inputs is not None:
+ for input_name, input_concept_string_or_code in blueprint.inputs.items():
+ stripped_input_concept_string_or_code = strip_multiplicity_from_concept_string_or_code(
+ concept_string_or_code=input_concept_string_or_code
+ )
+ if "." not in stripped_input_concept_string_or_code:
+ if (
+ not NativeConceptCode.is_native_concept_string_or_code(concept_string_or_code=stripped_input_concept_string_or_code)
+ and stripped_input_concept_string_or_code not in concept_codes_from_the_same_domain
+ ):
+ msg = (
+ f"Input stuff '{input_name}' with concept '{stripped_input_concept_string_or_code}' "
+ f"in pipe '{pipe_code}' (domain '{domain_code}') is invalid. "
+ f"The concept must be either native, declared in domain '{domain_code}', or fully qualified with a domain prefix. "
+ f"Declared concepts are: '{concept_codes_from_the_same_domain}'"
+ )
+ raise PipeFactoryError(msg)
+
+ if "." not in blueprint.output:
+ stripped_output_concept_string_or_code = strip_multiplicity_from_concept_string_or_code(concept_string_or_code=blueprint.output)
+ if (
+ not NativeConceptCode.is_native_concept_string_or_code(concept_string_or_code=stripped_output_concept_string_or_code)
+ and stripped_output_concept_string_or_code not in concept_codes_from_the_same_domain
+ ):
+ msg = (
+ f"Output concept '{stripped_output_concept_string_or_code}' in pipe '{pipe_code}' (domain '{domain_code}') is invalid. "
+ f"The concept must be either native, declared in domain '{domain_code}', or fully qualified with a domain prefix. "
+ f"Declared concepts are: '{concept_codes_from_the_same_domain}'"
+ )
+ raise PipeFactoryError(msg)
+
+ # Parse common attributes
+ parsed_output = cls._parse_output_concept_string(domain=domain_code, pipe_code=pipe_code, output_string=blueprint.output)
+ parsed_inputs = InputRequirementsFactory.make_from_blueprint(
+ domain=domain_code,
+ blueprint=blueprint.inputs or {},
+ )
+
+ pipe_type = PipeType(blueprint.type)
+ pipe_category = pipe_type.category
+
# The factory class name for that specific type of Pipe is the pipe class name with "Factory" suffix
- factory_class_name = f"{blueprint.type}Factory"
+ factory_class_name = f"{pipe_type.value}Factory"
try:
pipe_factory: type[PipeFactoryProtocol[Any, Any]] = KajsonManager.get_class_registry().get_required_subclass(
name=factory_class_name,
@@ -48,10 +108,46 @@ class PipeFactory(PipeFactoryProtocol[PipeBlueprint, PipeAbstract]):
msg = f"Pipe '{pipe_code}' couldn't be created: factory '{factory_class_name}' is not a subclass of {type(PipeFactoryProtocol)}."
raise PipeFactoryError(msg) from factory_inheritance_error
- pipe_from_blueprint: PipeAbstract = pipe_factory.make_from_blueprint(
- domain=domain,
+ pipe: PipeAbstractType = pipe_factory.make(
+ pipe_category=pipe_category,
+ pipe_type=blueprint.type,
pipe_code=pipe_code,
+ domain_code=domain_code,
+ description=blueprint.description,
+ inputs=parsed_inputs,
+ output=parsed_output,
blueprint=blueprint,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
)
- return pipe_from_blueprint
+ return pipe
+
+ @classmethod
+ def _parse_output_concept_string(
+ cls,
+ domain: str,
+ pipe_code: str,
+ output_string: str,
+ ) -> Concept:
+ """Parse the output concept string and return the Concept object."""
+ # Parse output to strip multiplicity brackets
+ try:
+ output_parse_result = parse_concept_with_multiplicity(output_string)
+ except PipeVariableMultiplicityError as exc:
+ msg = f"Error parsing concept with multiplicity for pipe '{pipe_code}': {exc}"
+ raise PipeFactoryError(msg) from exc
+
+ # Get output concept
+ try:
+ output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
+ domain=domain,
+ concept_string_or_code=output_parse_result.concept,
+ )
+ except ConceptFactoryError as exc:
+ msg = f"Error making domain and concept code for pipe '{pipe_code}': {exc}"
+ raise PipeFactoryError(msg) from exc
+
+ return get_required_concept(
+ concept_string=ConceptFactory.make_concept_string_with_domain(
+ domain=output_domain_and_code.domain,
+ concept_code=output_domain_and_code.concept_code,
+ ),
+ )
diff --git a/pipelex/libraries/concept/concept_library.py b/pipelex/libraries/concept/concept_library.py
index 4c34b9ee2..ffeba20fd 100644
--- a/pipelex/libraries/concept/concept_library.py
+++ b/pipelex/libraries/concept/concept_library.py
@@ -91,9 +91,6 @@ class ConceptLibrary(RootModel[ConceptLibraryRoot], ConceptLibraryAbstract):
"""`concept_string` can have the domain or not. If it doesn't have the domain, it is assumed to be native.
If it is not native and doesnt have a domain, it should raise an error
"""
- if Concept.is_implicit_concept(concept_string=concept_string):
- return ConceptFactory.make_implicit_concept(concept_code=concept_string.split(".")[1])
-
if not is_concept_string_valid(concept_string=concept_string):
msg = f"Concept string '{concept_string}' is not a valid concept string"
raise ConceptLibraryError(msg)
diff --git a/pipelex/libraries/library.py b/pipelex/libraries/library.py
index aeed8bbc8..870d6bbbf 100644
--- a/pipelex/libraries/library.py
+++ b/pipelex/libraries/library.py
@@ -49,7 +49,7 @@ class Library(BaseModel):
# Validate concept dependencies exist
# Note: This should NEVER fail as concepts are validated during pipe construction via get_required_concept()
# TODO: Make this non mandatory in production, or a test
- for concept in [pipe.output, *pipe.inputs.concepts]:
+ for concept in pipe.concept_dependencies:
try:
self.concept_library.is_concept_exists(concept_string=concept.concept_string)
except ConceptLibraryError as concept_error:
diff --git a/pipelex/libraries/library_manager.py b/pipelex/libraries/library_manager.py
index 85f2f267e..a2357935c 100644
--- a/pipelex/libraries/library_manager.py
+++ b/pipelex/libraries/library_manager.py
@@ -203,7 +203,6 @@ class LibraryManager(LibraryManagerAbstract):
concept = ConceptFactory.make_from_blueprint_or_description(
domain=blueprint.domain,
concept_code=concept_code,
- concept_codes_from_the_same_domain=list(blueprint.concept.keys()),
concept_blueprint_or_description=concept_blueprint_or_description,
)
concepts.append(concept)
@@ -215,11 +214,11 @@ class LibraryManager(LibraryManagerAbstract):
pipes: list[PipeAbstract] = []
if blueprint.pipe is not None:
for pipe_name, pipe_blueprint in blueprint.pipe.items():
- pipe = PipeFactory.make_from_blueprint(
- domain=blueprint.domain,
+ pipe = PipeFactory[PipeAbstract].make_from_blueprint(
+ domain_code=blueprint.domain,
pipe_code=pipe_name,
blueprint=pipe_blueprint,
- concept_codes_from_the_same_domain=list(blueprint.concept.keys()) if blueprint.concept else None,
+ concept_codes_from_the_same_domain=[the_concept.code for the_concept in all_concepts],
)
pipes.append(pipe)
all_pipes.extend(pipes)
diff --git a/pipelex/pipe_controllers/batch/pipe_batch_factory.py b/pipelex/pipe_controllers/batch/pipe_batch_factory.py
index 52e2724f2..718885d75 100644
--- a/pipelex/pipe_controllers/batch/pipe_batch_factory.py
+++ b/pipelex/pipe_controllers/batch/pipe_batch_factory.py
@@ -1,13 +1,10 @@
+from typing import Any
+
from typing_extensions import override
-from pipelex.core.concepts.concept_factory import ConceptFactory
-from pipelex.core.concepts.exceptions import ConceptFactoryError
-from pipelex.core.pipes.exceptions import PipeVariableMultiplicityError
-from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory
+from pipelex.core.concepts.concept import Concept
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
from pipelex.core.pipes.pipe_factory import PipeFactoryProtocol
-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
-from pipelex.hub import get_required_concept
-from pipelex.pipe_controllers.batch.exceptions import PipeBatchFactoryError
from pipelex.pipe_controllers.batch.pipe_batch import PipeBatch
from pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprint
from pipelex.pipe_run.pipe_run_params import BatchParams
@@ -16,49 +13,25 @@ from pipelex.pipe_run.pipe_run_params import BatchParams
class PipeBatchFactory(PipeFactoryProtocol[PipeBatchBlueprint, PipeBatch]):
@classmethod
@override
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeBatchBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeBatch:
- # Parse output to strip multiplicity brackets
- try:
- output_parse_result = parse_concept_with_multiplicity(blueprint.output)
- except PipeVariableMultiplicityError as exc:
- msg = f"Error parsing concept with multiplicity for PipeBatch: {exc}"
- raise PipeBatchFactoryError(msg) from exc
-
- try:
- output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
- except ConceptFactoryError as exc:
- msg = f"Error making domain and concept code for PipeBatch: {exc}"
- raise PipeBatchFactoryError(msg) from exc
-
- inputs = InputRequirementsFactory.make_from_blueprint(
- domain=domain,
- blueprint=blueprint.inputs or {},
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
- output = get_required_concept(
- concept_string=ConceptFactory.make_concept_string_with_domain(
- domain=output_domain_and_code.domain,
- concept_code=output_domain_and_code.concept_code,
- ),
- )
batch_params = BatchParams.make_batch_params(
input_list_name=blueprint.input_list_name,
input_item_name=blueprint.input_item_name,
)
return PipeBatch(
- domain=domain,
+ domain=domain_code,
code=pipe_code,
- description=blueprint.description,
+ description=description,
inputs=inputs,
output=output,
branch_pipe_code=blueprint.branch_pipe_code,
diff --git a/pipelex/pipe_controllers/condition/pipe_condition_factory.py b/pipelex/pipe_controllers/condition/pipe_condition_factory.py
index 4858b62f4..f6a7a656b 100644
--- a/pipelex/pipe_controllers/condition/pipe_condition_factory.py
+++ b/pipelex/pipe_controllers/condition/pipe_condition_factory.py
@@ -1,12 +1,10 @@
+from typing import Any
+
from typing_extensions import override
-from pipelex.core.concepts.concept_factory import ConceptFactory
-from pipelex.core.concepts.exceptions import ConceptFactoryError
-from pipelex.core.pipes.exceptions import PipeVariableMultiplicityError
-from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory, InputRequirementsFactoryError
+from pipelex.core.concepts.concept import Concept
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
from pipelex.core.pipes.pipe_factory import PipeFactoryProtocol
-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
-from pipelex.hub import get_required_concept
from pipelex.pipe_controllers.condition.exceptions import PipeConditionFactoryError
from pipelex.pipe_controllers.condition.pipe_condition import PipeCondition
from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint
@@ -15,48 +13,19 @@ from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeCond
class PipeConditionFactory(PipeFactoryProtocol[PipeConditionBlueprint, PipeCondition]):
@classmethod
@override
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeConditionBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeCondition:
- # Parse output to strip multiplicity brackets
- try:
- output_parse_result = parse_concept_with_multiplicity(blueprint.output)
- except PipeVariableMultiplicityError as exc:
- msg = f"Error parsing concept with multiplicity for PipeCondition: {exc}"
- raise PipeConditionFactoryError(msg) from exc
-
- try:
- output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
- except ConceptFactoryError as exc:
- msg = f"Error making domain and concept code for PipeCondition: {exc}"
- raise PipeConditionFactoryError(msg) from exc
-
- try:
- inputs = InputRequirementsFactory.make_from_blueprint(
- domain=domain,
- blueprint=blueprint.inputs or {},
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
- except InputRequirementsFactoryError as exc:
- msg = f"Error making input requirements for PipeCondition: {exc}"
- raise PipeConditionFactoryError(msg) from exc
-
- output = get_required_concept(
- concept_string=ConceptFactory.make_concept_string_with_domain(
- domain=output_domain_and_code.domain,
- concept_code=output_domain_and_code.concept_code,
- ),
- )
-
# Compute expression from expression_template or expression in blueprint
+ expression: str | None = None
if blueprint.expression_template:
expression = blueprint.expression_template
elif blueprint.expression:
@@ -66,9 +35,9 @@ class PipeConditionFactory(PipeFactoryProtocol[PipeConditionBlueprint, PipeCondi
raise PipeConditionFactoryError(msg)
return PipeCondition(
- domain=domain,
+ domain=domain_code,
code=pipe_code,
- description=blueprint.description,
+ description=description,
inputs=inputs,
output=output,
expression=expression,
diff --git a/pipelex/pipe_controllers/parallel/pipe_parallel_factory.py b/pipelex/pipe_controllers/parallel/pipe_parallel_factory.py
index 4464ccd35..6236e6676 100644
--- a/pipelex/pipe_controllers/parallel/pipe_parallel_factory.py
+++ b/pipelex/pipe_controllers/parallel/pipe_parallel_factory.py
@@ -1,11 +1,11 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
from typing_extensions import override
+from pipelex.core.concepts.concept import Concept
from pipelex.core.concepts.concept_factory import ConceptFactory
-from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
from pipelex.core.pipes.pipe_factory import PipeFactoryProtocol
-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
from pipelex.hub import get_required_concept
from pipelex.pipe_controllers.parallel.exceptions import PipeParallelFactoryError
from pipelex.pipe_controllers.parallel.pipe_parallel import PipeParallel
@@ -19,19 +19,23 @@ if TYPE_CHECKING:
class PipeParallelFactory(PipeFactoryProtocol[PipeParallelBlueprint, PipeParallel]):
@classmethod
@override
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeParallelBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeParallel:
parallel_sub_pipes: list[SubPipe] = []
for sub_pipe_blueprint in blueprint.parallels:
if not sub_pipe_blueprint.result:
msg = f"Unexpected error in pipe '{pipe_code}': PipeParallel requires a result specified for each parallel sub pipe"
raise PipeParallelFactoryError(message=msg)
- sub_pipe = SubPipeFactory.make_from_blueprint(sub_pipe_blueprint, concept_codes_from_the_same_domain=concept_codes_from_the_same_domain)
+ sub_pipe = SubPipeFactory.make_from_blueprint(sub_pipe_blueprint)
parallel_sub_pipes.append(sub_pipe)
if not blueprint.add_each_output and not blueprint.combined_output:
msg = (
@@ -42,14 +46,11 @@ class PipeParallelFactory(PipeFactoryProtocol[PipeParallelBlueprint, PipeParalle
message=msg,
)
- # Parse output to strip multiplicity brackets
- output_parse_result = parse_concept_with_multiplicity(blueprint.output)
-
+ # Handle combined_output if specified
if blueprint.combined_output:
combined_output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
+ domain=domain_code,
+ concept_string_or_code=blueprint.combined_output,
)
combined_output = get_required_concept(
concept_string=ConceptFactory.make_concept_string_with_domain(
@@ -60,27 +61,10 @@ class PipeParallelFactory(PipeFactoryProtocol[PipeParallelBlueprint, PipeParalle
else:
combined_output = None
- output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
- inputs = InputRequirementsFactory.make_from_blueprint(
- domain=domain,
- blueprint=blueprint.inputs or {},
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
-
- output = get_required_concept(
- concept_string=ConceptFactory.make_concept_string_with_domain(
- domain=output_domain_and_code.domain,
- concept_code=output_domain_and_code.concept_code,
- ),
- )
return PipeParallel(
- domain=domain,
+ domain=domain_code,
code=pipe_code,
- description=blueprint.description,
+ description=description,
inputs=inputs,
output=output,
parallel_sub_pipes=parallel_sub_pipes,
diff --git a/pipelex/pipe_controllers/sequence/pipe_sequence_factory.py b/pipelex/pipe_controllers/sequence/pipe_sequence_factory.py
index 3b0acd0d8..499a71512 100644
--- a/pipelex/pipe_controllers/sequence/pipe_sequence_factory.py
+++ b/pipelex/pipe_controllers/sequence/pipe_sequence_factory.py
@@ -1,63 +1,42 @@
+from typing import TYPE_CHECKING, Any
+
from typing_extensions import override
-from pipelex.core.concepts.concept_factory import ConceptFactory
-from pipelex.core.concepts.exceptions import ConceptFactoryError
-from pipelex.core.pipes.exceptions import PipeVariableMultiplicityError
-from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory
+from pipelex.core.concepts.concept import Concept
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
from pipelex.core.pipes.pipe_factory import PipeFactoryProtocol
-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
-from pipelex.hub import get_required_concept
-from pipelex.pipe_controllers.sequence.exceptions import PipeSequenceFactoryError
from pipelex.pipe_controllers.sequence.pipe_sequence import PipeSequence
from pipelex.pipe_controllers.sequence.pipe_sequence_blueprint import PipeSequenceBlueprint
from pipelex.pipe_controllers.sub_pipe_factory import SubPipeFactory
+if TYPE_CHECKING:
+ from pipelex.pipe_controllers.sub_pipe import SubPipe
+
class PipeSequenceFactory(PipeFactoryProtocol[PipeSequenceBlueprint, PipeSequence]):
@classmethod
@override
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeSequenceBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeSequence:
- # Parse output to strip multiplicity brackets``
- try:
- output_parse_result = parse_concept_with_multiplicity(blueprint.output)
- except PipeVariableMultiplicityError as exc:
- msg = f"Error parsing concept with multiplicity for PipeSequence: {exc}"
- raise PipeSequenceFactoryError(msg) from exc
+ sequential_sub_pipes: list[SubPipe] = []
+ for step in blueprint.steps:
+ sub_pipe = SubPipeFactory.make_from_blueprint(blueprint=step)
+ sequential_sub_pipes.append(sub_pipe)
- try:
- output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
- except ConceptFactoryError as exc:
- msg = f"Error making domain and concept code for PipeSequence: {exc}"
- raise PipeSequenceFactoryError(msg) from exc
-
- output = get_required_concept(
- concept_string=ConceptFactory.make_concept_string_with_domain(
- domain=output_domain_and_code.domain,
- concept_code=output_domain_and_code.concept_code,
- ),
- )
return PipeSequence(
- domain=domain,
+ domain=domain_code,
code=pipe_code,
- description=blueprint.description,
- inputs=InputRequirementsFactory.make_from_blueprint(
- domain=domain,
- blueprint=blueprint.inputs or {},
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- ),
+ description=description,
+ inputs=inputs,
output=output,
- sequential_sub_pipes=[
- SubPipeFactory.make_from_blueprint(blueprint=step, concept_codes_from_the_same_domain=concept_codes_from_the_same_domain)
- for step in blueprint.steps
- ],
+ sequential_sub_pipes=sequential_sub_pipes,
)
diff --git a/pipelex/pipe_controllers/sub_pipe.py b/pipelex/pipe_controllers/sub_pipe.py
index 20d26dea4..9a738b3bf 100644
--- a/pipelex/pipe_controllers/sub_pipe.py
+++ b/pipelex/pipe_controllers/sub_pipe.py
@@ -4,12 +4,13 @@ from pipelex import log
from pipelex.core.memory.exceptions import WorkingMemoryStuffNotFoundError
from pipelex.core.memory.working_memory import WorkingMemory
from pipelex.core.pipes.inputs.exceptions import PipeInputError, PipeInputNotFoundError
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.pipes.pipe_output import PipeOutput
from pipelex.core.pipes.variable_multiplicity import VariableMultiplicity
from pipelex.core.stuffs.list_content import ListContent
from pipelex.hub import get_pipeline_tracker, get_required_pipe
+from pipelex.pipe_controllers.batch.pipe_batch import PipeBatch
from pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprint
-from pipelex.pipe_controllers.batch.pipe_batch_factory import PipeBatchFactory
from pipelex.pipe_controllers.condition.pipe_condition import PipeCondition
from pipelex.pipe_run.pipe_run_params import BatchParams, PipeRunParams
from pipelex.pipeline.job_metadata import JobMetadata
@@ -20,7 +21,6 @@ class SubPipe(BaseModel):
output_name: str | None = None
output_multiplicity: VariableMultiplicity | None = None
batch_params: BatchParams | None = None
- concept_codes_from_the_same_domain: list[str] | None = None
async def run_pipe(
self,
@@ -70,11 +70,11 @@ class SubPipe(BaseModel):
},
)
- pipe_batch = PipeBatchFactory.make_from_blueprint(
- domain=sub_pipe.domain,
+ pipe_batch = PipeFactory[PipeBatch].make_from_blueprint(
+ domain_code=sub_pipe.domain,
pipe_code=self.pipe_code,
blueprint=pipe_batch_blueprint,
- concept_codes_from_the_same_domain=self.concept_codes_from_the_same_domain,
+ concept_codes_from_the_same_domain=[concept.code for concept in sub_pipe.concept_dependencies],
)
pipe_output = await pipe_batch.run_pipe(
job_metadata=job_metadata,
diff --git a/pipelex/pipe_controllers/sub_pipe_factory.py b/pipelex/pipe_controllers/sub_pipe_factory.py
index 00657fcc2..a58f11606 100644
--- a/pipelex/pipe_controllers/sub_pipe_factory.py
+++ b/pipelex/pipe_controllers/sub_pipe_factory.py
@@ -9,7 +9,6 @@ class SubPipeFactory:
def make_from_blueprint(
cls,
blueprint: SubPipeBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> SubPipe:
"""Create a SubPipe from a SubPipeBlueprint."""
output_multiplicity = make_variable_multiplicity(
@@ -29,5 +28,4 @@ class SubPipeFactory:
output_name=blueprint.result,
output_multiplicity=output_multiplicity,
batch_params=batch_params,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
)
diff --git a/pipelex/pipe_operators/compose/pipe_compose_factory.py b/pipelex/pipe_operators/compose/pipe_compose_factory.py
index 5c5b1b86a..caf671d12 100644
--- a/pipelex/pipe_operators/compose/pipe_compose_factory.py
+++ b/pipelex/pipe_operators/compose/pipe_compose_factory.py
@@ -1,13 +1,11 @@
+from typing import Any
+
from typing_extensions import override
from pipelex.cogt.templating.template_preprocessor import preprocess_template
-from pipelex.core.concepts.concept_factory import ConceptFactory
-from pipelex.core.concepts.exceptions import ConceptFactoryError
-from pipelex.core.pipes.exceptions import PipeVariableMultiplicityError
-from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory
+from pipelex.core.concepts.concept import Concept
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
from pipelex.core.pipes.pipe_factory import PipeFactoryProtocol
-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
-from pipelex.hub import get_required_concept
from pipelex.pipe_operators.compose.exceptions import PipeComposeFactoryError
from pipelex.pipe_operators.compose.pipe_compose import PipeCompose
from pipelex.pipe_operators.compose.pipe_compose_blueprint import PipeComposeBlueprint
@@ -18,12 +16,16 @@ from pipelex.tools.jinja2.jinja2_parsing import check_jinja2_parsing
class PipeComposeFactory(PipeFactoryProtocol[PipeComposeBlueprint, PipeCompose]):
@classmethod
@override
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeComposeBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeCompose:
preprocessed_template = preprocess_template(blueprint.template_source)
try:
@@ -35,36 +37,12 @@ class PipeComposeFactory(PipeFactoryProtocol[PipeComposeBlueprint, PipeCompose])
msg = f"Error parsing Jinja2 template for PipeCompose: {exc}"
raise PipeComposeFactoryError(msg) from exc
- # Parse output to strip multiplicity brackets
- try:
- output_parse_result = parse_concept_with_multiplicity(blueprint.output)
- except PipeVariableMultiplicityError as exc:
- msg = f"Error parsing concept with multiplicity for PipeCompose: {exc}"
- raise PipeComposeFactoryError(msg) from exc
- try:
- output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
- except ConceptFactoryError as exc:
- msg = f"Error making domain and concept code for PipeCompose: {exc}"
- raise PipeComposeFactoryError(msg) from exc
return PipeCompose(
- domain=domain,
+ domain=domain_code,
code=pipe_code,
- description=blueprint.description,
- inputs=InputRequirementsFactory.make_from_blueprint(
- domain=domain,
- blueprint=blueprint.inputs or {},
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- ),
- output=get_required_concept(
- concept_string=ConceptFactory.make_concept_string_with_domain(
- domain=output_domain_and_code.domain,
- concept_code=output_domain_and_code.concept_code,
- ),
- ),
+ description=description,
+ inputs=inputs,
+ output=output,
template=preprocessed_template,
templating_style=blueprint.templating_style,
category=blueprint.template_category,
diff --git a/pipelex/pipe_operators/extract/pipe_extract_factory.py b/pipelex/pipe_operators/extract/pipe_extract_factory.py
index a105fdb7d..0840abc17 100644
--- a/pipelex/pipe_operators/extract/pipe_extract_factory.py
+++ b/pipelex/pipe_operators/extract/pipe_extract_factory.py
@@ -1,12 +1,13 @@
+from typing import Any
+
from typing_extensions import override
from pipelex.config import get_config
-from pipelex.core.concepts.concept_factory import ConceptFactory
+from pipelex.core.concepts.concept import Concept
from pipelex.core.concepts.native.concept_native import NativeConceptCode
-from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
from pipelex.core.pipes.pipe_factory import PipeFactoryProtocol
-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
-from pipelex.hub import get_concept_library, get_native_concept, get_required_concept
+from pipelex.hub import get_concept_library, get_native_concept
from pipelex.pipe_operators.extract.exceptions import PipeExtractFactoryError
from pipelex.pipe_operators.extract.pipe_extract import PipeExtract
from pipelex.pipe_operators.extract.pipe_extract_blueprint import PipeExtractBlueprint
@@ -15,34 +16,21 @@ from pipelex.pipe_operators.extract.pipe_extract_blueprint import PipeExtractBlu
class PipeExtractFactory(PipeFactoryProtocol[PipeExtractBlueprint, PipeExtract]):
@classmethod
@override
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeExtractBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeExtract:
- # Parse output to strip multiplicity brackets
- output_parse_result = parse_concept_with_multiplicity(blueprint.output)
-
- output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
-
+ concept_library = get_concept_library()
image_stuff_name = None
pdf_stuff_name = None
- concept_library = get_concept_library()
- if blueprint.inputs is None:
- msg = "For PipeExtract you must provide either a pdf or an image or a concept that refines one of them"
- raise PipeExtractFactoryError(msg)
- inputs = InputRequirementsFactory.make_from_blueprint(
- domain=domain,
- blueprint=blueprint.inputs or {},
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
# Already validated above that we have exactly one input
input_name = blueprint.input_names[0]
input_requirement = inputs.get_required_input_requirement(input_name)
@@ -67,16 +55,13 @@ class PipeExtractFactory(PipeFactoryProtocol[PipeExtractBlueprint, PipeExtract])
)
raise PipeExtractFactoryError(msg)
+ page_views_dpi = blueprint.page_views_dpi or get_config().cogt.extract_config.default_page_views_dpi
+
return PipeExtract(
- domain=domain,
+ domain=domain_code,
code=pipe_code,
- description=blueprint.description,
- output=get_required_concept(
- concept_string=ConceptFactory.make_concept_string_with_domain(
- domain=output_domain_and_code.domain,
- concept_code=output_domain_and_code.concept_code,
- ),
- ),
+ description=description,
+ output=output,
inputs=inputs,
extract_choice=blueprint.model,
image_stuff_name=image_stuff_name,
@@ -84,5 +69,5 @@ class PipeExtractFactory(PipeFactoryProtocol[PipeExtractBlueprint, PipeExtract])
should_include_images=blueprint.page_images or False,
should_caption_images=blueprint.page_image_captions or False,
should_include_page_views=blueprint.page_views or False,
- page_views_dpi=blueprint.page_views_dpi or get_config().cogt.extract_config.default_page_views_dpi,
+ page_views_dpi=page_views_dpi,
)
diff --git a/pipelex/pipe_operators/func/pipe_func_factory.py b/pipelex/pipe_operators/func/pipe_func_factory.py
index 785804d21..f4a4e79d5 100644
--- a/pipelex/pipe_operators/func/pipe_func_factory.py
+++ b/pipelex/pipe_operators/func/pipe_func_factory.py
@@ -1,10 +1,10 @@
+from typing import Any
+
from typing_extensions import override
-from pipelex.core.concepts.concept_factory import ConceptFactory
-from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory
+from pipelex.core.concepts.concept import Concept
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
from pipelex.core.pipes.pipe_factory import PipeFactoryProtocol
-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
-from pipelex.hub import get_required_concept
from pipelex.pipe_operators.func.pipe_func import PipeFunc
from pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprint
@@ -12,36 +12,23 @@ from pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprint
class PipeFuncFactory(PipeFactoryProtocol[PipeFuncBlueprint, PipeFunc]):
@classmethod
@override
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeFuncBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeFunc:
- # Parse output to strip multiplicity brackets
- output_parse_result = parse_concept_with_multiplicity(blueprint.output)
-
- output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
# TODO: make function_name into a callable in PipeFunc
return PipeFunc(
- domain=domain,
+ domain=domain_code,
code=pipe_code,
- description=blueprint.description,
- inputs=InputRequirementsFactory.make_from_blueprint(
- domain=domain,
- blueprint=blueprint.inputs or {},
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- ),
- output=get_required_concept(
- concept_string=ConceptFactory.make_concept_string_with_domain(
- domain=output_domain_and_code.domain,
- concept_code=output_domain_and_code.concept_code,
- ),
- ),
+ description=description,
+ inputs=inputs,
+ output=output,
function_name=blueprint.function_name,
)
diff --git a/pipelex/pipe_operators/img_gen/pipe_img_gen_factory.py b/pipelex/pipe_operators/img_gen/pipe_img_gen_factory.py
index 558ff0fae..f571c8674 100644
--- a/pipelex/pipe_operators/img_gen/pipe_img_gen_factory.py
+++ b/pipelex/pipe_operators/img_gen/pipe_img_gen_factory.py
@@ -1,10 +1,11 @@
+from typing import Any
+
from typing_extensions import override
-from pipelex.core.concepts.concept_factory import ConceptFactory
-from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory
+from pipelex.core.concepts.concept import Concept
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
from pipelex.core.pipes.pipe_factory import PipeFactoryProtocol
from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
-from pipelex.hub import get_required_concept
from pipelex.pipe_operators.img_gen.pipe_img_gen import PipeImgGen
from pipelex.pipe_operators.img_gen.pipe_img_gen_blueprint import PipeImgGenBlueprint
@@ -12,12 +13,16 @@ from pipelex.pipe_operators.img_gen.pipe_img_gen_blueprint import PipeImgGenBlue
class PipeImgGenFactory(PipeFactoryProtocol[PipeImgGenBlueprint, PipeImgGen]):
@classmethod
@override
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeImgGenBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeImgGen:
# Parse output for multiplicity (may have brackets like "Image[]" or "Image[3]")
output_parse_result = parse_concept_with_multiplicity(blueprint.output)
@@ -25,18 +30,6 @@ class PipeImgGenFactory(PipeFactoryProtocol[PipeImgGenBlueprint, PipeImgGen]):
# Convert bracket notation to output_multiplicity (default to 1 if no brackets)
final_multiplicity = output_parse_result.multiplicity if isinstance(output_parse_result.multiplicity, int) else 1
- # Use concept without brackets for output concept resolution
- output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
- inputs = InputRequirementsFactory.make_from_blueprint(
- domain=domain,
- blueprint=blueprint.inputs or {},
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
-
img_gen_prompt = blueprint.img_gen_prompt
img_gen_prompt_var_name = blueprint.img_gen_prompt_var_name
@@ -48,16 +41,11 @@ class PipeImgGenFactory(PipeFactoryProtocol[PipeImgGenBlueprint, PipeImgGen]):
img_gen_prompt = blueprint.img_gen_prompt
return PipeImgGen(
- domain=domain,
+ domain=domain_code,
code=pipe_code,
- description=blueprint.description,
+ description=description,
inputs=inputs,
- output=get_required_concept(
- concept_string=ConceptFactory.make_concept_string_with_domain(
- domain=output_domain_and_code.domain,
- concept_code=output_domain_and_code.concept_code,
- ),
- ),
+ output=output,
output_multiplicity=final_multiplicity,
img_gen_prompt=img_gen_prompt,
img_gen_prompt_var_name=img_gen_prompt_var_name,
diff --git a/pipelex/pipe_operators/llm/pipe_llm_factory.py b/pipelex/pipe_operators/llm/pipe_llm_factory.py
index d09b842b9..fef79dc7a 100644
--- a/pipelex/pipe_operators/llm/pipe_llm_factory.py
+++ b/pipelex/pipe_operators/llm/pipe_llm_factory.py
@@ -1,3 +1,5 @@
+from typing import Any
+
from pydantic import ValidationError
from typing_extensions import override
@@ -7,7 +9,7 @@ from pipelex.cogt.templating.template_category import TemplateCategory
from pipelex.core.concepts.concept import Concept
from pipelex.core.concepts.concept_factory import ConceptFactory
from pipelex.core.concepts.native.concept_native import NativeConceptCode
-from pipelex.core.pipes.inputs.input_requirements_factory import InputRequirementsFactory
+from pipelex.core.pipes.inputs.input_requirements import InputRequirements
from pipelex.core.pipes.pipe_factory import PipeFactoryProtocol
from pipelex.core.pipes.variable_multiplicity import make_variable_multiplicity, parse_concept_with_multiplicity
from pipelex.hub import get_native_concept, get_optional_domain, get_required_concept
@@ -21,15 +23,19 @@ from pipelex.tools.jinja2.jinja2_errors import Jinja2TemplateSyntaxError
class PipeLLMFactory(PipeFactoryProtocol[PipeLLMBlueprint, PipeLLM]):
@classmethod
@override
- def make_from_blueprint(
+ def make(
cls,
- domain: str,
+ pipe_category: Any,
+ pipe_type: str,
pipe_code: str,
+ domain_code: str,
+ description: str | None,
+ inputs: InputRequirements,
+ output: Concept,
blueprint: PipeLLMBlueprint,
- concept_codes_from_the_same_domain: list[str] | None = None,
) -> PipeLLM:
system_prompt = blueprint.system_prompt
- if not system_prompt and (domain_obj := get_optional_domain(domain=domain)):
+ if not system_prompt and (domain_obj := get_optional_domain(domain=domain_code)):
system_prompt = domain_obj.system_prompt
system_prompt_jinja2_blueprint: TemplateBlueprint | None = None
@@ -42,7 +48,7 @@ class PipeLLMFactory(PipeFactoryProtocol[PipeLLMBlueprint, PipeLLM]):
except ValidationError as exc:
error_msg = (
f"Template syntax error in system prompt for pipe '{pipe_code}'"
- f"in domain '{domain}': {exc}. Template source:\n{blueprint.system_prompt}"
+ f"in domain '{domain_code}': {exc}. Template source:\n{blueprint.system_prompt}"
)
raise PipeLLMFactoryError(error_msg) from exc
@@ -55,7 +61,8 @@ class PipeLLMFactory(PipeFactoryProtocol[PipeLLMBlueprint, PipeLLM]):
)
except Jinja2TemplateSyntaxError as exc:
error_msg = (
- f"Template syntax error in user prompt for pipe '{pipe_code}' in domain '{domain}': {exc}. Template source:\n{blueprint.prompt}"
+ f"Template syntax error in user prompt for pipe '{pipe_code}' in domain '{domain_code}': "
+ f"{exc}. Template source:\n{blueprint.prompt}"
)
raise PipeLLMFactoryError(error_msg) from exc
@@ -66,9 +73,8 @@ class PipeLLMFactory(PipeFactoryProtocol[PipeLLMBlueprint, PipeLLM]):
input_parse_result = parse_concept_with_multiplicity(requirement_str)
domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
+ domain=domain_code,
concept_string_or_code=input_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
)
concept = get_required_concept(
concept_string=ConceptFactory.make_concept_string_with_domain(
@@ -106,25 +112,12 @@ class PipeLLMFactory(PipeFactoryProtocol[PipeLLMBlueprint, PipeLLM]):
multiple_items=output_parse_result.multiplicity if isinstance(output_parse_result.multiplicity, bool) else None,
)
- # Use concept without brackets for output concept resolution
- output_domain_and_code = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
- domain=domain,
- concept_string_or_code=output_parse_result.concept,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- )
- output_concept_domain, output_concept_code = output_domain_and_code.domain, output_domain_and_code.concept_code
return PipeLLM(
- domain=domain,
+ domain=domain_code,
code=pipe_code,
- description=blueprint.description,
- inputs=InputRequirementsFactory.make_from_blueprint(
- domain=domain,
- blueprint=blueprint.inputs or {},
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
- ),
- output=get_required_concept(
- concept_string=ConceptFactory.make_concept_string_with_domain(domain=output_concept_domain, concept_code=output_concept_code),
- ),
+ description=description,
+ inputs=inputs,
+ output=output,
llm_prompt_spec=llm_prompt_spec,
llm_choices=llm_choices,
structuring_method=blueprint.structuring_method,
diff --git a/tests/conftest.py b/tests/conftest.py
index b2d5805ee..24578696f 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,3 +1,4 @@
+from collections.abc import Callable, Generator
from pathlib import Path
import pytest
@@ -32,7 +33,7 @@ def reset_pipelex_config_fixture(routing_profile_setup: str | None): # noqa: AR
@pytest.fixture(scope="class")
-def load_test_library():
+def load_test_library() -> Generator[Callable[[list[Path]], None], None, None]:
library_id = None
def _load(library_dirs: list[Path]) -> None:
@@ -57,16 +58,17 @@ def load_test_library():
@pytest.fixture(scope="class")
-def load_empty_library():
+def load_empty_library() -> Generator[Callable[[], str], None, None]:
library_id = None
- def _load() -> None:
+ def _load() -> str:
nonlocal library_id
library_manager = get_library_manager()
library_id, _ = library_manager.open_library()
set_current_library(library_id=library_id)
log.verbose(f"Opened empty library: {library_id}")
+ return library_id
yield _load
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 7779c4569..4eedc246d 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
@@ -1,5 +1,3 @@
-"""Test simple pipe condition functionality with dry run validation."""
-
from pathlib import Path
from typing import Callable
@@ -12,8 +10,9 @@ from pipelex.core.domains.domain import SpecialDomain
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
from pipelex.core.pipes.inputs.exceptions import PipeRunInputsError
from pipelex.core.pipes.inputs.input_requirements import TypedNamedInputRequirement
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.pipe_controllers.condition.pipe_condition import PipeCondition
from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint
-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactory
from pipelex.pipe_run.exceptions import PipeRunError
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
@@ -38,8 +37,8 @@ class TestPipeConditionSimple:
default_outcome="process_small",
)
- pipe_condition = PipeConditionFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_condition = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code="test_domain",
pipe_code="test_condition_fail",
blueprint=pipe_condition_blueprint,
)
@@ -73,8 +72,8 @@ class TestPipeConditionSimple:
default_outcome="process_small",
)
- pipe_condition = PipeConditionFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_condition = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code="test_domain",
pipe_code="test_condition_succeed",
blueprint=pipe_condition_blueprint,
)
diff --git a/tests/integration/pipelex/pipes/controller/pipe_batch/test_pipe_batch_simple.py b/tests/integration/pipelex/pipes/controller/pipe_batch/test_pipe_batch_simple.py
index a896062a2..68179b903 100644
--- a/tests/integration/pipelex/pipes/controller/pipe_batch/test_pipe_batch_simple.py
+++ b/tests/integration/pipelex/pipes/controller/pipe_batch/test_pipe_batch_simple.py
@@ -1,26 +1,22 @@
-from __future__ import annotations
-
from pathlib import Path
-from typing import TYPE_CHECKING, cast
+from typing import Callable, cast
import pytest
from pytest import FixtureRequest
-if TYPE_CHECKING:
- from collections.abc import Callable
-
from pipelex import pretty_print
from pipelex.core.concepts.concept_blueprint import ConceptBlueprint
from pipelex.core.concepts.concept_factory import ConceptFactory
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.list_content import ListContent
from pipelex.core.stuffs.stuff_content import StuffContent
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.core.stuffs.text_content import TextContent
from pipelex.hub import get_concept_library
+from pipelex.pipe_controllers.batch.pipe_batch import PipeBatch
from pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprint
-from pipelex.pipe_controllers.batch.pipe_batch_factory import PipeBatchFactory
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
from pipelex.pipeline.job_metadata import JobMetadata
@@ -44,13 +40,11 @@ class TestPipeBatchSimple:
concept_code="TestConcept1",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["TestConcept1"],
)
concept_2 = ConceptFactory.make_from_blueprint(
concept_code="TestConcept2",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["TestConcept2"],
)
concept_library = get_concept_library()
concept_library.add_concepts([concept_1, concept_2])
@@ -66,11 +60,10 @@ class TestPipeBatchSimple:
input_item_name="text_item",
)
- pipe_batch = PipeBatchFactory.make_from_blueprint(
- domain=domain,
+ pipe_batch = PipeFactory[PipeBatch].make_from_blueprint(
+ domain_code=domain,
pipe_code="simple_batch",
blueprint=pipe_batch_blueprint,
- concept_codes_from_the_same_domain=["TestConcept1", "TestConcept2"],
)
# Create test data - list of text items
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 f8e75b03e..3962a34e7 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
@@ -1,5 +1,3 @@
-"""Simple integration test for PipeCondition controller."""
-
from pathlib import Path
from typing import Callable, cast
@@ -12,11 +10,12 @@ from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.domains.domain import SpecialDomain
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
from pipelex.core.pipes.inputs.exceptions import PipeRunInputsError
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.core.stuffs.text_content import TextContent
from pipelex.hub import get_pipe_router, get_required_pipe
+from pipelex.pipe_controllers.condition.pipe_condition import PipeCondition
from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint
-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactory
from pipelex.pipe_controllers.condition.special_outcome import SpecialOutcome
from pipelex.pipe_run.pipe_job_factory import PipeJobFactory
from pipelex.pipe_run.pipe_run_params import PipeRunMode
@@ -43,8 +42,8 @@ class TestPipeConditionSimple:
default_outcome=SpecialOutcome.CONTINUE,
)
- pipe_condition = PipeConditionFactory.make_from_blueprint(
- domain="test_integration",
+ pipe_condition = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code="test_integration",
pipe_code="text_length_condition",
blueprint=pipe_condition_blueprint,
)
@@ -116,8 +115,8 @@ class TestPipeConditionSimple:
default_outcome=SpecialOutcome.CONTINUE,
)
- pipe_condition = PipeConditionFactory.make_from_blueprint(
- domain="test_integration",
+ pipe_condition = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code="test_integration",
pipe_code="text_length_condition",
blueprint=pipe_condition_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 6618e394e..57463e50d 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
@@ -2,9 +2,10 @@ from pathlib import Path
from typing import Callable
from pipelex.core.concepts.concept_factory import ConceptBlueprint, ConceptFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.hub import get_concept_library
+from pipelex.pipe_controllers.condition.pipe_condition import PipeCondition
from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint
-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactory
from pipelex.pipe_controllers.condition.special_outcome import SpecialOutcome
@@ -19,13 +20,11 @@ class TestPipeConditionValidation:
concept_code="TestConcept",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["TestConcept"],
)
concept_2 = ConceptFactory.make_from_blueprint(
concept_code="Result",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["Result"],
)
concept_library = get_concept_library()
concept_library.add_concepts([concept_1, concept_2])
@@ -39,8 +38,8 @@ class TestPipeConditionValidation:
default_outcome="default_pipe",
)
- pipe_condition = PipeConditionFactory.make_from_blueprint(
- domain=domain,
+ pipe_condition = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code=domain,
pipe_code="test_condition",
blueprint=pipe_condition_blueprint,
)
@@ -63,13 +62,11 @@ class TestPipeConditionValidation:
concept_code="TestConcept",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["TestConcept"],
)
concept_2 = ConceptFactory.make_from_blueprint(
concept_code="Result",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["Result"],
)
concept_library.add_concepts([concept_1, concept_2])
@@ -82,8 +79,8 @@ class TestPipeConditionValidation:
default_outcome=SpecialOutcome.CONTINUE,
)
- pipe_condition_template = PipeConditionFactory.make_from_blueprint(
- domain=domain,
+ pipe_condition_template = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code=domain,
pipe_code="test_condition_template",
blueprint=pipe_condition_template_blueprint,
)
@@ -98,8 +95,8 @@ class TestPipeConditionValidation:
default_outcome=SpecialOutcome.CONTINUE,
)
- pipe_condition_expr = PipeConditionFactory.make_from_blueprint(
- domain=domain,
+ pipe_condition_expr = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code=domain,
pipe_code="test_condition_expr",
blueprint=pipe_condition_expr_blueprint,
)
diff --git a/tests/integration/pipelex/pipes/controller/pipe_parallel/test_pipe_parallel_simple.py b/tests/integration/pipelex/pipes/controller/pipe_parallel/test_pipe_parallel_simple.py
index aa313c6c2..5b1e74b5a 100644
--- a/tests/integration/pipelex/pipes/controller/pipe_parallel/test_pipe_parallel_simple.py
+++ b/tests/integration/pipelex/pipes/controller/pipe_parallel/test_pipe_parallel_simple.py
@@ -8,10 +8,11 @@ from pipelex.core.concepts.concept_factory import ConceptFactory
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.domains.domain import SpecialDomain
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.core.stuffs.text_content import TextContent
+from pipelex.pipe_controllers.parallel.pipe_parallel import PipeParallel
from pipelex.pipe_controllers.parallel.pipe_parallel_blueprint import PipeParallelBlueprint
-from pipelex.pipe_controllers.parallel.pipe_parallel_factory import PipeParallelFactory
from pipelex.pipe_controllers.sub_pipe_factory import SubPipeBlueprint
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
@@ -39,8 +40,8 @@ class TestPipeParallelSimple:
combined_output=None,
)
- pipe_parallel = PipeParallelFactory.make_from_blueprint(
- domain="test_integration",
+ pipe_parallel = PipeFactory[PipeParallel].make_from_blueprint(
+ domain_code="test_integration",
pipe_code="parallel_text_analyzer",
blueprint=pipe_parallel_blueprint,
)
@@ -158,8 +159,8 @@ class TestPipeParallelSimple:
combined_output=None,
)
- pipe_parallel = PipeParallelFactory.make_from_blueprint(
- domain="test_integration",
+ pipe_parallel = PipeFactory[PipeParallel].make_from_blueprint(
+ domain_code="test_integration",
pipe_code="parallel_text_analyzer",
blueprint=pipe_parallel_blueprint,
)
diff --git a/tests/integration/pipelex/pipes/controller/pipe_parallel/test_pipe_parallel_validation.py b/tests/integration/pipelex/pipes/controller/pipe_parallel/test_pipe_parallel_validation.py
index 7a3fdec43..fad2c1f6e 100644
--- a/tests/integration/pipelex/pipes/controller/pipe_parallel/test_pipe_parallel_validation.py
+++ b/tests/integration/pipelex/pipes/controller/pipe_parallel/test_pipe_parallel_validation.py
@@ -3,12 +3,13 @@ from typing import Callable
from pipelex.core.concepts.concept_blueprint import ConceptBlueprint
from pipelex.core.concepts.concept_factory import ConceptFactory
from pipelex.core.pipes.inputs.input_requirements import InputRequirements
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.hub import get_concept_library, get_pipe_library
+from pipelex.pipe_controllers.parallel.pipe_parallel import PipeParallel
from pipelex.pipe_controllers.parallel.pipe_parallel_blueprint import PipeParallelBlueprint
-from pipelex.pipe_controllers.parallel.pipe_parallel_factory import PipeParallelFactory
from pipelex.pipe_controllers.sub_pipe_factory import SubPipeBlueprint
+from pipelex.pipe_operators.llm.pipe_llm import PipeLLM
from pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint
-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactory
class TestPipeParallelValidation:
@@ -16,7 +17,6 @@ class TestPipeParallelValidation:
def test_pipe_parallel_with_real_pipe_structure(self, load_empty_library: Callable[[], None]):
load_empty_library()
- """Test PipeParallel structure with a real pipe"""
# Create a real PipeLLM that will infer inputs from the prompt template
domain = "test_domain"
concept_library = get_concept_library()
@@ -25,19 +25,16 @@ class TestPipeParallelValidation:
domain=domain,
concept_code="Document",
blueprint=concept_blueprint,
- concept_codes_from_the_same_domain=["Document"],
)
concept_2 = ConceptFactory.make_from_blueprint(
domain=domain,
concept_code="Context",
blueprint=concept_blueprint,
- concept_codes_from_the_same_domain=["Context"],
)
concept_3 = ConceptFactory.make_from_blueprint(
domain=domain,
concept_code="Analysis",
blueprint=concept_blueprint,
- concept_codes_from_the_same_domain=["Analysis"],
)
concept_library.add_concepts(concepts=[concept_1, concept_2, concept_3])
@@ -51,10 +48,11 @@ class TestPipeParallelValidation:
prompt="Analyze this document: \n@context\n@document",
)
- real_pipe = PipeLLMFactory.make_from_blueprint(
- domain=domain,
+ real_pipe = PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code=domain,
pipe_code="analyze_document",
blueprint=pipe_llm_blueprint,
+ concept_codes_from_the_same_domain=[concept_1.code, concept_2.code, concept_3.code],
)
pipe_library = get_pipe_library()
@@ -78,10 +76,11 @@ class TestPipeParallelValidation:
combined_output=None,
)
- pipe_parallel = PipeParallelFactory.make_from_blueprint(
- domain=domain,
+ pipe_parallel = PipeFactory[PipeParallel].make_from_blueprint(
+ domain_code=domain,
pipe_code="parallel_document_processor",
blueprint=pipe_parallel_blueprint,
+ concept_codes_from_the_same_domain=[concept_1.code, concept_2.code, concept_3.code],
)
# Verify the PipeParallel structure is correct
@@ -107,19 +106,16 @@ class TestPipeParallelValidation:
domain=domain,
concept_code="Document",
blueprint=concept_blueprint,
- concept_codes_from_the_same_domain=["Document"],
)
concept_2 = ConceptFactory.make_from_blueprint(
domain=domain,
concept_code="Context",
blueprint=concept_blueprint,
- concept_codes_from_the_same_domain=["Context"],
)
concept_3 = ConceptFactory.make_from_blueprint(
domain=domain,
concept_code="ProcessedAnalysis",
blueprint=concept_blueprint,
- concept_codes_from_the_same_domain=["ProcessedAnalysis"],
)
concept_library.add_concepts(concepts=[concept_1, concept_2, concept_3])
@@ -132,10 +128,11 @@ class TestPipeParallelValidation:
combined_output=None,
)
- pipe_parallel = PipeParallelFactory.make_from_blueprint(
- domain=domain,
+ pipe_parallel = PipeFactory[PipeParallel].make_from_blueprint(
+ domain_code=domain,
pipe_code="test_parallel",
blueprint=pipe_parallel_blueprint,
+ concept_codes_from_the_same_domain=[concept_1.code, concept_2.code, concept_3.code],
)
# Verify the PipeParallel was created correctly
@@ -160,19 +157,16 @@ class TestPipeParallelValidation:
domain=domain,
concept_code="Document",
blueprint=concept_blueprint,
- concept_codes_from_the_same_domain=["Document"],
)
concept_2 = ConceptFactory.make_from_blueprint(
domain=domain,
concept_code="Context",
blueprint=concept_blueprint,
- concept_codes_from_the_same_domain=["Context"],
)
concept_3 = ConceptFactory.make_from_blueprint(
domain=domain,
concept_code="ProcessedAnalysis",
blueprint=concept_blueprint,
- concept_codes_from_the_same_domain=["ProcessedAnalysis"],
)
concept_library.add_concepts(concepts=[concept_1, concept_2, concept_3])
@@ -189,10 +183,11 @@ class TestPipeParallelValidation:
combined_output=None,
)
- pipe_parallel = PipeParallelFactory.make_from_blueprint(
- domain=domain,
+ pipe_parallel = PipeFactory[PipeParallel].make_from_blueprint(
+ domain_code=domain,
pipe_code="parallel_document_processor",
blueprint=pipe_parallel_blueprint,
+ concept_codes_from_the_same_domain=[concept_1.code, concept_2.code, concept_3.code],
)
# Test that needed_inputs method can be called
diff --git a/tests/integration/pipelex/pipes/controller/pipe_sequence/test_pipe_sequence_simple.py b/tests/integration/pipelex/pipes/controller/pipe_sequence/test_pipe_sequence_simple.py
index 1e11f8071..96b847208 100644
--- a/tests/integration/pipelex/pipes/controller/pipe_sequence/test_pipe_sequence_simple.py
+++ b/tests/integration/pipelex/pipes/controller/pipe_sequence/test_pipe_sequence_simple.py
@@ -1,5 +1,3 @@
-"""Simple integration test for PipeSequence controller."""
-
from pathlib import Path
from typing import Callable, cast
@@ -11,11 +9,12 @@ from pipelex.core.concepts.concept_blueprint import ConceptBlueprint
from pipelex.core.concepts.concept_factory import ConceptFactory
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.core.stuffs.text_content import TextContent
from pipelex.hub import get_concept_library, get_native_concept
+from pipelex.pipe_controllers.sequence.pipe_sequence import PipeSequence
from pipelex.pipe_controllers.sequence.pipe_sequence_blueprint import PipeSequenceBlueprint
-from pipelex.pipe_controllers.sequence.pipe_sequence_factory import PipeSequenceFactory
from pipelex.pipe_controllers.sub_pipe_blueprint import SubPipeBlueprint
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
@@ -38,7 +37,6 @@ class TestPipeSequenceSimple:
concept_code="TestConcept1",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["TestConcept1"],
)
concept_library = get_concept_library()
concept_library.add_concepts([concept_1])
@@ -55,8 +53,8 @@ class TestPipeSequenceSimple:
],
)
- pipe_sequence = PipeSequenceFactory.make_from_blueprint(
- domain="test_integration",
+ pipe_sequence = PipeFactory[PipeSequence].make_from_blueprint(
+ domain_code=domain,
pipe_code="simple_sequence",
blueprint=pipe_sequence_blueprint,
)
diff --git a/tests/integration/pipelex/pipes/controller/pipe_sequence/test_pipe_sequence_validation.py b/tests/integration/pipelex/pipes/controller/pipe_sequence/test_pipe_sequence_validation.py
index 30856bfb9..a98605fe3 100644
--- a/tests/integration/pipelex/pipes/controller/pipe_sequence/test_pipe_sequence_validation.py
+++ b/tests/integration/pipelex/pipes/controller/pipe_sequence/test_pipe_sequence_validation.py
@@ -2,9 +2,10 @@ from pathlib import Path
from typing import Callable
from pipelex.core.concepts.concept_factory import ConceptBlueprint, ConceptFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.hub import get_concept_library
+from pipelex.pipe_controllers.sequence.pipe_sequence import PipeSequence
from pipelex.pipe_controllers.sequence.pipe_sequence_blueprint import PipeSequenceBlueprint
-from pipelex.pipe_controllers.sequence.pipe_sequence_factory import PipeSequenceFactory
from pipelex.pipe_controllers.sub_pipe_factory import SubPipeBlueprint
@@ -19,13 +20,11 @@ class TestPipeSequenceValidation:
concept_code="TestConcept",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["TestConcept"],
)
concept_2 = ConceptFactory.make_from_blueprint(
concept_code="ProcessedText",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["ProcessedText"],
)
concept_library = get_concept_library()
concept_library.add_concepts([concept_1, concept_2])
@@ -37,8 +36,8 @@ class TestPipeSequenceValidation:
steps=[SubPipeBlueprint(pipe="test_pipe_1", result="intermediate_result")],
)
- pipe_sequence = PipeSequenceFactory.make_from_blueprint(
- domain=domain,
+ pipe_sequence = PipeFactory[PipeSequence].make_from_blueprint(
+ domain_code=domain,
pipe_code="test_sequence",
blueprint=pipe_sequence_blueprint,
)
@@ -59,13 +58,11 @@ class TestPipeSequenceValidation:
concept_code="TestConcept",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["TestConcept"],
)
concept_2 = ConceptFactory.make_from_blueprint(
concept_code="ProcessedText",
domain=domain,
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["ProcessedText"],
)
concept_library = get_concept_library()
concept_library.add_concepts([concept_1, concept_2])
@@ -77,8 +74,8 @@ class TestPipeSequenceValidation:
steps=[SubPipeBlueprint(pipe="step_1", result="intermediate"), SubPipeBlueprint(pipe="step_2", result="final_output")],
)
- pipe_sequence = PipeSequenceFactory.make_from_blueprint(
- domain=domain,
+ pipe_sequence = PipeFactory[PipeSequence].make_from_blueprint(
+ domain_code=domain,
pipe_code="test_sequence",
blueprint=pipe_sequence_blueprint,
)
diff --git a/tests/integration/pipelex/pipes/operator/pipe_extract/test_pipe_extract.py b/tests/integration/pipelex/pipes/operator/pipe_extract/test_pipe_extract.py
index df21cc580..d5c5cd4b6 100644
--- a/tests/integration/pipelex/pipes/operator/pipe_extract/test_pipe_extract.py
+++ b/tests/integration/pipelex/pipes/operator/pipe_extract/test_pipe_extract.py
@@ -7,13 +7,14 @@ from pipelex.core.concepts.concept_blueprint import ConceptBlueprint
from pipelex.core.concepts.concept_factory import ConceptFactory
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.image_content import ImageContent
from pipelex.core.stuffs.page_content import PageContent
from pipelex.core.stuffs.pdf_content import PDFContent
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.hub import get_concept_library, get_pipe_router
+from pipelex.pipe_operators.extract.pipe_extract import PipeExtract
from pipelex.pipe_operators.extract.pipe_extract_blueprint import PipeExtractBlueprint
-from pipelex.pipe_operators.extract.pipe_extract_factory import PipeExtractFactory
from pipelex.pipe_run.pipe_job_factory import PipeJobFactory
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
@@ -36,7 +37,6 @@ class TestPipeExtract:
concept_code="PageScan",
domain="extract",
blueprint=ConceptBlueprint(description="Lorem Ipsum"),
- concept_codes_from_the_same_domain=["PageScan"],
)
concept_library.add_new_concept(concept=concept_1)
@@ -64,8 +64,8 @@ class TestPipeExtract:
)
pipe_job = PipeJobFactory.make_pipe_job(
- pipe=PipeExtractFactory.make_from_blueprint(
- domain="generic",
+ pipe=PipeFactory[PipeExtract].make_from_blueprint(
+ domain_code="generic",
pipe_code="adhoc_for_test_pipe_extract_from_image",
blueprint=pipe_extract_blueprint,
),
@@ -112,8 +112,8 @@ class TestPipeExtract:
)
pipe_job = PipeJobFactory.make_pipe_job(
- pipe=PipeExtractFactory.make_from_blueprint(
- domain="generic",
+ pipe=PipeFactory[PipeExtract].make_from_blueprint(
+ domain_code="generic",
pipe_code="adhoc_for_test_pipe_extract_from_pdf",
blueprint=blueprint,
),
diff --git a/tests/integration/pipelex/pipes/operator/pipe_func/test_pipe_func.py b/tests/integration/pipelex/pipes/operator/pipe_func/test_pipe_func.py
index ab5881e8c..e28888be2 100644
--- a/tests/integration/pipelex/pipes/operator/pipe_func/test_pipe_func.py
+++ b/tests/integration/pipelex/pipes/operator/pipe_func/test_pipe_func.py
@@ -6,11 +6,12 @@ from pipelex import log, pretty_print
from pipelex.core.concepts.concept_factory import ConceptFactory
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.core.stuffs.text_content import TextContent
from pipelex.hub import get_pipe_router
+from pipelex.pipe_operators.func.pipe_func import PipeFunc
from pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprint
-from pipelex.pipe_operators.func.pipe_func_factory import PipeFuncFactory
from pipelex.pipe_run.pipe_job_factory import PipeJobFactory
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
@@ -64,8 +65,8 @@ if __name__ == "__main__":
)
pipe_job = PipeJobFactory.make_pipe_job(
- pipe=PipeFuncFactory.make_from_blueprint(
- domain="source_code",
+ pipe=PipeFactory[PipeFunc].make_from_blueprint(
+ domain_code="source_code",
pipe_code="wrap_lines",
blueprint=pipe_func_blueprint,
),
diff --git a/tests/integration/pipelex/pipes/operator/pipe_img_gen/test_pipe_img_gen_run.py b/tests/integration/pipelex/pipes/operator/pipe_img_gen/test_pipe_img_gen_run.py
index 8e3b56b9d..ca6fa93a2 100644
--- a/tests/integration/pipelex/pipes/operator/pipe_img_gen/test_pipe_img_gen_run.py
+++ b/tests/integration/pipelex/pipes/operator/pipe_img_gen/test_pipe_img_gen_run.py
@@ -1,20 +1,18 @@
-from typing import TYPE_CHECKING, Callable, cast
+from typing import Callable, cast
import pytest
from pipelex import pretty_print
from pipelex.core.concepts.native.concept_native import NativeConceptCode
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.hub import get_pipe_router
+from pipelex.pipe_operators.img_gen.pipe_img_gen import PipeImgGen, PipeImgGenOutput
from pipelex.pipe_operators.img_gen.pipe_img_gen_blueprint import PipeImgGenBlueprint
-from pipelex.pipe_operators.img_gen.pipe_img_gen_factory import PipeImgGenFactory
from pipelex.pipe_run.pipe_job_factory import PipeJobFactory
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
from tests.integration.pipelex.test_data import ImageGenTestCases
-if TYPE_CHECKING:
- from pipelex.pipe_operators.img_gen.pipe_img_gen import PipeImgGenOutput
-
@pytest.mark.dry_runnable
@pytest.mark.img_gen
@@ -38,8 +36,8 @@ class TestPipeImgGenRun:
)
pipe_job = PipeJobFactory.make_pipe_job(
- pipe=PipeImgGenFactory.make_from_blueprint(
- domain="generic",
+ pipe=PipeFactory[PipeImgGen].make_from_blueprint(
+ domain_code="generic",
pipe_code="adhoc_for_test_pipe_img_gen",
blueprint=pipe_img_gen_blueprint,
),
diff --git a/tests/integration/pipelex/pipes/operator/pipe_llm/test_pipe_llm.py b/tests/integration/pipelex/pipes/operator/pipe_llm/test_pipe_llm.py
index 7522405f3..68e4e1253 100644
--- a/tests/integration/pipelex/pipes/operator/pipe_llm/test_pipe_llm.py
+++ b/tests/integration/pipelex/pipes/operator/pipe_llm/test_pipe_llm.py
@@ -6,12 +6,13 @@ import pytest
from pipelex import log, pretty_print
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.stuff import Stuff
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.core.stuffs.text_content import TextContent
from pipelex.hub import get_class_registry, get_native_concept, get_pipe_library, get_pipe_router
+from pipelex.pipe_operators.llm.pipe_llm import PipeLLM
from pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint, StructuringMethod
-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactory
from pipelex.pipe_run.pipe_job_factory import PipeJobFactory
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
@@ -35,8 +36,8 @@ class TestPipeLLMBasic:
system_prompt=PipeTestCases.SYSTEM_PROMPT,
prompt=PipeTestCases.USER_PROMPT,
)
- pipe = PipeLLMFactory.make_from_blueprint(
- domain="documents",
+ pipe = PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="documents",
pipe_code="adhoc_for_test_pipe_llm",
blueprint=pipe_llm_blueprint,
)
@@ -110,8 +111,8 @@ class TestPipeLLMBasic:
pipe_code = f"extract_{topic}_{concept}_{structuring_method}"
pipe_code = pipe_code.lower().replace(" ", "_")
- pipe = PipeLLMFactory.make_from_blueprint(
- domain="test_structured_generations",
+ pipe = PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="test_structured_generations",
pipe_code=pipe_code,
blueprint=pipe_llm_blueprint,
)
@@ -169,8 +170,8 @@ class TestPipeLLMBasic:
pipe_job = PipeJobFactory.make_pipe_job(
working_memory=working_memory,
- pipe=PipeLLMFactory.make_from_blueprint(
- domain="generic",
+ pipe=PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="generic",
pipe_code="adhoc_for_test_pipe_llm_image",
blueprint=pipe_llm_blueprint,
),
diff --git a/tests/integration/pipelex/pipes/test_bracket_notation_controllers.py b/tests/integration/pipelex/pipes/test_bracket_notation_controllers.py
index 28ee6e484..32b2536c2 100644
--- a/tests/integration/pipelex/pipes/test_bracket_notation_controllers.py
+++ b/tests/integration/pipelex/pipes/test_bracket_notation_controllers.py
@@ -1,17 +1,16 @@
-"""Integration tests for bracket notation in controller pipe factories."""
-
from typing import Callable
from pipelex.core.concepts.concept_blueprint import ConceptBlueprint
from pipelex.core.concepts.concept_factory import ConceptFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.hub import get_concept_library
+from pipelex.pipe_controllers.batch.pipe_batch import PipeBatch
from pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprint
-from pipelex.pipe_controllers.batch.pipe_batch_factory import PipeBatchFactory
+from pipelex.pipe_controllers.condition.pipe_condition import PipeCondition
from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint
-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactory
from pipelex.pipe_controllers.condition.special_outcome import SpecialOutcome
+from pipelex.pipe_controllers.parallel.pipe_parallel import PipeParallel
from pipelex.pipe_controllers.parallel.pipe_parallel_blueprint import PipeParallelBlueprint
-from pipelex.pipe_controllers.parallel.pipe_parallel_factory import PipeParallelFactory
class TestBracketNotationInControllers:
@@ -23,13 +22,18 @@ class TestBracketNotationInControllers:
domain = "test"
concept_library = get_concept_library()
- concept_1 = ConceptFactory.make_from_blueprint(
+ concept_data_item = ConceptFactory.make_from_blueprint(
concept_code="DataItem",
domain=domain,
blueprint=ConceptBlueprint(description="Data item"),
- concept_codes_from_the_same_domain=["DataItem"],
)
- concept_library.add_concepts([concept_1])
+ concept_library.add_concepts([concept_data_item])
+ concept_processed_data = ConceptFactory.make_from_blueprint(
+ concept_code="ProcessedData",
+ domain=domain,
+ blueprint=ConceptBlueprint(description="Processed data"),
+ )
+ concept_library.add_concepts([concept_processed_data])
blueprint = PipeParallelBlueprint(
description="Process items in parallel",
@@ -39,10 +43,11 @@ class TestBracketNotationInControllers:
add_each_output=True,
)
- pipe = PipeParallelFactory.make_from_blueprint(
- domain=domain,
+ pipe = PipeFactory[PipeParallel].make_from_blueprint(
+ domain_code=domain,
pipe_code="test_parallel",
blueprint=blueprint,
+ concept_codes_from_the_same_domain=[concept_data_item.code, concept_processed_data.code],
)
assert pipe.inputs.root["data"].multiplicity == 2
@@ -60,13 +65,11 @@ class TestBracketNotationInControllers:
concept_code="Category",
domain=domain,
blueprint=ConceptBlueprint(description="Category"),
- concept_codes_from_the_same_domain=["Category"],
)
concept_2 = ConceptFactory.make_from_blueprint(
concept_code="Result",
domain=domain,
blueprint=ConceptBlueprint(description="Result"),
- concept_codes_from_the_same_domain=["Result"],
)
concept_library.add_concepts([concept_1, concept_2])
@@ -79,10 +82,11 @@ class TestBracketNotationInControllers:
default_outcome=SpecialOutcome.CONTINUE,
)
- pipe = PipeConditionFactory.make_from_blueprint(
- domain=domain,
+ pipe = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code=domain,
pipe_code="test_condition",
blueprint=blueprint,
+ concept_codes_from_the_same_domain=[concept_1.code, concept_2.code],
)
assert pipe.inputs.root["items"].multiplicity is True
@@ -96,13 +100,17 @@ class TestBracketNotationInControllers:
domain = "test"
concept_library = get_concept_library()
- concept_1 = ConceptFactory.make_from_blueprint(
+ concept_item = ConceptFactory.make_from_blueprint(
concept_code="Item",
domain=domain,
blueprint=ConceptBlueprint(description="Item"),
- concept_codes_from_the_same_domain=["Item"],
)
- concept_library.add_concepts([concept_1])
+ concept_processed_item = ConceptFactory.make_from_blueprint(
+ concept_code="ProcessedItem",
+ domain=domain,
+ blueprint=ConceptBlueprint(description="Processed item"),
+ )
+ concept_library.add_concepts([concept_item, concept_processed_item])
blueprint = PipeBatchBlueprint(
description="Batch process items",
@@ -113,10 +121,11 @@ class TestBracketNotationInControllers:
input_item_name="item",
)
- pipe = PipeBatchFactory.make_from_blueprint(
- domain=domain,
+ pipe = PipeFactory[PipeBatch].make_from_blueprint(
+ domain_code=domain,
pipe_code="test_batch",
blueprint=blueprint,
+ concept_codes_from_the_same_domain=[concept_item.code, concept_processed_item.code],
)
assert pipe.inputs.root["items"].multiplicity is True
diff --git a/tests/integration/pipelex/pipes/test_bracket_notation_operators/test_bracket_notation_operators.py b/tests/integration/pipelex/pipes/test_bracket_notation_operators/test_bracket_notation_operators.py
index f47f54262..4a4e4f999 100644
--- a/tests/integration/pipelex/pipes/test_bracket_notation_operators/test_bracket_notation_operators.py
+++ b/tests/integration/pipelex/pipes/test_bracket_notation_operators/test_bracket_notation_operators.py
@@ -1,22 +1,21 @@
-"""Integration tests for bracket notation in operator pipe factories."""
-
from pathlib import Path
from typing import Callable
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.memory.working_memory import WorkingMemory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.list_content import ListContent
from pipelex.core.stuffs.text_content import TextContent
+from pipelex.pipe_operators.compose.pipe_compose import PipeCompose
from pipelex.pipe_operators.compose.pipe_compose_blueprint import PipeComposeBlueprint
-from pipelex.pipe_operators.compose.pipe_compose_factory import PipeComposeFactory
+from pipelex.pipe_operators.extract.pipe_extract import PipeExtract
from pipelex.pipe_operators.extract.pipe_extract_blueprint import PipeExtractBlueprint
-from pipelex.pipe_operators.extract.pipe_extract_factory import PipeExtractFactory
+from pipelex.pipe_operators.func.pipe_func import PipeFunc
from pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprint
-from pipelex.pipe_operators.func.pipe_func_factory import PipeFuncFactory
+from pipelex.pipe_operators.img_gen.pipe_img_gen import PipeImgGen
from pipelex.pipe_operators.img_gen.pipe_img_gen_blueprint import PipeImgGenBlueprint
-from pipelex.pipe_operators.img_gen.pipe_img_gen_factory import PipeImgGenFactory
+from pipelex.pipe_operators.llm.pipe_llm import PipeLLM
from pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint
-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactory
from pipelex.system.registries.func_registry import pipe_func
@@ -44,8 +43,8 @@ class TestBracketNotationInOperators:
prompt="Generate items about $topic",
)
- pipe = PipeLLMFactory.make_from_blueprint(
- domain="test",
+ pipe = PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="test",
pipe_code="test_llm",
blueprint=blueprint,
)
@@ -63,8 +62,8 @@ class TestBracketNotationInOperators:
prompt="Generate 5 items",
)
- pipe = PipeLLMFactory.make_from_blueprint(
- domain="test",
+ pipe = PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="test",
pipe_code="test_llm",
blueprint=blueprint,
)
@@ -82,8 +81,8 @@ class TestBracketNotationInOperators:
prompt="Summarize @documents based on $query",
)
- pipe = PipeLLMFactory.make_from_blueprint(
- domain="test",
+ pipe = PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="test",
pipe_code="test_llm",
blueprint=blueprint,
)
@@ -102,8 +101,8 @@ class TestBracketNotationInOperators:
output=f"{NativeConceptCode.IMAGE}[3]",
)
- pipe = PipeImgGenFactory.make_from_blueprint(
- domain="test",
+ pipe = PipeFactory[PipeImgGen].make_from_blueprint(
+ domain_code="test",
pipe_code="test_img_gen",
blueprint=blueprint,
)
@@ -121,8 +120,8 @@ class TestBracketNotationInOperators:
function_name="process_function",
)
- pipe = PipeFuncFactory.make_from_blueprint(
- domain="test",
+ pipe = PipeFactory[PipeFunc].make_from_blueprint(
+ domain_code="test",
pipe_code="test_func",
blueprint=blueprint,
)
@@ -140,8 +139,8 @@ class TestBracketNotationInOperators:
template="<ul>{% for item in items %}<li>{{ item }}</li>{% endfor %}</ul>",
)
- pipe = PipeComposeFactory.make_from_blueprint(
- domain="test",
+ pipe = PipeFactory[PipeCompose].make_from_blueprint(
+ domain_code="test",
pipe_code="test_compose",
blueprint=blueprint,
)
@@ -158,8 +157,8 @@ class TestBracketNotationInOperators:
output=f"{NativeConceptCode.PAGE}[]", # Extract returns list of pages
)
- pipe = PipeExtractFactory.make_from_blueprint(
- domain="test",
+ pipe = PipeFactory[PipeExtract].make_from_blueprint(
+ domain_code="test",
pipe_code="test_extract",
blueprint=blueprint,
)
diff --git a/tests/integration/pipelex/pipes/test_image_inputs.py b/tests/integration/pipelex/pipes/test_image_inputs.py
index 333d24af5..98f49d684 100644
--- a/tests/integration/pipelex/pipes/test_image_inputs.py
+++ b/tests/integration/pipelex/pipes/test_image_inputs.py
@@ -7,14 +7,15 @@ from pytest import FixtureRequest
from pipelex.core.concepts.concept_factory import ConceptFactory
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.image_content import ImageContent
from pipelex.core.stuffs.page_content import PageContent
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.core.stuffs.text_and_images_content import TextAndImagesContent
from pipelex.core.stuffs.text_content import TextContent
from pipelex.hub import get_native_concept, get_pipe_router, get_required_pipe
+from pipelex.pipe_operators.llm.pipe_llm import PipeLLM
from pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint
-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactory
from pipelex.pipe_run.pipe_job_factory import PipeJobFactory
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
@@ -118,8 +119,8 @@ class TestImageInputs:
prompt="Describe the page: @page",
)
- pipe_llm = PipeLLMFactory.make_from_blueprint(
- domain="test_pipes",
+ pipe_llm = PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="test_pipes",
pipe_code="test_image_input_within_concept_with_text",
blueprint=pipe_llm_blueprint,
)
diff --git a/tests/integration/pipelex/pipes/test_pipe_compose.py b/tests/integration/pipelex/pipes/test_pipe_compose.py
index 735e7bd61..dd8320208 100644
--- a/tests/integration/pipelex/pipes/test_pipe_compose.py
+++ b/tests/integration/pipelex/pipes/test_pipe_compose.py
@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Callable, cast
+from typing import Callable, cast
import pytest
@@ -8,19 +8,17 @@ from pipelex.cogt.templating.template_category import TemplateCategory
from pipelex.cogt.templating.templating_style import TagStyle, TemplatingStyle, TextFormat
from pipelex.core.concepts.native.concept_native import NativeConceptCode
from pipelex.core.memory.working_memory_factory import WorkingMemoryFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.core.stuffs.stuff_factory import StuffFactory
from pipelex.core.stuffs.text_content import TextContent
from pipelex.hub import get_native_concept, get_pipe_router
+from pipelex.pipe_operators.compose.pipe_compose import PipeCompose, PipeComposeOutput
from pipelex.pipe_operators.compose.pipe_compose_blueprint import PipeComposeBlueprint
-from pipelex.pipe_operators.compose.pipe_compose_factory import PipeComposeFactory
from pipelex.pipe_run.pipe_job_factory import PipeJobFactory
from pipelex.pipe_run.pipe_run_params import PipeRunMode
from pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactory
from tests.cases import JINJA2TestCases
-if TYPE_CHECKING:
- from pipelex.pipe_operators.compose.pipe_compose import PipeComposeOutput
-
@pytest.mark.dry_runnable
@pytest.mark.asyncio(loop_scope="class")
@@ -45,8 +43,8 @@ class TestPipeCompose:
)
pipe_job = PipeJobFactory.make_pipe_job(
- pipe=PipeComposeFactory.make_from_blueprint(
- domain="generic",
+ pipe=PipeFactory[PipeCompose].make_from_blueprint(
+ domain_code="generic",
pipe_code="adhoc_for_test_pipe_compose_for_any",
blueprint=pipe_compose_blueprint,
),
@@ -84,8 +82,8 @@ class TestPipeCompose:
)
pipe_job = PipeJobFactory.make_pipe_job(
- pipe=PipeComposeFactory.make_from_blueprint(
- domain="generic",
+ pipe=PipeFactory[PipeCompose].make_from_blueprint(
+ domain_code="generic",
pipe_code="adhoc_for_test_pipe_compose",
blueprint=pipe_compose_blueprint,
),
diff --git a/tests/integration/pipelex/plugins/test_external_plugin.py b/tests/integration/pipelex/plugins/test_external_plugin.py
index 36c758cca..de1242213 100644
--- a/tests/integration/pipelex/plugins/test_external_plugin.py
+++ b/tests/integration/pipelex/plugins/test_external_plugin.py
@@ -13,9 +13,10 @@ from pipelex.cogt.llm.llm_setting import LLMSetting
from pipelex.cogt.llm.llm_worker_abstract import LLMWorkerAbstract
from pipelex.cogt.usage.token_category import NbTokensByCategoryDict, TokenCategory
from pipelex.core.concepts.native.concept_native import NativeConceptCode
+from pipelex.core.pipes.pipe_factory import PipeFactory
from pipelex.hub import get_inference_manager, get_pipe_router, get_report_delegate
+from pipelex.pipe_operators.llm.pipe_llm import PipeLLM
from pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint
-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactory
from pipelex.pipe_run.pipe_job_factory import PipeJobFactory
from pipelex.tools.typing.pydantic_utils import BaseModelTypeVar
from tests.integration.pipelex.cogt.test_data import LLMTestConstants, Person
@@ -109,8 +110,8 @@ class TestExternalPlugin:
)
pipe_job = PipeJobFactory.make_pipe_job(
- pipe=PipeLLMFactory.make_from_blueprint(
- domain="generic",
+ pipe=PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="generic",
pipe_code="adhoc_for_test_pipe_llm_with_external_llm_handle",
blueprint=pipe_llm_blueprint,
),
diff --git a/tests/integration/pipelex/test_inline_structure_concepts.py b/tests/integration/pipelex/test_inline_structure_concepts.py
index 24c733ba2..f15d2806d 100644
--- a/tests/integration/pipelex/test_inline_structure_concepts.py
+++ b/tests/integration/pipelex/test_inline_structure_concepts.py
@@ -51,7 +51,6 @@ class TestInlineStructureConcepts:
domain="test_domain",
concept_code="TestFeatureAnalysis",
blueprint=blueprint,
- concept_codes_from_the_same_domain=["TestFeatureAnalysis"],
)
# Verify concept properties
@@ -92,7 +91,6 @@ class TestInlineStructureConcepts:
domain="test_domain",
concept_code="TestStringRef",
blueprint=blueprint,
- concept_codes_from_the_same_domain=["TestStringRef"],
)
# Verify concept properties
@@ -111,7 +109,6 @@ class TestInlineStructureConcepts:
domain="test_domain",
concept_code="TestAutoDetect",
blueprint=blueprint,
- concept_codes_from_the_same_domain=["TestAutoDetect"],
)
# Should default to TextContent since TestAutoDetect is not a registered class
@@ -149,7 +146,6 @@ class TestInlineStructureConcepts:
domain="test_domain",
concept_code="ComplexDocument",
blueprint=blueprint,
- concept_codes_from_the_same_domain=["ComplexDocument"],
)
# Verify concept creation
@@ -188,7 +184,6 @@ not a registered subclass of StuffContent",
domain="test_domain",
concept_code="TestInvalidRef",
blueprint=ConceptBlueprint(description="Test invalid reference", structure="NonExistentClass"),
- concept_codes_from_the_same_domain=["TestInvalidRef"],
)
def test_multiple_inline_structures_do_not_conflict(self):
@@ -204,7 +199,6 @@ not a registered subclass of StuffContent",
domain="test_domain",
concept_code="Person",
blueprint=blueprint1,
- concept_codes_from_the_same_domain=["Person"],
)
# Second structure with same field names but different context
@@ -218,7 +212,6 @@ not a registered subclass of StuffContent",
domain="test_domain",
concept_code="Product",
blueprint=blueprint2,
- concept_codes_from_the_same_domain=["Product"],
)
# Both should be created successfully
@@ -269,7 +262,6 @@ not a registered subclass of StuffContent",
domain="test_domain",
concept_code="AnimalInfo",
blueprint=blueprint,
- concept_codes_from_the_same_domain=["AnimalInfo"],
)
# Verify concept properties
diff --git a/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_batch/test_data.py b/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_batch/test_data.py
index c0f05dbde..f9479d303 100644
--- a/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_batch/test_data.py
+++ b/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_batch/test_data.py
@@ -20,8 +20,6 @@ class PipeBatchTestCases:
description="Batch with custom names",
inputs={"data": "DataList"},
output="Results",
- type="PipeBatch",
- pipe_category="PipeController",
branch_pipe_code="transform_data",
input_list_name="data_list",
input_item_name="current_data",
diff --git a/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_condition/test_data.py b/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_condition/test_data.py
index 65ac95d34..5a8f41e82 100644
--- a/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_condition/test_data.py
+++ b/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_condition/test_data.py
@@ -24,8 +24,6 @@ class PipeConditionTestCases:
description="Conditional with template",
inputs={"item": "Item"},
output="native.Anything",
- type="PipeCondition",
- pipe_category="PipeController",
expression=None,
expression_template="{{ item.category }}",
outcomes={
diff --git a/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_parallel/test_data.py b/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_parallel/test_data.py
index d616eed43..97d9a0696 100644
--- a/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_parallel/test_data.py
+++ b/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_parallel/test_data.py
@@ -25,8 +25,6 @@ class PipeParallelTestCases:
description="Run pipes in parallel",
inputs={"data": "Data"},
output="Results",
- type="PipeParallel",
- pipe_category="PipeController",
parallels=[
SubPipeBlueprint(pipe="analyze_data", result="analysis"),
SubPipeBlueprint(pipe="transform_data", result="transformed"),
@@ -56,8 +54,6 @@ class PipeParallelTestCases:
description="Parallel with combined output",
inputs={"input": "Input"},
output="CombinedResult",
- type="PipeParallel",
- pipe_category="PipeController",
parallels=[
SubPipeBlueprint(pipe="pipe1", result="result1"),
SubPipeBlueprint(pipe="pipe2", result="result2"),
@@ -86,8 +82,6 @@ class PipeParallelTestCases:
description="Parallel with combined output",
inputs={"input": "Input"},
output="CombinedResult",
- type="PipeParallel",
- pipe_category="PipeController",
parallels=[
SubPipeBlueprint(pipe="pipe1", result="result1"),
SubPipeBlueprint(pipe="pipe2", result="result2"),
diff --git a/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_sequence/test_data.py b/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_sequence/test_data.py
index fb597ec92..b369447b1 100644
--- a/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_sequence/test_data.py
+++ b/tests/unit/pipelex/builder/pipe/pipe_controller/pipe_sequence/test_data.py
@@ -24,8 +24,6 @@ class PipeSequenceTestCases:
description="A sequence of operations",
inputs={"input_data": "Text"},
output="ProcessedData",
- type="PipeSequence",
- pipe_category="PipeController",
steps=[
SubPipeBlueprint(pipe="step1", result="result1"),
SubPipeBlueprint(pipe="step2", result="result2"),
diff --git a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_compose/test_data.py b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_compose/test_data.py
index 8ade49b9f..b0abde695 100644
--- a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_compose/test_data.py
+++ b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_compose/test_data.py
@@ -22,8 +22,6 @@ class PipeComposeTestCases:
description="Render a template",
inputs={"data": "Data"},
output="RenderedText",
- type="PipeCompose",
- pipe_category="PipeOperator",
template=TemplateBlueprint(
template="Hello {{ data.name }}!",
category=TemplateCategory.MARKDOWN,
diff --git a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_extract/test_data.py b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_extract/test_data.py
index cb9e558d3..05caa098f 100644
--- a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_extract/test_data.py
+++ b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_extract/test_data.py
@@ -19,8 +19,6 @@ class PipeExtractTestCases:
description="Extract text from image",
inputs={"image": "Image"},
output="Page[]",
- type="PipeExtract",
- pipe_category="PipeOperator",
model=ExtractSkill.EXTRACT_TEXT_FROM_VISUALS,
),
)
@@ -42,8 +40,6 @@ class PipeExtractTestCases:
description="Extract with page options",
inputs={"document": "PDF"},
output="Page[]",
- type="PipeExtract",
- pipe_category="PipeOperator",
model=ExtractSkill.EXTRACT_TEXT_FROM_PDF,
page_images=True,
page_image_captions=True,
diff --git a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_func/test_data.py b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_func/test_data.py
index 2583fcaae..1b8f6ab61 100644
--- a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_func/test_data.py
+++ b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_func/test_data.py
@@ -18,8 +18,6 @@ class PipeFuncTestCases:
description="Execute a function",
inputs={"data": "Data"},
output="ProcessedData",
- type="PipeFunc",
- pipe_category="PipeOperator",
function_name="process_data",
),
)
@@ -37,8 +35,6 @@ class PipeFuncTestCases:
description="Generate data",
inputs=None,
output="GeneratedData",
- type="PipeFunc",
- pipe_category="PipeOperator",
function_name="generate_data",
),
)
diff --git a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_img_gen/test_data.py b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_img_gen/test_data.py
index 82c4d216d..6e670b907 100644
--- a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_img_gen/test_data.py
+++ b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_img_gen/test_data.py
@@ -18,8 +18,6 @@ class PipeImgGenTestCases:
description="Generate an image",
inputs={"my_prompt": "Text"},
output="native.Image",
- type="PipeImgGen",
- pipe_category="PipeOperator",
img_gen_prompt_var_name="my_prompt",
model=ImgGenSkill.GEN_IMAGE_BASIC,
aspect_ratio=None,
@@ -43,8 +41,6 @@ class PipeImgGenTestCases:
description="Generate image with options",
inputs={"description": "Text"},
output="Image[3]",
- type="PipeImgGen",
- pipe_category="PipeOperator",
img_gen_prompt=None,
model=ImgGenSkill.GEN_IMAGE_FAST,
aspect_ratio=None,
diff --git a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_llm/test_pipe_llm.py b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_llm/test_pipe_llm.py
index 14fff9054..9bbf321ed 100644
--- a/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_llm/test_pipe_llm.py
+++ b/tests/unit/pipelex/builder/pipe/pipe_operator/pipe_llm/test_pipe_llm.py
@@ -4,8 +4,11 @@ import pytest
from pipelex import pretty_print
from pipelex.builder.pipe.pipe_llm_spec import PipeLLMSpec
+from pipelex.core.concepts.concept_factory import ConceptFactory
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.hub import get_concept_library
+from pipelex.pipe_operators.llm.pipe_llm import PipeLLM
from pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint
-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactory
from tests.unit.pipelex.builder.pipe.pipe_operator.pipe_llm.test_data import PipeLLMTestCases
@@ -15,15 +18,24 @@ class TestPipeLLMBlueprintConversion:
PipeLLMTestCases.TEST_CASES,
)
def test_pipe_llm_spec_to_blueprint(
- self, test_name: str, pipe_spec: PipeLLMSpec, expected_blueprint: PipeLLMBlueprint, load_empty_library: Callable[[], None]
+ self, test_name: str, pipe_spec: PipeLLMSpec, expected_blueprint: PipeLLMBlueprint, load_empty_library: Callable[[], str]
):
load_empty_library()
+ item_concept = ConceptFactory.make(concept_code="Item", domain="test_domain", description="Item", structure_class_name="Item")
+ data_concept = ConceptFactory.make(concept_code="Data", domain="test_domain", description="Data", structure_class_name="Data")
+ analysis_concept = ConceptFactory.make(concept_code="Analysis", domain="test_domain", description="Analysis", structure_class_name="Analysis")
+ concept_library = get_concept_library()
+ concept_library.add_new_concept(concept=item_concept)
+ concept_library.add_new_concept(concept=data_concept)
+ concept_library.add_new_concept(concept=analysis_concept)
+
blueprint = pipe_spec.to_blueprint()
assert blueprint == expected_blueprint
- pipe_llm_from_blueprint = PipeLLMFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_llm = PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_name}",
blueprint=blueprint,
+ concept_codes_from_the_same_domain=[data_concept.code, item_concept.code, analysis_concept.code],
)
- pretty_print(pipe_llm_from_blueprint, title="PipeLLM from blueprint")
+ pretty_print(pipe_llm, title="PipeLLM from blueprint")
diff --git a/tests/unit/pipelex/core/bundles/test_data_pipe_sorter.py b/tests/unit/pipelex/core/bundles/test_data_pipe_sorter.py
index b6c48bddd..ce04e1ff0 100644
--- a/tests/unit/pipelex/core/bundles/test_data_pipe_sorter.py
+++ b/tests/unit/pipelex/core/bundles/test_data_pipe_sorter.py
@@ -18,26 +18,22 @@ class PipeSorterTestCases:
# Test case 1: No dependencies - all operators
NO_DEPENDENCIES_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
- "pipe_c": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="C", inputs={}, output="Text"),
- "pipe_a": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="A", inputs={}, output="Text"),
- "pipe_b": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="B", inputs={}, output="Text"),
+ "pipe_c": PipeLLMBlueprint(description="C", inputs={}, output="Text"),
+ "pipe_a": PipeLLMBlueprint(description="A", inputs={}, output="Text"),
+ "pipe_b": PipeLLMBlueprint(description="B", inputs={}, output="Text"),
}
NO_DEPENDENCIES_EXPECTED: ClassVar[list[str]] = ["pipe_a", "pipe_b", "pipe_c"] # Alphabetical order (all are roots)
# Test case 2: Simple chain A -> B -> C
SIMPLE_CHAIN_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
"pipe_c": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="C depends on B",
inputs={},
output="Text",
steps=[SubPipeBlueprint(pipe="pipe_b", result="result_b")],
),
- "pipe_a": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="A no deps", inputs={}, output="Text"),
+ "pipe_a": PipeLLMBlueprint(description="A no deps", inputs={}, output="Text"),
"pipe_b": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="B depends on A",
inputs={},
output="Text",
@@ -54,8 +50,6 @@ class PipeSorterTestCases:
# D
DIAMOND_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
"pipe_d": PipeParallelBlueprint(
- type="PipeParallel",
- pipe_category="PipeController",
description="D depends on B and C",
inputs={},
output="Text",
@@ -65,18 +59,14 @@ class PipeSorterTestCases:
],
add_each_output=True,
),
- "pipe_a": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="A", inputs={}, output="Text"),
+ "pipe_a": PipeLLMBlueprint(description="A", inputs={}, output="Text"),
"pipe_c": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="C depends on A",
inputs={},
output="Text",
steps=[SubPipeBlueprint(pipe="pipe_a", result="result_a")],
),
"pipe_b": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="B depends on A",
inputs={},
output="Text",
@@ -91,24 +81,20 @@ class PipeSorterTestCases:
MULTIPLE_CHAINS_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
# Chain 1: A -> B
"pipe_b": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="B depends on A",
inputs={},
output="Text",
steps=[SubPipeBlueprint(pipe="pipe_a", result="result_a")],
),
- "pipe_a": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="A", inputs={}, output="Text"),
+ "pipe_a": PipeLLMBlueprint(description="A", inputs={}, output="Text"),
# Chain 2: X -> Y
"pipe_y": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="Y depends on X",
inputs={},
output="Text",
steps=[SubPipeBlueprint(pipe="pipe_x", result="result_x")],
),
- "pipe_x": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="X", inputs={}, output="Text"),
+ "pipe_x": PipeLLMBlueprint(description="X", inputs={}, output="Text"),
}
# Depth-first from roots (pipe_b, pipe_y alphabetically): pipe_b -> pipe_a, then pipe_y -> pipe_x
MULTIPLE_CHAINS_EXPECTED: ClassVar[list[str]] = ["pipe_b", "pipe_a", "pipe_y", "pipe_x"]
@@ -116,8 +102,6 @@ class PipeSorterTestCases:
# Test case 5: PipeBatch dependency
PIPE_BATCH_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
"batch_pipe": PipeBatchBlueprint(
- type="PipeBatch",
- pipe_category="PipeController",
description="Batch depends on process",
inputs={},
output="Text",
@@ -125,15 +109,13 @@ class PipeSorterTestCases:
input_list_name="items",
input_item_name="item",
),
- "process_item": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="Process", inputs={}, output="Text"),
+ "process_item": PipeLLMBlueprint(description="Process", inputs={}, output="Text"),
}
PIPE_BATCH_EXPECTED: ClassVar[list[str]] = ["batch_pipe", "process_item"]
# Test case 6: PipeCondition with multiple branches
PIPE_CONDITION_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
"router": PipeConditionBlueprint(
- type="PipeCondition",
- pipe_category="PipeController",
description="Routes to different pipes",
inputs={},
output="Text",
@@ -144,9 +126,9 @@ class PipeSorterTestCases:
},
default_outcome="process_default",
),
- "process_large": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="Large", inputs={}, output="Text"),
- "process_small": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="Small", inputs={}, output="Text"),
- "process_default": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="Default", inputs={}, output="Text"),
+ "process_large": PipeLLMBlueprint(description="Large", inputs={}, output="Text"),
+ "process_small": PipeLLMBlueprint(description="Small", inputs={}, output="Text"),
+ "process_default": PipeLLMBlueprint(description="Default", inputs={}, output="Text"),
}
# Router first, then its dependencies in alphabetical order
PIPE_CONDITION_EXPECTED: ClassVar[list[str]] = ["router", "process_default", "process_large", "process_small"]
@@ -154,24 +136,18 @@ class PipeSorterTestCases:
# Test case 7: Circular dependency (should raise error)
CIRCULAR_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
"pipe_a": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="A depends on C (circular!)",
inputs={},
output="Text",
steps=[SubPipeBlueprint(pipe="pipe_c", result="result_c")],
),
"pipe_b": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="B depends on A",
inputs={},
output="Text",
steps=[SubPipeBlueprint(pipe="pipe_a", result="result_a")],
),
"pipe_c": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="C depends on B",
inputs={},
output="Text",
@@ -182,8 +158,6 @@ class PipeSorterTestCases:
# Test case 8: Reference to non-existent pipe (should be ignored in sorting)
MISSING_DEPENDENCY_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
"pipe_b": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="B depends on A and Z (Z doesn't exist)",
inputs={},
output="Text",
@@ -192,43 +166,33 @@ class PipeSorterTestCases:
SubPipeBlueprint(pipe="pipe_z", result="result_z"), # Z doesn't exist in this bundle
],
),
- "pipe_a": PipeLLMBlueprint(type="PipeLLM", pipe_category="PipeOperator", description="A", inputs={}, output="Text"),
+ "pipe_a": PipeLLMBlueprint(description="A", inputs={}, output="Text"),
}
MISSING_DEPENDENCY_EXPECTED: ClassVar[list[str]] = ["pipe_b", "pipe_a"] # Z is ignored as it's not in the bundle
# Test case 9: Image inversion pipeline - realistic multi-step sequence
IMAGE_INVERSION_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
"analyze_image_content": PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description="Analyzes the input photo to understand visual elements, composition, mood, etc.",
inputs={"input_photo": "Image"},
output="ImageAnalysis",
),
"define_opposite_concept": PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description="Determines what constitutes the opposite for the analyzed image",
inputs={"image_analysis": "ImageAnalysis"},
output="OppositeDefinition",
),
"generate_image_prompt": PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description="Crafts a detailed image generation prompt from the opposite definition",
inputs={"opposite_definition": "OppositeDefinition"},
output="ImagePrompt",
),
"generate_opposite_image": PipeImgGenBlueprint(
- type="PipeImgGen",
- pipe_category="PipeOperator",
description="Generates the opposite image using AI",
inputs={"generation_prompt": "ImagePrompt"},
output="Image",
),
"photo_opposite_pipeline": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="Main pipeline that generates the opposite of an input photo",
inputs={"input_photo": "Image"},
output="Image",
@@ -253,8 +217,6 @@ class PipeSorterTestCases:
COMPLEX_NESTED_PIPES: ClassVar[dict[str, PipeBlueprintUnion]] = {
# Main sequence with nested controllers
"main_pipeline": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="Main pipeline with nested controllers",
inputs={"input": "Text"},
output="Text",
@@ -266,8 +228,6 @@ class PipeSorterTestCases:
),
# Nested sequence
"nested_sequence": PipeSequenceBlueprint(
- type="PipeSequence",
- pipe_category="PipeController",
description="Nested preparation sequence",
inputs={"input": "Text"},
output="Text",
@@ -278,8 +238,6 @@ class PipeSorterTestCases:
),
# Condition router
"router": PipeConditionBlueprint(
- type="PipeCondition",
- pipe_category="PipeController",
description="Routes based on size",
inputs={"prepared": "Text"},
output="Text",
@@ -292,43 +250,31 @@ class PipeSorterTestCases:
),
# LLM operators
"prepare_data": PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description="Prepare the data",
inputs={"input": "Text"},
output="Text",
),
"validate_data": PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description="Validate the prepared data",
inputs={"prepared_data": "Text"},
output="Text",
),
"process_small": PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description="Process small items",
inputs={"item": "Text"},
output="Text",
),
"process_large": PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description="Process large items",
inputs={"item": "Text"},
output="Text",
),
"process_default": PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description="Default processing",
inputs={"item": "Text"},
output="Text",
),
"final_process": PipeLLMBlueprint(
- type="PipeLLM",
- pipe_category="PipeOperator",
description="Final processing step",
inputs={"processed": "Text"},
output="Text",
diff --git a/tests/unit/pipelex/core/concepts/concept_factory/data.py b/tests/unit/pipelex/core/concepts/concept_factory/data.py
index 7b3bcbd7c..c51ac573e 100644
--- a/tests/unit/pipelex/core/concepts/concept_factory/data.py
+++ b/tests/unit/pipelex/core/concepts/concept_factory/data.py
@@ -35,113 +35,39 @@ class TestCases:
]
# Test cases for make_domain_and_concept_code_from_concept_string_or_concept_code method
- MAKE_DOMAIN_AND_CONCEPT_CODE_TEST_CASES: ClassVar[list[tuple[str, str, list[str] | None, DomainAndConceptCode]]] = [
+ MAKE_DOMAIN_AND_CONCEPT_CODE_TEST_CASES: ClassVar[list[tuple[str, str, DomainAndConceptCode]]] = [
# Test case 1: Concept string with dot notation
- ("my_domain", "other_domain.ConceptName", None, DomainAndConceptCode(domain="other_domain", concept_code="ConceptName")),
+ ("my_domain", "other_domain.ConceptName", DomainAndConceptCode(domain="other_domain", concept_code="ConceptName")),
# Test case 2: Concept string with dot notation (ignores same domain codes)
- ("my_domain", "other_domain.ConceptName", ["ConceptName"], DomainAndConceptCode(domain="other_domain", concept_code="ConceptName")),
+ ("my_domain", "other_domain.ConceptName", DomainAndConceptCode(domain="other_domain", concept_code="ConceptName")),
# Test case 3: Native concept code (Text)
- ("my_domain", "Text", None, DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Text")),
+ ("my_domain", "Text", DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Text")),
# Test case 4: Native concept code (Image)
- ("my_domain", "Image", None, DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Image")),
+ ("my_domain", "Image", DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Image")),
# Test case 5: Native concept code (PDF)
- ("my_domain", "PDF", None, DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="PDF")),
+ ("my_domain", "PDF", DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="PDF")),
# Test case 6: Native concept code with same domain codes provided (native takes precedence)
- ("my_domain", "Text", ["Text", "OtherConcept"], DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Text")),
+ ("my_domain", "Text", DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Text")),
# Test case 7: Concept code from same domain
- ("my_domain", "MyConcept", ["MyConcept", "OtherConcept"], DomainAndConceptCode(domain="my_domain", concept_code="MyConcept")),
- # Test case 8: Concept code from same domain (case sensitive)
- ("my_domain", "MyConcept", ["MyCon", "OtherConcept"], DomainAndConceptCode(domain=SpecialDomain.IMPLICIT, concept_code="MyConcept")),
- # Test case 9: Unknown concept code (no same domain codes)
- ("my_domain", "UnknownConcept", None, DomainAndConceptCode(domain=SpecialDomain.IMPLICIT, concept_code="UnknownConcept")),
- # Test case 10: Unknown concept code (not in same domain codes)
- (
- "my_domain",
- "UnknownConcept",
- ["KnownConcept", "OtherConcept"],
- DomainAndConceptCode(domain=SpecialDomain.IMPLICIT, concept_code="UnknownConcept"),
- ),
- # Test case 11: Empty same domain codes list
- ("my_domain", "SomeConcept", [], DomainAndConceptCode(domain=SpecialDomain.IMPLICIT, concept_code="SomeConcept")),
- # Test case 12: Different domain in concept string
- ("my_domain", "another_domain.SomeConcept", ["SomeConcept"], DomainAndConceptCode(domain="another_domain", concept_code="SomeConcept")),
+ ("my_domain", "MyConcept", DomainAndConceptCode(domain="my_domain", concept_code="MyConcept")),
+ # Test case 8: Different domain in concept string
+ ("my_domain", "another_domain.SomeConcept", DomainAndConceptCode(domain="another_domain", concept_code="SomeConcept")),
# Test case 13: All native concept codes
- ("my_domain", "Dynamic", None, DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Dynamic")),
- ("my_domain", "TextAndImages", None, DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="TextAndImages")),
- ("my_domain", "Number", None, DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Number")),
- ("my_domain", "Page", None, DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Page")),
- ("my_domain", "Anything", None, DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Anything")),
+ ("my_domain", "Dynamic", DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Dynamic")),
+ ("my_domain", "TextAndImages", DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="TextAndImages")),
+ ("my_domain", "Number", DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Number")),
+ ("my_domain", "Page", DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Page")),
+ ("my_domain", "Anything", DomainAndConceptCode(domain=SpecialDomain.NATIVE, concept_code="Anything")),
]
# Test cases for make_from_blueprint method
- MAKE_FROM_BLUEPRINT_TEST_CASES: ClassVar[list[tuple[str, str, str, ConceptBlueprint, list[str] | None, Concept]]] = [
- # Test case 1: Simple blueprint with no structure or refines (goes to implicit)
- (
- "simple_blueprint",
- "my_domain",
- "SimpleConcept",
- ConceptBlueprint(description="A simple concept"),
- None,
- Concept(
- domain=SpecialDomain.IMPLICIT,
- code="SimpleConcept",
- description="A simple concept",
- structure_class_name=NativeConceptCode.TEXT.structure_class_name,
- refines=None,
- ),
- ),
- # Test case 2: Blueprint with string structure (existing class, goes to implicit)
- (
- "string_structure_existing_class",
- "my_domain",
- "ConceptWithStructure",
- ConceptBlueprint(description="A concept with string structure", structure="TextContent"),
- None,
- Concept(
- domain=SpecialDomain.IMPLICIT,
- code="ConceptWithStructure",
- description="A concept with string structure",
- structure_class_name=NativeConceptCode.TEXT.structure_class_name,
- refines=None,
- ),
- ),
- # Test case 3: Blueprint with refines (native concept, goes to implicit)
- (
- "blueprint_with_refines_text",
- "my_domain",
- "MyTextConcept",
- ConceptBlueprint(description="A concept that refines Text", refines="Text"),
- None,
- Concept(
- domain=SpecialDomain.IMPLICIT,
- code="MyTextConcept",
- description="A concept that refines Text",
- structure_class_name=NativeConceptCode.TEXT.structure_class_name,
- refines="native.Text",
- ),
- ),
- # Test case 4: Blueprint with refines (fully qualified native concept, goes to implicit)
- (
- "blueprint_with_refines_native_image",
- "my_domain",
- "MyImageConcept",
- ConceptBlueprint(description="A concept that refines native.Image", refines="native.Image"),
- None,
- Concept(
- domain=SpecialDomain.IMPLICIT,
- code="MyImageConcept",
- description="A concept that refines native.Image",
- structure_class_name=NativeConceptCode.IMAGE.structure_class_name,
- refines="native.Image",
- ),
- ),
+ MAKE_FROM_BLUEPRINT_TEST_CASES: ClassVar[list[tuple[str, str, str, ConceptBlueprint, Concept]]] = [
# Test case 5: Native concept code (should go to native domain)
(
"native_concept_code",
"my_domain",
"Text",
ConceptBlueprint(description="Native text concept"),
- None,
Concept(
domain=SpecialDomain.NATIVE,
code="Text",
@@ -156,7 +82,6 @@ class TestCases:
"my_domain",
"DomainConcept",
ConceptBlueprint(description="A concept from same domain"),
- ["DomainConcept", "OtherConcept"],
Concept(
domain="my_domain",
code="DomainConcept",
@@ -165,48 +90,6 @@ class TestCases:
refines=None,
),
),
- # Test case 7: Unknown concept code (should go to implicit domain)
- (
- "implicit_concept",
- "my_domain",
- "UnknownConcept",
- ConceptBlueprint(description="An unknown concept"),
- ["KnownConcept"],
- Concept(
- domain=SpecialDomain.IMPLICIT,
- code="UnknownConcept",
- description="An unknown concept",
- structure_class_name=NativeConceptCode.TEXT.structure_class_name,
- refines=None,
- ),
- ),
- # Test case 8: Blueprint with dict structure (implicit domain)
- (
- "dict_structure_implicit",
- SpecialDomain.IMPLICIT,
- "PersonConcept",
- ConceptBlueprint(
- description="A person with structured data",
- structure={
- "name": "The person's name",
- "age": ConceptStructureBlueprint(description="The person's age", type=ConceptStructureBlueprintFieldType.NUMBER, required=True),
- "active": ConceptStructureBlueprint(
- description="Whether the person is active",
- type=ConceptStructureBlueprintFieldType.BOOLEAN,
- required=False,
- default_value=True,
- ),
- },
- ),
- None,
- Concept(
- domain=SpecialDomain.IMPLICIT,
- code="PersonConcept",
- description="A person with structured data",
- structure_class_name="PersonConcept",
- refines=None,
- ),
- ),
# Test case 9: Blueprint with dict structure (same domain)
(
"dict_structure_same_domain",
@@ -225,7 +108,6 @@ class TestCases:
),
},
),
- ["PersonConcept", "OtherConcept"],
Concept(
domain="my_domain",
code="PersonConcept",
@@ -234,28 +116,12 @@ class TestCases:
refines=None,
),
),
- # Test case 10: Blueprint with refines (implicit domain)
- (
- "refines_implicit_domain",
- "my_domain",
- "ConceptWithRefines",
- ConceptBlueprint(description="A concept with refines", refines="Text"),
- None,
- Concept(
- domain=SpecialDomain.IMPLICIT,
- code="ConceptWithRefines",
- description="A concept with refines",
- structure_class_name=NativeConceptCode.TEXT.structure_class_name,
- refines="native.Text",
- ),
- ),
# Test case 11: Blueprint with refines (same domain)
(
"refines_same_domain",
"my_domain",
"ConceptWithRefines",
ConceptBlueprint(description="A concept with refines", refines="native.Image"),
- ["ConceptWithRefines", "OtherConcept"],
Concept(
domain="my_domain",
code="ConceptWithRefines",
diff --git a/tests/unit/pipelex/core/concepts/concept_factory/test_concept_factory.py b/tests/unit/pipelex/core/concepts/concept_factory/test_concept_factory.py
index 59cf33f9d..d42ba6d8c 100644
--- a/tests/unit/pipelex/core/concepts/concept_factory/test_concept_factory.py
+++ b/tests/unit/pipelex/core/concepts/concept_factory/test_concept_factory.py
@@ -81,26 +81,23 @@ class TestConceptFactory:
assert ConceptFactory.normalize_structure_blueprint(mixed_structure_blueprint2) == expected_structure2
@pytest.mark.parametrize(
- ("domain", "concept_string_or_code", "concept_codes_from_the_same_domain", "expected_result"),
+ ("domain", "concept_string_or_code", "expected_result"),
TestCases.MAKE_DOMAIN_AND_CONCEPT_CODE_TEST_CASES,
)
def test_make_domain_and_concept_code_from_concept_string_or_code(
self,
domain: str,
concept_string_or_code: str,
- concept_codes_from_the_same_domain: list[str] | None,
expected_result: list[str],
):
- """Test make_domain_and_concept_code_from_concept_string_or_code method with various inputs."""
result = ConceptFactory.make_domain_and_concept_code_from_concept_string_or_code(
domain=domain,
concept_string_or_code=concept_string_or_code,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
)
assert result == expected_result
@pytest.mark.parametrize(
- ("test_name", "domain", "concept_code", "blueprint", "concept_codes_from_the_same_domain", "expected_concept"),
+ ("test_name", "domain", "concept_code", "blueprint", "expected_concept"),
TestCases.MAKE_FROM_BLUEPRINT_TEST_CASES,
)
def test_make_from_blueprint(
@@ -109,7 +106,6 @@ class TestConceptFactory:
domain: str,
concept_code: str,
blueprint: ConceptBlueprint,
- concept_codes_from_the_same_domain: list[str] | None,
expected_concept: Concept,
):
"""Test make_from_blueprint method with various blueprint configurations."""
@@ -117,7 +113,6 @@ class TestConceptFactory:
domain=domain,
concept_code=concept_code,
blueprint=blueprint,
- concept_codes_from_the_same_domain=concept_codes_from_the_same_domain,
)
assert result == expected_concept, f"Concept mismatch for {test_name}"
diff --git a/tests/unit/pipelex/core/concepts/test_concept.py b/tests/unit/pipelex/core/concepts/test_concept.py
index c4e70c197..98d37dbb0 100644
--- a/tests/unit/pipelex/core/concepts/test_concept.py
+++ b/tests/unit/pipelex/core/concepts/test_concept.py
@@ -83,7 +83,6 @@ class TestConcept:
concept_code=NativeConceptCode.TEXT,
domain=valid_domain,
blueprint=ConceptBlueprint(description=valid_definition),
- concept_codes_from_the_same_domain=["RandomConcept"],
),
)
is True
@@ -104,7 +103,6 @@ class TestConcept:
concept_code=NativeConceptCode.IMAGE,
domain=valid_domain,
blueprint=ConceptBlueprint(description=valid_definition),
- concept_codes_from_the_same_domain=["RandomConcept"],
),
)
is True
@@ -115,7 +113,6 @@ class TestConcept:
concept_code=NativeConceptCode.PDF,
domain=valid_domain,
blueprint=ConceptBlueprint(description=valid_definition),
- concept_codes_from_the_same_domain=["RandomConcept"],
),
)
is True
@@ -126,7 +123,6 @@ class TestConcept:
concept_code=NativeConceptCode.TEXT_AND_IMAGES,
domain=valid_domain,
blueprint=ConceptBlueprint(description=valid_definition),
- concept_codes_from_the_same_domain=["RandomConcept"],
),
)
is True
@@ -137,7 +133,6 @@ class TestConcept:
concept_code=NativeConceptCode.NUMBER,
domain=valid_domain,
blueprint=ConceptBlueprint(description=valid_definition),
- concept_codes_from_the_same_domain=["RandomConcept"],
),
)
is True
@@ -148,7 +143,6 @@ class TestConcept:
concept_code=NativeConceptCode.ANYTHING,
domain=valid_domain,
blueprint=ConceptBlueprint(description=valid_definition),
- concept_codes_from_the_same_domain=["RandomConcept"],
),
)
is True
@@ -159,7 +153,6 @@ class TestConcept:
concept_code="RandomConcept",
domain=valid_domain,
blueprint=ConceptBlueprint(description=valid_definition),
- concept_codes_from_the_same_domain=["RandomConcept"],
),
)
is False
@@ -226,25 +219,21 @@ class TestConcept:
concept_code="Code1",
domain="domain1",
blueprint=ConceptBlueprint(description="Lorem Ipsum", refines=NativeConceptCode.TEXT),
- concept_codes_from_the_same_domain=["Code1"],
)
concept2 = ConceptFactory.make_from_blueprint(
concept_code="Code2",
domain="domain1",
blueprint=ConceptBlueprint(description="Lorem Ipsum", refines=NativeConceptCode.TEXT),
- concept_codes_from_the_same_domain=["Code1"],
)
concept3 = ConceptFactory.make_from_blueprint(
concept_code="Code3",
domain="domain2",
blueprint=ConceptBlueprint(description="Lorem Ipsum", structure="TextContent"),
- concept_codes_from_the_same_domain=["Code1"],
)
concept4 = ConceptFactory.make_from_blueprint(
concept_code="Code4",
domain="domain1",
blueprint=ConceptBlueprint(description="Lorem Ipsum", structure="ImageContent"),
- concept_codes_from_the_same_domain=["Code1"],
)
concept_5 = ConceptFactory.make_native_concept(
diff --git a/tests/unit/pipelex/core/concepts/test_helpers.py b/tests/unit/pipelex/core/concepts/test_helpers.py
new file mode 100644
index 000000000..db5418353
--- /dev/null
+++ b/tests/unit/pipelex/core/concepts/test_helpers.py
@@ -0,0 +1,59 @@
+import pytest
+
+from pipelex.core.concepts.helpers import strip_multiplicity_from_concept_string_or_code
+
+
+class TestStripMultiplicityFromConceptStringOrCode:
+ """Test the strip_multiplicity_from_concept_string_or_code function."""
+
+ @pytest.mark.parametrize(
+ ("input_string", "expected_output"),
+ [
+ # No multiplicity (PascalCase concepts)
+ ("ConceptCode", "ConceptCode"),
+ ("MyConceptCode", "MyConceptCode"),
+ ("ComplexConceptName", "ComplexConceptName"),
+ # Empty multiplicity
+ ("ConceptCode[]", "ConceptCode"),
+ ("MyConceptCode[]", "MyConceptCode"),
+ # Single digit multiplicity
+ ("ConceptCode[1]", "ConceptCode"),
+ ("ConceptCode[5]", "ConceptCode"),
+ ("ConceptCode[9]", "ConceptCode"),
+ # Multi-digit multiplicity
+ ("ConceptCode[10]", "ConceptCode"),
+ ("ConceptCode[100]", "ConceptCode"),
+ ("ConceptCode[999]", "ConceptCode"),
+ # Large number multiplicity
+ ("ConceptCode[1000]", "ConceptCode"),
+ ("ConceptCode[99999]", "ConceptCode"),
+ ("ConceptCode[999999]", "ConceptCode"),
+ # More PascalCase concepts with multiplicity
+ ("MyConcept[123]", "MyConcept"),
+ ("AnotherConcept[42]", "AnotherConcept"),
+ # Domain-prefixed concepts (domain.ConceptCode format)
+ # Domain is snake_case, Concept is PascalCase
+ ("my_domain.ConceptCode", "my_domain.ConceptCode"),
+ ("my_domain.ConceptCode[]", "my_domain.ConceptCode"),
+ ("my_domain.ConceptCode[1]", "my_domain.ConceptCode"),
+ ("my_domain.ConceptCode[5]", "my_domain.ConceptCode"),
+ ("my_domain.ConceptCode[100]", "my_domain.ConceptCode"),
+ ("my_domain.ConceptCode[9999]", "my_domain.ConceptCode"),
+ # Different domain names with multiplicity
+ ("some_domain.MyConceptCode[42]", "some_domain.MyConceptCode"),
+ ("another_domain.SomeOtherConcept[]", "another_domain.SomeOtherConcept"),
+ ("complex_domain_name.ComplexConceptName[123]", "complex_domain_name.ComplexConceptName"),
+ ],
+ )
+ def test_strip_multiplicity(self, input_string: str, expected_output: str):
+ """Test stripping multiplicity from concept strings with various formats.
+
+ This tests:
+ - Concepts without multiplicity (should return unchanged)
+ - Concepts with empty multiplicity []
+ - Concepts with single-digit multiplicity [1-9]
+ - Concepts with multi-digit multiplicity [10-999]
+ - Concepts with large multiplicity [1000+]
+ """
+ result = strip_multiplicity_from_concept_string_or_code(input_string)
+ assert result == expected_output
diff --git a/tests/unit/pipelex/core/pipes/data.py b/tests/unit/pipelex/core/pipes/data.py
index 61974e0c6..3af1cc27f 100644
--- a/tests/unit/pipelex/core/pipes/data.py
+++ b/tests/unit/pipelex/core/pipes/data.py
@@ -31,9 +31,6 @@ SINGLE_ITEM_NO_BRACKETS_TEST_CASES: list[tuple[str, str, str, int | bool | None]
("native", "native.Text", "native.Text", None),
("native", "native.Image", "native.Image", None),
("native", "native.PDF", "native.PDF", None),
- # Implicit concept creation (unknown concept codes become implicit)
- ("my_domain", "MyConcept", "implicit.MyConcept", None),
- ("accounting", "Invoice", "implicit.Invoice", None),
]
# Format: (domain, requirement_str, expected_concept_string)
@@ -41,9 +38,6 @@ MULTIPLE_ITEMS_EMPTY_BRACKETS_TEST_CASES: list[tuple[str, str, str]] = [
# Native domain tests
("native", "native.Text[]", "native.Text"),
("native", "native.Image[]", "native.Image"),
- # Implicit concept creation with empty brackets
- ("my_domain", "MyConcept[]", "implicit.MyConcept"),
- ("accounting", "Invoice[]", "implicit.Invoice"),
]
# Format: (domain, requirement_str, expected_concept_string, expected_multiplicity)
@@ -52,28 +46,20 @@ FIXED_COUNT_TEST_CASES: list[tuple[str, str, str, int]] = [
("native", "native.Text[5]", "native.Text", 5),
("native", "native.Image[3]", "native.Image", 3),
("native", "native.PDF[10]", "native.PDF", 10),
- # Implicit concept creation with fixed counts
- ("my_domain", "MyConcept[7]", "implicit.MyConcept", 7),
- ("accounting", "Invoice[2]", "implicit.Invoice", 2),
- ("hr", "Employee[10]", "implicit.Employee", 10),
]
# Format: (domain, requirement_str, concept_codes_from_same_domain, expected_concept_string, expected_multiplicity, description)
-CONCEPT_CODE_RESOLUTION_TEST_CASES: list[tuple[str, str, list[str] | None, str, int | bool | None, str]] = [
+CONCEPT_CODE_RESOLUTION_TEST_CASES: list[tuple[str, str, str, int | bool | None, str]] = [
# Native concepts resolved from concept code only (no multiplicity)
- ("native", "Text", None, "native.Text", None, "Native Text without brackets"),
- ("native", "Image[3]", None, "native.Image", 3, "Native Image with fixed count"),
- ("native", "PDF[]", None, "native.PDF", True, "Native PDF with empty brackets"),
+ ("native", "Text", "native.Text", None, "Native Text without brackets"),
+ ("native", "Image[3]", "native.Image", 3, "Native Image with fixed count"),
+ ("native", "PDF[]", "native.PDF", True, "Native PDF with empty brackets"),
# Native concepts with concept_codes_from_same_domain (native always takes precedence)
- ("native", "Text[5]", ["Text", "Image", "PDF"], "native.Text", 5, "Native Text with concept codes list"),
+ ("native", "Text[5]", "native.Text", 5, "Native Text with concept codes list"),
# Native concepts take precedence even when used with custom domain parameter
- ("my_domain", "Text", ["Text", "Document"], "native.Text", None, "Native Text takes precedence over custom domain"),
- ("my_domain", "Image[2]", ["Image", "Photo"], "native.Image", 2, "Native Image takes precedence"),
- ("accounting", "Text[3]", ["Invoice", "Receipt"], "native.Text", 3, "Native always wins"),
- # Unknown concepts (not native, not in concept_codes_from_same_domain) create implicit concepts
- ("my_domain", "UnknownConcept[5]", ["KnownConcept"], "implicit.UnknownConcept", 5, "Unknown concept with known list"),
- ("my_domain", "UnknownConcept", None, "implicit.UnknownConcept", None, "Unknown concept without list"),
- ("accounting", "UnknownInvoice[]", ["Invoice"], "implicit.UnknownInvoice", True, "Unknown with empty brackets"),
+ ("my_domain", "Text", "native.Text", None, "Native Text takes precedence over custom domain"),
+ ("my_domain", "Image[2]", "native.Image", 2, "Native Image takes precedence"),
+ ("accounting", "Text[3]", "native.Text", 3, "Native always wins"),
]
# Format: (domain, requirement_str, expected_concept_string, expected_multiplicity)
@@ -82,9 +68,6 @@ EXPLICIT_DOMAIN_IN_STRING_TEST_CASES: list[tuple[str, str, str, int | bool | Non
("my_domain", "native.Text", "native.Text", None),
("accounting", "native.Image[3]", "native.Image", 3),
("test_domain", "native.PDF[]", "native.PDF", True),
- # Explicitly using implicit domain creates implicit concepts
- ("my_domain", "implicit.OtherConcept[2]", "implicit.OtherConcept", 2),
- ("test_domain", "implicit.LineItem", "implicit.LineItem", None),
]
# Format: (domain, requirement_str, expected_concept_string, expected_multiplicity)
@@ -95,9 +78,6 @@ VARIOUS_FIXED_COUNTS_TEST_CASES: list[tuple[str, str, str, int]] = [
("native", "native.Image[10]", "native.Image", 10),
("native", "native.Image[100]", "native.Image", 100),
("native", "native.Image[999]", "native.Image", 999),
- # Implicit concepts with various counts (unknown concept codes)
- ("my_domain", "CustomConcept[1]", "implicit.CustomConcept", 1),
- ("accounting", "Transaction[50]", "implicit.Transaction", 50),
]
# Format: (domain, requirement_str, expected_concept_string)
@@ -108,7 +88,4 @@ DIFFERENT_CONCEPT_CODES_TEST_CASES: list[tuple[str, str, str]] = [
("native", "native.PDF", "native.PDF"),
("native", "native.Number", "native.Number"),
("native", "native.Page", "native.Page"),
- # Implicit concepts (unknown concept codes)
- ("my_domain", "CustomConcept", "implicit.CustomConcept"),
- ("accounting", "Invoice", "implicit.Invoice"),
]
diff --git a/tests/unit/pipelex/core/pipes/test_input_requirements_factory.py b/tests/unit/pipelex/core/pipes/test_input_requirements_factory.py
index 63a2fce48..cd6c25228 100644
--- a/tests/unit/pipelex/core/pipes/test_input_requirements_factory.py
+++ b/tests/unit/pipelex/core/pipes/test_input_requirements_factory.py
@@ -201,14 +201,13 @@ class TestMakeInputRequirementsFromString:
assert isinstance(exc_info.value.__cause__, ConceptStringError)
@pytest.mark.parametrize(
- ("domain", "requirement_str", "concept_codes_from_same_domain", "expected_concept_string", "expected_multiplicity", "description"),
+ ("domain", "requirement_str", "expected_concept_string", "expected_multiplicity", "description"),
CONCEPT_CODE_RESOLUTION_TEST_CASES,
)
def test_concept_code_resolution(
self,
domain: str,
requirement_str: str,
- concept_codes_from_same_domain: list[str] | None,
expected_concept_string: str,
expected_multiplicity: int | bool | None,
description: str,
@@ -218,14 +217,12 @@ class TestMakeInputRequirementsFromString:
This tests:
1. Native concepts are always recognized regardless of domain parameter
- 2. Unknown concepts (not native, not in the domain) become implicit concepts
- 3. concept_codes_from_same_domain helps resolve ambiguous concept codes
+ 2. concept_codes_from_same_domain helps resolve ambiguous concept codes
"""
load_empty_library()
result = InputRequirementsFactory.make_from_string(
domain=domain,
requirement_str=requirement_str,
- concept_codes_from_the_same_domain=concept_codes_from_same_domain,
)
assert isinstance(result, InputRequirement)
diff --git a/tests/unit/pipelex/core/stuffs/test_stuff_content_factory.py b/tests/unit/pipelex/core/stuffs/test_stuff_content_factory.py
index 5b56cdee5..bdea9f274 100644
--- a/tests/unit/pipelex/core/stuffs/test_stuff_content_factory.py
+++ b/tests/unit/pipelex/core/stuffs/test_stuff_content_factory.py
@@ -37,25 +37,11 @@ class TestCases:
"content": {"title": "Test Question", "description": "What are aerodynamic features?"},
}
- # Test cases for unregistered class (creates implicit concept, returns TextContent)
- UNREGISTERED_STRING_BLUEPRINT: ClassVar[dict[str, Any]] = {
- "concept_string": "unknown.NonExistentConcept",
- "content": "This should create implicit concept and return TextContent",
- }
-
- # Test cases for unregistered class with dict content
- UNREGISTERED_DICT_BLUEPRINT: ClassVar[dict[str, Any]] = {
- "concept_string": "unknown.NonExistentConcept",
- "content": {"text": "Dict content for implicit concept"},
- }
-
TEST_BLUEPRINTS: ClassVar[list[tuple[str, dict[str, Any]]]] = [
("text_string", TEXT_STRING_BLUEPRINT),
("text_dict", TEXT_DICT_BLUEPRINT),
("text_no_prefix", TEXT_NO_PREFIX_BLUEPRINT),
("registered_class", REGISTERED_CLASS_BLUEPRINT),
- ("unregistered_string", UNREGISTERED_STRING_BLUEPRINT),
- ("unregistered_dict", UNREGISTERED_DICT_BLUEPRINT),
]
@@ -100,16 +86,6 @@ class TestStuffContentFactory:
assert isinstance(result, TextContent)
assert result.text == "Test text content"
- def test_make_stuffcontent_from_concept_code_required_implicit_concept(self):
- """Test required method with implicit concept (should create TextContent)."""
- result = StuffContentFactory.make_stuff_content_from_concept_required(
- concept=ConceptFactory.make_native_concept(native_concept_code=NativeConceptCode.TEXT),
- value="Test content for implicit concept",
- )
-
- assert isinstance(result, TextContent)
- assert result.text == "Test content for implicit concept"
-
def test_make_stuffcontent_from_concept_code_with_fallback_text_success(self):
"""Test fallback method with native.Text concept."""
result = StuffContentFactory.make_stuff_content_from_concept_with_fallback(
@@ -120,26 +96,6 @@ class TestStuffContentFactory:
assert isinstance(result, TextContent)
assert result.text == "Test text content"
- def test_make_stuffcontent_from_concept_code_with_fallback_implicit_string(self):
- """Test fallback method with implicit concept and string value."""
- result = StuffContentFactory.make_stuff_content_from_concept_with_fallback(
- concept=ConceptFactory.make_native_concept(native_concept_code=NativeConceptCode.TEXT),
- value="Fallback text content",
- )
-
- assert isinstance(result, TextContent)
- assert result.text == "Fallback text content"
-
- def test_make_stuffcontent_from_concept_code_with_fallback_implicit_dict(self):
- """Test fallback method with implicit concept and dict value."""
- result = StuffContentFactory.make_stuff_content_from_concept_with_fallback(
- concept=ConceptFactory.make_native_concept(native_concept_code=NativeConceptCode.TEXT),
- value={"text": "Dict fallback content"},
- )
-
- assert isinstance(result, TextContent)
- assert result.text == "Dict fallback content"
-
@pytest.mark.parametrize(
("test_name", "blueprint"),
TestCases.TEST_BLUEPRINTS,
@@ -163,7 +119,6 @@ class TestStuffContentFactory:
elif test_name == "registered_class":
# Test with registered class - since MockRegisteredContent isn't actually registered,
- # it will be treated as an implicit concept and return TextContent
# But the content dict format is incompatible with TextContent's expected structure
# Test required method - it will succeed but create TextContent
@@ -173,7 +128,6 @@ class TestStuffContentFactory:
concept=ConceptFactory.make_native_concept(native_concept_code=NativeConceptCode.TEXT),
value=content,
)
- # If it succeeds, it should be TextContent (due to implicit concept)
assert isinstance(result_required, TextContent)
except Exception:
log.error(f"Failed to make stuff content from concept with required: {content}")
@@ -185,15 +139,11 @@ class TestStuffContentFactory:
concept=ConceptFactory.make_native_concept(native_concept_code=NativeConceptCode.TEXT),
value=content,
)
- # If it succeeds, it should be TextContent (due to implicit concept)
assert isinstance(result_fallback, TextContent)
except Exception:
log.error(f"Failed to make stuff content from concept with fallback: {content}")
elif test_name.startswith("unregistered_"):
- # Test behavior for unregistered/implicit concepts
- # Both methods should work and return TextContent due to implicit concept creation
-
result_required = StuffContentFactory.make_stuff_content_from_concept_required(
concept=ConceptFactory.make_native_concept(native_concept_code=NativeConceptCode.TEXT),
value=content,
diff --git a/tests/unit/pipelex/core/stuffs/test_stuff_factory_implicit_memory.py b/tests/unit/pipelex/core/stuffs/test_stuff_factory_implicit_memory.py
index 41ec5e290..217c9d36b 100644
--- a/tests/unit/pipelex/core/stuffs/test_stuff_factory_implicit_memory.py
+++ b/tests/unit/pipelex/core/stuffs/test_stuff_factory_implicit_memory.py
@@ -169,7 +169,7 @@ class TestStuffFactoryImplicitMemoryErrors:
expected_exception: type[Exception],
error_match: str,
):
- log.info(f"Testing error case: {test_name}")
+ log.verbose(f"Testing error case: {test_name}")
log.verbose(f"setup_test_concept: {setup_test_concept}")
with pytest.raises(expected_exception, match=error_match):
diff --git a/tests/unit/pipelex/pipe_controllers/batch/test_pipe_batch_input.py b/tests/unit/pipelex/pipe_controllers/batch/test_pipe_batch_input.py
index c3a650f03..2531b6abe 100644
--- a/tests/unit/pipelex/pipe_controllers/batch/test_pipe_batch_input.py
+++ b/tests/unit/pipelex/pipe_controllers/batch/test_pipe_batch_input.py
@@ -3,8 +3,9 @@ from typing import Callable
import pytest
from pipelex import log
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.pipe_controllers.batch.pipe_batch import PipeBatch
from pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprint
-from pipelex.pipe_controllers.batch.pipe_batch_factory import PipeBatchFactory
from tests.unit.pipelex.pipe_controllers.batch.data import PipeBatchInputTestCases
@@ -23,8 +24,8 @@ class TestPipeBatchValidateInputs:
log.verbose(f"Testing valid case: {test_id}")
# Validation happens automatically during instantiation via model_validator
- pipe_batch = PipeBatchFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_batch = PipeFactory[PipeBatch].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
)
diff --git a/tests/unit/pipelex/pipe_controllers/condition/test_pipe_condition_input.py b/tests/unit/pipelex/pipe_controllers/condition/test_pipe_condition_input.py
index f46102909..5a55e3b03 100644
--- a/tests/unit/pipelex/pipe_controllers/condition/test_pipe_condition_input.py
+++ b/tests/unit/pipelex/pipe_controllers/condition/test_pipe_condition_input.py
@@ -4,8 +4,9 @@ import pytest
from pipelex import log
from pipelex.core.pipes.exceptions import PipeValidationError
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.pipe_controllers.condition.pipe_condition import PipeCondition
from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint
-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactory
from tests.unit.pipelex.pipe_controllers.condition.data import PipeConditionInputTestCases
@@ -24,8 +25,8 @@ class TestPipeConditionValidateInputs:
log.verbose(f"Testing valid case: {test_id}")
# Validation happens automatically during instantiation via model_validator
- pipe_condition = PipeConditionFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_condition = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
)
@@ -51,11 +52,12 @@ class TestPipeConditionValidateInputs:
with pytest.raises((PipeValidationError, ValueError)) as exc_info: # noqa: PT012
# Construct blueprint from dict at test time to trigger validation
blueprint = PipeConditionBlueprint.model_validate(blueprint_dict)
- PipeConditionFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_condition = PipeFactory[PipeCondition].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
- ).validate_with_libraries()
+ )
+ pipe_condition.validate_with_libraries()
error_str = str(exc_info.value)
assert expected_error_message_fragment in error_str, (
diff --git a/tests/unit/pipelex/pipe_controllers/parallel/test_pipe_parallel_input.py b/tests/unit/pipelex/pipe_controllers/parallel/test_pipe_parallel_input.py
index 4f4dd8bf1..ada263cb0 100644
--- a/tests/unit/pipelex/pipe_controllers/parallel/test_pipe_parallel_input.py
+++ b/tests/unit/pipelex/pipe_controllers/parallel/test_pipe_parallel_input.py
@@ -4,8 +4,9 @@ import pytest
from pipelex import log
from pipelex.core.pipes.exceptions import PipeValidationError
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.pipe_controllers.parallel.pipe_parallel import PipeParallel
from pipelex.pipe_controllers.parallel.pipe_parallel_blueprint import PipeParallelBlueprint
-from pipelex.pipe_controllers.parallel.pipe_parallel_factory import PipeParallelFactory
from tests.unit.pipelex.pipe_controllers.parallel.data import PipeParallelInputTestCases
@@ -24,8 +25,8 @@ class TestPipeParallelValidateInputs:
log.verbose(f"Testing valid case: {test_id}")
# Validation happens automatically during instantiation via model_validator
- pipe_parallel = PipeParallelFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_parallel = PipeFactory[PipeParallel].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
)
@@ -51,11 +52,12 @@ class TestPipeParallelValidateInputs:
with pytest.raises((PipeValidationError, ValueError)) as exc_info: # noqa: PT012
# Construct blueprint from dict at test time to trigger validation
blueprint = PipeParallelBlueprint.model_validate(blueprint_dict)
- PipeParallelFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_parallel = PipeFactory[PipeParallel].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
)
+ pipe_parallel.validate_with_libraries()
error_str = str(exc_info.value)
assert expected_error_message_fragment in error_str, (
diff --git a/tests/unit/pipelex/pipe_controllers/sequence/test_pipe_sequence_input.py b/tests/unit/pipelex/pipe_controllers/sequence/test_pipe_sequence_input.py
index 77d523fc1..e165223ca 100644
--- a/tests/unit/pipelex/pipe_controllers/sequence/test_pipe_sequence_input.py
+++ b/tests/unit/pipelex/pipe_controllers/sequence/test_pipe_sequence_input.py
@@ -4,8 +4,9 @@ import pytest
from pipelex import log
from pipelex.core.pipes.exceptions import PipeValidationError
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.pipe_controllers.sequence.pipe_sequence import PipeSequence
from pipelex.pipe_controllers.sequence.pipe_sequence_blueprint import PipeSequenceBlueprint
-from pipelex.pipe_controllers.sequence.pipe_sequence_factory import PipeSequenceFactory
from tests.unit.pipelex.pipe_controllers.sequence.data import PipeSequenceInputTestCases
@@ -24,8 +25,8 @@ class TestPipeSequenceValidateInputs:
log.verbose(f"Testing valid case: {test_id}")
# Validation happens automatically during instantiation via model_validator
- pipe_sequence = PipeSequenceFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_sequence = PipeFactory[PipeSequence].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
)
@@ -51,11 +52,12 @@ class TestPipeSequenceValidateInputs:
with pytest.raises((PipeValidationError, ValueError)) as exc_info: # noqa: PT012
# Construct blueprint from dict at test time to trigger validation
blueprint = PipeSequenceBlueprint.model_validate(blueprint_dict)
- PipeSequenceFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_sequence = PipeFactory[PipeSequence].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
- ).validate_with_libraries()
+ )
+ pipe_sequence.validate_with_libraries()
error_str = str(exc_info.value)
assert expected_error_message_fragment in error_str, (
diff --git a/tests/unit/pipelex/pipe_operators/pipe_compose/test_pipe_compose_input.py b/tests/unit/pipelex/pipe_operators/pipe_compose/test_pipe_compose_input.py
index 02c5500f8..8d393d13b 100644
--- a/tests/unit/pipelex/pipe_operators/pipe_compose/test_pipe_compose_input.py
+++ b/tests/unit/pipelex/pipe_operators/pipe_compose/test_pipe_compose_input.py
@@ -3,8 +3,9 @@ from typing import Callable
import pytest
from pipelex import log
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.pipe_operators.compose.pipe_compose import PipeCompose
from pipelex.pipe_operators.compose.pipe_compose_blueprint import PipeComposeBlueprint
-from pipelex.pipe_operators.compose.pipe_compose_factory import PipeComposeFactory
from tests.unit.pipelex.pipe_operators.pipe_compose.data import PipeComposeInputTestCases
@@ -23,8 +24,8 @@ class TestPipeComposeValidateInputs:
log.verbose(f"Testing valid case: {test_id}")
# Validation happens automatically during instantiation via model_validator
- pipe_compose = PipeComposeFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_compose = PipeFactory[PipeCompose].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
)
diff --git a/tests/unit/pipelex/pipe_operators/pipe_func/test_pipe_func_input.py b/tests/unit/pipelex/pipe_operators/pipe_func/test_pipe_func_input.py
index 0c9ad0066..b91a21653 100644
--- a/tests/unit/pipelex/pipe_operators/pipe_func/test_pipe_func_input.py
+++ b/tests/unit/pipelex/pipe_operators/pipe_func/test_pipe_func_input.py
@@ -4,8 +4,9 @@ from typing import Callable
import pytest
from pipelex import log
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.pipe_operators.func.pipe_func import PipeFunc
from pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprint
-from pipelex.pipe_operators.func.pipe_func_factory import PipeFuncFactory
from tests.unit.pipelex.pipe_operators.pipe_func.data import PipeFuncInputTestCases
@@ -30,8 +31,8 @@ class TestPipeFuncValidation:
"""Test that PipeFunc works correctly with valid, registered functions."""
log.verbose(f"Testing valid case: {test_id}")
- pipe_func = PipeFuncFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_func = PipeFactory[PipeFunc].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
)
diff --git a/tests/unit/pipelex/pipe_operators/pipe_img_gen/test_pipe_img_gen_input.py b/tests/unit/pipelex/pipe_operators/pipe_img_gen/test_pipe_img_gen_input.py
index fda6d1ac2..d90008098 100644
--- a/tests/unit/pipelex/pipe_operators/pipe_img_gen/test_pipe_img_gen_input.py
+++ b/tests/unit/pipelex/pipe_operators/pipe_img_gen/test_pipe_img_gen_input.py
@@ -4,8 +4,9 @@ import pytest
from pipelex import log
from pipelex.core.pipes.exceptions import PipeValidationError, PipeValidationErrorType
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.pipe_operators.img_gen.pipe_img_gen import PipeImgGen
from pipelex.pipe_operators.img_gen.pipe_img_gen_blueprint import PipeImgGenBlueprint
-from pipelex.pipe_operators.img_gen.pipe_img_gen_factory import PipeImgGenFactory
from tests.unit.pipelex.pipe_operators.pipe_img_gen.data import PipeImgGenInputTestCases
@@ -23,8 +24,8 @@ class TestPipeImgGenValidateInputs:
load_empty_library()
log.verbose(f"Testing valid case: {test_id}")
- pipe_img_gen = PipeImgGenFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_img_gen = PipeFactory[PipeImgGen].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
)
@@ -47,12 +48,13 @@ class TestPipeImgGenValidateInputs:
load_empty_library()
log.verbose(f"Testing error case: {test_id}")
+ pipe_img_gen = PipeFactory[PipeImgGen].make_from_blueprint(
+ domain_code="test_domain",
+ pipe_code=f"test_pipe_{test_id}",
+ blueprint=blueprint,
+ )
with pytest.raises(PipeValidationError) as exc_info:
- PipeImgGenFactory.make_from_blueprint(
- domain="test_domain",
- pipe_code=f"test_pipe_{test_id}",
- blueprint=blueprint,
- ).validate_with_libraries()
+ pipe_img_gen.validate_with_libraries()
# Verify the error type matches
assert exc_info.value.error_type == expected_error_type, f"Expected error type {expected_error_type}, but got {exc_info.value.error_type}"
diff --git a/tests/unit/pipelex/pipe_operators/pipe_llm/test_pipe_llm_input.py b/tests/unit/pipelex/pipe_operators/pipe_llm/test_pipe_llm_input.py
index 58372a64a..932deefe3 100644
--- a/tests/unit/pipelex/pipe_operators/pipe_llm/test_pipe_llm_input.py
+++ b/tests/unit/pipelex/pipe_operators/pipe_llm/test_pipe_llm_input.py
@@ -3,8 +3,9 @@ from typing import Callable
import pytest
from pipelex import log
+from pipelex.core.pipes.pipe_factory import PipeFactory
+from pipelex.pipe_operators.llm.pipe_llm import PipeLLM
from pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint
-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactory
from tests.unit.pipelex.pipe_operators.pipe_llm.data import PipeLLMInputTestCases
@@ -22,8 +23,8 @@ class TestPipeLLMValidateInputs:
load_empty_library()
log.verbose(f"Testing valid case: {test_id}")
- pipe_llm = PipeLLMFactory.make_from_blueprint(
- domain="test_domain",
+ pipe_llm = PipeFactory[PipeLLM].make_from_blueprint(
+ domain_code="test_domain",
pipe_code=f"test_pipe_{test_id}",
blueprint=blueprint,
)
diff --git a/tests/unit/pipelex/tools/test.plx b/tests/unit/pipelex/tools/test.plx
index 37372dabb..d57a23de1 100644
--- a/tests/unit/pipelex/tools/test.plx
+++ b/tests/unit/pipelex/tools/test.plx
@@ -1,6 +1,10 @@
domain = "test"
+[concept]
+CodebaseFileContent = "The content of a codebase file"
+FilePath = "The path of a file"
+
[pipe.read_doc_file]
type = "PipeFunc"
description = "Read the content of related codebase files"