Skip to content

Build AI methods with your coding agent, then run them anywhere: as an MCP for chatbots, as a webapp for people, or via API for your software.

Tidy errors

Louis Choquelf8af107de98e
diff --git a/pipelex/libraries/pipelines/builder/builder.py b/pipelex/libraries/pipelines/builder/builder.py
index 38d48245c..4e8dabebf 100644
--- a/pipelex/libraries/pipelines/builder/builder.py
+++ b/pipelex/libraries/pipelines/builder/builder.py
@@ -8,15 +8,26 @@ from pipelex.core.domains.domain_blueprint import DomainBlueprint
from pipelex.core.memory.working_memory import WorkingMemory
from pipelex.core.stuffs.stuff_content import ListContent, StructuredContent
from pipelex.exceptions import (
- ConceptDefinitionError,
ConceptLoadingError,
DomainLoadingError,
- PipeDefinitionError,
- PipelexError,
PipeLoadingError,
StaticValidationError,
)
-from pipelex.hub import get_class_registry, get_library_manager
+from pipelex.hub import get_library_manager
+from pipelex.libraries.pipelines.builder.builder_errors import (
+ ConceptDefinitionErrorData,
+ ConceptFailure,
+ ConceptSpecError,
+ DomainFailure,
+ PipeBuilderError,
+ PipeDefinitionErrorData,
+ PipeFailure,
+ PipelexBundleError,
+ PipelexBundleUnexpectedError,
+ PipeSpecError,
+ StaticValidationErrorData,
+ ValidateDryRunError,
+)
from pipelex.libraries.pipelines.builder.concept.concept_spec import ConceptSpec
from pipelex.libraries.pipelines.builder.pipe.pipe_batch_spec import PipeBatchSpec
from pipelex.libraries.pipelines.builder.pipe.pipe_compose_spec import PipeComposeSpec
@@ -36,10 +47,6 @@ class DomainInformation(StructuredContent):
definition: str = Field(description="Definition of the domain of the knowledge work.")
-class PipeBuilderError(Exception):
- pass
-
-
PipeSpecUnion = Annotated[
PipeFuncSpec
| PipeImgGenSpec
@@ -54,71 +61,6 @@ PipeSpecUnion = Annotated[
]
-class DomainFailure(StructuredContent):
- """Details of a single domain failure during dry run."""
-
- domain_code: str = Field(description="The code of the domain that failed")
- error_message: str = Field(description="The error message for this domain")
-
-
-class ConceptFailure(StructuredContent):
- """Details of a single concept failure during dry run."""
-
- concept_spec: ConceptSpec = Field(description="The failing concept spec with concept code")
- error_message: str = Field(description="The error message for this concept")
-
-
-class ConceptSpecError(PipelexError):
- """Details of a single concept failure during dry run."""
-
- def __init__(self, message: str, concept_failure: ConceptFailure):
- self.concept_failure = concept_failure
- super().__init__(message)
-
-
-class PipeFailure(StructuredContent):
- """Details of a single pipe failure during dry run."""
-
- pipe_spec: PipeSpecUnion = Field(description="The failing pipe spec with pipe code")
- error_message: str = Field(description="The error message for this pipe")
-
-
-class PipeSpecError(PipelexError):
- """Details of a single pipe failure during dry run."""
-
- def __init__(self, message: str, pipe_failure: PipeFailure):
- self.pipe_failure = pipe_failure
- super().__init__(message)
-
-
-class ValidateDryRunError(Exception):
- """Raised when validating the dry run of a pipe."""
-
-
-class PipelexBundleError(PipelexError):
- def __init__(
- self,
- message: str,
- static_validation_error: StaticValidationError | None = None,
- domain_failures: list[DomainFailure] | None = None,
- pipe_failures: list[PipeFailure] | None = None,
- concept_failures: list[ConceptFailure] | None = None,
- concept_definition_errors: list[ConceptDefinitionError] | None = None,
- pipe_definition_errors: list[PipeDefinitionError] | None = None,
- ):
- self.static_validation_error = static_validation_error
- self.domain_failures = domain_failures
- self.pipe_failures = pipe_failures
- self.concept_failures = concept_failures
- self.concept_definition_errors = concept_definition_errors
- self.pipe_definition_errors = pipe_definition_errors
- super().__init__(message)
-
-
-class PipelexBundleUnexpectedError(PipelexError):
- """Raised when an unexpected error occurs during validation."""
-
-
class PipelexBundleSpec(StructuredContent):
"""Complete spec of a Pipelex bundle TOML definition.
@@ -286,18 +228,45 @@ async def validate_bundle_spec(pipelex_bundle_spec: PipelexBundleSpec):
try:
pipes = library_manager.load_from_blueprint(blueprint=pipelex_bundle_blueprint)
except StaticValidationError as static_validation_error:
- raise PipelexBundleError(message=static_validation_error.desc(), static_validation_error=static_validation_error) from static_validation_error
+ static_validation_error_data = StaticValidationErrorData(
+ error_type=static_validation_error.error_type,
+ domain=static_validation_error.domain,
+ pipe_code=static_validation_error.pipe_code,
+ variable_names=static_validation_error.variable_names,
+ required_concept_codes=static_validation_error.required_concept_codes,
+ provided_concept_code=static_validation_error.provided_concept_code,
+ file_path=static_validation_error.file_path,
+ explanation=static_validation_error.explanation,
+ )
+ raise PipelexBundleError(
+ message=static_validation_error.desc(), static_validation_error=static_validation_error_data
+ ) from static_validation_error
except DomainLoadingError as domain_loading_error:
domain_failures = [DomainFailure(domain_code=domain_loading_error.domain_code, error_message=str(domain_loading_error))]
raise PipelexBundleError(message=domain_loading_error.message, domain_failures=domain_failures) from domain_loading_error
except ConceptLoadingError as concept_loading_error:
+ concept_def_error = concept_loading_error.concept_definition_error
+ concept_definition_error_data = ConceptDefinitionErrorData(
+ message=str(concept_def_error),
+ domain_code=concept_def_error.domain_code,
+ concept_code=concept_def_error.concept_code,
+ description=concept_def_error.description,
+ structure_class_python_code=concept_def_error.structure_class_python_code,
+ source=concept_def_error.source,
+ )
raise PipelexBundleError(
- message=concept_loading_error.message, concept_definition_errors=[concept_loading_error.concept_definition_error]
+ message=concept_loading_error.message, concept_definition_errors=[concept_definition_error_data]
) from concept_loading_error
except PipeLoadingError as pipe_loading_error:
- raise PipelexBundleError(
- message=pipe_loading_error.message, pipe_definition_errors=[pipe_loading_error.pipe_definition_error]
- ) from pipe_loading_error
+ pipe_def_error = pipe_loading_error.pipe_definition_error
+ pipe_definition_error_data = PipeDefinitionErrorData(
+ message=str(pipe_def_error),
+ domain_code=pipe_def_error.domain_code,
+ pipe_code=pipe_def_error.pipe_code,
+ description=pipe_def_error.description,
+ source=pipe_def_error.source,
+ )
+ raise PipelexBundleError(message=pipe_loading_error.message, pipe_definition_errors=[pipe_definition_error_data]) from pipe_loading_error
dry_run_result = await dry_run_pipes(pipes=pipes, raise_on_failure=False)
library_manager.remove_from_blueprint(blueprint=pipelex_bundle_blueprint)
diff --git a/pipelex/libraries/pipelines/builder/builder_errors.py b/pipelex/libraries/pipelines/builder/builder_errors.py
new file mode 100644
index 000000000..0568c0e6f
--- /dev/null
+++ b/pipelex/libraries/pipelines/builder/builder_errors.py
@@ -0,0 +1,190 @@
+"""Error classes and their structured content representations for the builder domain."""
+
+from pydantic import Field
+
+from pipelex.core.stuffs.stuff_content import StructuredContent
+from pipelex.exceptions import (
+ PipelexError,
+ StaticValidationErrorType,
+)
+from pipelex.libraries.pipelines.builder.concept.concept_spec import ConceptSpec
+from pipelex.libraries.pipelines.builder.pipe.pipe_batch_spec import PipeBatchSpec
+from pipelex.libraries.pipelines.builder.pipe.pipe_compose_spec import PipeComposeSpec
+from pipelex.libraries.pipelines.builder.pipe.pipe_condition_spec import PipeConditionSpec
+from pipelex.libraries.pipelines.builder.pipe.pipe_func_spec import PipeFuncSpec
+from pipelex.libraries.pipelines.builder.pipe.pipe_img_spec import PipeImgGenSpec
+from pipelex.libraries.pipelines.builder.pipe.pipe_llm_spec import PipeLLMSpec
+from pipelex.libraries.pipelines.builder.pipe.pipe_ocr_spec import PipeOcrSpec
+from pipelex.libraries.pipelines.builder.pipe.pipe_parallel_spec import PipeParallelSpec
+from pipelex.libraries.pipelines.builder.pipe.pipe_sequence_spec import PipeSequenceSpec
+from pipelex.types import Self
+
+# Type alias for pipe spec union
+PipeSpecUnion = (
+ PipeFuncSpec
+ | PipeImgGenSpec
+ | PipeComposeSpec
+ | PipeLLMSpec
+ | PipeOcrSpec
+ | PipeBatchSpec
+ | PipeConditionSpec
+ | PipeParallelSpec
+ | PipeSequenceSpec
+)
+
+
+# ============================================================================
+# BaseModel (StructuredContent) versions of error information
+# ============================================================================
+
+
+class StaticValidationErrorData(StructuredContent):
+ """Structured data for StaticValidationError."""
+
+ error_type: StaticValidationErrorType = Field(description="The type of static validation error")
+ domain: str = Field(description="The domain where the error occurred")
+ pipe_code: str | None = Field(None, description="The pipe code if applicable")
+ variable_names: list[str] | None = Field(None, description="Variable names involved in the error")
+ required_concept_codes: list[str] | None = Field(None, description="Required concept codes")
+ provided_concept_code: str | None = Field(None, description="The provided concept code")
+ file_path: str | None = Field(None, description="The file path where the error occurred")
+ explanation: str | None = Field(None, description="Additional explanation of the error")
+
+
+class ConceptDefinitionErrorData(StructuredContent):
+ """Structured data for ConceptDefinitionError."""
+
+ message: str = Field(description="The error message")
+ domain_code: str = Field(description="The domain code")
+ concept_code: str = Field(description="The concept code")
+ description: str = Field(description="Description of the concept")
+ structure_class_python_code: str | None = Field(None, description="Python code for the structure class if available")
+ source: str | None = Field(None, description="Source of the error")
+
+
+class PipeDefinitionErrorData(StructuredContent):
+ """Structured data for PipeDefinitionError."""
+
+ message: str = Field(description="The error message")
+ domain_code: str | None = Field(None, description="The domain code")
+ pipe_code: str | None = Field(None, description="The pipe code")
+ description: str | None = Field(None, description="Description of the pipe")
+ source: str | None = Field(None, description="Source of the error")
+
+
+class DomainFailure(StructuredContent):
+ """Details of a single domain failure during dry run."""
+
+ domain_code: str = Field(description="The code of the domain that failed")
+ error_message: str = Field(description="The error message for this domain")
+
+
+class ConceptFailure(StructuredContent):
+ """Details of a single concept failure during dry run."""
+
+ concept_spec: ConceptSpec = Field(description="The failing concept spec with concept code")
+ error_message: str = Field(description="The error message for this concept")
+
+
+class PipeFailure(StructuredContent):
+ """Details of a single pipe failure during dry run."""
+
+ pipe_spec: (
+ PipeFuncSpec
+ | PipeImgGenSpec
+ | PipeComposeSpec
+ | PipeLLMSpec
+ | PipeOcrSpec
+ | PipeBatchSpec
+ | PipeConditionSpec
+ | PipeParallelSpec
+ | PipeSequenceSpec
+ ) = Field(description="The failing pipe spec with pipe code")
+ error_message: str = Field(description="The error message for this pipe")
+
+
+class PipelexBundleErrorData(StructuredContent):
+ """Structured data for PipelexBundleError."""
+
+ message: str = Field(description="The main error message")
+ static_validation_error: StaticValidationErrorData | None = Field(None, description="Static validation error if present")
+ domain_failures: list[DomainFailure] | None = Field(None, description="List of domain failures")
+ pipe_failures: list[PipeFailure] | None = Field(None, description="List of pipe failures")
+ concept_failures: list[ConceptFailure] | None = Field(None, description="List of concept failures")
+ concept_definition_errors: list[ConceptDefinitionErrorData] | None = Field(None, description="List of concept definition errors")
+ pipe_definition_errors: list[PipeDefinitionErrorData] | None = Field(None, description="List of pipe definition errors")
+
+
+# ============================================================================
+# Exception classes with as_structured_content() methods
+# ============================================================================
+
+
+class PipeBuilderError(Exception):
+ """Base exception for pipe builder errors."""
+
+
+class ConceptSpecError(PipelexError):
+ """Details of a single concept failure during dry run."""
+
+ def __init__(self: Self, message: str, concept_failure: ConceptFailure) -> None:
+ self.concept_failure = concept_failure
+ super().__init__(message)
+
+ def as_structured_content(self: Self) -> ConceptFailure:
+ """Return the concept failure as structured content."""
+ return self.concept_failure
+
+
+class PipeSpecError(PipelexError):
+ """Details of a single pipe failure during dry run."""
+
+ def __init__(self: Self, message: str, pipe_failure: PipeFailure) -> None:
+ self.pipe_failure = pipe_failure
+ super().__init__(message)
+
+ def as_structured_content(self: Self) -> PipeFailure:
+ """Return the pipe failure as structured content."""
+ return self.pipe_failure
+
+
+class ValidateDryRunError(Exception):
+ """Raised when validating the dry run of a pipe."""
+
+
+class PipelexBundleError(PipelexError):
+ """Main bundle error that aggregates multiple types of errors."""
+
+ def __init__(
+ self: Self,
+ message: str,
+ static_validation_error: StaticValidationErrorData | None = None,
+ domain_failures: list[DomainFailure] | None = None,
+ pipe_failures: list[PipeFailure] | None = None,
+ concept_failures: list[ConceptFailure] | None = None,
+ concept_definition_errors: list[ConceptDefinitionErrorData] | None = None,
+ pipe_definition_errors: list[PipeDefinitionErrorData] | None = None,
+ ) -> None:
+ self.static_validation_error = static_validation_error
+ self.domain_failures = domain_failures
+ self.pipe_failures = pipe_failures
+ self.concept_failures = concept_failures
+ self.concept_definition_errors = concept_definition_errors
+ self.pipe_definition_errors = pipe_definition_errors
+ super().__init__(message)
+
+ def as_structured_content(self: Self) -> PipelexBundleErrorData:
+ """Convert the error to structured content."""
+ return PipelexBundleErrorData(
+ message=str(self),
+ static_validation_error=self.static_validation_error,
+ domain_failures=self.domain_failures,
+ pipe_failures=self.pipe_failures,
+ concept_failures=self.concept_failures,
+ concept_definition_errors=self.concept_definition_errors,
+ pipe_definition_errors=self.pipe_definition_errors,
+ )
+
+
+class PipelexBundleUnexpectedError(PipelexError):
+ """Raised when an unexpected error occurs during validation."""
diff --git a/pipelex/libraries/pipelines/builder/builder_loop.py b/pipelex/libraries/pipelines/builder/builder_loop.py
index 2c586a9cc..99219b16b 100644
--- a/pipelex/libraries/pipelines/builder/builder_loop.py
+++ b/pipelex/libraries/pipelines/builder/builder_loop.py
@@ -1,13 +1,13 @@
-from pipelex import pretty_print
+from pipelex import log, pretty_print
from pipelex.client.protocol import ImplicitMemory
from pipelex.language.plx_factory import PlxFactory
from pipelex.libraries.pipelines.builder.builder import (
- PipelexBundleError,
PipelexBundleSpec,
PipeSpecUnion,
reconstruct_bundle_with_pipe_fixes,
validate_bundle_spec,
)
+from pipelex.libraries.pipelines.builder.builder_errors import PipelexBundleError
from pipelex.pipeline.execute import execute_pipeline
from pipelex.tools.misc.file_utils import save_text_to_path
@@ -28,8 +28,9 @@ class BuilderLoop:
try:
await validate_bundle_spec(pipelex_bundle_spec=pipelex_bundle_spec)
- except PipelexBundleError as exc:
- pretty_print(exc, title="Pipelex Bundle Error")
+ except PipelexBundleError as bundle_error:
+ pretty_print(bundle_error.as_structured_content(), title="Pipelex Bundle Error")
+ log.error("Some pipes are failing, we should fix them but it's not implemented yet...")
fixed_pipes: list[PipeSpecUnion] = []
# TODO: fixe the pipes)