flowyml 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

flowyml/stacks/azure.py

@@ -0,0 +1,295 @@
+"""Azure Stack Components and Preset Stack."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from flowyml.stacks.base import Stack
+from flowyml.stacks.components import ArtifactStore, ContainerRegistry, DockerConfig, ResourceConfig
+from flowyml.core.remote_orchestrator import RemoteOrchestrator
+from flowyml.stacks.plugins import register_component
+from flowyml.storage.metadata import SQLiteMetadataStore
+from flowyml.core.submission_result import SubmissionResult
+
+
+@register_component(name="azure_blob")
+class AzureBlobArtifactStore(ArtifactStore):
+    """Artifact store backed by Azure Blob Storage."""
+
+    def __init__(
+        self,
+        name: str = "azure_blob",
+        account_url: str | None = None,
+        container_name: str | None = None,
+        credential: Any | None = None,
+    ):
+        super().__init__(name)
+        self.account_url = account_url
+        self.container_name = container_name
+        self.credential = credential
+
+    def _client(self):
+        from azure.storage.blob import BlobServiceClient
+
+        credential = self.credential
+        if credential is None:
+            from azure.identity import DefaultAzureCredential
+
+            credential = DefaultAzureCredential(exclude_shared_token_cache_credential=True)
+
+        return BlobServiceClient(account_url=self.account_url, credential=credential)
+
+    def validate(self) -> bool:
+        if not self.account_url or not self.container_name:
+            raise ValueError("account_url and container_name are required for AzureBlobArtifactStore")
+        try:
+            client = self._client()
+            container_client = client.get_container_client(self.container_name)
+            container_client.get_container_properties()
+        except Exception as exc:
+            raise ValueError(f"Unable to access container '{self.container_name}': {exc}") from exc
+        return True
+
+    def save(self, artifact: Any, path: str) -> str:
+        blob_name = path.lstrip("/")
+        client = self._client().get_container_client(self.container_name)
+        if isinstance(artifact, (str, Path)) and Path(artifact).exists():
+            with open(Path(artifact), "rb") as f:
+                client.upload_blob(name=blob_name, data=f, overwrite=True)
+        else:
+            data = artifact if isinstance(artifact, bytes) else str(artifact).encode()
+            client.upload_blob(name=blob_name, data=data, overwrite=True)
+        return f"{self.account_url}/{self.container_name}/{blob_name}"
+
+    def load(self, path: str) -> bytes:
+        blob_name = path.lstrip("/")
+        client = self._client().get_blob_client(self.container_name, blob_name)
+        downloader = client.download_blob()
+        return downloader.readall()
+
+    def exists(self, path: str) -> bool:
+        blob_name = path.lstrip("/")
+        client = self._client().get_blob_client(self.container_name, blob_name)
+        return client.exists()
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": "azure_blob",
+            "account_url": self.account_url,
+            "container_name": self.container_name,
+        }
+
+
+@register_component(name="acr")
+class ACRContainerRegistry(ContainerRegistry):
+    """Azure Container Registry integration."""
+
+    def __init__(
+        self,
+        name: str = "acr",
+        registry_name: str | None = None,
+        login_server: str | None = None,
+        username: str | None = None,
+        password: str | None = None,
+    ):
+        super().__init__(name)
+        self.registry_name = registry_name
+        self.login_server = login_server or (f"{registry_name}.azurecr.io" if registry_name else None)
+        self.username = username
+        self.password = password
+
+    def validate(self) -> bool:
+        if not self.registry_name and not self.login_server:
+            raise ValueError("registry_name or login_server is required for ACRContainerRegistry")
+        return True
+
+    def _login(self) -> None:
+        if self.username and self.password:
+            subprocess.run(
+                ["docker", "login", self.login_server, "-u", self.username, "-p", self.password],
+                check=True,
+            )
+        else:
+            subprocess.run(["az", "acr", "login", "--name", self.registry_name], check=True)
+
+    def push_image(self, image_name: str, tag: str = "latest") -> str:
+        full_uri = self.get_image_uri(image_name, tag)
+        self._login()
+        subprocess.run(["docker", "tag", f"{image_name}:{tag}", full_uri], check=True)
+        subprocess.run(["docker", "push", full_uri], check=True)
+        return full_uri
+
+    def pull_image(self, image_name: str, tag: str = "latest") -> None:
+        full_uri = self.get_image_uri(image_name, tag)
+        self._login()
+        subprocess.run(["docker", "pull", full_uri], check=True)
+
+    def get_image_uri(self, image_name: str, tag: str = "latest") -> str:
+        return f"{self.login_server}/{image_name}:{tag}"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": "acr",
+            "login_server": self.login_server,
+            "registry_name": self.registry_name,
+        }
+
+
+@register_component(name="azure_ml")
+class AzureMLOrchestrator(RemoteOrchestrator):
+    """Submit pipeline runs to Azure ML managed compute."""
+
+    def __init__(
+        self,
+        name: str = "azure_ml",
+        subscription_id: str | None = None,
+        resource_group: str | None = None,
+        workspace_name: str | None = None,
+        compute: str | None = None,
+        experiment_name: str = "flowyml",
+        credential: Any | None = None,
+    ):
+        super().__init__(name)
+        self.subscription_id = subscription_id
+        self.resource_group = resource_group
+        self.workspace_name = workspace_name
+        self.compute = compute
+        self.experiment_name = experiment_name
+        self.credential = credential
+
+    def _client(self):
+        from azure.ai.ml import MLClient
+        from azure.identity import DefaultAzureCredential
+
+        credential = self.credential or DefaultAzureCredential(exclude_shared_token_cache_credential=True)
+        return MLClient(
+            credential,
+            subscription_id=self.subscription_id,
+            resource_group_name=self.resource_group,
+            workspace_name=self.workspace_name,
+        )
+
+    def validate(self) -> bool:
+        if not all([self.subscription_id, self.resource_group, self.workspace_name, self.compute]):
+            raise ValueError(
+                "subscription_id, resource_group, workspace_name, and compute are required for AzureMLOrchestrator",
+            )
+        return True
+
+    def run_pipeline(
+        self,
+        pipeline: Any,
+        run_id: str,
+        resources: ResourceConfig | None = None,
+        docker_config: DockerConfig | None = None,
+        inputs: dict[str, Any] | None = None,
+        context: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> SubmissionResult:
+        """Submit pipeline to Azure ML.
+
+        Returns:
+            SubmissionResult with job name and optional wait function.
+        """
+        from azure.ai.ml import command
+
+        ml_client = self._client()
+        job_name = kwargs.get("job_name") or f"{pipeline.name}-{run_id[:8]}"
+
+        # Build command job
+        job = command(
+            code=".",  # Use current directory or specify path
+            command="python -m flowyml.cli.run",
+            environment=docker_config.image if docker_config else self.environment_name,
+            compute=self.compute,
+            display_name=job_name,
+            experiment_name=self.experiment_name,
+        )
+
+        submitted = ml_client.jobs.create_or_update(job)
+
+        def wait_for_completion():
+            ml_client.jobs.stream(submitted.name)
+
+        return SubmissionResult(
+            job_id=submitted.name,
+            wait_for_completion=wait_for_completion,
+            metadata={"studio_url": submitted.studio_url},
+        )
+
+    def get_run_status(self, run_id: str) -> str:
+        client = self._client()
+        job = client.jobs.get(run_id)
+        return job.status
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": "azure_ml",
+            "subscription_id": self.subscription_id,
+            "resource_group": self.resource_group,
+            "workspace_name": self.workspace_name,
+            "compute": self.compute,
+        }
+
+
+class AzureMLStack(Stack):
+    """Managed Azure ML stack built from AzureML orchestrator, Blob storage, and ACR."""
+
+    def __init__(
+        self,
+        name: str = "azure",
+        subscription_id: str | None = None,
+        resource_group: str | None = None,
+        workspace_name: str | None = None,
+        compute: str | None = None,
+        account_url: str | None = None,
+        container_name: str | None = None,
+        registry_name: str | None = None,
+        login_server: str | None = None,
+        metadata_store: Any | None = None,
+    ):
+        orchestrator = AzureMLOrchestrator(
+            subscription_id=subscription_id,
+            resource_group=resource_group,
+            workspace_name=workspace_name,
+            compute=compute,
+        )
+        artifact_store = AzureBlobArtifactStore(account_url=account_url, container_name=container_name)
+        container_registry = ACRContainerRegistry(registry_name=registry_name, login_server=login_server)
+
+        if metadata_store is None:
+            metadata_store = SQLiteMetadataStore()
+
+        super().__init__(
+            name=name,
+            executor=None,
+            artifact_store=artifact_store,
+            metadata_store=metadata_store,
+            container_registry=container_registry,
+            orchestrator=orchestrator,
+        )
+
+        self.subscription_id = subscription_id
+        self.workspace_name = workspace_name
+
+    def validate(self) -> bool:
+        self.orchestrator.validate()
+        self.artifact_store.validate()
+        self.container_registry.validate()
+        return True
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "type": "azure",
+            "subscription_id": self.subscription_id,
+            "workspace_name": self.workspace_name,
+            "orchestrator": self.orchestrator.to_dict(),
+            "artifact_store": self.artifact_store.to_dict(),
+            "container_registry": self.container_registry.to_dict(),
+        }

flowyml/stacks/bridge.py

@@ -6,7 +6,7 @@ frameworks (ZenML, Airflow, Prefect, etc.) using rule-based adaptation.
 
 import inspect
 from dataclasses import dataclass, field
-from typing import Any, Optional
+from typing import Any
 import logging
 
 from flowyml.stacks.components import (
@@ -25,8 +25,8 @@ class AdaptationRule:
     """Rule for adapting an external component."""
 
     # Matching criteria
-    source_type: Optional[str] = None  # e.g., "zenml.orchestrators.base.BaseOrchestrator"
-    name_pattern: Optional[str] = None  # e.g., ".*Orchestrator"
+    source_type: str | None = None  # e.g., "zenml.orchestrators.base.BaseOrchestrator"
+    name_pattern: str | None = None  # e.g., ".*Orchestrator"
     has_methods: list[str] = field(default_factory=list)  # e.g., ["run", "prepare_pipeline"]
 
     # Adaptation logic
@@ -49,7 +49,7 @@ class GenericBridge:
         self,
         external_class: Any,
         name: str,
-        config: Optional[dict[str, Any]] = None,
+        config: dict[str, Any] | None = None,
     ) -> type[StackComponent]:
         """Dynamically create a wrapper class based on rules.
 
