julee 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

julee/__init__.py

@@ -1,3 +1,3 @@
 """Julee - Clean architecture for accountable and transparent digital supply chains."""
 
-__version__ = "0.1.1"
+__version__ = "0.1.5"

julee/api/tests/routers/test_assembly_specifications.py

@@ -25,6 +25,8 @@ from julee.repositories.memory import (
     MemoryAssemblySpecificationRepository,
 )
 
+pytestmark = pytest.mark.unit
+
 
 @pytest.fixture
 def memory_repo() -> MemoryAssemblySpecificationRepository:

julee/api/tests/routers/test_documents.py

@@ -18,6 +18,8 @@ from julee.api.routers.documents import router
 from julee.domain.models.document import Document, DocumentStatus
 from julee.repositories.memory import MemoryDocumentRepository
 
+pytestmark = pytest.mark.unit
+
 
 @pytest.fixture
 def memory_repo() -> MemoryDocumentRepository:

julee/api/tests/routers/test_knowledge_service_configs.py

@@ -22,6 +22,8 @@ from julee.domain.models.knowledge_service_config import (
     ServiceApi,
 )
 
+pytestmark = pytest.mark.unit
+
 
 @pytest.fixture
 def mock_repository() -> AsyncMock:

julee/api/tests/routers/test_knowledge_service_queries.py

@@ -22,6 +22,8 @@ from julee.repositories.memory import (
     MemoryKnowledgeServiceQueryRepository,
 )
 
+pytestmark = pytest.mark.unit
+
 
 @pytest.fixture
 def memory_repo() -> MemoryKnowledgeServiceQueryRepository:

julee/api/tests/routers/test_system.py

@@ -17,6 +17,8 @@ from fastapi.testclient import TestClient
 from julee.api.responses import ServiceStatus
 from julee.api.routers.system import router
 
+pytestmark = pytest.mark.unit
+
 
 @pytest.fixture
 def app_with_router() -> FastAPI:

julee/api/tests/routers/test_workflows.py

@@ -16,6 +16,8 @@ from fastapi_pagination import add_pagination
 from julee.api.dependencies import get_temporal_client
 from julee.api.routers.workflows import router
 
+pytestmark = pytest.mark.unit
+
 
 @pytest.fixture
 def mock_temporal_client() -> MagicMock:

julee/api/tests/test_app.py

@@ -25,6 +25,8 @@ from julee.repositories.memory.knowledge_service_config import (
     MemoryKnowledgeServiceConfigRepository,
 )
 
+pytestmark = pytest.mark.unit
+
 
 @pytest.fixture
 def memory_repo() -> MemoryKnowledgeServiceQueryRepository:

julee/api/tests/test_dependencies.py

@@ -16,6 +16,8 @@ from julee.api.dependencies import (
     get_startup_dependencies,
 )
 
+pytestmark = pytest.mark.unit
+
 
 @pytest.fixture
 def mock_container() -> AsyncMock:

julee/api/tests/test_requests.py

@@ -21,6 +21,8 @@ from julee.domain.models import (
     KnowledgeServiceQuery,
 )
 
+pytestmark = pytest.mark.unit
+
 
 class TestCreateAssemblySpecificationRequest:
     """Test CreateAssemblySpecificationRequest model."""

julee/contrib/polling/__init__.py

@@ -12,8 +12,10 @@ The polling module includes:
 - Co-located tests and examples
 
 Example usage:
