ai-pipeline-core 0.1.12__py3-none-any.whl → 0.4.1__py3-none-any.whl

ai_pipeline_core-0.4.1.dist-info/RECORD

@@ -0,0 +1,76 @@
+ai_pipeline_core/__init__.py,sha256=REZQInD3-LSShbonlXFpbe-IfjEtr90kkEx3JFxgfMA,3270
+ai_pipeline_core/exceptions.py,sha256=csAl7vq6xjSFBF8-UM9WZODCbhsOdOG5zH6IbA8iteM,1280
+ai_pipeline_core/prompt_manager.py,sha256=3wFkL5rrjtUT1cLInkgyhS8hKnO4MeD1cdXAEuLhgoE,9459
+ai_pipeline_core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_pipeline_core/settings.py,sha256=BUz8JEFfJQrdE4rNOhQWwxnTrfekLjWkoy-3wDZQ7PY,5142
+ai_pipeline_core/testing.py,sha256=jIRrLxNvTwdamucfJoHET2qMeRhhMZV9uEJXO5vAfis,279
+ai_pipeline_core/deployment/__init__.py,sha256=wTkVK6gcEQvqBajFMTAuodRONpN25yHbR1jtcumf0WQ,900
+ai_pipeline_core/deployment/base.py,sha256=ros0VzvkNCwbPgG9D49ceKSjTq857iRHzvW-uhiaNUE,34750
+ai_pipeline_core/deployment/contract.py,sha256=a1qbHhneTGB27oSOUy79CUIhOIzOoq37M63XoIMzA4Y,1952
+ai_pipeline_core/deployment/deploy.py,sha256=TCF4fH5f-K1ADODZHEyf-x7PJzDbv4qtWxlpoCe_mTs,22909
+ai_pipeline_core/deployment/helpers.py,sha256=yVtGFUs4AFXkpLkiQ_ale0nXXt5btfWSb5PAbikQHNs,3312
+ai_pipeline_core/deployment/progress.py,sha256=5tVD9nW0N-b8Z2BxazcWCWHFpLu6pJ-eqPmRyj68X6Y,3591
+ai_pipeline_core/deployment/remote.py,sha256=tOexisKEeeBoHLGYZWqcjr2H-nqqYc6kvoDL72AW78w,4661
+ai_pipeline_core/docs_generator/__init__.py,sha256=JbWbk-Lw5GgWrCMRuw8zvKNTZY2jXv7XqoMiBYudvRI,1255
+ai_pipeline_core/docs_generator/__main__.py,sha256=CH4agiM2suFJ63MhTg5m0GuXdc40z-6o4ojR72JQWVA,145
+ai_pipeline_core/docs_generator/cli.py,sha256=8OjdMtzQraPxWN3uPapSNJnKyPLPtnygKL0rF5JL2GY,7172
+ai_pipeline_core/docs_generator/extractor.py,sha256=yHQfeb_LwgBZW5dBY65L6a4qvNvxnwWiFXhqeZV5y5w,10631
+ai_pipeline_core/docs_generator/guide_builder.py,sha256=cxVEoYMfwOsFWDLbXddJ7IBBCRshbfSUoQ84ZMw_YQE,22232
+ai_pipeline_core/docs_generator/trimmer.py,sha256=olsl4MSmMHqsIEeVu9HU7xjONmIbSU7NmPwWdhOH6AA,1052
+ai_pipeline_core/docs_generator/validator.py,sha256=w-UdE6h6LLCwVy9Qqmv-TavIttA_1mcRoAhF9_HKszc,4460
+ai_pipeline_core/document_store/__init__.py,sha256=5aHsCpRkfkaLhLo0sVaKXEjqCcRYgzkVJErULKUpDAk,366
+ai_pipeline_core/document_store/_summary.py,sha256=qwy4kHEEwHwXGN7LVol09qzf7RjOJ2-6qTme-mtE8aM,377
+ai_pipeline_core/document_store/_summary_worker.py,sha256=K4575wCot0EoKCEsOj8XMCS1O6aWC37S9L_3TZjONco,6659
+ai_pipeline_core/document_store/clickhouse.py,sha256=vUlN2rIxCn5A8ceBFbpaHPS2O3tYEuR_UZkffWdy7E4,20636
+ai_pipeline_core/document_store/factory.py,sha256=F56ZM8TxgzFNYUkdzZidbxTe-JDiIAqi_tlE30cdlp0,1499
+ai_pipeline_core/document_store/local.py,sha256=r_dCJ46fto89yxZfKuGNQonpocQ1TwFFaCUntW-ZSQw,13396
+ai_pipeline_core/document_store/memory.py,sha256=MlsWHLLaEK6MdHBPZUgsNkbkFPvd2d2gFcfdDMBYvXo,3679
+ai_pipeline_core/document_store/protocol.py,sha256=UhA60PuSMBwpX9yVLOtUAsKqdPnU2synDos6cB-WQng,2407
+ai_pipeline_core/documents/__init__.py,sha256=LphKH_CiN3BQ0gjtJps1Y1WF_Lt2Qg-75aq2U1_PvP8,723
+ai_pipeline_core/documents/_context_vars.py,sha256=JbgQoCNaHPrOAMlEa6HYB8Ti7iw_jQfZOi5eNrwHYWg,2687
+ai_pipeline_core/documents/_hashing.py,sha256=_u1P4z1bMNSREJ6GNf3sSqf0TCrDr9sVcAIG9bnORnU,1667
+ai_pipeline_core/documents/attachment.py,sha256=eVpb27Qu8mLO2Bxv_JYd5JXhgViaJusVM8RBGcU1iQE,2951
+ai_pipeline_core/documents/context.py,sha256=vlORnRk2klMTZk6X4jEJayeH4B2Xo6ZxZ-31mtdba6o,5482
+ai_pipeline_core/documents/document.py,sha256=lU3hqbyYswRlWAiS9YGW9IRZnVA-3qmMpnAKPmi8Bws,26157
+ai_pipeline_core/documents/mime_type.py,sha256=QeRX6GiQnTpqx3Fk8QLhi1lT0Z5uEs496dGc4_xqgsA,6530
+ai_pipeline_core/documents/utils.py,sha256=9WOW3zvKYxQPnM8LjYFy3V9-yqc6hwgCaiog3kUH274,5413
+ai_pipeline_core/images/__init__.py,sha256=Hc2QKR27Q2Q-h5nH-EbzfxdE3dHArBm-st5_xjOKFh0,8854
+ai_pipeline_core/images/_processing.py,sha256=MrCuPGsyyEl9UlXYIPhZs0wN8CPTMZmejV2Lo2wyCZk,4362
+ai_pipeline_core/llm/__init__.py,sha256=oyRvYD5DLDl7JIRTBUaiVz6jUC5dLLujkMNFpfRp2zc,795
+ai_pipeline_core/llm/ai_messages.py,sha256=Ycmntk5d6NUFqVVsnNR_IDwJUFuHYEH7CPvmmDfYaJI,17424
+ai_pipeline_core/llm/client.py,sha256=CjxOiniuy5CEsA_Xz0KPLCBthbnUfC43fTpuDcqkIUM,30276
+ai_pipeline_core/llm/model_options.py,sha256=hg8xR0RJdJKp8QJNA4EbLnfFsnkE4HnxD85aYxc--hM,9164
+ai_pipeline_core/llm/model_response.py,sha256=Ml9wcssSssqibReJxCc9EQu488pz69Cmq_XNBs_xmak,12219
+ai_pipeline_core/llm/model_types.py,sha256=qHoUPPEkHu9B4kJ5xcIC09fk72v667ZxvzigxtgLpVo,2174
+ai_pipeline_core/logging/__init__.py,sha256=H8G3bycxwNxc4e4Gjwi-al9e2ufTJbTV5iFKCF1Ticw,495
+ai_pipeline_core/logging/logging.yml,sha256=qsf6vcxtWIHD5xwJGtylibiuy_0KF_Ji7-qb-xvFtaU,1357
+ai_pipeline_core/logging/logging_config.py,sha256=JnTarGSSkpi7eqR7N13TLKeuwNCvZgwJUPlhObiwrHk,6095
+ai_pipeline_core/logging/logging_mixin.py,sha256=Jn3x0xvSwSjbAMfWELMOEfffWBB1u4IeIr7M2-55CJs,7191
+ai_pipeline_core/observability/__init__.py,sha256=km2nIiY3aYH13s2m4nR91erQG4qKnGuvQkrKDdVW3bw,720
+ai_pipeline_core/observability/_document_tracking.py,sha256=tXv6rbGIuxOYdq22aVbyn9Ve5EhYHPnrYCE-kj2NGXI,5428
+ai_pipeline_core/observability/_initialization.py,sha256=GfwRHpg90Og3PzmG1ZUilJVXoFx9BIWpbMgXxJ5Alqk,6747
+ai_pipeline_core/observability/_logging_bridge.py,sha256=T3PpkgoI0YKN2vvBJEHzR5rFMFNHq9REHJs7PQX2VQk,2053
+ai_pipeline_core/observability/_summary.py,sha256=GAZXzXVkwUcubSiGb5DgkHfO1gGwx6pYoDz6RUJmL5k,3390
+ai_pipeline_core/observability/tracing.py,sha256=KhIXSl5fe39UE1Eokz9-1fe5biX6anKbwZDmXY_Z2LU,27050
+ai_pipeline_core/observability/_debug/__init__.py,sha256=V8pbgdQOx-7oFKQ_sNzAZ1-oq5c73P4kVjEClZDXe8k,942
+ai_pipeline_core/observability/_debug/_auto_summary.py,sha256=LMvETvx_RPKF8srewCKwjigTiWs3KfDmQAYYSuVybIM,2687
+ai_pipeline_core/observability/_debug/_config.py,sha256=CWfnK-F3knUuOQ34y_CjmU3l67J85NIZ3siftYhevc0,3367
+ai_pipeline_core/observability/_debug/_content.py,sha256=ECy2vR8wDHJq0RD2X10XS-ed8uCq9VD3K8fnGOjQxgs,30657
+ai_pipeline_core/observability/_debug/_processor.py,sha256=FkX1xqeJds-Gctt5keYSTSaC85FM4QaeFIEevTn7Qh8,3875
+ai_pipeline_core/observability/_debug/_summary.py,sha256=gD7MtWldBRs2VniQxUBjr6XbD2Z8HhbqZdnkcr4HdzE,11274
+ai_pipeline_core/observability/_debug/_types.py,sha256=Cw80SWSVso02kkj6T7hICGU_vn3W2RUEv74h94V5ZfI,2220
+ai_pipeline_core/observability/_debug/_writer.py,sha256=0JOmaQtg9OuhqcAf15C2AAlkicIOGEoyWerKTiOmuTw,32497
+ai_pipeline_core/observability/_tracking/__init__.py,sha256=tiZhj_d0STL0ACq2mTktciGjXzpepfMtl5KA_OFElTE,245
+ai_pipeline_core/observability/_tracking/_client.py,sha256=q3YhKJVm3jEWDXzKclQmndZ6RYIu7_F4Az_uY98uA-k,6634
+ai_pipeline_core/observability/_tracking/_internal.py,sha256=zv4DI2a8pG3wM_QEuwTNxk2V_q0jEZe6HsL6P7eVO7Y,820
+ai_pipeline_core/observability/_tracking/_models.py,sha256=p3nZucNGr-JsdscqnbJOy8JL1B-w6p43I-1bXvOkfc8,3237
+ai_pipeline_core/observability/_tracking/_processor.py,sha256=H8D82gRs4JY6ya0ewojoVAg85FUQV-imi9bQO8M0kGU,5999
+ai_pipeline_core/observability/_tracking/_service.py,sha256=diK-0qJg4HU-BHgpN1NTyFEbgPXq2e0gluRq21B8IbE,10357
+ai_pipeline_core/observability/_tracking/_writer.py,sha256=xZjwYyIxDzzzPxqkKjYAYOyNP4uvKXZ-r_u-APSV_x8,9246
+ai_pipeline_core/pipeline/__init__.py,sha256=uMv1jwSyq8Ym8Hbn5097twBJLdwN1iMeqnVM4EWyrhA,282
+ai_pipeline_core/pipeline/decorators.py,sha256=CDJAeOjGLt5Ewc0Jc9zEuwLZwKyutOv89LSRS9dcXmI,37456
+ai_pipeline_core/pipeline/options.py,sha256=KF4FcT085-IwX8r649v0a9ua5xnApM0qG2wJHWbq39A,438
+ai_pipeline_core-0.4.1.dist-info/METADATA,sha256=s6YKwEgTfky-_y2CqKaYnU5yHcxOf_r7MxpdxfRL0OE,29947
+ai_pipeline_core-0.4.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ai_pipeline_core-0.4.1.dist-info/licenses/LICENSE,sha256=kKj8mfbdWwkyG3U6n7ztB3bAZlEwShTkAsvaY657i3I,1074
+ai_pipeline_core-0.4.1.dist-info/RECORD,,

