FlowerPower 0.9.12.4__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

flowerpower/job_queue/apscheduler/utils.py

@@ -0,0 +1,309 @@
+from operator import attrgetter
+from typing import List
+
+from rich.console import Console
+from rich.table import Table
+
+
+def humanize_crontab(minute, hour, day, month, day_of_week):
+    days = {
+        "0": "Sunday",
+        "sun": "Sunday",
+        "7": "Sunday",
+        "1": "Monday",
+        "mon": "Monday",
+        "2": "Tuesday",
+        "tue": "Tuesday",
+        "3": "Wednesday",
+        "wed": "Wednesday",
+        "4": "Thursday",
+        "thu": "Thursday",
+        "5": "Friday",
+        "fri": "Friday",
+        "6": "Saturday",
+        "sat": "Saturday",
+        "*": "*",
+    }
+    months = {
+        "1": "January",
+        "2": "February",
+        "3": "March",
+        "4": "April",
+        "5": "May",
+        "6": "June",
+        "7": "July",
+        "8": "August",
+        "9": "September",
+        "10": "October",
+        "11": "November",
+        "12": "December",
+        "*": "*",
+    }
+
+    def get_day_name(day_input):
+        day_input = str(day_input).lower().strip()
+        if "-" in day_input:
+            start, end = day_input.split("-")
+            return f"{days.get(start.strip(), start)}-{days.get(end.strip(), end)}"
+        if "," in day_input:
+            return ", ".join(
+                days.get(d.strip(), d.strip()) for d in day_input.split(",")
+            )
+        return days.get(day_input, day_input)
+
+    try:
+        minute, hour, day, month, day_of_week = map(
+            str.strip, map(str, [minute, hour, day, month, day_of_week])
+        )
+
+        if "/" in minute:
+            return f"every {minute.split('/')[1]} minutes"
+        if "/" in hour:
+            return f"every {hour.split('/')[1]} hours"
+
+        if all(x == "*" for x in [minute, hour, day, month, day_of_week]):
+            return "every minute"
+        if [minute, hour, day, month, day_of_week] == ["0", "*", "*", "*", "*"]:
+            return "every hour"
+
+        if (
+            minute == "0"
+            and hour != "*"
+            and day == "*"
+            and month == "*"
+            and day_of_week == "*"
+        ):
+            return (
+                "every day at midnight"
+                if hour == "0"
+                else "every day at noon"
+                if hour == "12"
+                else f"every day at {hour}:00"
+            )
+
+        if (
+            minute == "0"
+            and hour == "0"
+            and day == "*"
+            and month == "*"
+            and day_of_week != "*"
+        ):
+            return f"every {get_day_name(day_of_week)} at midnight"
+
+        if (
+            minute == "0"
+            and hour != "*"
+            and day == "*"
+            and month == "*"
+            and day_of_week != "*"
+        ):
+            return (
+                "every weekday at {hour}:00"
+                if "-" in day_of_week
+                and "mon" in day_of_week.lower()
+                and "fri" in day_of_week.lower()
+                else f"every {get_day_name(day_of_week)} at {hour}:00"
+            )
+
+        if (
+            minute != "*"
+            and hour != "*"
+            and day == "*"
+            and month == "*"
+            and day_of_week == "*"
+        ):
+            return f"every day at {hour}:{minute.zfill(2)}"
+
+        if day != "*" and month != "*" and minute == "0" and hour == "0":
+            return f"on day {day} of {months.get(month, month)} at midnight"
+
+        if (
+            minute != "*"
+            and hour == "*"
+            and day == "*"
+            and month == "*"
+            and day_of_week == "*"
+        ):
+            return f"every hour at minute {minute}"
+
+        parts = []
+        if minute != "*":
+            parts.append(f"at minute {minute}")
+        if hour != "*":
+            parts.append(f"hour {hour}")
+        if day != "*":
+            parts.append(f"day {day}")
+        if month != "*":
+            parts.append(f"month {months.get(month, month)}")
+        if day_of_week != "*":
+            parts.append(f"on {get_day_name(day_of_week)}")
+
+        return f"runs {' '.join(parts)}" if parts else "every minute"
+    except Exception:
+        return f"{minute} {hour} {day} {month} {day_of_week}"
+
+
+def format_trigger(trigger):
+    trigger_type = trigger.__class__.__name__
+
+    if trigger_type == "IntervalTrigger":
+        for unit in ["seconds", "minutes", "hours", "days"]:
+            if value := getattr(trigger, unit, None):
+                return f"Interval: Every {value}{unit[0]}"
+        return "Interval"
+
+    if trigger_type == "CronTrigger":
+        try:
+            cron_parts = dict(
+                part.split("=")
+                for part in str(trigger).strip("CronTrigger(").rstrip(")").split(", ")
+            )
+            cron_parts = {k: v.strip("'") for k, v in cron_parts.items()}
+            crontab = f"{cron_parts['minute']} {cron_parts['hour']} {cron_parts['day']} {cron_parts['month']} {cron_parts['day_of_week']}"
+            human_readable = humanize_crontab(**{
+                k: cron_parts[k]
+                for k in ["minute", "hour", "day", "month", "day_of_week"]
+            })
+            return f"Cron: {human_readable} ({crontab})"
+        except Exception:
+            return f"Cron: {str(trigger)}"
+
+    if trigger_type == "DateTrigger":
+        return f"Date: Once at {trigger.run_date.strftime('%Y-%m-%d %H:%M:%S')}"
+
+    return f"{trigger_type}: {str(trigger)}"
+
+
+def display_schedules(schedules: List):
+    console = Console()
+    total_width = console.width - 10
+
+    width_ratios = {
+        "id": 0.20,
+        "task": 0.10,
+        "trigger": 0.25,
+        "name": 0.15,
+        "run_args": 0.15,
+        "next_fire": 0.08,
+        "last_fire": 0.08,
+        "paused": 0.01,
+    }
+
+    widths = {k: max(10, int(total_width * ratio)) for k, ratio in width_ratios.items()}
+
+    table = Table(
+        show_header=True,
+        header_style="bold magenta",
+        width=total_width,
+        row_styles=["", "dim"],
+        border_style="blue",
+        show_lines=True,
+    )
+
+    for col, style, width in [
+        ("ID", "dim", widths["id"]),
+        ("Task", "cyan", widths["task"]),
+        ("Trigger", "blue", widths["trigger"]),
+        ("Name", "yellow", widths["name"]),
+        ("Run Args", "yellow", widths["run_args"]),
+        ("Next Fire Time", "green", widths["next_fire"]),
+        ("Last Fire Time", "red", widths["last_fire"]),
+        ("Paused", "bold", widths["paused"]),
+    ]:
+        table.add_column(col, style=style, width=width)
+
+    for schedule in sorted(schedules, key=attrgetter("next_fire_time")):
+        table.add_row(
+            schedule.id,
+            schedule.task_id.split(":")[-1],
+            format_trigger(schedule.trigger),
+            (
+                str(schedule.args[1])
+                if schedule.args and len(schedule.args) > 1
+                else "None"
+            ),
+            "\n".join(f"{k}: {v}" for k, v in (schedule.kwargs or {}).items())
+            or "None",
+            (
+                schedule.next_fire_time.strftime("%Y-%m-%d %H:%M:%S")
+                if schedule.next_fire_time
+                else "Never"
+            ),
+            (
+                schedule.last_fire_time.strftime("%Y-%m-%d %H:%M:%S")
+                if schedule.last_fire_time
+                else "Never"
+            ),
+            "✓" if schedule.paused else "✗",
+        )
+
+    console.print(table)
+
+
+def display_tasks(tasks):
+    console = Console()
+    table = Table(title="Tasks")
+
+    widths = {"id": 50, "executor": 15, "max_jobs": 15, "misfire": 20}
+
+    for col, style, width in [
+        ("ID", "cyan", widths["id"]),
+        ("Job Executor", "blue", widths["executor"]),
+        ("Max Running Jobs", "yellow", widths["max_jobs"]),
+        ("Misfire Grace Time", "green", widths["misfire"]),
+    ]:
+        table.add_column(col, style=style, width=width)
+
+    for task in sorted(tasks, key=attrgetter("id")):
+        table.add_row(
+            task.id,
+            str(task.job_executor),
+            str(task.max_running_jobs or "None"),
+            str(task.misfire_grace_time or "None"),
+        )
+
+    console.print(table)
+
+
+def display_jobs(jobs):
+    console = Console()
+    table = Table(title="Jobs")
+
+    widths = {
+        "id": 10,
+        "task_id": 40,
+        "args": 20,
+        "kwargs": 20,
+        "schedule": 15,
+        "created": 25,
+        "status": 15,
+    }
+
+    for col, style, width in [
+        ("ID", "cyan", widths["id"]),
+        ("Task ID", "blue", widths["task_id"]),
+        ("Args", "yellow", widths["args"]),
+        ("Kwargs", "yellow", widths["kwargs"]),
+        ("Schedule ID", "green", widths["schedule"]),
+        ("Created At", "magenta", widths["created"]),
+        ("Status", "red", widths["status"]),
+    ]:
+        table.add_column(col, style=style, width=width)
+
+    for job in sorted(jobs, key=attrgetter("id")):
+        status = "Running" if job.acquired_by else "Pending"
+        table.add_row(
+            str(job.id),
+            job.task_id,
+            str(job.args if job.args else "None"),
+            (
+                "\n".join(f"{k}: {v}" for k, v in job.kwargs.items())
+                if job.kwargs
+                else "None"
+            ),
+            str(job.schedule_id or "None"),
+            job.created_at.strftime("%Y-%m-%d %H:%M:%S"),
+            status,
+        )
+
+    console.print(table)