-    from julee.contrib.polling import PollingConfig, HttpPollerService
-    from julee.contrib.polling import PollingProtocol, PollingResult
+    from julee.contrib.polling.domain.models.polling_config import PollingConfig, PollingProtocol
+    from julee.contrib.polling.infrastructure.services.polling.http import HttpPollerService
+    from julee.contrib.polling.domain.services.poller import PollerService
+    from julee.contrib.polling.domain.models.polling_config import PollingResult
 
     # Configure polling
     config = PollingConfig(
@@ -26,22 +28,23 @@ Example usage:
     # Poll the endpoint
     service = HttpPollerService()
     result = await service.poll_endpoint(config)
+
+Note: All imports must be explicit to avoid import chains that can pull
+non-deterministic code into Temporal workflows. Import directly from
+the specific modules you need rather than using this convenience module.
 """
 
-from .domain import PollerService, PollingConfig, PollingProtocol, PollingResult
-from .infrastructure import HttpPollerService, TemporalPollerService
-from .infrastructure.temporal import WorkflowPollerServiceProxy
-
-__all__ = [
-    # Domain models
-    "PollingConfig",
-    "PollingProtocol",
-    "PollingResult",
-    # Domain services
-    "PollerService",
-    # Infrastructure implementations
-    "HttpPollerService",
-    # Temporal integration
-    "TemporalPollerService",
-    "WorkflowPollerServiceProxy",
-]
+# No re-exports to avoid import chains that pull non-deterministic code
+# into Temporal workflows. Import from specific submodules instead:
+#
+# Domain:
+# - from julee.contrib.polling.domain.models.polling_config import PollingConfig, PollingProtocol, PollingResult
+# - from julee.contrib.polling.domain.services.poller import PollerService
+#
+# Infrastructure:
+# - from julee.contrib.polling.infrastructure.services.polling.http import HttpPollerService
+# - from julee.contrib.polling.infrastructure.temporal.manager import PollingManager
+# - from julee.contrib.polling.infrastructure.temporal.proxies import WorkflowPollerServiceProxy
+# - from julee.contrib.polling.infrastructure.temporal.activities import TemporalPollerService
+
+__all__ = []

julee/contrib/polling/apps/__init__.py

@@ -0,0 +1,17 @@
+"""
+Application entry points for the polling contrib module.
+
+This module contains the application-layer components that provide entry points
+for the polling contrib module, including worker pipelines, API routes, and
+CLI commands.
+
+Following the ADR contrib module structure, this layer wires together domain
+services and infrastructure implementations into runnable applications.
+
+No re-exports to avoid import chains that pull non-deterministic code
+into Temporal workflows. Import directly from specific modules:
+
+- from julee.contrib.polling.apps.worker.pipelines import NewDataDetectionPipeline
+"""
+
+__all__ = []

julee/contrib/polling/apps/worker/__init__.py

@@ -0,0 +1,17 @@
+"""
+Worker applications for the polling contrib module.
+
+This module contains worker-specific entry points for the polling contrib module,
+including Temporal workflows (pipelines) that orchestrate polling operations
+with durability guarantees.
+
+The worker applications in this module can be registered with Temporal workers
+to provide polling capabilities within workflow contexts.
+
+No re-exports to avoid import chains that pull non-deterministic code
+into Temporal workflows. Import directly from specific modules:
+
+- from julee.contrib.polling.apps.worker.pipelines import NewDataDetectionPipeline
+"""
+
+__all__ = []

julee/contrib/polling/apps/worker/pipelines.py

@@ -0,0 +1,288 @@
+"""
+Temporal workflows for polling operations in the Julee polling contrib module.
+
+This module contains workflows that orchestrate polling operations with
+Temporal's durability guarantees, providing retry logic, state management,
+and reliable execution for endpoint polling and change detection.
+"""
+
+import hashlib
+import logging
+from typing import Any
+
+from temporalio import workflow
+
+from julee.contrib.polling.domain.models.polling_config import PollingConfig
+from julee.contrib.polling.infrastructure.temporal.proxies import (
+    WorkflowPollerServiceProxy,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@workflow.defn
+class NewDataDetectionPipeline:
+    """
+    Temporal workflow for endpoint polling with new data detection.
+
+    This workflow:
+    1. Polls an endpoint using the configured polling service
+    2. Compares result with previous completion to detect changes
+    3. Triggers downstream processing when new data is detected
+    4. Returns completion result for next scheduled execution
+
+    The workflow uses Temporal's schedule last completion result feature
+    to automatically receive the previous execution's result for comparison.
+    """
+
+    def __init__(self) -> None:
+        self.current_step = "initialized"
+        self.endpoint_id: str | None = None
+        self.has_new_data: bool = False
+
+    @workflow.query
+    def get_current_step(self) -> str:
+        """Query method to get the current workflow step."""
+        return self.current_step
+
+    @workflow.query
+    def get_endpoint_id(self) -> str | None:
+        """Query method to get the endpoint ID being polled."""
+        return self.endpoint_id
+
+    @workflow.query
+    def get_has_new_data(self) -> bool:
+        """Query method to check if new data was detected."""
+        return self.has_new_data
+
+    async def trigger_downstream_pipeline(
+        self,
+        downstream_pipeline: str,
+        previous_data: bytes | None,
+        new_data: bytes,
+    ) -> bool:
+        """
+        Trigger downstream pipeline workflow.
+
+        Args:
+            downstream_pipeline: Name of the downstream workflow to trigger
+            previous_data: Previous content (None if first run)
+            new_data: New content that was detected
+
+        Returns:
+            True if successfully triggered, False otherwise
+        """
+        try:
+            # Start external workflow for downstream processing (fire-and-forget)
+            await workflow.start_child_workflow(
+                downstream_pipeline,  # This would be the workflow class name
+                args=[previous_data, new_data],
+                id=f"downstream-{self.endpoint_id}-{workflow.info().workflow_id}",
+                task_queue="downstream-processing-queue",
+            )
+
+            workflow.logger.info(
+                "Downstream pipeline triggered successfully",
+                extra={
+                    "endpoint_id": self.endpoint_id,
+                    "downstream_pipeline": downstream_pipeline,
+                },
+            )
+            return True
+
+        except Exception as e:
+            workflow.logger.error(
+                "Failed to trigger downstream pipeline",
+                extra={
+                    "endpoint_id": self.endpoint_id,
+                    "downstream_pipeline": downstream_pipeline,
+                    "error": str(e),
+                    "error_type": type(e).__name__,
+                },
+            )
+            # Don't fail the polling workflow if downstream trigger fails
+            return False
+
+    @workflow.run
+    async def run(
+        self,
+        config: PollingConfig | dict[str, Any],
+        downstream_pipeline: str | None = None,
+    ) -> dict[str, Any]:
+        """
+        Execute the new data detection workflow.
+
+        Args:
+            config: Configuration for the polling operation (PollingConfig or dict from schedule)
+            downstream_pipeline: Optional pipeline to trigger when new data detected
+
+        Returns:
+            Completion result containing polling result and detection metadata
+
+        Raises:
+            RuntimeError: If polling or downstream processing fails after retries
+        """
+        # Convert dict to PollingConfig if needed (for schedule compatibility)
+        # Temporal schedules serialize arguments as dicts, not Pydantic models
+        if isinstance(config, dict):
+            config = PollingConfig.model_validate(config)
+
+        self.endpoint_id = config.endpoint_identifier
+
+        # Fetch previous completion result from Temporal
+        previous_completion = workflow.get_last_completion_result()
+
+        workflow.logger.info(
+            "Starting new data detection pipeline",
+            extra={
+                "endpoint_id": self.endpoint_id,
+                "polling_protocol": config.polling_protocol.value,
+                "has_previous_completion": previous_completion is not None,
+                "workflow_id": workflow.info().workflow_id,
+                "run_id": workflow.info().run_id,
+            },
+        )
+
+        self.current_step = "polling_endpoint"
+
+        try:
+            # Step 1: Poll the endpoint
+            polling_service = WorkflowPollerServiceProxy()
+            polling_result = await polling_service.poll_endpoint(config)
+
+            # Extract the timestamp from when polling actually happened
+            polled_at = polling_result.polled_at.isoformat()
+
+            workflow.logger.debug(
+                "Polling completed",
+                extra={
+                    "endpoint_id": self.endpoint_id,
+                    "polling_success": polling_result.success,
+                    "content_length": len(polling_result.content),
+                },
+            )
+
+            self.current_step = "detecting_changes"
+
+            # Step 2: Detect new data using hash comparison
+            current_content = polling_result.content
+            current_hash = hashlib.sha256(current_content).hexdigest()
+
+            previous_hash = None
+            if previous_completion and "polling_result" in previous_completion:
+                previous_hash = previous_completion["polling_result"].get(
+                    "content_hash"
+                )
+
+            has_new_data = previous_hash != current_hash
+            self.has_new_data = has_new_data
+
+            workflow.logger.info(
+                f"DEBUG: Change detection - has_new_data: {has_new_data}, "
+                f"is_first_run: {previous_hash is None}, "
+                f"current_hash: {current_hash[:8]}..., "
+                f"previous_hash: {previous_hash[:8] if previous_hash else 'None'}..."
+            )
+
+            # Step 3: Trigger downstream processing if new data detected
+            downstream_triggered = False
+            if has_new_data and downstream_pipeline:
+                self.current_step = "triggering_downstream"
+
+                workflow.logger.info(
+                    "Triggering downstream pipeline",
+                    extra={
+                        "endpoint_id": self.endpoint_id,
+                        "downstream_pipeline": downstream_pipeline,
+                        "content_length": len(current_content),
+                    },
+                )
+
+                # Get previous data for comparison
+                previous_data = None
+                if previous_completion and "polling_result" in previous_completion:
+                    prev_content_str = previous_completion["polling_result"].get(
+                        "content"
+                    )
+                    if prev_content_str:
+                        try:
+                            previous_data = prev_content_str.encode("utf-8")
+                        except (UnicodeDecodeError, AttributeError) as e:
+                            workflow.logger.error(
+                                "Failed to decode previous content for downstream pipeline",
+                                extra={
+                                    "endpoint_id": self.endpoint_id,
+                                    "error": str(e),
+                                    "error_type": type(e).__name__,
+                                },
+                            )
+                            raise RuntimeError(
+                                f"Previous content is corrupted or invalid: {e}"
+                            )
+                    elif previous_hash:
+                        # We have previous run but no content - this is an error
+                        workflow.logger.error(
+                            "Previous content not available for downstream pipeline but previous hash exists",
+                            extra={
+                                "endpoint_id": self.endpoint_id,
+                                "previous_hash": previous_hash,
+                            },
+                        )
+                        raise RuntimeError(
+                            "Previous content is missing from completion result but is required for downstream pipeline"
+                        )
+
+                downstream_triggered = await self.trigger_downstream_pipeline(
+                    downstream_pipeline,
+                    previous_data,
+                    current_content,
+                )
+
+            self.current_step = "completed"
+
+            # Step 4: Return completion result for next scheduled execution
+            completion_result = {
+                "polling_result": {
+                    "success": polling_result.success,
+                    "content_hash": current_hash,
+                    "content": current_content.decode("utf-8", errors="ignore"),
+                    "polled_at": polled_at,
+                    "content_length": len(current_content),
+                },
+                "detection_result": {
+                    "has_new_data": has_new_data,
+                    "previous_hash": previous_hash,
+                    "current_hash": current_hash,
+                },
+                "downstream_triggered": downstream_triggered,
+                "endpoint_id": self.endpoint_id,
+                "completed_at": workflow.now().isoformat(),
+            }
+
+            workflow.logger.info(
+                "New data detection pipeline completed successfully",
+                extra={
+                    "endpoint_id": self.endpoint_id,
+                    "has_new_data": has_new_data,
+                    "downstream_triggered": downstream_triggered,
+                },
+            )
+
+            return completion_result
+
+        except Exception as e:
+            self.current_step = "failed"
+
+            workflow.logger.error(
+                "New data detection pipeline failed",
+                extra={
+                    "endpoint_id": self.endpoint_id,
+                    "error": str(e),
+                    "error_type": type(e).__name__,
+                    "current_step": self.current_step,
+                },
+                exc_info=True,
+            )
+
+            # Re-raise to let Temporal handle retry logic
+            raise

julee/contrib/polling/domain/__init__.py

@@ -4,14 +4,12 @@ Domain layer for the polling contrib module.
 This module contains the core domain models, services, and business rules
 for the polling contrib module. It defines the fundamental concepts and
 protocols that govern polling operations.
-"""
 
-from .models import PollingConfig, PollingProtocol, PollingResult
-from .services import PollerService
+No re-exports to avoid import chains that pull non-deterministic code
+into Temporal workflows. Import directly from specific modules:
+
+- from julee.contrib.polling.domain.models.polling_config import PollingConfig, PollingProtocol, PollingResult
+- from julee.contrib.polling.domain.services.poller import PollerService
+"""
 
-__all__ = [
-    "PollingConfig",
-    "PollingProtocol",
-    "PollingResult",
-    "PollerService",
-]
+__all__ = []

julee/contrib/polling/domain/models/__init__.py

@@ -2,12 +2,11 @@
 Polling domain models.
 
 This module contains the core domain models for the polling contrib module.
-"""
 
-from .polling_config import PollingConfig, PollingProtocol, PollingResult
+No re-exports to avoid import chains that pull non-deterministic code
+into Temporal workflows. Import directly from specific modules:
+
+- from julee.contrib.polling.domain.models.polling_config import PollingConfig, PollingProtocol, PollingResult
+"""
 
-__all__ = [
-    "PollingConfig",
-    "PollingProtocol",
-    "PollingResult",
-]
+__all__ = []

julee/contrib/polling/domain/models/polling_config.py

@@ -9,7 +9,7 @@ from datetime import datetime, timezone
 from enum import Enum
 from typing import Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 
 class PollingProtocol(str, Enum):
@@ -37,3 +37,20 @@ class PollingResult(BaseModel):
     polled_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
     content_hash: str | None = None
     error_message: str | None = None
+
+    @field_validator("content", mode="before")
+    @classmethod
+    def validate_content(cls, v):
+        """Convert list of integers to bytes (for Temporal serialization compatibility)."""
+        if isinstance(v, list):
+            # Temporal may serialize bytes as list of integers
+            return bytes(v)
+        elif isinstance(v, str):
+            # Handle string input
+            return v.encode("utf-8")
+        elif isinstance(v, bytes):
+            return v
+        else:
+            raise ValueError(
+                f"Content must be bytes, string, or list of integers, got {type(v)}"
+            )

julee/contrib/polling/domain/services/__init__.py

@@ -2,10 +2,11 @@
 Polling domain services.
 
 This module contains the service protocols for the polling contrib module.
-"""
 
-from .poller import PollerService
+No re-exports to avoid import chains that pull non-deterministic code
+into Temporal workflows. Import directly from specific modules:
+
+- from julee.contrib.polling.domain.services.poller import PollerService
+"""
 
-__all__ = [
-    "PollerService",
-]
+__all__ = []

julee/contrib/polling/domain/services/poller.py

@@ -10,7 +10,7 @@ mechanisms and are created via factory functions.
 
 from typing import Protocol, runtime_checkable
 
-from ..models import PollingConfig, PollingResult
+from ..models.polling_config import PollingConfig, PollingResult
 
 
 @runtime_checkable

julee/contrib/polling/infrastructure/__init__.py

@@ -3,13 +3,14 @@ Infrastructure layer for the polling contrib module.
 
 This module contains the concrete implementations of domain protocols
 and external system integrations for the polling contrib module.
-"""
 
-from .services import HttpPollerService
-from .temporal import TemporalPollerService, WorkflowPollerServiceProxy
+No re-exports to avoid import chains that pull non-deterministic code
+into Temporal workflows. Import directly from specific modules:
+
+- from julee.contrib.polling.infrastructure.services.polling.http import HttpPollerService
+- from julee.contrib.polling.infrastructure.temporal.manager import PollingManager
+- from julee.contrib.polling.infrastructure.temporal.proxies import WorkflowPollerServiceProxy
+- from julee.contrib.polling.infrastructure.temporal.activities import TemporalPollerService
+"""
 
-__all__ = [
-    "HttpPollerService",
-    "TemporalPollerService",
-    "WorkflowPollerServiceProxy",
-]
+__all__ = []

julee/contrib/polling/infrastructure/services/__init__.py

@@ -3,10 +3,11 @@ Infrastructure services for the polling contrib module.
 
 This module contains the concrete implementations of domain services
 for the polling contrib module.
-"""
 
-from .polling import HttpPollerService
+No re-exports to avoid import chains that pull non-deterministic code
+into Temporal workflows. Import directly from specific modules:
+
+- from julee.contrib.polling.infrastructure.services.polling.http import HttpPollerService
+"""
 
-__all__ = [
-    "HttpPollerService",
-]
+__all__ = []

julee/contrib/polling/infrastructure/services/polling/__init__.py

@@ -3,10 +3,11 @@ Polling infrastructure services.
 
 This module contains the concrete implementations of polling services
 for different protocols and mechanisms.
-"""
 
-from .http import HttpPollerService
+No re-exports to avoid import chains that pull non-deterministic code
+into Temporal workflows. Import directly from specific modules:
+
+- from julee.contrib.polling.infrastructure.services.polling.http import HttpPollerService
+"""
 
-__all__ = [
-    "HttpPollerService",
-]
+__all__ = []

julee/contrib/polling/infrastructure/services/polling/http/__init__.py

@@ -3,10 +3,11 @@ HTTP polling implementation.
 
 This module provides HTTP-specific polling functionality for the polling
 contrib module.
-"""
 
-from .http_poller_service import HttpPollerService
+No re-exports to avoid import chains that pull non-deterministic code
+into Temporal workflows. Import directly from specific modules:
+
+- from julee.contrib.polling.infrastructure.services.polling.http.http_poller_service import HttpPollerService
+"""
 
-__all__ = [
-    "HttpPollerService",
-]
+__all__ = []

julee/contrib/polling/infrastructure/services/polling/http/http_poller_service.py

@@ -11,8 +11,11 @@ from typing import Any
 
 import httpx
 
-from julee.contrib.polling.domain.models import PollingConfig, PollingResult
-from julee.contrib.polling.domain.services import PollerService
+from julee.contrib.polling.domain.models.polling_config import (
+    PollingConfig,
+    PollingResult,
+)
+from julee.contrib.polling.domain.services.poller import PollerService
 
 
 class HttpPollerService(PollerService):