{ai_pipeline_core-0.1.12.dist-info → ai_pipeline_core-0.4.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

ai_pipeline_core/documents/document_list.py

@@ -1,240 +0,0 @@
-"""Type-safe list container for Document objects.
-
-@public
-"""
-
-from typing import Any, Iterable, SupportsIndex, Union, overload
-
-from typing_extensions import Self
-
-from .document import Document
-
-
-class DocumentList(list[Document]):
-    """Type-safe container for Document objects.
-
-    @public
-
-    Specialized list with validation and filtering for documents.
-
-    Best Practice: Use default constructor in 90% of cases. Only enable
-    validate_same_type or validate_duplicates when you explicitly need them.
-
-    Example:
-        >>> # RECOMMENDED - default constructor for most cases
-        >>> docs = DocumentList([doc1, doc2])
-        >>> # Or empty initialization
-        >>> docs = DocumentList()
-        >>> docs.append(MyDocument(name="file.txt", content=b"data"))
-        >>>
-        >>> # Only use validation flags when specifically needed:
-        >>> docs = DocumentList(validate_same_type=True)  # Rare use case
-        >>> doc = docs.get_by("file.txt")  # Get by name
-    """
-
-    def __init__(
-        self,
-        documents: list[Document] | None = None,
-        validate_same_type: bool = False,
-        validate_duplicates: bool = False,
-    ) -> None:
-        """Initialize DocumentList.
-
-        @public
-
-        Args:
-            documents: Initial list of documents.
-            validate_same_type: Enforce same document type.
-            validate_duplicates: Prevent duplicate filenames.
-        """
-        super().__init__()
-        self._validate_same_type = validate_same_type
-        self._validate_duplicates = validate_duplicates
-        if documents:
-            self.extend(documents)
-
-    def _validate_no_duplicates(self) -> None:
-        """Check for duplicate document names.
-
-        Raises:
-            ValueError: If duplicate document names are found.
-        """
-        if not self._validate_duplicates:
-            return
-
-        filenames = [doc.name for doc in self]
-        seen: set[str] = set()
-        duplicates: list[str] = []
-        for name in filenames:
-            if name in seen:
-                duplicates.append(name)
-            seen.add(name)
-        if duplicates:
-            unique_duplicates = list(set(duplicates))
-            raise ValueError(f"Duplicate document names found: {unique_duplicates}")
-
-    def _validate_no_description_files(self) -> None:
-        """Ensure no documents use reserved description file extension.
-
-        Raises:
-            ValueError: If any document uses the reserved description file extension.
-        """
-        description_files = [
-            doc.name for doc in self if doc.name.endswith(Document.DESCRIPTION_EXTENSION)
-        ]
-        if description_files:
-            raise ValueError(
-                f"Documents with {Document.DESCRIPTION_EXTENSION} suffix are not allowed: "
-                f"{description_files}"
-            )
-
-    def _validate_types(self) -> None:
-        """Ensure all documents are of the same class type.
-
-        Raises:
-            ValueError: If documents have different class types.
-        """
-        if not self._validate_same_type or not self:
-            return
-
-        first_class = type(self[0])
-        different_types = [doc for doc in self if type(doc) is not first_class]
-        if different_types:
-            types = list({type(doc).__name__ for doc in self})
-            raise ValueError(f"All documents must have the same type. Found types: {types}")
-
-    def _validate(self) -> None:
-        """Run all configured validation checks."""
-        self._validate_no_duplicates()
-        self._validate_no_description_files()
-        self._validate_types()
-
-    def append(self, document: Document) -> None:
-        """Add a document to the end of the list."""
-        super().append(document)
-        self._validate()
-
-    def extend(self, documents: Iterable[Document]) -> None:
-        """Add multiple documents to the list."""
-        super().extend(documents)
-        self._validate()
-
-    def insert(self, index: SupportsIndex, document: Document) -> None:
-        """Insert a document at the specified position."""
-        super().insert(index, document)
-        self._validate()
-
-    @overload
-    def __setitem__(self, index: SupportsIndex, value: Document) -> None: ...
-
-    @overload
-    def __setitem__(self, index: slice, value: Iterable[Document]) -> None: ...
-
-    def __setitem__(self, index: Union[SupportsIndex, slice], value: Any) -> None:
-        """Set item or slice with validation."""
-        super().__setitem__(index, value)
-        self._validate()
-
-    def __iadd__(self, other: Any) -> "Self":
-        """In-place addition (+=) with validation.
-
-        Returns:
-            Self: This DocumentList after modification.
-        """
-        result = super().__iadd__(other)
-        self._validate()
-        return result
-
-    @overload
-    def filter_by(self, arg: str) -> "DocumentList": ...
-
-    @overload
-    def filter_by(self, arg: type[Document]) -> "DocumentList": ...
-
-    @overload
-    def filter_by(self, arg: list[type[Document]]) -> "DocumentList": ...
-
-    def filter_by(self, arg: str | type[Document] | list[type[Document]]) -> "DocumentList":
-        """Filter documents by name or type(s).
-
-        @public
-
-        Args:
-            arg: Document name (str), single document type, or list of document types.
-
-        Returns:
-            New DocumentList with filtered documents.
-
-        Raises:
-            TypeError: If arg is not a valid type (str, Document type, or list of Document types).
-
-        Example:
-            >>> docs.filter_by("file.txt")  # Filter by name
-            >>> docs.filter_by(MyDocument)  # Filter by type
-            >>> docs.filter_by([Doc1, Doc2])  # Filter by multiple types
-        """
-        if isinstance(arg, str):
-            # Filter by name
-            return DocumentList([doc for doc in self if doc.name == arg])
-        elif isinstance(arg, type):
-            # Filter by single type (including subclasses)
-            return DocumentList([doc for doc in self if isinstance(doc, arg)])
-        elif isinstance(arg, list):  # type: ignore[reportUnnecessaryIsInstance]
-            # Filter by multiple types
-            documents = DocumentList()
-            for document_type in arg:
-                documents.extend([doc for doc in self if isinstance(doc, document_type)])
-            return documents
-        else:
-            raise TypeError(f"Invalid argument type for filter_by: {type(arg)}")
-
-    @overload
-    def get_by(self, arg: str) -> Document: ...
-
-    @overload
-    def get_by(self, arg: type[Document]) -> Document: ...
-
-    @overload
-    def get_by(self, arg: str, required: bool = True) -> Document | None: ...
-
-    @overload
-    def get_by(self, arg: type[Document], required: bool = True) -> Document | None: ...
-
-    def get_by(self, arg: str | type[Document], required: bool = True) -> Document | None:
-        """Get a single document by name or type.
-
-        @public
-
-        Args:
-            arg: Document name (str) or document type.
-            required: If True, raises ValueError when not found. If False, returns None.
-
-        Returns:
-            The first matching document, or None if not found and required=False.
-
-        Raises:
-            ValueError: If required=True and document not found.
-            TypeError: If arg is not a string or Document type.
-
-        Example:
-            >>> doc = docs.get_by("file.txt")  # Get by name, raises if not found
-            >>> doc = docs.get_by(MyDocument, required=False)  # Returns None if not found
-        """
-        if isinstance(arg, str):
-            # Get by name
-            for doc in self:
-                if doc.name == arg:
-                    return doc
-            if required:
-                raise ValueError(f"Document with name '{arg}' not found")
-            return None
-        elif isinstance(arg, type):  # type: ignore[reportUnnecessaryIsInstance]
-            # Get by type (including subclasses)
-            for doc in self:
-                if isinstance(doc, arg):
-                    return doc
-            if required:
-                raise ValueError(f"Document of type '{arg.__name__}' not found")
-            return None
-        else:
-            raise TypeError(f"Invalid argument type for get_by: {type(arg)}")

ai_pipeline_core/documents/flow_document.py

@@ -1,128 +0,0 @@
-"""Flow-specific document base class for persistent pipeline data.
-
-@public
-
-This module provides the FlowDocument abstract base class for documents
-that need to persist across Prefect flow runs and between pipeline steps.
-"""
-
-from typing import Literal, final
-
-from .document import Document
-
-
-class FlowDocument(Document):
-    """Abstract base class for documents that persist across flow runs.
-
-    @public
-
-    FlowDocument is used for data that needs to be saved between pipeline
-    steps and across multiple flow executions. These documents are typically
-    written to the file system using the simple_runner utilities.
-
-    Key characteristics:
-    - Persisted to file system between pipeline steps
-    - Survives across multiple flow runs
-    - Used for flow inputs and outputs
-    - Saved in directories named after the document's canonical name
-
-    Creating FlowDocuments:
-        **Use the `create` classmethod** for most use cases. It handles automatic
-        conversion of various content types. Only use __init__ when you have bytes.
-
-        >>> from enum import StrEnum
-        >>>
-        >>> # Simple document with pass:
-        >>> class MyDoc(FlowDocument):
-        ...     pass
-        >>>
-        >>> # Document with restricted file names:
-        >>> class ConfigDoc(FlowDocument):
-        ...     class FILES(StrEnum):
-        ...         CONFIG = "config.yaml"
-        ...         SETTINGS = "settings.json"
-        >>>
-        >>> # RECOMMENDED - automatic conversion:
-        >>> doc = MyDoc.create(name="data.json", content={"key": "value"})
-        >>> doc = ConfigDoc.create(name="config.yaml", content={"host": "localhost"})
-
-    Persistence:
-        Documents are saved to: {output_dir}/{canonical_name}/{filename}
-        For example: output/my_doc/data.json
-
-    Note:
-        - Cannot instantiate FlowDocument directly - must subclass
-        - Used with FlowConfig to define flow input/output types
-        - No additional abstract methods to implement
-
-    See Also:
-        TaskDocument: For temporary documents within task execution
-        TemporaryDocument: For documents that are never persisted
-    """
-
-    def __init__(
-        self,
-        *,
-        name: str,
-        content: bytes,
-        description: str | None = None,
-    ) -> None:
-        """Initialize a FlowDocument with raw bytes content.
-
-        Important:
-            **Most users should use the `create` classmethod instead of __init__.**
-            The create method provides automatic content conversion for various types
-            (str, dict, list, Pydantic models) while __init__ only accepts bytes.
-
-        Prevents direct instantiation of the abstract FlowDocument class.
-        FlowDocument must be subclassed for specific document types.
-
-        Args:
-            name: Document filename (required, keyword-only)
-            content: Document content as raw bytes (required, keyword-only)
-            description: Optional human-readable description (keyword-only)
-
-        Raises:
-            TypeError: If attempting to instantiate FlowDocument directly
-                      instead of using a concrete subclass.
-
-        Example:
-            >>> from enum import StrEnum
-            >>>
-            >>> # Simple subclass:
-            >>> class MyFlowDoc(FlowDocument):
-            ...     pass
-            >>>
-            >>> # With FILES restriction:
-            >>> class RestrictedDoc(FlowDocument):
-            ...     class FILES(StrEnum):
-            ...         DATA = "data.json"
-            ...         METADATA = "metadata.yaml"
-            >>>
-            >>> # Direct constructor - only for bytes:
-            >>> doc = MyFlowDoc(name="test.bin", content=b"raw data")
-            >>>
-            >>> # RECOMMENDED - use create for automatic conversion:
-            >>> doc = RestrictedDoc.create(name="data.json", content={"key": "value"})
-            >>> # This would raise DocumentNameError:
-            >>> # doc = RestrictedDoc.create(name="other.json", content={})
-        """
-        if type(self) is FlowDocument:
-            raise TypeError("Cannot instantiate abstract FlowDocument class directly")
-        super().__init__(name=name, content=content, description=description)
-
-    @final
-    def get_base_type(self) -> Literal["flow"]:
-        """Return the base type identifier for flow documents.
-
-        This method is final and cannot be overridden by subclasses.
-        It identifies this document as a flow-persistent document.
-
-        Returns:
-            "flow" - Indicates this document persists across flow runs.
-
-        Note:
-            This determines the document's lifecycle and persistence behavior
-            in the pipeline system.
-        """
-        return "flow"

ai_pipeline_core/documents/task_document.py

@@ -1,133 +0,0 @@
-"""Task-specific document base class for temporary pipeline data.
-
-@public
-
-This module provides the TaskDocument abstract base class for documents
-that exist only during Prefect task execution and are not persisted.
-"""
-
-from typing import Literal, final
-
-from .document import Document
-
-
-class TaskDocument(Document):
-    """Abstract base class for temporary documents within task execution.
-
-    @public
-
-    TaskDocument is used for intermediate data that exists only during
-    the execution of a Prefect task and is not persisted to disk. These
-    documents are ideal for temporary processing results, transformations,
-    and data that doesn't need to survive beyond the current task.
-
-    Key characteristics:
-    - Not persisted to file system
-    - Exists only during task execution
-    - Garbage collected after task completes
-    - Used for intermediate processing results
-    - Reduces persistent I/O for temporary data
-
-    Creating TaskDocuments:
-        **Use the `create` classmethod** for most use cases. It handles automatic
-        conversion of various content types. Only use __init__ when you have bytes.
-
-        >>> from enum import StrEnum
-        >>>
-        >>> # Simple task document:
-        >>> class TempDoc(TaskDocument):
-        ...     pass
-        >>>
-        >>> # With restricted files:
-        >>> class CacheDoc(TaskDocument):
-        ...     class FILES(StrEnum):
-        ...         CACHE = "cache.json"
-        ...         INDEX = "index.dat"
-        >>>
-        >>> # RECOMMENDED - automatic conversion:
-        >>> doc = TempDoc.create(name="temp.json", content={"status": "processing"})
-        >>> doc = CacheDoc.create(name="cache.json", content={"data": [1, 2, 3]})
-
-    Use Cases:
-        - Intermediate transformation results
-        - Temporary buffers during processing
-        - Task-local cache data
-        - Processing status documents
-
-    Note:
-        - Cannot instantiate TaskDocument directly - must subclass
-        - Not saved by simple_runner utilities
-        - Reduces I/O overhead for temporary data
-        - No additional abstract methods to implement
-
-    See Also:
-        FlowDocument: For documents that persist across flow runs
-        TemporaryDocument: Alternative for non-persistent documents
-    """
-
-    def __init__(
-        self,
-        *,
-        name: str,
-        content: bytes,
-        description: str | None = None,
-    ) -> None:
-        """Initialize a TaskDocument with raw bytes content.
-
-        Important:
-            **Most users should use the `create` classmethod instead of __init__.**
-            The create method provides automatic content conversion for various types
-            (str, dict, list, Pydantic models) while __init__ only accepts bytes.
-
-        Prevents direct instantiation of the abstract TaskDocument class.
-        TaskDocument must be subclassed for specific temporary document types.
-
-        Args:
-            name: Document filename (required, keyword-only)
-            content: Document content as raw bytes (required, keyword-only)
-            description: Optional human-readable description (keyword-only)
-
-        Raises:
-            TypeError: If attempting to instantiate TaskDocument directly
-                      instead of using a concrete subclass.
-
-        Example:
-            >>> from enum import StrEnum
-            >>>
-            >>> # Simple subclass:
-            >>> class MyTaskDoc(TaskDocument):
-            ...     pass
-            >>>
-            >>> # With FILES restriction:
-            >>> class TempProcessDoc(TaskDocument):
-            ...     class FILES(StrEnum):
-            ...         BUFFER = "buffer.bin"
-            ...         STATUS = "status.json"
-            >>>
-            >>> # Direct constructor - only for bytes:
-            >>> doc = MyTaskDoc(name="temp.bin", content=b"raw data")
-            >>>
-            >>> # RECOMMENDED - use create for automatic conversion:
-            >>> doc = TempProcessDoc.create(name="status.json", content={"percent": 50})
-            >>> # This would raise DocumentNameError:
-            >>> # doc = TempProcessDoc.create(name="other.json", content={})
-        """
-        if type(self) is TaskDocument:
-            raise TypeError("Cannot instantiate abstract TaskDocument class directly")
-        super().__init__(name=name, content=content, description=description)
-
-    @final
-    def get_base_type(self) -> Literal["task"]:
-        """Return the base type identifier for task documents.
-
-        This method is final and cannot be overridden by subclasses.
-        It identifies this document as a task-scoped temporary document.
-
-        Returns:
-            "task" - Indicates this document is temporary within task execution.
-
-        Note:
-            This determines that the document will not be persisted and
-            exists only during task execution.
-        """
-        return "task"

ai_pipeline_core/documents/temporary_document.py

@@ -1,95 +0,0 @@
-"""Temporary document implementation for non-persistent data.
-
-@public
-
-This module provides the TemporaryDocument class for documents that
-are never persisted, regardless of context.
-"""
-
-from typing import Any, Literal, final
-
-from .document import Document
-
-
-@final
-class TemporaryDocument(Document):
-    r"""Concrete document class for data that is never persisted.
-
-    @public
-
-    TemporaryDocument is a final (non-subclassable) document type for
-    data that should never be saved to disk, regardless of whether it's
-    used in a flow or task context. Unlike FlowDocument and TaskDocument
-    which are abstract, TemporaryDocument can be instantiated directly.
-
-    Key characteristics:
-    - Never persisted to file system
-    - Can be instantiated directly (not abstract)
-    - Cannot be subclassed (annotated with Python's @final decorator in code)
-    - Useful for transient data like API responses or intermediate calculations
-    - Ignored by simple_runner save operations
-
-    Creating TemporaryDocuments:
-        **Use the `create` classmethod** for most use cases. It handles automatic
-        conversion of various content types. Only use __init__ when you have bytes.
-
-        >>> # RECOMMENDED - automatic conversion:
-        >>> doc = TemporaryDocument.create(
-        ...     name="api_response.json",
-        ...     content={"status": "ok", "data": [1, 2, 3]}
-        ... )
-        >>> doc = TemporaryDocument.create(
-        ...     name="credentials.txt",
-        ...     content="secret_token_xyz"
-        ... )
-        >>>
-        >>> # Direct constructor - only for bytes:
-        >>> doc = TemporaryDocument(
-        ...     name="binary.dat",
-        ...     content=b"\x00\x01\x02"
-        ... )
-        >>>
-        >>> doc.is_temporary  # Always True
-
-    Use Cases:
-        - API responses that shouldn't be cached
-        - Sensitive credentials or tokens
-        - Intermediate calculations
-        - Temporary transformations
-        - Data explicitly marked as non-persistent
-
-    Note:
-        - This is a final class and cannot be subclassed
-        - Use when you explicitly want to prevent persistence
-        - Useful for sensitive data that shouldn't be written to disk
-
-    See Also:
-        FlowDocument: For documents that persist across flow runs
-        TaskDocument: For documents temporary within task execution
-    """
-
-    def __init_subclass__(cls, **kwargs: Any) -> None:
-        """Disallow subclassing.
-
-        Args:
-            **kwargs: Additional keyword arguments (ignored).
-
-        Raises:
-            TypeError: Always raised to prevent subclassing of `TemporaryDocument`.
-        """
-        raise TypeError("TemporaryDocument is final and cannot be subclassed")
-
-    def get_base_type(self) -> Literal["temporary"]:
-        """Return the base type identifier for temporary documents.
-
-        Identifies this document as temporary, ensuring it will
-        never be persisted by the pipeline system.
-
-        Returns:
-            "temporary" - Indicates this document is never persisted.
-
-        Note:
-            Documents with this type are explicitly excluded from
-            all persistence operations in the pipeline system.
-        """
-        return "temporary"