@@ -75,7 +75,7 @@ class GenericBridge:
         else:
             return self._create_generic_wrapper(external_class, name, component_type, rule)
 
-    def _find_matching_rule(self, external_class: Any) -> Optional[AdaptationRule]:
+    def _find_matching_rule(self, external_class: Any) -> AdaptationRule | None:
         """Find the first rule that matches the external class."""
         for rule in self.rules:
             # Check source type
@@ -120,7 +120,7 @@ class GenericBridge:
         self,
         external_class: Any,
         name: str,
-        rule: Optional[AdaptationRule],
+        rule: AdaptationRule | None,
     ) -> type[Orchestrator]:
         """Create a wrapper for an Orchestrator."""
 
@@ -174,7 +174,7 @@ class GenericBridge:
         self,
         external_class: Any,
         name: str,
-        rule: Optional[AdaptationRule],
+        rule: AdaptationRule | None,
     ) -> type[ArtifactStore]:
         """Create a wrapper for an Artifact Store."""
 
@@ -216,7 +216,7 @@ class GenericBridge:
         self,
         external_class: Any,
         name: str,
-        rule: Optional[AdaptationRule],
+        rule: AdaptationRule | None,
     ) -> type[ContainerRegistry]:
         """Create a wrapper for a Container Registry."""
 
