julee 0.1.4__tar.gz → 0.1.6__tar.gz

julee-0.1.6/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: julee
+Version: 0.1.6
+Summary: Julee - Clean architecture for accountable and transparent digital supply chains
+Author-email: Pyx Industries <chris@pyx.io>
+License: GPL-3.0
+Project-URL: Homepage, https://github.com/pyx-industries/julee
+Project-URL: Repository, https://github.com/pyx-industries/julee
+Project-URL: Documentation, https://github.com/pyx-industries/julee#readme
+Project-URL: Issues, https://github.com/pyx-industries/julee/issues
+Keywords: temporal,workflow,document-processing,ai,supply-chain
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.20.0
+Requires-Dist: python-multipart
+Requires-Dist: fastapi-pagination>=0.12.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: temporalio[pydantic]>=1.3.0
+Requires-Dist: minio>=7.0.0
+Requires-Dist: anthropic>=0.66.0
+Requires-Dist: click>=0.8.0
+Requires-Dist: Jinja2>=3.0.0
+Requires-Dist: PyYAML>=6.0.0
+Requires-Dist: python-magic>=0.4.27
+Requires-Dist: multihash>=0.1.1
+Requires-Dist: six>=1.16.0
+Requires-Dist: jsonschema>=4.0.0
+Requires-Dist: jsonpointer>=3.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.5.0; extra == "dev"
+Requires-Dist: hypothesis>=6.0.0; extra == "dev"
+Requires-Dist: factory-boy>=3.2.0; extra == "dev"
+Requires-Dist: mypy>=1.7.0; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
+Requires-Dist: types-jsonschema; extra == "dev"
+Requires-Dist: types-python-dateutil; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Requires-Dist: bandit; extra == "dev"
+Requires-Dist: pip-tools>=7.0.0; extra == "dev"
+Requires-Dist: asyncpg; extra == "dev"
+Requires-Dist: sphinx>=7.0.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.0.0; extra == "docs"
+Requires-Dist: sphinx-autobuild>=2021.3.14; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=2.0.0; extra == "docs"
+Requires-Dist: furo>=2023.9.10; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.25.0; extra == "docs"
+Requires-Dist: sphinxcontrib-mermaid>=0.9.2; extra == "docs"
+Requires-Dist: sphinxcontrib-plantuml>=0.25; extra == "docs"
+Requires-Dist: sphinx-autoapi>=3.0.0; extra == "docs"
+Dynamic: license-file
+
+# Julee
+
+Clean architecture for accountable and transparent digital supply chains.
+
+Julee is a Python framework for building resilient, auditable business processes using Temporal workflows. Solutions are organized around your business domain—your bounded contexts become "accelerators" that speak your business language, not framework jargon.
+
+**Use Julee when:** processes must be done correctly, may be complex or long-running, need compliance audit trails (responsible AI, algorithmic due-diligence), or depend on unreliable services that may fail, timeout, or be rate-limited.
+
+**Core concepts:** Accelerators are collections of pipelines that automate a business area. Pipelines are use cases wrapped with Temporal, providing durability (survives crashes), reliability (automatic retries), observability (complete execution history), and supply chain provenance (audit trails that become "digital product passports").
+
+## Installation
+
+```bash
+pip install julee
+```
+
+## Runtime Dependencies
+
+Julee applications require: [Temporal](https://temporal.io/) (workflow orchestration), S3-compatible object storage (e.g. MinIO), PostgreSQL (for Temporal).
+
+## Documentation
+
+Full documentation at [julee.readthedocs.io](https://julee.readthedocs.io), package on [PyPI](https://pypi.org/project/julee/).
+
+## Example
+
+This repository includes a Docker Compose example demonstrating a meeting minutes extraction system:
+
+```bash
+cp .env.example .env  # Add your ANTHROPIC_API_KEY
+docker compose up --build
+```
+
+See the `demo-ui/` directory for the UI source.
+
+## License
+
+GPL-3.0 — see [LICENSE](LICENSE) for details.

julee-0.1.6/README.md

@@ -0,0 +1,38 @@
+# Julee
+
+Clean architecture for accountable and transparent digital supply chains.
+
+Julee is a Python framework for building resilient, auditable business processes using Temporal workflows. Solutions are organized around your business domain—your bounded contexts become "accelerators" that speak your business language, not framework jargon.
+
+**Use Julee when:** processes must be done correctly, may be complex or long-running, need compliance audit trails (responsible AI, algorithmic due-diligence), or depend on unreliable services that may fail, timeout, or be rate-limited.
+
+**Core concepts:** Accelerators are collections of pipelines that automate a business area. Pipelines are use cases wrapped with Temporal, providing durability (survives crashes), reliability (automatic retries), observability (complete execution history), and supply chain provenance (audit trails that become "digital product passports").
+
+## Installation
+
+```bash
+pip install julee
+```
+
+## Runtime Dependencies
+
+Julee applications require: [Temporal](https://temporal.io/) (workflow orchestration), S3-compatible object storage (e.g. MinIO), PostgreSQL (for Temporal).
+
+## Documentation
+
+Full documentation at [julee.readthedocs.io](https://julee.readthedocs.io), package on [PyPI](https://pypi.org/project/julee/).
+
+## Example
+
+This repository includes a Docker Compose example demonstrating a meeting minutes extraction system:
+
+```bash
+cp .env.example .env  # Add your ANTHROPIC_API_KEY
+docker compose up --build
+```
+
+See the `demo-ui/` directory for the UI source.
+
+## License
+
+GPL-3.0 — see [LICENSE](LICENSE) for details.

{julee-0.1.4 → julee-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "julee"
-version = "0.1.4"
+version = "0.1.6"
 description = "Julee - Clean architecture for accountable and transparent digital supply chains"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -54,6 +54,7 @@ dev = [
     "pytest>=8.0.0",
     "pytest-asyncio>=1.0.0",
     "pytest-cov>=4.1.0",
+    "pytest-xdist>=3.5.0",
     "hypothesis>=6.0.0",
     "factory-boy>=3.2.0",
     # Type checking
@@ -71,6 +72,8 @@ dev = [
     "pip-tools>=7.0.0",
     # Database (for testing)
     "asyncpg",
+    # Sphinx (for sphinx_hcd tests)
+    "sphinx>=7.0.0",
 ]
 
 docs = [
@@ -106,10 +109,20 @@ asyncio_mode = "auto"
 addopts = [
     "--strict-markers",
     "--tb=short",
+    "-n", "auto",
+    "--dist", "loadgroup",
     "--cov=src/julee",
     "--cov-report=term-missing",
     "--cov-report=html",
 ]
+markers = [
+    "unit: Unit tests (fast, isolated)",
+    "integration: Integration tests (slower, with dependencies)",
+    "e2e: End-to-end tests (slowest, full stack)",
+    "llm: Tests that use real LLM API calls (slow, costs money)",
+    "contract: Contract tests (verify external API shapes and mock fidelity)",
+    "slow: Slow tests (stress tests, load tests)",
+]
 
 [tool.coverage.run]
 source = ["src/julee"]

{julee-0.1.4 → julee-0.1.6}/src/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-0.1.4 → julee-0.1.6}/src/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-0.1.4 → julee-0.1.6}/src/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-0.1.4 → julee-0.1.6}/src/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-0.1.4 → julee-0.1.6}/src/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-0.1.4 → julee-0.1.6}/src/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-0.1.4 → julee-0.1.6}/src/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-0.1.4 → julee-0.1.6}/src/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-0.1.4 → julee-0.1.6}/src/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-0.1.4 → julee-0.1.6}/src/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-0.1.6/src/julee/contrib/polling/__init__.py

@@ -0,0 +1,50 @@
+"""
+Polling Contrib Module.
+
+This module provides ready-made polling functionality for external endpoints.
+It follows the Julee contrib module pattern, providing a complete polling
+solution that can be imported and used by Julee solutions.
+
+The polling module includes:
+- Domain models for polling configuration and results
+- Service protocols for polling operations
+- HTTP implementation for REST API polling
+- Co-located tests and examples
+
+Example usage:
+    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(
+        endpoint_identifier="api-v1",
+        polling_protocol=PollingProtocol.HTTP,
+        connection_params={"url": "https://api.example.com/data"},
+        timeout_seconds=30
+    )
+
+    # 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.
+"""
+
+# 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-0.1.6/src/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-0.1.6/src/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-0.1.6/src/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-0.1.6/src/julee/contrib/polling/domain/__init__.py

@@ -0,0 +1,15 @@
+"""
+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.
+
+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__ = []