dotflow 0.15.0.dev2__py3-none-any.whl → 0.15.0.dev4__py3-none-any.whl

dotflow/__init__.py

@@ -1,6 +1,6 @@
 """Dotflow __init__ module."""
 
-__version__ = "0.15.0.dev2"
+__version__ = "0.15.0.dev4"
 __description__ = "🎲 Dotflow turns an idea into flow!"
 
 from .core.action import Action as action

dotflow/abc/flow.py

@@ -4,6 +4,7 @@ from abc import ABC, abstractmethod
 from uuid import UUID
 
 from dotflow.core.task import Task
+from dotflow.core.types import TypeStatus
 
 
 class Flow(ABC):
@@ -40,3 +41,21 @@ class Flow(ABC):
     @abstractmethod
     def run(self) -> None:
         return None
+
+    def _try_restore_checkpoint(self, task: Task):
+        """Attempts to restore a checkpoint. Returns the Context if found, None otherwise."""
+        if not self.resume:
+            return None
+
+        context = task.config.storage.get(
+            key=task.config.storage.key(task=task)
+        )
+
+        if context.storage is None:
+            return None
+
+        task.status = TypeStatus.COMPLETED
+        task.current_context = context
+        self._flow_callback(task=task)
+
+        return context

dotflow/abc/server.py