@@ -259,7 +259,7 @@ class GenericBridge:
         external_class: Any,
         name: str,
         comp_type: ComponentType,
-        rule: Optional[AdaptationRule],
+        rule: AdaptationRule | None,
     ) -> type[StackComponent]:
         """Create a generic wrapper."""
 

flowyml/stacks/components.py

@@ -99,8 +99,30 @@ class Orchestrator(StackComponent):
         return ComponentType.ORCHESTRATOR
 
     @abstractmethod
-    def run_pipeline(self, pipeline: Any, **kwargs) -> Any:
-        """Run a pipeline on this orchestrator."""
+    def run_pipeline(
+        self,
+        pipeline: Any,
+        run_id: str,
+        resources: "ResourceConfig | None" = None,
+        docker_config: "DockerConfig | None" = None,
+        inputs: dict[str, Any] | None = None,
+        context: dict[str, Any] | None = None,
+        **kwargs,
+    ) -> Any:
+        """Run a pipeline on this orchestrator.
+
+        Args:
+            pipeline: The pipeline to run.
+            run_id: The unique run identifier.
+            resources: Resource configuration.
+            docker_config: Docker configuration.
+            inputs: Input data.
+            context: Context variables.
+            **kwargs: Additional arguments.
+
+        Returns:
+            The run result or job ID.
+        """
         pass
 
     @abstractmethod

flowyml/stacks/gcp.py

@@ -6,17 +6,22 @@ on Google Cloud Platform using Vertex AI, Cloud Storage, and Container Registry.
 
 from typing import Any
 