flowerpower/job_queue/base.py

@@ -0,0 +1,382 @@
+"""
+Base scheduler interface for FlowerPower.
+
+This module defines the abstract base classes for scheduling operations
+that can be implemented by different backend providers (APScheduler, RQ, etc.).
+"""
+
+import abc
+import posixpath
+import sys
+import urllib.parse
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncEngine
+
+from ..cfg import ProjectConfig
+from ..fs import AbstractFileSystem, get_filesystem
+# from ..utils.misc import update_config_from_dict
+from ..settings import BACKEND_PROPERTIES
+
+
+class BackendType(str, Enum):
+    POSTGRESQL = "postgresql"
+    MYSQL = "mysql"
+    SQLITE = "sqlite"
+    MONGODB = "mongodb"
+    MQTT = "mqtt"
+    REDIS = "redis"
+    NATS_KV = "nats_kv"
+    MEMORY = "memory"
+
+    @property
+    def properties(self):
+        return BACKEND_PROPERTIES[self.value]
+
+    @property
+    def uri_prefix(self) -> str:
+        return self.properties.get("uri_prefix", "")
+
+    @property
+    def default_port(self):
+        return self.properties.get("default_port")
+
+    @property
+    def default_host(self) -> str:
+        return self.properties.get("default_host", "")
+
+    @property
+    def default_username(self) -> str:
+        return self.properties.get("default_username", "")
+
+    @property
+    def default_password(self) -> str:
+        return self.properties.get("default_password", "")
+
+    @property
+    def default_database(self) -> str:
+        return self.properties.get("default_database", "")
+
+    @property
+    def is_sqla_type(self) -> bool:
+        return self.properties.get("is_sqla_type", False)
+
+    @property
+    def is_mongodb_type(self) -> bool:
+        return self.value == "mongodb"
+
+    @property
+    def is_mqtt_type(self) -> bool:
+        return self.value == "mqtt"
+
+    @property
+    def is_redis_type(self) -> bool:
+        return self.value == "redis"
+
+    @property
+    def is_nats_kv_type(self) -> bool:
+        return self.value == "nats_kv"
+
+    @property
+    def is_memory_type(self) -> bool:
+        return self.value == "memory"
+
+    @property
+    def is_sqlite_type(self) -> bool:
+        return self.value == "sqlite"
+
+    def gen_uri(
+        self,
+        host: str | None = None,
+        port: int | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        database: str | None = None,
+        ssl: bool = False,
+        ca_file: str | None = None,
+        cert_file: str | None = None,
+        key_file: str | None = None,
+        verify_ssl: bool = False,
+    ) -> str:
+        # Handle host and port
+        host = host or self.default_host
+        port = port or self.default_port
+        database = database or self.default_database
+        username = username or self.default_username
+        password = password or self.default_password
+
+        # components: List[str] = []
+        # Get the appropriate URI prefix based on backend type and SSL setting
+        if self.is_redis_type:
+            uri_prefix = "rediss://" if ssl else "redis://"
+        elif self.is_nats_kv_type:
+            uri_prefix = "nats+tls://" if ssl else "nats://"
+        elif self.is_mqtt_type:
+            uri_prefix = "mqtts://" if ssl else "mqtt://"
+            if ssl and port == 1883:
+                port = 8883
+        else:
+            uri_prefix = self.uri_prefix
+
+        # Handle authentication
+        if username and password:
+            auth = f"{urllib.parse.quote(username)}:{urllib.parse.quote(password)}@"
+        elif username:
+            auth = f"{urllib.parse.quote(username)}@"
+        elif password:
+            auth = f":{urllib.parse.quote(password)}@"
+        else:
+            auth = ""
+
+        port_part = f":{port}"  # if port is not None else self.default_port
+
+        # Special handling for SQLite and memory types
+        if self.is_sqlite_type or self.is_memory_type:
+            if self.is_sqlite_type and database:
+                return f"{uri_prefix}{database}"
+            return "memory://"
+
+        # Build path component
+        database = database or self.default_database
+        path = f"/{database}" if database else ""
+
+        # Construct base URI
+        base_uri = f"{uri_prefix}{auth}{host}{port_part}{path}"
+
+        # Prepare query parameters for SSL files
+        query_params: list[str] = []
+
+        if ssl:
+            # Always add ssl query parameter if ssl=True
+            if self.value == "postgresql":
+                query_params.append("ssl=verify-full" if verify_ssl else "ssl=allow")
+                if ca_file:
+                    query_params.append(f"sslrootcert={urllib.parse.quote(ca_file)}")
+                if cert_file:
+                    query_params.append(f"sslcert={urllib.parse.quote(cert_file)}")
+                if key_file:
+                    query_params.append(f"sslkey={urllib.parse.quote(key_file)}")
+            elif self.value == "mysql":
+                query_params.append("ssl=true")
+                if ca_file:
+                    query_params.append(f"ssl_ca={urllib.parse.quote(ca_file)}")
+                if cert_file:
+                    query_params.append(f"ssl_cert={urllib.parse.quote(cert_file)}")
+                if key_file:
+                    query_params.append(f"ssl_key={urllib.parse.quote(key_file)}")
+            elif self.is_mongodb_type:
+                query_params.append("tls=true")
+                if ca_file:
+                    query_params.append(f"tlsCAFile={urllib.parse.quote(ca_file)}")
+                if cert_file and key_file:
+                    query_params.append(
+                        f"tlsCertificateKeyFile={urllib.parse.quote(cert_file)}"
+                    )
+            elif self.is_redis_type:
+                query_params.append("ssl=true")
+                if ca_file:
+                    query_params.append(f"ssl_ca_certs={urllib.parse.quote(ca_file)}")
+                if cert_file:
+                    query_params.append(f"ssl_certfile={urllib.parse.quote(cert_file)}")
+                if key_file:
+                    query_params.append(f"ssl_keyfile={urllib.parse.quote(key_file)}")
+            elif self.is_nats_kv_type:
+                query_params.append("tls=true")
+                if ca_file:
+                    query_params.append(f"tls_ca_file={urllib.parse.quote(ca_file)}")
+                if cert_file:
+                    query_params.append(
+                        f"tls_cert_file={urllib.parse.quote(cert_file)}"
+                    )
+                if key_file:
+                    query_params.append(f"tls_key_file={urllib.parse.quote(key_file)}")
+            elif self.is_mqtt_type:
+                query_params.append("tls=true")
+                if ca_file:
+                    query_params.append(f"tls_ca_file={urllib.parse.quote(ca_file)}")
+                if cert_file:
+                    query_params.append(
+                        f"tls_cert_file={urllib.parse.quote(cert_file)}"
+                    )
+                if key_file:
+                    query_params.append(f"tls_key_file={urllib.parse.quote(key_file)}")
+
+        # Compose query string if Any params exist
+        query_string = ""
+        if query_params:
+            query_string = "?" + "&".join(query_params)
+
+        return f"{base_uri}{query_string}"
+
+
+@dataclass(slots=True)
+class BaseBackend:
+    type: BackendType | str | None = None
+    uri: str | None = None
+    username: str | None = None
+    password: str | None = None
+    host: str | None = None
+    port: int | None = None
+    database: str | None = None
+    ssl: bool = False
+    ca_file: str | None = None
+    cert_file: str | None = None
+    key_file: str | None = None
+    verify_ssl: bool = False
+    _kwargs: dict = field(default_factory=dict)
+    _sqla_engine: AsyncEngine | None = (
+        None  # SQLAlchemy async engine instance for SQL backends
+    )
+    _client: Any | None = None  # Native client instance for non-SQL backends
+
+    def __post_init__(self):
+        if self.type is None:
+            self.type = "memory"
+
+        elif isinstance(self.type, str):
+            try:
+                self.type = BackendType[self.type.upper()]
+            except KeyError:
+                raise ValueError(
+                    f"Invalid backend type: {self.type}. Valid types: {[bt.value for bt in BackendType]}"
+                )
+
+        if not self.uri:
+            self.uri = self.type.gen_uri(
+                username=self.username,
+                password=self.password,
+                host=self.host,
+                port=self.port,
+                database=self.database,
+                ssl=self.ssl,
+                ca_file=self.ca_file,
+                cert_file=self.cert_file,
+                key_file=self.key_file,
+                verify_ssl=self.verify_ssl,
+            )
+
+        # Setup is handled by backend-specific implementations
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "BaseBackend":
+        return cls(**d)
+
+
+class BaseTrigger(abc.ABC):
+    """
+    Abstract base class for schedule triggers.
+
+    A trigger determines when a scheduled job should be executed.
+    """
+
+    def __init__(self, trigger_type: str):
+        self.trigger_type = trigger_type
+
+    @abc.abstractmethod
+    def get_trigger_instance(self, **kwargs) -> Any:
+        """
+        Get the backend-specific trigger instance.
+
+        Args:
+            **kwargs: Keyword arguments specific to the trigger type
+
+        Returns:
+            Any: A backend-specific trigger instance
+        """
+        pass
+
+
+class BaseJobQueueManager:
+    """
+    Abstract base class for scheduler workers (APScheduler, RQ, etc.).
+    Defines the required interface for all scheduler backends.
+
+    Can be used as a context manager:
+
+    ```python
+    with RQManager(name="test") as manager:
+        manager.add_job(job1)
+    ```
+    """
+
+    def __enter__(self):
+        """Context manager entry - returns self for use in with statement."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - ensures workers are stopped."""
+        if hasattr(self, "_worker_process") and self._worker_process is not None:
+            self.stop_worker()
+        if hasattr(self, "_worker_pool") and self._worker_pool is not None:
+            self.stop_worker_pool()
+        if hasattr(self, "_worker") and self._worker is not None:
+            self.stop_worker()
+        if hasattr(self, "_scheduler") and self._scheduler is not None:
+            self.stop_scheduler()
+        return False  # Don't suppress exceptions
+
+    def __init__(
+        self,
+        type: str | None = None,
+        name: str | None = None,
+        base_dir: str | None = None,
+        backend: BaseBackend | None = None,
+        storage_options: dict = None,
+        fs: AbstractFileSystem | None = None,
+        **kwargs,
+    ):
+        """
+        Initialize the APScheduler backend.
+
+        Args:
+            name: Name of the scheduler
+            base_dir: Base directory for the FlowerPower project
+            backend: APSBackend instance with data store and event broker
+            storage_options: Storage options for filesystem access
+            fs: Filesystem to use
+            cfg_override: Configuration overrides for the worker
+        """
+        self.name = name or ""
+        self._base_dir = base_dir or str(Path.cwd())
+        self._storage_options = storage_options or {}
+        self._backend = backend
+        self._type = type
+        self._pipelines_dir = kwargs.get("pipelines_dir", "pipelines")
+        self._conf_dir = "conf"
+
+        if fs is None:
+            fs = get_filesystem(self._base_dir, **(self._storage_options or {}))
+        self._fs = fs
+
+        self._add_modules_path()
+        self._load_config()
+
+    def _load_config(self) -> None:
+        """Load the configuration.
+
+        Args:
+            cfg_updates: Configuration updates to apply
+        """
+        self.cfg = ProjectConfig.load(
+            base_dir=self._base_dir, job_queue_type=self._type, fs=self._fs
+        ).job_queue
+
+    def _add_modules_path(self):
+        """
+        Sync the filesystem.
+
+        Returns:
+            None
+        """
+        if self._fs.is_cache_fs:
+            self._fs.sync()
+
+        if self._fs.path not in sys.path:
+            sys.path.insert(0, self._fs.path)
+
+        modules_path = posixpath.join(self._fs.path, self._pipelines_dir)
+        if modules_path not in sys.path:
+            sys.path.insert(0, modules_path)

flowerpower/job_queue/rq/__init__.py

@@ -0,0 +1,10 @@
+from .setup import RQBackend
+from .utils import show_jobs, show_schedules
+from .manager import RQManager
+
+__all__ = [
+    "RQManager",
+    "RQBackend",
+    "show_jobs",
+    "show_schedules",
+]