@@ -0,0 +1,30 @@
+"""Abstract base for remote server communication."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class Server(ABC):
+    """Server ABC provider for sending workflow and task
+    data to a remote API.
+
+    Implementations should handle HTTP communication with
+    a server like dotflow-api, sending execution data
+    (status, duration, errors, context) in real time.
+    """
+
+    @abstractmethod
+    def create_workflow(self, workflow: Any) -> None:
+        """Register a new workflow on the remote server."""
+
+    @abstractmethod
+    def update_workflow(self, workflow: Any, status: str = "") -> None:
+        """Update workflow status on the remote server."""
+
+    @abstractmethod
+    def create_task(self, task: Any) -> None:
+        """Register a new task on the remote server."""
+
+    @abstractmethod
+    def update_task(self, task: Any) -> None:
+        """Update task data on the remote server."""

dotflow/cli/commands/cloud.py

@@ -20,6 +20,11 @@ def _get_template_dir() -> Path | None:
     cloud_dir = target / settings.TEMPLATE_CLOUD_DIR
 
     if cloud_dir.exists():
+        run(
+            ["git", "-C", str(target), "pull", "--ff-only"],
+            capture_output=True,
+            text=True,
+        )
         return cloud_dir
 
     try:
@@ -121,6 +126,7 @@ class CloudGenerateCommand(Command):
             if not project_name:
                 project_name = Path.cwd().name
 
+        project_name = project_name.replace("_", "-").lower()
         module_name = project_name.replace("-", "_")
 
         print(
@@ -133,7 +139,9 @@ class CloudGenerateCommand(Command):
 
         for filename in files:
             filepath = (output / filename).resolve()
-            if not str(filepath).startswith(str(output)):
+            try:
+                filepath.relative_to(output)
+            except ValueError:
                 print(
                     settings.ERROR_ALERT,
                     f"  Skipped (unsafe filename): {filename}",

dotflow/cli/commands/deploy.py

@@ -1,110 +1,171 @@
 """Command deploy module."""
 
 from rich import print  # type: ignore
+from rich.prompt import Prompt
 
 from dotflow.cli.command import Command
+from dotflow.cloud.alibaba.constants import (
+    DEFAULT_REGION as ALI_DEFAULT_REGION,
+)
+from dotflow.cloud.alibaba.constants import PLATFORMS as ALI_PLATFORMS
+from dotflow.cloud.alibaba.constants import (
+    SCHEDULED_PLATFORMS as ALI_SCHEDULED,
+)
+from dotflow.cloud.aws.constants import DEFAULT_REGION as AWS_DEFAULT_REGION
+from dotflow.cloud.aws.constants import PLATFORMS as AWS_PLATFORMS
+from dotflow.cloud.aws.constants import SCHEDULED_PLATFORMS as AWS_SCHEDULED
+from dotflow.cloud.gcp.constants import DEFAULT_REGION as GCP_DEFAULT_REGION
+from dotflow.cloud.gcp.constants import PLATFORMS as GCP_PLATFORMS
+from dotflow.cloud.gcp.constants import SCHEDULED_PLATFORMS as GCP_SCHEDULED
 from dotflow.settings import Settings as settings
 
-SAM_PLATFORMS = {
-    "ecs-scheduled",
-}
-
 DEFAULT_REGIONS = {
-    "lambda": "us-east-1",
-    "lambda-scheduled": "us-east-1",
-    "lambda-s3-trigger": "us-east-1",
-    "lambda-sqs-trigger": "us-east-1",
-    "lambda-api-trigger": "us-east-1",
-    "ecs": "us-east-1",
-    "cloud-run": "us-central1",
-    "cloud-run-scheduled": "us-central1",
+    **dict.fromkeys(AWS_PLATFORMS, AWS_DEFAULT_REGION),
+    **dict.fromkeys(GCP_PLATFORMS, GCP_DEFAULT_REGION),
+    **dict.fromkeys(ALI_PLATFORMS, ALI_DEFAULT_REGION),
 }
 
+SCHEDULED_PLATFORMS = AWS_SCHEDULED | GCP_SCHEDULED | ALI_SCHEDULED
+
+
+class ScheduleResolver:
+    """Resolves a schedule expression.
+
+    From CLI args, template, or user input.
+    """
+
+    @classmethod
+    def _get_provider(cls, platform: str) -> type | None:
+        if platform in AWS_PLATFORMS:
+            from dotflow.cloud.aws.schedule import AWSSchedule
+
+            return AWSSchedule
+
+        return None
+
+    @classmethod
+    def resolve(cls, schedule: str | None, platform: str) -> str | None:
+        if platform not in SCHEDULED_PLATFORMS:
+            return schedule
+
+        provider = cls._get_provider(platform)
+
+        if schedule:
+            return provider.convert(schedule) if provider else schedule
+
+        raw = cls._ask_schedule(provider)
+
+        if not raw:
+            raise SystemExit(
+                f"{settings.ERROR_ALERT} --schedule (cron) is required for {platform}"
+            )
+
+        return provider.convert(raw) if provider else raw
+
+    @classmethod
+    def _ask_schedule(cls, provider: type | None) -> str | None:
+        template_schedule = None
+        if provider:
+            template_schedule = provider.read_from_template()
+
+        choices = {}
+        if template_schedule:
+            choices["1"] = f"Use from template.yaml: {template_schedule}"
+        choices["2"] = "Enter cron expression"
+
+        print(settings.QUESTION_ALERT, "Cron schedule is required:")
+        for key, label in choices.items():
+            print(f"  [bold cyan]{key}[/bold cyan] - {label}")
+
+        choice = Prompt.ask("  Select", choices=list(choices.keys()))
+
+        if choice == "1" and template_schedule:
+            print(settings.INFO_ALERT, f"Using cron: {template_schedule}")
+            return template_schedule
+
+        print("  Format: [bold]min hour day month weekday[/bold]")
+        return Prompt.ask("  Cron (e.g. */5 * * * *)") or None
+
 
 class DeployCommand(Command):
     def setup(self):
         platform = self.params.platform
         name = self.params.project
-        region = self.params.region or DEFAULT_REGIONS.get(
-            platform, "us-east-1"
+        region = self.params.region or DEFAULT_REGIONS.get(platform)
+        schedule = ScheduleResolver.resolve(
+            getattr(self.params, "schedule", None), platform
         )
-        schedule = getattr(self.params, "schedule", None)
-
-        if platform in SAM_PLATFORMS:
-            print(
-                settings.INFO_ALERT,
-                f"'{platform}' requires SAM for full trigger setup.",
-            )
-            print("  Run: sam build && sam deploy")
-            return
 
-        deployers = {
-            "lambda": self._deploy_lambda,
-            "lambda-scheduled": self._deploy_lambda,
-            "lambda-s3-trigger": self._deploy_lambda_s3,
-            "lambda-sqs-trigger": self._deploy_lambda_sqs,
-            "lambda-api-trigger": self._deploy_lambda_api,
-            "ecs": self._deploy_ecs,
-            "cloud-run": self._deploy_cloud_run,
-            "cloud-run-scheduled": self._deploy_cloud_run,
-            "github-actions": self._deploy_github_actions,
-        }
-
-        handler = deployers.get(platform)
+        method_name = f"_deploy_{platform.replace('-', '_')}"
+        handler = getattr(self, method_name, None)
         if not handler:
             print(
-                settings.ERROR_ALERT,
-                f"Deploy not supported for '{platform}'.",
+                settings.ERROR_ALERT, f"Deploy not supported for '{platform}'."
             )
             return
 
         handler(name=name, region=region, schedule=schedule)
 
-    def _deploy_lambda(self, name: str, region: str, schedule: str = None):
-        """Deploy to AWS Lambda."""
+    def _deploy_lambda(self, name, region, schedule=None):
         from dotflow.cloud.aws import LambdaDeployer
 
-        deployer = LambdaDeployer(region=region)
-        deployer.deploy(name, schedule=schedule)
+        LambdaDeployer(region=region).deploy(name, schedule=schedule)
 
-    def _deploy_lambda_api(self, name: str, region: str, **kwargs):
-        """Deploy to AWS Lambda + API Gateway."""
-        from dotflow.cloud.aws import LambdaApiDeployer
+    def _deploy_lambda_scheduled(self, name, region, schedule=None):
+        from dotflow.cloud.aws import LambdaDeployer
 
-        deployer = LambdaApiDeployer(region=region)
-        deployer.deploy(name)
+        LambdaDeployer(region=region).deploy(name, schedule=schedule)
 
-    def _deploy_lambda_s3(self, name: str, region: str, **kwargs):
-        """Deploy to AWS Lambda + S3 Trigger."""
+    def _deploy_lambda_s3_trigger(self, name, region, **kwargs):
         from dotflow.cloud.aws import LambdaS3Deployer
 
-        deployer = LambdaS3Deployer(region=region)
-        deployer.deploy(name)
+        LambdaS3Deployer(region=region).deploy(name)
 
-    def _deploy_lambda_sqs(self, name: str, region: str, **kwargs):
-        """Deploy to AWS Lambda + SQS Trigger."""
+    def _deploy_lambda_sqs_trigger(self, name, region, **kwargs):
         from dotflow.cloud.aws import LambdaSQSDeployer
 
-        deployer = LambdaSQSDeployer(region=region)
-        deployer.deploy(name)
+        LambdaSQSDeployer(region=region).deploy(name)
+
+    def _deploy_lambda_api_trigger(self, name, region, **kwargs):
+        from dotflow.cloud.aws import LambdaApiDeployer
 
-    def _deploy_ecs(self, name: str, region: str, **kwargs):
-        """Deploy to AWS ECS Fargate."""
+        LambdaApiDeployer(region=region).deploy(name)
+
+    def _deploy_ecs(self, name, region, **kwargs):
         from dotflow.cloud.aws import ECSDeployer
 
-        deployer = ECSDeployer(region=region)
-        deployer.deploy(name)
+        ECSDeployer(region=region).deploy(name)
+
+    def _deploy_ecs_scheduled(self, name, region, schedule=None):
+        from dotflow.cloud.aws import ECSScheduledDeployer
 
-    def _deploy_cloud_run(self, name: str, region: str, **kwargs):
-        """Deploy to Google Cloud Run."""
+        ECSScheduledDeployer(region=region).deploy(name, schedule=schedule)
+
+    def _deploy_cloud_run(self, name, region, **kwargs):
         from dotflow.cloud.gcp import CloudRunDeployer
 
-        deployer = CloudRunDeployer(region=region)
-        deployer.deploy(name)
+        CloudRunDeployer(region=region).deploy(name)
+
+    def _deploy_cloud_run_scheduled(self, name, region, **kwargs):
+        from dotflow.cloud.gcp import CloudRunDeployer
 
-    def _deploy_github_actions(self, name: str, **kwargs):
-        """Deploy to GitHub Actions."""
+        CloudRunDeployer(region=region).deploy(name)
+
+    def _deploy_github_actions(self, name, **kwargs):
         from dotflow.cloud.github import ActionsDeployer
 
-        deployer = ActionsDeployer()
-        deployer.deploy(name)
+        ActionsDeployer().deploy(name)
+
+    def _deploy_alibaba_fc(self, name, region, **kwargs):
+        from dotflow.cloud.alibaba import AliyunFCDeployer
+
+        AliyunFCDeployer(region=region).deploy(name)
+
+    def _deploy_alibaba_fc_scheduled(self, name, region, schedule=None):
+        from dotflow.cloud.alibaba import (
+            AliyunFCScheduledDeployer,
+        )
+
+        AliyunFCScheduledDeployer(region=region).deploy(
+            name, schedule=schedule
+        )

dotflow/cli/commands/init.py

@@ -6,12 +6,10 @@ from rich import print  # type: ignore
 from dotflow.cli.command import Command
 from dotflow.settings import Settings as settings
 
-TEMPLATE_REPO = "https://github.com/dotflow-io/template"
-
 
 class InitCommand(Command):
     def setup(self):
-        cookiecutter(TEMPLATE_REPO)
+        cookiecutter(settings.TEMPLATE_REPO)
 
         print(
             settings.INFO_ALERT,

dotflow/cli/commands/log.py

@@ -14,7 +14,8 @@ class LogCommand(Command):
 
             print(
                 settings.INFO_ALERT,
-                f"To access all logs, open the file ({settings.LOG_PATH.resolve()}).",
+                "To access all logs, open the file"
+                f" ({settings.LOG_PATH.resolve()}).",
             )
         else:
             print(settings.WARNING_ALERT, "Log file not found.")

dotflow/cli/commands/storage.py

@@ -0,0 +1,55 @@
+"""Storage resolver for CLI commands"""
+
+from dotflow.providers import (
+    StorageDefault,
+    StorageFile,
+    StorageGCS,
+    StorageS3,
+)
+from dotflow.settings import Settings as settings
+
+
+class StorageResolver:
+    """Resolves a storage provider instance from CLI params."""
+
+    def __init__(self, params):
+        self.params = params
+
+    def resolve(self):
+        """Returns a storage instance or None if no --storage was specified."""
+        if not self.params.storage:
+            return None
+
+        resolvers = {
+            "default": self._resolve_local,
+            "file": self._resolve_local,
+            "s3": self._resolve_s3,
+            "gcs": self._resolve_gcs,
+        }
+
+        resolver = resolvers.get(self.params.storage)
+        if resolver is None:
+            return None
+
+        return resolver()
+
+    def _resolve_local(self):
+        storage_cls = {"default": StorageDefault, "file": StorageFile}
+        return storage_cls[self.params.storage](path=self.params.path)
+
+    def _resolve_s3(self):
+        self._require("bucket")
+        return StorageS3(bucket=self.params.bucket, region=self.params.region)
+
+    def _resolve_gcs(self):
+        self._require("bucket")
+        return StorageGCS(
+            bucket=self.params.bucket, project=self.params.gcp_project
+        )
+
+    def _require(self, arg):
+        if not getattr(self.params, arg, None):
+            raise SystemExit(
+                f"{settings.ERROR_ALERT} --storage {self.params.storage}"
+                f" requires --{arg}"
+            )

dotflow/cli/setup.py

@@ -163,7 +163,7 @@ class Command:
         cmd_generate.add_argument(
             "--platform",
             required=True,
-            help="Target platform (e.g. docker, lambda, cloud-run, ecs, kubernetes)",
+            help=("Target platform (e.g. docker, lambda, cloud-run)"),
         )
         cmd_generate.add_argument(
             "--project",
@@ -206,7 +206,7 @@ class Command:
         self.cmd_deploy.add_argument(
             "--schedule",
             default=None,
-            help="Schedule expression (e.g. 'rate(6 hours)')",
+            help="Cron expression (e.g. '*/5 * * * *')",
         )
         self.cmd_deploy.set_defaults(exec=DeployCommand)
 
@@ -233,6 +233,9 @@ class Command:
         except ImportModuleError as err:
             print(settings.WARNING_ALERT, err)
 
+        except KeyboardInterrupt:
+            print("\n", settings.INFO_ALERT, "Aborted.")
+
         except Exception as err:
             logger.error(f"Internal problem: {str(err)}")
             print(settings.ERROR_ALERT, MESSAGE_UNKNOWN_ERROR)

dotflow/cloud/alibaba/__init__.py

@@ -0,0 +1,11 @@
+"""Alibaba Cloud module."""
+
+from dotflow.cloud.alibaba.deployers import (
+    AliyunFCDeployer,
+    AliyunFCScheduledDeployer,
+)
+
+__all__ = [
+    "AliyunFCDeployer",
+    "AliyunFCScheduledDeployer",
+]

dotflow/cloud/alibaba/constants.py

@@ -0,0 +1,22 @@
+"""Alibaba Cloud constants."""
+
+SDK_NOT_FOUND = (
+    "alibabacloud-fc-open20210406 is required: "
+    "pip install dotflow[deploy-alibaba]"
+)
+
+CREDENTIALS_NOT_FOUND = (
+    "Alibaba Cloud credentials not found. "
+    "Run 'aliyun configure' or set "
+    "ALIBABA_CLOUD_ACCESS_KEY_ID and "
+    "ALIBABA_CLOUD_ACCESS_KEY_SECRET."
+)
+
+PLATFORMS = {
+    "alibaba-fc",
+    "alibaba-fc-scheduled",
+}
+
+SCHEDULED_PLATFORMS = {"alibaba-fc-scheduled"}
+
+DEFAULT_REGION = "cn-hangzhou"

dotflow/cloud/alibaba/deployers/__init__.py

@@ -0,0 +1,13 @@
+"""Alibaba Cloud deployers."""
+
+from dotflow.cloud.alibaba.deployers.fc import (
+    AliyunFCDeployer,
+)
+from dotflow.cloud.alibaba.deployers.fc_scheduled import (
+    AliyunFCScheduledDeployer,
+)
+
+__all__ = [
+    "AliyunFCDeployer",
+    "AliyunFCScheduledDeployer",
+]

dotflow/cloud/alibaba/deployers/fc.py

@@ -0,0 +1,134 @@
+"""Alibaba Function Compute deployment."""
+
+from __future__ import annotations
+
+import os
+
+from rich import print  # type: ignore
+
+from dotflow.cloud.alibaba.constants import (
+    CREDENTIALS_NOT_FOUND,
+    SDK_NOT_FOUND,
+)
+from dotflow.cloud.alibaba.services.cr import ContainerRegistry
+from dotflow.cloud.core import Deployer
+from dotflow.settings import Settings as settings
+
+
+class AliyunFCDeployer(Deployer):
+    """Deploy dotflow pipeline to Alibaba Cloud FC."""
+
+    def __init__(
+        self,
+        region: str = "cn-hangzhou",
+        namespace: str = "dotflow",
+    ):
+        try:
+            from alibabacloud_fc_open20210406.client import (
+                Client,
+            )
+            from alibabacloud_tea_openapi.models import (
+                Config,
+            )
+        except ImportError as err:
+            raise SystemExit(SDK_NOT_FOUND) from err
+
+        key_id = os.environ.get("ALIBABA_CLOUD_ACCESS_KEY_ID")
+        key_secret = os.environ.get("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
+
+        if not key_id or not key_secret:
+            try:
+                import json
+                from pathlib import Path
+
+                config_path = Path.home() / ".aliyun" / "config.json"
+                data = json.loads(config_path.read_text())
+                for p in data.get("profiles", []):
+                    if p.get("name") == data.get("current"):
+                        key_id = p.get("access_key_id")
+                        key_secret = p.get("access_key_secret")
+                        if not region or region == "cn-hangzhou":
+                            region = p.get("region_id", region)
+                        break
+            except Exception:
+                pass
+
+        if not key_id or not key_secret:
+            raise SystemExit(CREDENTIALS_NOT_FOUND)
+
+        self._region = region
+        self._namespace = namespace
+
+        config = Config(
+            access_key_id=key_id,
+            access_key_secret=key_secret,
+            region_id=region,
+        )
+        config.endpoint = f"{self._region}.fc.aliyuncs.com"
+        self._fc = Client(config)
+
+        self._cr = ContainerRegistry(
+            region=region,
+            namespace=namespace,
+        )
+
+    @staticmethod
+    def _sanitize_name(name: str) -> str:
+        return name.replace("_", "-").lower()
+
+    def deploy(self, name: str, **kwargs) -> None:
+        """Deploy to Alibaba Function Compute."""
+        name = self._sanitize_name(name)
+        print(
+            settings.INFO_ALERT,
+            f"Deploying to Alibaba FC '{name}'...",
+        )
+
+        image_uri = self._cr.push(name)
+        self._create_or_update_function(name, image_uri)
+
+        print(settings.INFO_ALERT, "Done.")
+
+    def _create_or_update_function(self, name: str, image_uri: str) -> None:
+        """Create or update FC function."""
+        from alibabacloud_fc_open20210406 import models
+
+        try:
+            self._fc.get_function(name)
+            print(f"  {settings.STEP_ICON} Updating function '{name}'...")
+            self._fc.update_function(
+                name,
+                models.UpdateFunctionRequest(
+                    runtime="custom-container",
+                    handler="handler.handler",
+                    timeout=900,
+                    memory_size=512,
+                    custom_container_config=(
+                        models.CustomContainerConfig(
+                            image=image_uri,
+                            port=9000,
+                        )
+                    ),
+                ),
+            )
+        except Exception as err:
+            if not (hasattr(err, "status_code") and err.status_code == 404):
+                raise
+            print(f"  {settings.STEP_ICON} Creating function '{name}'...")
+            self._fc.create_function(
+                models.CreateFunctionRequest(
+                    function_name=name,
+                    runtime="custom-container",
+                    handler="handler.handler",
+                    timeout=900,
+                    cpu=1,
+                    memory_size=512,
+                    disk_size=512,
+                    custom_container_config=(
+                        models.CustomContainerConfig(
+                            image=image_uri,
+                            port=9000,
+                        )
+                    ),
+                )
+            )