+import subprocess
 from flowyml.stacks.base import Stack
 from flowyml.stacks.components import (
-    Orchestrator,
     ArtifactStore,
     ContainerRegistry,
     ResourceConfig,
     DockerConfig,
 )
+from flowyml.core.remote_orchestrator import RemoteOrchestrator
+from flowyml.stacks.plugins import register_component
+from flowyml.core.submission_result import SubmissionResult
+from flowyml.core.execution_status import ExecutionStatus
 
 
-class VertexAIOrchestrator(Orchestrator):
+@register_component(name="vertex_ai")
+class VertexAIOrchestrator(RemoteOrchestrator):
     """Vertex AI orchestrator for running pipelines on Google Cloud.
 
     This orchestrator submits pipeline jobs to Vertex AI Pipelines,
@@ -76,28 +81,35 @@ class VertexAIOrchestrator(Orchestrator):
     def run_pipeline(
         self,
         pipeline: Any,
+        run_id: str,
         resources: ResourceConfig | None = None,
         docker_config: DockerConfig | None = None,
+        inputs: dict[str, Any] | None = None,
+        context: dict[str, Any] | None = None,
         **kwargs,
-    ) -> str:
+    ) -> "SubmissionResult":
         """Run pipeline on Vertex AI.
 
         Args:
             pipeline: Pipeline to run
+            run_id: Run identifier
             resources: Resource configuration
             docker_config: Docker configuration
+            inputs: Input data
+            context: Context variables
             **kwargs: Additional arguments
 
         Returns:
-            Job ID
+            SubmissionResult with job resource name
         """
         from google.cloud import aiplatform
+        import time
 
         # Initialize Vertex AI
         aiplatform.init(project=self.project_id, location=self.region)
 
         # Create custom job
-        job_display_name = f"{pipeline.name}-{pipeline.run_id}"
+        job_display_name = f"{pipeline.name}-{run_id[:8]}"
 
         # Build worker pool specs
         worker_pool_specs = self._build_worker_pool_specs(
@@ -114,16 +126,66 @@ class VertexAIOrchestrator(Orchestrator):
             encryption_spec_key_name=self.encryption_key,
         )
 
-        job.run(sync=False)
-
-        return job.resource_name
+        # Submit job asynchronously
+        job.submit()
+
+        job_id = job.resource_name
+
+        # Create wait function
+        def wait_for_completion():
+            """Poll job status until completion."""
+            while True:
+                status = self.get_run_status(job_id)
+                if status.is_finished:
+                    if not status.is_successful:
+                        raise RuntimeError(f"Vertex AI job {job_id} failed with status: {status}")
+                    break
+                time.sleep(15)  # Poll every 15 seconds
+
+        return SubmissionResult(
+            job_id=job_id,
+            wait_for_completion=wait_for_completion,
+            metadata={
+                "platform": "vertex_ai",
+                "project": self.project_id,
+                "region": self.region,
+                "job_name": job_display_name,
+            },
+        )
 
-    def get_run_status(self, run_id: str) -> str:
+    def get_run_status(self, job_id: str) -> "ExecutionStatus":
         """Get status of a Vertex AI job."""
         from google.cloud import aiplatform
 
-        job = aiplatform.CustomJob(run_id)
-        return job.state.name
+        try:
+            job = aiplatform.CustomJob(job_id)
+            state = job.state.name
+
+            # Map Vertex AI states to ExecutionStatus
+            status_map = {
+                "JOB_STATE_QUEUED": ExecutionStatus.PROVISIONING,
+                "JOB_STATE_PENDING": ExecutionStatus.PROVISIONING,
+                "JOB_STATE_RUNNING": ExecutionStatus.RUNNING,
+                "JOB_STATE_SUCCEEDED": ExecutionStatus.COMPLETED,
+                "JOB_STATE_FAILED": ExecutionStatus.FAILED,
+                "JOB_STATE_CANCELLING": ExecutionStatus.STOPPING,
+                "JOB_STATE_CANCELLED": ExecutionStatus.CANCELLED,
+            }
+            return status_map.get(state, ExecutionStatus.RUNNING)
+        except Exception as e:
+            print(f"Error fetching job status: {e}")
+            return ExecutionStatus.FAILED
+
+    def stop_run(self, job_id: str, graceful: bool = True) -> None:
+        """Cancel a Vertex AI job."""
+        from google.cloud import aiplatform
+
+        try:
+            job = aiplatform.CustomJob(job_id)
+            job.cancel()
+        except Exception as e:
+            print(f"Error cancelling job {job_id}: {e}")
+            raise
 
     def _build_worker_pool_specs(
         self,
@@ -171,6 +233,7 @@ class VertexAIOrchestrator(Orchestrator):
         }
 
 
+@register_component(name="gcs")
 class GCSArtifactStore(ArtifactStore):
     """Google Cloud Storage artifact store.
 
