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.mdindex 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-25diff --git a/pipelex/builder/builder.plx b/pipelex/builder/builder.plxindex 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.plxdeleted file mode 100644index 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.plxindex 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.pyindex 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 yourselfllm_choice: LLMModelChoice = self.llm_skillreturn 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.pyindex 67f26a4bb..4f2f33b6b 100644--- a/pipelex/core/concepts/concept.py+++ b/pipelex/core/concepts/concept.py@@ -9,7 +9,6 @@ from pipelex.base_exceptions import PipelexUnexpectedErrorfrom pipelex.core.concepts.exceptions import ConceptCodeError, ConceptStringError, ConceptValueErrorfrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.concepts.validation import validate_concept_code, validate_concept_string-from pipelex.core.domains.domain import SpecialDomainfrom pipelex.core.domains.exceptions import DomainCodeErrorfrom pipelex.core.domains.validation import validate_domain_codefrom 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)-@classmethoddef 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.pyindex 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__,- )-@classmethoddef 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:@classmethoddef 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)@classmethoddef 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: ConceptBlueprintif 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.pynew file mode 100644index 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_codediff --git a/pipelex/core/domains/domain.py b/pipelex/core/domains/domain.pyindex 0f72e0534..116da1c2f 100644--- a/pipelex/core/domains/domain.py+++ b/pipelex/core/domains/domain.py@@ -4,7 +4,6 @@ from pipelex.types import StrEnumclass 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 Falseclass Domain(BaseModel):diff --git a/pipelex/core/pipes/inputs/input_requirements_factory.py b/pipelex/core/pipes/inputs/input_requirements_factory.pyindex 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_requirementreturn 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 prefixrequirement_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 resolutionReturns: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 multiplicitydiff --git a/pipelex/core/pipes/pipe_abstract.py b/pipelex/core/pipes/pipe_abstract.pyindex 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")@classmethoddef validate_pipe_code_syntax(cls, code: str) -> str:diff --git a/pipelex/core/pipes/pipe_blueprint.py b/pipelex/core/pipes/pipe_blueprint.pyindex 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 = Nonepipe_category: Any = Field(exclude=True) # Technical field for Union discrimination, not user-facingtype: Any # TODO: Find a better way to handle this.diff --git a/pipelex/core/pipes/pipe_factory.py b/pipelex/core/pipes/pipe_factory.pyindex 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, TypeVarfrom kajson.exceptions import ClassRegistryInheritanceError, ClassRegistryNotFoundErrorfrom 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 PipeAbstractPipeBlueprintType = 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_checkableclass 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- @overridedef 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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 InputRequirementsfrom 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 PipeBatchFactoryErrorfrom pipelex.pipe_controllers.batch.pipe_batch import PipeBatchfrom pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprintfrom pipelex.pipe_run.pipe_run_params import BatchParams@@ -16,49 +13,25 @@ from pipelex.pipe_run.pipe_run_params import BatchParamsclass 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.pyindex 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 InputRequirementsfrom pipelex.core.pipes.pipe_factory import PipeFactoryProtocol-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity-from pipelex.hub import get_required_conceptfrom pipelex.pipe_controllers.condition.exceptions import PipeConditionFactoryErrorfrom pipelex.pipe_controllers.condition.pipe_condition import PipeConditionfrom pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint@@ -15,48 +13,19 @@ from pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeCondclass 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 = Noneif blueprint.expression_template:expression = blueprint.expression_templateelif blueprint.expression:@@ -66,9 +35,9 @@ class PipeConditionFactory(PipeFactoryProtocol[PipeConditionBlueprint, PipeCondiraise 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.pyindex 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, Anyfrom typing_extensions import override+from pipelex.core.concepts.concept import Conceptfrom 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 InputRequirementsfrom pipelex.core.pipes.pipe_factory import PipeFactoryProtocol-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicityfrom pipelex.hub import get_required_conceptfrom pipelex.pipe_controllers.parallel.exceptions import PipeParallelFactoryErrorfrom 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, PipeParallemessage=msg,)- # Parse output to strip multiplicity brackets- output_parse_result = parse_concept_with_multiplicity(blueprint.output)-+ # Handle combined_output if specifiedif 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, PipeParalleelse: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.pyindex 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 InputRequirementsfrom 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 PipeSequenceFactoryErrorfrom pipelex.pipe_controllers.sequence.pipe_sequence import PipeSequencefrom pipelex.pipe_controllers.sequence.pipe_sequence_blueprint import PipeSequenceBlueprintfrom 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.pyindex 20d26dea4..9a738b3bf 100644--- a/pipelex/pipe_controllers/sub_pipe.py+++ b/pipelex/pipe_controllers/sub_pipe.py@@ -4,12 +4,13 @@ from pipelex import logfrom pipelex.core.memory.exceptions import WorkingMemoryStuffNotFoundErrorfrom pipelex.core.memory.working_memory import WorkingMemoryfrom pipelex.core.pipes.inputs.exceptions import PipeInputError, PipeInputNotFoundError+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.pipes.pipe_output import PipeOutputfrom pipelex.core.pipes.variable_multiplicity import VariableMultiplicityfrom pipelex.core.stuffs.list_content import ListContentfrom pipelex.hub import get_pipeline_tracker, get_required_pipe+from pipelex.pipe_controllers.batch.pipe_batch import PipeBatchfrom pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprint-from pipelex.pipe_controllers.batch.pipe_batch_factory import PipeBatchFactoryfrom pipelex.pipe_controllers.condition.pipe_condition import PipeConditionfrom pipelex.pipe_run.pipe_run_params import BatchParams, PipeRunParamsfrom pipelex.pipeline.job_metadata import JobMetadata@@ -20,7 +21,6 @@ class SubPipe(BaseModel):output_name: str | None = Noneoutput_multiplicity: VariableMultiplicity | None = Nonebatch_params: BatchParams | None = None- concept_codes_from_the_same_domain: list[str] | None = Noneasync 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.pyindex 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.pyindex 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 overridefrom 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 InputRequirementsfrom pipelex.core.pipes.pipe_factory import PipeFactoryProtocol-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity-from pipelex.hub import get_required_conceptfrom pipelex.pipe_operators.compose.exceptions import PipeComposeFactoryErrorfrom pipelex.pipe_operators.compose.pipe_compose import PipeComposefrom pipelex.pipe_operators.compose.pipe_compose_blueprint import PipeComposeBlueprint@@ -18,12 +16,16 @@ from pipelex.tools.jinja2.jinja2_parsing import check_jinja2_parsingclass 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 excreturn 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.pyindex 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 overridefrom pipelex.config import get_config-from pipelex.core.concepts.concept_factory import ConceptFactory+from pipelex.core.concepts.concept import Conceptfrom 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 InputRequirementsfrom 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_conceptfrom pipelex.pipe_operators.extract.exceptions import PipeExtractFactoryErrorfrom pipelex.pipe_operators.extract.pipe_extract import PipeExtractfrom pipelex.pipe_operators.extract.pipe_extract_blueprint import PipeExtractBlueprint@@ -15,34 +16,21 @@ from pipelex.pipe_operators.extract.pipe_extract_blueprint import PipeExtractBluclass 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 = Nonepdf_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 inputinput_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.pyindex 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 InputRequirementsfrom pipelex.core.pipes.pipe_factory import PipeFactoryProtocol-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity-from pipelex.hub import get_required_conceptfrom pipelex.pipe_operators.func.pipe_func import PipeFuncfrom pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprint@@ -12,36 +12,23 @@ from pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprintclass 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 PipeFuncreturn 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.pyindex 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 InputRequirementsfrom pipelex.core.pipes.pipe_factory import PipeFactoryProtocolfrom pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity-from pipelex.hub import get_required_conceptfrom pipelex.pipe_operators.img_gen.pipe_img_gen import PipeImgGenfrom 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 PipeImgGenBlueclass 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_promptimg_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_promptreturn 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.pyindex 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 ValidationErrorfrom typing_extensions import override@@ -7,7 +9,7 @@ from pipelex.cogt.templating.template_category import TemplateCategoryfrom pipelex.core.concepts.concept import Conceptfrom pipelex.core.concepts.concept_factory import ConceptFactoryfrom 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 InputRequirementsfrom pipelex.core.pipes.pipe_factory import PipeFactoryProtocolfrom pipelex.core.pipes.variable_multiplicity import make_variable_multiplicity, parse_concept_with_multiplicityfrom pipelex.hub import get_native_concept, get_optional_domain, get_required_concept@@ -21,15 +23,19 @@ from pipelex.tools.jinja2.jinja2_errors import Jinja2TemplateSyntaxErrorclass 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_promptsystem_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_codereturn 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.pyindex b2d5805ee..24578696f 100644--- a/tests/conftest.py+++ b/tests/conftest.py@@ -1,3 +1,4 @@+from collections.abc import Callable, Generatorfrom pathlib import Pathimport 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 = Nonedef _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_idlibrary_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_idyield _loaddiff --git a/tests/e2e/pipelex/pipes/pipe_controller/pipe_condition/test_pipe_condition_simple.py b/tests/e2e/pipelex/pipes/pipe_controller/pipe_condition/test_pipe_condition_simple.pyindex 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 Pathfrom typing import Callable@@ -12,8 +10,9 @@ from pipelex.core.domains.domain import SpecialDomainfrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactoryfrom pipelex.core.pipes.inputs.exceptions import PipeRunInputsErrorfrom pipelex.core.pipes.inputs.input_requirements import TypedNamedInputRequirement+from pipelex.core.pipes.pipe_factory import PipeFactory+from pipelex.pipe_controllers.condition.pipe_condition import PipeConditionfrom pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactoryfrom pipelex.pipe_run.exceptions import PipeRunErrorfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom 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.pyindex 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, castimport pytestfrom pytest import FixtureRequest-if TYPE_CHECKING:- from collections.abc import Callable-from pipelex import pretty_printfrom pipelex.core.concepts.concept_blueprint import ConceptBlueprintfrom pipelex.core.concepts.concept_factory import ConceptFactoryfrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.list_content import ListContentfrom pipelex.core.stuffs.stuff_content import StuffContentfrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.core.stuffs.text_content import TextContentfrom pipelex.hub import get_concept_library+from pipelex.pipe_controllers.batch.pipe_batch import PipeBatchfrom pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprint-from pipelex.pipe_controllers.batch.pipe_batch_factory import PipeBatchFactoryfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactoryfrom 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 itemsdiff --git a/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_simple.py b/tests/integration/pipelex/pipes/controller/pipe_condition/test_pipe_condition_simple.pyindex 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 Pathfrom typing import Callable, cast@@ -12,11 +10,12 @@ from pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.domains.domain import SpecialDomainfrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactoryfrom pipelex.core.pipes.inputs.exceptions import PipeRunInputsError+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.core.stuffs.text_content import TextContentfrom pipelex.hub import get_pipe_router, get_required_pipe+from pipelex.pipe_controllers.condition.pipe_condition import PipeConditionfrom pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactoryfrom pipelex.pipe_controllers.condition.special_outcome import SpecialOutcomefrom pipelex.pipe_run.pipe_job_factory import PipeJobFactoryfrom 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.pyindex 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 Pathfrom typing import Callablefrom pipelex.core.concepts.concept_factory import ConceptBlueprint, ConceptFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.hub import get_concept_library+from pipelex.pipe_controllers.condition.pipe_condition import PipeConditionfrom pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactoryfrom 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.pyindex 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 ConceptFactoryfrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.domains.domain import SpecialDomainfrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.core.stuffs.text_content import TextContent+from pipelex.pipe_controllers.parallel.pipe_parallel import PipeParallelfrom pipelex.pipe_controllers.parallel.pipe_parallel_blueprint import PipeParallelBlueprint-from pipelex.pipe_controllers.parallel.pipe_parallel_factory import PipeParallelFactoryfrom pipelex.pipe_controllers.sub_pipe_factory import SubPipeBlueprintfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom 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.pyindex 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 Callablefrom pipelex.core.concepts.concept_blueprint import ConceptBlueprintfrom pipelex.core.concepts.concept_factory import ConceptFactoryfrom pipelex.core.pipes.inputs.input_requirements import InputRequirements+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.hub import get_concept_library, get_pipe_library+from pipelex.pipe_controllers.parallel.pipe_parallel import PipeParallelfrom pipelex.pipe_controllers.parallel.pipe_parallel_blueprint import PipeParallelBlueprint-from pipelex.pipe_controllers.parallel.pipe_parallel_factory import PipeParallelFactoryfrom pipelex.pipe_controllers.sub_pipe_factory import SubPipeBlueprint+from pipelex.pipe_operators.llm.pipe_llm import PipeLLMfrom pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactoryclass 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 templatedomain = "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 calleddiff --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.pyindex 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 Pathfrom typing import Callable, cast@@ -11,11 +9,12 @@ from pipelex.core.concepts.concept_blueprint import ConceptBlueprintfrom pipelex.core.concepts.concept_factory import ConceptFactoryfrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.core.stuffs.text_content import TextContentfrom pipelex.hub import get_concept_library, get_native_concept+from pipelex.pipe_controllers.sequence.pipe_sequence import PipeSequencefrom pipelex.pipe_controllers.sequence.pipe_sequence_blueprint import PipeSequenceBlueprint-from pipelex.pipe_controllers.sequence.pipe_sequence_factory import PipeSequenceFactoryfrom pipelex.pipe_controllers.sub_pipe_blueprint import SubPipeBlueprintfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom 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.pyindex 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 Pathfrom typing import Callablefrom pipelex.core.concepts.concept_factory import ConceptBlueprint, ConceptFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.hub import get_concept_library+from pipelex.pipe_controllers.sequence.pipe_sequence import PipeSequencefrom pipelex.pipe_controllers.sequence.pipe_sequence_blueprint import PipeSequenceBlueprint-from pipelex.pipe_controllers.sequence.pipe_sequence_factory import PipeSequenceFactoryfrom 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.pyindex 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 ConceptBlueprintfrom pipelex.core.concepts.concept_factory import ConceptFactoryfrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.image_content import ImageContentfrom pipelex.core.stuffs.page_content import PageContentfrom pipelex.core.stuffs.pdf_content import PDFContentfrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.hub import get_concept_library, get_pipe_router+from pipelex.pipe_operators.extract.pipe_extract import PipeExtractfrom pipelex.pipe_operators.extract.pipe_extract_blueprint import PipeExtractBlueprint-from pipelex.pipe_operators.extract.pipe_extract_factory import PipeExtractFactoryfrom pipelex.pipe_run.pipe_job_factory import PipeJobFactoryfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom 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.pyindex 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_printfrom pipelex.core.concepts.concept_factory import ConceptFactoryfrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.core.stuffs.text_content import TextContentfrom pipelex.hub import get_pipe_router+from pipelex.pipe_operators.func.pipe_func import PipeFuncfrom pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprint-from pipelex.pipe_operators.func.pipe_func_factory import PipeFuncFactoryfrom pipelex.pipe_run.pipe_job_factory import PipeJobFactoryfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom 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.pyindex 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, castimport pytestfrom pipelex import pretty_printfrom pipelex.core.concepts.native.concept_native import NativeConceptCode+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.hub import get_pipe_router+from pipelex.pipe_operators.img_gen.pipe_img_gen import PipeImgGen, PipeImgGenOutputfrom pipelex.pipe_operators.img_gen.pipe_img_gen_blueprint import PipeImgGenBlueprint-from pipelex.pipe_operators.img_gen.pipe_img_gen_factory import PipeImgGenFactoryfrom pipelex.pipe_run.pipe_job_factory import PipeJobFactoryfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactoryfrom 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.pyindex 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 pytestfrom pipelex import log, pretty_printfrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.stuff import Stufffrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.core.stuffs.text_content import TextContentfrom pipelex.hub import get_class_registry, get_native_concept, get_pipe_library, get_pipe_router+from pipelex.pipe_operators.llm.pipe_llm import PipeLLMfrom pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint, StructuringMethod-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactoryfrom pipelex.pipe_run.pipe_job_factory import PipeJobFactoryfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom 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.pyindex 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 Callablefrom pipelex.core.concepts.concept_blueprint import ConceptBlueprintfrom pipelex.core.concepts.concept_factory import ConceptFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.hub import get_concept_library+from pipelex.pipe_controllers.batch.pipe_batch import PipeBatchfrom 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 PipeConditionfrom pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactoryfrom pipelex.pipe_controllers.condition.special_outcome import SpecialOutcome+from pipelex.pipe_controllers.parallel.pipe_parallel import PipeParallelfrom pipelex.pipe_controllers.parallel.pipe_parallel_blueprint import PipeParallelBlueprint-from pipelex.pipe_controllers.parallel.pipe_parallel_factory import PipeParallelFactoryclass 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 Truediff --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.pyindex 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 Pathfrom typing import Callablefrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.memory.working_memory import WorkingMemory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.list_content import ListContentfrom pipelex.core.stuffs.text_content import TextContent+from pipelex.pipe_operators.compose.pipe_compose import PipeComposefrom 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 PipeExtractfrom 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 PipeFuncfrom 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 PipeImgGenfrom 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 PipeLLMfrom pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactoryfrom 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.pyindex 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 FixtureRequestfrom pipelex.core.concepts.concept_factory import ConceptFactoryfrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.image_content import ImageContentfrom pipelex.core.stuffs.page_content import PageContentfrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.core.stuffs.text_and_images_content import TextAndImagesContentfrom pipelex.core.stuffs.text_content import TextContentfrom pipelex.hub import get_native_concept, get_pipe_router, get_required_pipe+from pipelex.pipe_operators.llm.pipe_llm import PipeLLMfrom pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactoryfrom pipelex.pipe_run.pipe_job_factory import PipeJobFactoryfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom 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.pyindex 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, castimport pytest@@ -8,19 +8,17 @@ from pipelex.cogt.templating.template_category import TemplateCategoryfrom pipelex.cogt.templating.templating_style import TagStyle, TemplatingStyle, TextFormatfrom pipelex.core.concepts.native.concept_native import NativeConceptCodefrom pipelex.core.memory.working_memory_factory import WorkingMemoryFactory+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.core.stuffs.stuff_factory import StuffFactoryfrom pipelex.core.stuffs.text_content import TextContentfrom pipelex.hub import get_native_concept, get_pipe_router+from pipelex.pipe_operators.compose.pipe_compose import PipeCompose, PipeComposeOutputfrom pipelex.pipe_operators.compose.pipe_compose_blueprint import PipeComposeBlueprint-from pipelex.pipe_operators.compose.pipe_compose_factory import PipeComposeFactoryfrom pipelex.pipe_run.pipe_job_factory import PipeJobFactoryfrom pipelex.pipe_run.pipe_run_params import PipeRunModefrom pipelex.pipe_run.pipe_run_params_factory import PipeRunParamsFactoryfrom 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.pyindex 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 LLMSettingfrom pipelex.cogt.llm.llm_worker_abstract import LLMWorkerAbstractfrom pipelex.cogt.usage.token_category import NbTokensByCategoryDict, TokenCategoryfrom pipelex.core.concepts.native.concept_native import NativeConceptCode+from pipelex.core.pipes.pipe_factory import PipeFactoryfrom pipelex.hub import get_inference_manager, get_pipe_router, get_report_delegate+from pipelex.pipe_operators.llm.pipe_llm import PipeLLMfrom pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactoryfrom pipelex.pipe_run.pipe_job_factory import PipeJobFactoryfrom pipelex.tools.typing.pydantic_utils import BaseModelTypeVarfrom 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.pyindex 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 propertiesdiff --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.pyindex 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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 pytestfrom pipelex import pretty_printfrom 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 PipeLLMfrom pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactoryfrom 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.pyindex 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 operatorsNO_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 -> CSIMPLE_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:# DDIAMOND_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_xMULTIPLE_CHAINS_EXPECTED: ClassVar[list[str]] = ["pipe_b", "pipe_a", "pipe_y", "pipe_x"]@@ -116,8 +102,6 @@ class PipeSorterTestCases:# Test case 5: PipeBatch dependencyPIPE_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 branchesPIPE_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 orderPIPE_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 sequenceIMAGE_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.pyindex 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.pyindex 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.pyindex 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.pynew file mode 100644index 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_outputdiff --git a/tests/unit/pipelex/core/pipes/data.py b/tests/unit/pipelex/core/pipes/data.pyindex 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.pyindex 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.pyindex 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.pyindex 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.pyindex 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 Callableimport pytestfrom pipelex import log+from pipelex.core.pipes.pipe_factory import PipeFactory+from pipelex.pipe_controllers.batch.pipe_batch import PipeBatchfrom pipelex.pipe_controllers.batch.pipe_batch_blueprint import PipeBatchBlueprint-from pipelex.pipe_controllers.batch.pipe_batch_factory import PipeBatchFactoryfrom 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.pyindex 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 pytestfrom pipelex import logfrom pipelex.core.pipes.exceptions import PipeValidationError+from pipelex.core.pipes.pipe_factory import PipeFactory+from pipelex.pipe_controllers.condition.pipe_condition import PipeConditionfrom pipelex.pipe_controllers.condition.pipe_condition_blueprint import PipeConditionBlueprint-from pipelex.pipe_controllers.condition.pipe_condition_factory import PipeConditionFactoryfrom 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 validationblueprint = 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.pyindex 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 pytestfrom pipelex import logfrom pipelex.core.pipes.exceptions import PipeValidationError+from pipelex.core.pipes.pipe_factory import PipeFactory+from pipelex.pipe_controllers.parallel.pipe_parallel import PipeParallelfrom pipelex.pipe_controllers.parallel.pipe_parallel_blueprint import PipeParallelBlueprint-from pipelex.pipe_controllers.parallel.pipe_parallel_factory import PipeParallelFactoryfrom 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 validationblueprint = 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.pyindex 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 pytestfrom pipelex import logfrom pipelex.core.pipes.exceptions import PipeValidationError+from pipelex.core.pipes.pipe_factory import PipeFactory+from pipelex.pipe_controllers.sequence.pipe_sequence import PipeSequencefrom pipelex.pipe_controllers.sequence.pipe_sequence_blueprint import PipeSequenceBlueprint-from pipelex.pipe_controllers.sequence.pipe_sequence_factory import PipeSequenceFactoryfrom 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 validationblueprint = 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.pyindex 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 Callableimport pytestfrom pipelex import log+from pipelex.core.pipes.pipe_factory import PipeFactory+from pipelex.pipe_operators.compose.pipe_compose import PipeComposefrom pipelex.pipe_operators.compose.pipe_compose_blueprint import PipeComposeBlueprint-from pipelex.pipe_operators.compose.pipe_compose_factory import PipeComposeFactoryfrom 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.pyindex 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 Callableimport pytestfrom pipelex import log+from pipelex.core.pipes.pipe_factory import PipeFactory+from pipelex.pipe_operators.func.pipe_func import PipeFuncfrom pipelex.pipe_operators.func.pipe_func_blueprint import PipeFuncBlueprint-from pipelex.pipe_operators.func.pipe_func_factory import PipeFuncFactoryfrom 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.pyindex 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 pytestfrom pipelex import logfrom 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 PipeImgGenfrom pipelex.pipe_operators.img_gen.pipe_img_gen_blueprint import PipeImgGenBlueprint-from pipelex.pipe_operators.img_gen.pipe_img_gen_factory import PipeImgGenFactoryfrom 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 matchesassert 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.pyindex 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 Callableimport pytestfrom pipelex import log+from pipelex.core.pipes.pipe_factory import PipeFactory+from pipelex.pipe_operators.llm.pipe_llm import PipeLLMfrom pipelex.pipe_operators.llm.pipe_llm_blueprint import PipeLLMBlueprint-from pipelex.pipe_operators.llm.pipe_llm_factory import PipeLLMFactoryfrom 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.plxindex 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"