@@ -280,6 +343,7 @@ class GCSArtifactStore(ArtifactStore):
         }
 
 
+@register_component(name="gcr")
 class GCRContainerRegistry(ContainerRegistry):
     """Google Container Registry integration.
 
@@ -478,6 +542,8 @@ class GCPStack(Stack):
 
         self.project_id = project_id
         self.region = region
+        self.vertex_endpoints = VertexEndpointManager(project_id=project_id, region=region)
+        self.cloud_run = CloudRunDeployer(project_id=project_id, region=region)
 
     def validate(self) -> bool:
         """Validate all GCP stack components."""
@@ -497,3 +563,84 @@ class GCPStack(Stack):
             "artifact_store": self.artifact_store.to_dict(),
             "container_registry": self.container_registry.to_dict(),
         }
+
+
+class VertexEndpointManager:
+    """Deploy trained models as Vertex AI endpoints."""
+
+    def __init__(self, project_id: str | None, region: str = "us-central1"):
+        self.project_id = project_id
+        self.region = region
+
+    def deploy_model(
+        self,
+        model_display_name: str,
+        artifact_uri: str,
+        serving_image: str,
+        endpoint_display_name: str | None = None,
+        machine_type: str = "n1-standard-4",
+    ) -> str:
+        from google.cloud import aiplatform
+
+        aiplatform.init(project=self.project_id, location=self.region)
+        model = aiplatform.Model.upload(
+            display_name=model_display_name,
+            artifact_uri=artifact_uri,
+            serving_container_image_uri=serving_image,
+        )
+        endpoint = model.deploy(
+            machine_type=machine_type,
+            endpoint=aiplatform.Endpoint.create(
+                display_name=endpoint_display_name or f"{model_display_name}-endpoint",
+            ),
+        )
+        return endpoint.resource_name
+
+
+class CloudRunDeployer:
+    """Deploy container images to Cloud Run."""
+
+    def __init__(self, project_id: str | None, region: str = "us-central1"):
+        self.project_id = project_id
+        self.region = region
+
+    def deploy_service(
+        self,
+        service_name: str,
+        image: str,
+        env: dict[str, str] | None = None,
+        allow_unauthenticated: bool = True,
+    ) -> str:
+        command = [
+            "gcloud",
+            "run",
+            "deploy",
+            service_name,
+            f"--image={image}",
+            f"--region={self.region}",
+            f"--project={self.project_id}",
+        ]
+        if allow_unauthenticated:
+            command.append("--allow-unauthenticated")
+
+        env = env or {}
+        for key, value in env.items():
+            command.append(f"--set-env-vars={key}={value}")
+
+        subprocess.run(command, check=True)
+        url_result = subprocess.run(
+            [
+                "gcloud",
+                "run",
+                "services",
+                "describe",
+                service_name,
+                f"--region={self.region}",
+                f"--project={self.project_id}",
+                "--format=value(status.url)",
+            ],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        return url_result.stdout.strip()

flowyml/stacks/local.py

@@ -46,12 +46,17 @@ class LocalStack(Stack):
         artifact_store = LocalArtifactStore(artifact_path)
         metadata_store = SQLiteMetadataStore(metadata_path)
 
+        from flowyml.core.orchestrator import LocalOrchestrator
+
+        orchestrator = LocalOrchestrator()
+
         # Initialize base stack
         super().__init__(
             name=name,
             executor=executor,
             artifact_store=artifact_store,
             metadata_store=metadata_store,
+            orchestrator=orchestrator,
         )
 
         # Ensure directories exist

flowyml/stacks/plugins.py

@@ -14,7 +14,7 @@ import inspect
 import subprocess
 import sys
 from dataclasses import dataclass, field
-from typing import Any, Optional, Protocol, runtime_checkable
+from typing import Any, Protocol, runtime_checkable
 
 from flowyml.stacks.components import (
     StackComponent,
@@ -48,7 +48,7 @@ class PluginBridge(Protocol):
         self,
         component_class: Any,
         name: str,
-        config: Optional[dict[str, Any]] = None,
+        config: dict[str, Any] | None = None,
     ) -> type[StackComponent]:
         """Wrap an external component class into a flowyml component."""
         ...