pemexe 0.1.0__py3-none-any.whl

pem/cli.py

@@ -0,0 +1,385 @@
+import asyncio
+from typing import Annotated
+
+import typer
+
+from pem.core.executor import Executor
+from pem.core.scheduler import scheduler_manager
+from pem.db.database import SessionLocal, create_db_and_tables
+from pem.db.models import Job
+
+app = typer.Typer(help="Python Execution Manager (pem)")
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context) -> None:
+    create_db_and_tables()
+    # If no command is provided, show help
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        ctx.exit()
+
+
+def _add_job(name: str, path: str, job_type: str, dependencies: list[str] | None = None) -> Job:
+    """Helper function to add a job to the database."""
+    db = SessionLocal()
+    try:
+        # Check if job with this name already exists
+        existing_job = db.query(Job).filter(Job.name == name).first()
+        if existing_job:
+            typer.secho(f"❌ Job '{name}' already exists.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        new_job = Job(name=name, path=path, job_type=job_type, dependencies=dependencies)
+        db.add(new_job)
+        db.commit()
+        db.refresh(new_job)
+        typer.secho(f"✅ {job_type.capitalize()} job '{name}' added.", fg=typer.colors.GREEN)
+        return new_job
+    finally:
+        db.close()
+
+
+def _get_job(name: str) -> Job | None:
+    """Helper function to get a job from the database."""
+    db = SessionLocal()
+    try:
+        return db.query(Job).filter(Job.name == name).first()
+    finally:
+        db.close()
+
+
+@app.command("run")
+def run_job(
+    name: Annotated[str, typer.Argument(help="Name of the job to run.")],
+    path: Annotated[
+        str | None,
+        typer.Option("--path", help="Path to script/project (required if job doesn't exist)."),
+    ] = None,
+    script: Annotated[bool, typer.Option("-s", "--script", help="Add as script job type.")] = False,
+    project: Annotated[bool, typer.Option("-p", "--project", help="Add as project job type.")] = False,
+    dependencies: Annotated[
+        list[str] | None,
+        typer.Option("--with", "-w", help="Dependencies for script jobs."),
+    ] = None,
+    add_only: Annotated[bool, typer.Option("--add-only", help="Only add the job, don't run it.")] = False,
+    run_only: Annotated[bool, typer.Option("--run-only", help="Only run existing job, don't add if missing.")] = False,
+) -> None:
+    """Run a job. Can add and run, or just add, or just run existing job."""
+    # Validate mutually exclusive options
+    if script and project:
+        typer.secho("❌ Cannot specify both --script and --project.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    if add_only and run_only:
+        typer.secho("❌ Cannot specify both --add-only and --run-only.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    # Get existing job
+    db = SessionLocal()
+    try:
+        job = db.query(Job).filter(Job.name == name).first()
+    finally:
+        db.close()
+
+    # If job doesn't exist and we're in run-only mode, error
+    if not job and run_only:
+        typer.secho(f"❌ Job '{name}' not found and --run-only specified.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+    # If job doesn't exist, we need to add it
+    if not job:
+        if not path:
+            typer.secho("❌ Path is required when adding a new job.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        if not script and not project:
+            typer.secho("❌ Must specify either --script (-s) or --project (-p) for new jobs.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        job_type = "script" if script else "project"
+
+        # Validate dependencies only for scripts
+        if project and dependencies:
+            typer.secho("❌ Dependencies are only supported for script jobs.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        job = _add_job(name, path, job_type, dependencies)
+
+    # If we're only adding, stop here
+    if add_only:
+        return
+
+    # Run the job
+    async def run() -> None:
+        executor = Executor(job)
+        result = await executor.execute()
+        if result["status"] == "SUCCEEDED":
+            typer.secho(f"✅ Job '{name}' completed successfully.", fg=typer.colors.GREEN)
+        else:
+            typer.secho(f"❌ Job '{name}' failed with exit code {result['exit_code']}.", fg=typer.colors.RED)
+        typer.secho(f"📋 Log file: {result['log_path']}", fg=typer.colors.BLUE)
+
+    asyncio.run(run())
+
+
+@app.command("schedule")
+def schedule_job(
+    name: Annotated[str, typer.Argument(help="Name of the job to schedule.")],
+    schedule_type: Annotated[
+        str,
+        typer.Option("--type", "-t", help="Schedule type: once, interval, cron, until_done"),
+    ] = "once",
+    run_date: Annotated[
+        str | None,
+        typer.Option("--date", help="Run date (YYYY-MM-DD HH:MM:SS) for 'once' type"),
+    ] = None,
+    seconds: Annotated[int, typer.Option("--seconds", help="Seconds for interval type")] = 0,
+    minutes: Annotated[int, typer.Option("--minutes", help="Minutes for interval type")] = 0,
+    hours: Annotated[int, typer.Option("--hours", help="Hours for interval type")] = 0,
+    days: Annotated[int, typer.Option("--days", help="Days for interval type")] = 0,
+    cron_minute: Annotated[str | None, typer.Option("--cron-minute", help="Cron minute (0-59)")] = None,
+    cron_hour: Annotated[str | None, typer.Option("--cron-hour", help="Cron hour (0-23)")] = None,
+    cron_day: Annotated[str | None, typer.Option("--cron-day", help="Cron day of month (1-31)")] = None,
+    cron_month: Annotated[str | None, typer.Option("--cron-month", help="Cron month (1-12)")] = None,
+    cron_dow: Annotated[str | None, typer.Option("--cron-dow", help="Cron day of week (0-6, 0=Sunday)")] = None,
+    max_retries: Annotated[int, typer.Option("--max-retries", help="Max retries for until_done type")] = 10,
+    retry_interval: Annotated[
+        int,
+        typer.Option("--retry-interval", help="Retry interval in seconds for until_done"),
+    ] = 60,
+) -> None:
+    """Schedule a job to run in the background."""
+    db = SessionLocal()
+    try:
+        job = db.query(Job).filter(Job.name == name).first()
+        if not job:
+            typer.secho(f"❌ Job '{name}' not found.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        # Validate schedule type
+        valid_types = ["once", "interval", "cron", "until_done"]
+        if schedule_type not in valid_types:
+            typer.secho(f"❌ Invalid schedule type. Must be one of: {', '.join(valid_types)}", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        # Prepare scheduling arguments
+        schedule_kwargs = {}
+
+        if schedule_type == "once":
+            if not run_date:
+                typer.secho("❌ --date is required for 'once' schedule type", fg=typer.colors.RED)
+                raise typer.Exit(code=1)
+            schedule_kwargs["run_date"] = run_date
+
+        elif schedule_type == "interval":
+            if not any([seconds, minutes, hours, days]):
+                typer.secho(
+                    "❌ At least one interval parameter (seconds, minutes, hours, days) is required",
+                    fg=typer.colors.RED,
+                )
+                raise typer.Exit(code=1)
+            schedule_kwargs.update({"seconds": seconds, "minutes": minutes, "hours": hours, "days": days})
+
+        elif schedule_type == "cron":
+            cron_params = {
+                "minute": cron_minute,
+                "hour": cron_hour,
+                "day": cron_day,
+                "month": cron_month,
+                "day_of_week": cron_dow,
+            }
+            # Only include non-None values
+            schedule_kwargs.update({k: v for k, v in cron_params.items() if v is not None})
+            if not schedule_kwargs:
+                typer.secho("❌ At least one cron parameter is required", fg=typer.colors.RED)
+                raise typer.Exit(code=1)
+
+        elif schedule_type == "until_done":
+            schedule_kwargs.update({"max_retries": max_retries, "retry_interval": retry_interval})
+
+        # Schedule the job
+        scheduler_job_id = scheduler_manager.schedule_job(job.id, schedule_type, **schedule_kwargs)  # type: ignore
+
+        typer.secho(f"✅ Job '{name}' scheduled successfully.", fg=typer.colors.GREEN)
+        typer.secho(f"📅 Scheduler ID: {scheduler_job_id}", fg=typer.colors.BLUE)
+
+        if schedule_type == "until_done":
+            typer.secho(
+                f"🔄 Job will run repeatedly until successful (max {max_retries} attempts)",
+                fg=typer.colors.YELLOW,
+            )
+
+    finally:
+        db.close()
+
+
+@app.command("list")
+def list_jobs(
+    scheduled: Annotated[
+        bool,
+        typer.Option("--scheduled", "-s", help="Show scheduled jobs instead of stored jobs"),
+    ] = False,
+) -> None:
+    """Lists all jobs managed by pem (stored) or scheduled jobs (with --scheduled)."""
+    if scheduled:
+        # List scheduled jobs
+        scheduled_jobs = scheduler_manager.list_scheduled_jobs()
+
+        if not scheduled_jobs:
+            typer.secho("No scheduled jobs found.", fg=typer.colors.YELLOW)
+            return
+
+        typer.secho("Scheduled Jobs:", fg=typer.colors.BLUE)
+        for job in scheduled_jobs:
+            typer.secho(f"- {job['id']}", fg=typer.colors.WHITE)
+            typer.secho(f"  Next run: {job['next_run']}", fg=typer.colors.CYAN)
+            typer.secho(f"  Trigger: {job['trigger']}", fg=typer.colors.CYAN)
+            if "start_time" in job:
+                typer.secho(f"  Started: {job['start_time']}", fg=typer.colors.CYAN)
+            if "max_retries" in job:
+                typer.secho(f"  Max retries: {job['max_retries']}", fg=typer.colors.CYAN)
+            typer.secho("")
+    else:
+        # List stored jobs
+        db = SessionLocal()
+        try:
+            if not (jobs := db.query(Job).all()):
+                typer.secho("No jobs found.", fg=typer.colors.YELLOW)
+                return
+
+            typer.secho("Jobs:", fg=typer.colors.BLUE)
+            for job in jobs:
+                status = "✅ enabled" if job.is_enabled else "❌ disabled"
+                dependencies = f", deps: {job.dependencies}" if job.dependencies else ""
+                typer.secho(
+                    f"- {job.name} ({job.job_type}) - Path: {job.path}{dependencies} - {status}",
+                    fg=typer.colors.GREEN if job.is_enabled else typer.colors.RED,
+                )
+        finally:
+            db.close()
+
+
+@app.command("cancel")
+def cancel_scheduled_job(scheduler_job_id: Annotated[str, typer.Argument(help="Scheduler job ID to cancel.")]) -> None:
+    """Cancel a scheduled job."""
+    success = scheduler_manager.cancel_job(scheduler_job_id)
+
+    if success:
+        typer.secho(f"✅ Scheduled job '{scheduler_job_id}' cancelled successfully.", fg=typer.colors.GREEN)
+    else:
+        typer.secho(f"❌ Failed to cancel scheduled job '{scheduler_job_id}'. Job not found.", fg=typer.colors.RED)
+        raise typer.Exit(code=1)
+
+
+@app.command("show")
+def show_job(name: Annotated[str, typer.Argument(help="Name of the job to show.")]) -> None:
+    """Shows detailed information about a specific job."""
+    db = SessionLocal()
+    try:
+        job = db.query(Job).filter(Job.name == name).first()
+        if not job:
+            typer.secho(f"❌ Job '{name}' not found.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        typer.secho("Job Details:", fg=typer.colors.BLUE)
+        typer.secho(f"  Name: {job.name}", fg=typer.colors.WHITE)
+        typer.secho(f"  Type: {job.job_type}", fg=typer.colors.WHITE)
+        typer.secho(f"  Path: {job.path}", fg=typer.colors.WHITE)
+        typer.secho(f"  Dependencies: {job.dependencies or 'None'}", fg=typer.colors.WHITE)
+        typer.secho(f"  Enabled: {'Yes' if job.is_enabled else 'No'}", fg=typer.colors.WHITE)
+        typer.secho(f"  ID: {job.id}", fg=typer.colors.WHITE)
+    finally:
+        db.close()
+
+
+@app.command("update")
+def update_job(
+    name: Annotated[str, typer.Argument(help="Name of the job to update.")],
+    new_name: Annotated[str | None, typer.Option("--name", "-n")] = None,
+    path: Annotated[str | None, typer.Option("--path", "-p")] = None,
+    dependencies: Annotated[list[str] | None, typer.Option("--with", "-w")] = None,
+    enabled: Annotated[bool | None, typer.Option("--enabled/--disabled")] = None,
+) -> None:
+    """Updates an existing job."""
+    db = SessionLocal()
+    try:
+        job = db.query(Job).filter(Job.name == name).first()
+        if not job:
+            typer.secho(f"❌ Job '{name}' not found.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        # Update fields if provided
+        if new_name:
+            job.name = new_name
+        if path:
+            job.path = path
+        if dependencies is not None:
+            job.dependencies = dependencies
+        if enabled is not None:
+            job.is_enabled = enabled
+
+        db.commit()
+        typer.secho(f"✅ Job '{name}' updated successfully.", fg=typer.colors.GREEN)
+    finally:
+        db.close()
+
+
+@app.command("delete")
+def delete_job(
+    name: Annotated[str, typer.Argument(help="Name of the job to delete.")],
+    force: Annotated[bool, typer.Option("--force", "-f")] = False,
+) -> None:
+    """Deletes a job."""
+    db = SessionLocal()
+    try:
+        job = db.query(Job).filter(Job.name == name).first()
+        if not job:
+            typer.secho(f"❌ Job '{name}' not found.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        if not force:
+            confirm = typer.confirm(f"Are you sure you want to delete job '{name}'?")
+            if not confirm:
+                typer.secho("❌ Operation cancelled.", fg=typer.colors.YELLOW)
+                return
+
+        db.delete(job)
+        db.commit()
+        typer.secho(f"✅ Job '{name}' deleted successfully.", fg=typer.colors.GREEN)
+    finally:
+        db.close()
+
+
+@app.command("enable")
+def enable_job(name: Annotated[str, typer.Argument(help="Name of the job to enable.")]) -> None:
+    """Enables a job."""
+    db = SessionLocal()
+    try:
+        job = db.query(Job).filter(Job.name == name).first()
+        if not job:
+            typer.secho(f"❌ Job '{name}' not found.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        job.is_enabled = True
+        db.commit()
+        typer.secho(f"✅ Job '{name}' enabled.", fg=typer.colors.GREEN)
+    finally:
+        db.close()
+
+
+@app.command("disable")
+def disable_job(name: Annotated[str, typer.Argument(help="Name of the job to disable.")]) -> None:
+    """Disables a job."""
+    db = SessionLocal()
+    try:
+        job = db.query(Job).filter(Job.name == name).first()
+        if not job:
+            typer.secho(f"❌ Job '{name}' not found.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+
+        job.is_enabled = False
+        db.commit()
+        typer.secho(f"✅ Job '{name}' disabled.", fg=typer.colors.GREEN)
+    finally:
+        db.close()

pem/core/executor.py

@@ -0,0 +1,82 @@
+import asyncio
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from pem.db.models import Job
+
+
+class Executor:
+    """Unified executor for handling both script and project jobs."""
+
+    def __init__(self, job: Job) -> None:
+        self.job = job
+        self.logs_dir = Path("./logs").resolve()
+        self.logs_dir.mkdir(exist_ok=True)
+
+        # Set up paths based on job type
+        if self.job.job_type == "script":
+            self.script_path = Path(self.job.path).resolve()
+        elif self.job.job_type == "project":
+            self.project_path = Path(self.job.path).resolve()
+            self.venv_path = self.project_path / ".pem_venv"
+        else:
+            msg = f"Unsupported job type: {self.job.job_type}, it must be either 'script' or 'project'."
+            raise ValueError(msg)
+
+    async def _run_command(self, command: list[str], log_file_handle, cwd: Path | None = None) -> int:
+        """Run a command and write output to log file."""
+        process = await asyncio.create_subprocess_exec(
+            *command,
+            stdout=log_file_handle,
+            stderr=subprocess.STDOUT,
+            cwd=cwd,
+        )
+        await process.wait()
+        return process.returncode or 0
+
+    async def _execute_script(self, log_file) -> int:
+        """Execute a script job using 'uv run'."""
+        command = ["uv", "run"]  # TODO: Add python version
+        if self.job.dependencies:
+            for dep in self.job.dependencies:
+                command.extend(["--with", dep])
+        command.extend(["--script", str(self.script_path)])
+
+        log_file.write(f"--- Running command: {' '.join(command)} ---\n\n")
+        return await self._run_command(command, log_file)
+
+    async def _execute_project(self, log_file) -> int:
+        """Execute a project job using a dedicated venv."""
+        await self._run_command(
+            ["uv", "sync", "--directory", str(self.venv_path)],
+            log_file,
+            self.project_path,
+        )
+
+        return await self._run_command(
+            ["uv", "run", "--directory", str(self.venv_path), "main.py"],  # TODO: get python file
+            log_file,
+            self.project_path,
+        )
+
+    async def execute(self) -> dict[str, Any]:
+        """Execute the job based on its type."""
+        start_time = datetime.utcnow()
+        log_filename = f"{self.job.name}_{start_time.strftime('%Y%m%d_%H%M%S')}.log"
+        log_path = self.logs_dir / log_filename
+
+        with open(log_path, "w") as log_file:
+            log_file.write(f"--- Starting execution at {start_time.isoformat()} ---\n")
+
+            if self.job.job_type == "script":
+                exit_code = await self._execute_script(log_file)
+            elif self.job.job_type == "project":
+                exit_code = await self._execute_project(log_file)
+            else:
+                msg = f"Unsupported job type: {self.job.job_type}"
+                raise ValueError(msg)
+
+        status = "SUCCEEDED" if exit_code == 0 else "FAILED"
+        return {"status": status, "exit_code": exit_code, "log_path": str(log_path)}

pem/core/scheduler.py

@@ -0,0 +1,251 @@
+"""Scheduler manager for handling background job execution."""
+
+import asyncio
+import contextlib
+import threading
+from datetime import datetime
+from typing import Any, Literal
+
+from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
+from apscheduler.schedulers.background import BackgroundScheduler
+
+from pem.core.executor import Executor
+from pem.db.database import SessionLocal
+from pem.db.models import Job
+from pem.settings import DATABASE_URL
+
+ScheduleType = Literal["once", "interval", "cron", "until_done"]
+
+
+def execute_job_standalone(job_id: int) -> dict[str, Any]:
+    """Standalone function to execute a job (for scheduler serialization)."""
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        return loop.run_until_complete(_execute_job_async(job_id))
+    finally:
+        loop.close()
+
+
+async def _execute_job_async(job_id: int) -> dict[str, Any]:
+    """Execute a job asynchronously."""
+    db = SessionLocal()
+    try:
+        job = db.query(Job).filter(Job.id == job_id).first()
+        if not job:
+            return {"status": "FAILED", "error": "Job not found"}
+
+        executor = Executor(job)
+        return await executor.execute()
+    finally:
+        db.close()
+
+
+def execute_until_done_standalone(job_id: int, max_retries: int = 10, retry_interval: int = 60) -> None:
+    """Standalone function to execute a job repeatedly until it succeeds."""
+    attempt = 0
+    while attempt < max_retries:
+        attempt += 1
+
+        result = execute_job_standalone(job_id)
+
+        if result["status"] == "SUCCEEDED":
+            break
+        if attempt < max_retries:
+            threading.Event().wait(retry_interval)
+        else:
+            pass
+
+
+class SchedulerManager:
+    """Manages background scheduling of jobs."""
+
+    def __init__(self) -> None:
+        self.scheduler = BackgroundScheduler()
+        self.scheduler.add_jobstore(SQLAlchemyJobStore(url=DATABASE_URL), "default")
+        self.running_jobs = {}  # Track running until_done jobs
+        self._setup_scheduler()
+
+    def _setup_scheduler(self) -> None:
+        """Initialize and start the scheduler."""
+        with contextlib.suppress(Exception):
+            self.scheduler.start()
+
+    def shutdown(self) -> None:
+        """Shutdown the scheduler."""
+        if self.scheduler.running:
+            self.scheduler.shutdown()
+
+    async def _execute_job_async(self, job_id: int) -> dict[str, Any]:
+        """Execute a job asynchronously."""
+        db = SessionLocal()
+        try:
+            job = db.query(Job).filter(Job.id == job_id).first()
+            if not job:
+                return {"status": "FAILED", "error": "Job not found"}
+
+            executor = Executor(job)
+            return await executor.execute()
+        finally:
+            db.close()
+
+    def _execute_job_sync(self, job_id: int) -> dict[str, Any]:
+        """Execute a job synchronously (wrapper for scheduler)."""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            return loop.run_until_complete(self._execute_job_async(job_id))
+        finally:
+            loop.close()
+
+    def _execute_until_done(self, job_id: int, max_retries: int = 10, retry_interval: int = 60) -> None:
+        """Execute a job repeatedly until it succeeds or max retries reached."""
+        attempt = 0
+        while attempt < max_retries:
+            attempt += 1
+
+            result = self._execute_job_sync(job_id)
+
+            if result["status"] == "SUCCEEDED":
+                # Remove from running jobs tracker
+                if job_id in self.running_jobs:
+                    del self.running_jobs[job_id]
+                break
+            if attempt < max_retries:
+                threading.Event().wait(retry_interval)
+            elif job_id in self.running_jobs:
+                del self.running_jobs[job_id]
+
+    def schedule_job(self, job_id: int, schedule_type: ScheduleType, **kwargs) -> str:
+        """Schedule a job with different scheduling options.
+
+        Args:
+            job_id: The job ID to schedule
+            schedule_type: Type of scheduling (once, interval, cron, until_done)
+            **kwargs: Additional scheduling parameters
+
+        Returns:
+            scheduler_job_id: The APScheduler job ID
+
+        """
+        scheduler_job_id = f"pem_job_{job_id}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+
+        if schedule_type == "once":
+            # Schedule to run once at a specific time
+            run_date = kwargs.get("run_date")
+            if isinstance(run_date, str):
+                run_date = datetime.fromisoformat(run_date)
+
+            self.scheduler.add_job(
+                func=execute_job_standalone,
+                trigger="date",
+                run_date=run_date,
+                args=[job_id],
+                id=scheduler_job_id,
+                replace_existing=True,
+            )
+
+        elif schedule_type == "interval":
+            # Schedule to run at regular intervals
+            seconds = kwargs.get("seconds", 0)
+            minutes = kwargs.get("minutes", 0)
+            hours = kwargs.get("hours", 0)
+            days = kwargs.get("days", 0)
+
+            self.scheduler.add_job(
+                func=execute_job_standalone,
+                trigger="interval",
+                seconds=seconds,
+                minutes=minutes,
+                hours=hours,
+                days=days,
+                args=[job_id],
+                id=scheduler_job_id,
+                replace_existing=True,
+            )
+
+        elif schedule_type == "cron":
+            # Schedule using cron expression
+            cron_kwargs = {
+                k: v for k, v in kwargs.items() if k in ["second", "minute", "hour", "day", "month", "day_of_week"]
+            }
+
+            self.scheduler.add_job(
+                func=execute_job_standalone,
+                trigger="cron",
+                args=[job_id],
+                id=scheduler_job_id,
+                replace_existing=True,
+                **cron_kwargs,
+            )
+
+        elif schedule_type == "until_done":
+            # Run in background thread until success
+            max_retries = kwargs.get("max_retries", 10)
+            retry_interval = kwargs.get("retry_interval", 60)
+
+            # Track this job
+            self.running_jobs[job_id] = {
+                "scheduler_job_id": scheduler_job_id,
+                "start_time": datetime.now(),
+                "max_retries": max_retries,
+                "retry_interval": retry_interval,
+            }
+
+            # Run in a separate thread
+            thread = threading.Thread(
+                target=execute_until_done_standalone,
+                args=[job_id, max_retries, retry_interval],
+                daemon=True,
+            )
+            thread.start()
+
+        return scheduler_job_id
+
+    def list_scheduled_jobs(self) -> list[dict]:
+        """List all scheduled jobs."""
+        jobs = []
+        for job in self.scheduler.get_jobs():
+            if job.id.startswith("pem_job_"):
+                jobs.append(
+                    {
+                        "id": job.id,
+                        "next_run": job.next_run_time,
+                        "trigger": str(job.trigger),
+                        "func": job.func.__name__,
+                    },
+                )
+
+        # Add until_done jobs
+        for info in self.running_jobs.values():
+            jobs.append(
+                {
+                    "id": info["scheduler_job_id"],
+                    "next_run": "running until done",
+                    "trigger": "until_done",
+                    "func": "_execute_until_done",
+                    "start_time": info["start_time"],
+                    "max_retries": info["max_retries"],
+                },
+            )
+
+        return jobs
+
+    def cancel_job(self, scheduler_job_id: str) -> bool:
+        """Cancel a scheduled job."""
+        try:
+            # Check if it's an until_done job
+            for job_id, info in list(self.running_jobs.items()):
+                if info["scheduler_job_id"] == scheduler_job_id:
+                    del self.running_jobs[job_id]
+                    return True
+
+            # Remove from scheduler
+            self.scheduler.remove_job(scheduler_job_id)
+            return True
+        except Exception:
+            return False
+
+
+# Global scheduler instance
+scheduler_manager = SchedulerManager()

pem/db/database.py

@@ -0,0 +1,14 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+from pem.settings import DATABASE_URL
+
+Base = declarative_base()
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+def create_db_and_tables() -> None:
+    """Creates the database and tables if they don't exist."""
+    Base.metadata.create_all(bind=engine)

pem/db/models.py

@@ -0,0 +1,51 @@
+import datetime
+
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    DateTime,
+    ForeignKey,
+    Integer,
+    String,
+)
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from pem.db.database import Base
+
+
+class Job(Base):
+    """Represents a job that can be executed."""
+
+    __tablename__ = "jobs"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    name: Mapped[str] = mapped_column(String, unique=True, nullable=False, index=True)
+    job_type: Mapped[str] = mapped_column(String, nullable=False)
+    path: Mapped[str] = mapped_column(String, nullable=False)
+    dependencies: Mapped[list[str] | None] = mapped_column(JSON, nullable=True)
+    is_enabled: Mapped[bool] = mapped_column(Boolean, default=True)
+
+    runs: Mapped[list["ExecutionRun"]] = relationship(
+        "ExecutionRun",
+        back_populates="job",
+        cascade="all, delete-orphan",
+    )
+
+
+class ExecutionRun(Base):
+    """Represents a single execution of a job."""
+
+    __tablename__ = "execution_runs"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    job_id: Mapped[int] = mapped_column(Integer, ForeignKey("jobs.id"), nullable=False)
+    start_time: Mapped[datetime.datetime] = mapped_column(DateTime, default=datetime.datetime.utcnow)
+    end_time: Mapped[datetime.datetime | None] = mapped_column(DateTime, nullable=True)
+    status: Mapped[str] = mapped_column(String, nullable=False)
+    exit_code: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    log_path: Mapped[str | None] = mapped_column(String, nullable=True)
+
+    job: Mapped["Job"] = relationship(
+        "Job",
+        back_populates="runs",
+    )

pem/settings.py

@@ -0,0 +1,3 @@
+"""Configuration settings for the PEM application."""
+
+DATABASE_URL = "sqlite:///pem.db"

pemexe-0.1.0.dist-info/METADATA

@@ -0,0 +1,275 @@
+Metadata-Version: 2.4
+Name: pemexe
+Version: 0.1.0
+Summary: 🚀 Python Execution Manager - A powerful, modern tool for managing, scheduling, and executing Python scripts and projects with comprehensive logging, flexible scheduling, and dependency management. Perfect for DevOps, data science, and automation workflows.
+Author: Arian Omrani
+Project-URL: Homepage, https://github.com/arian24b/pem
+Project-URL: Issues, https://github.com/arian24b/pem/issues
+Keywords: python,scheduler,automation,devops,task-runner,cron,execution,management,scripts,projects,cli,background-jobs,logging,dependencies
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: apscheduler>=3.11.0
+Requires-Dist: sqlalchemy>=2.0.41
+Requires-Dist: typer>=0.16.0
+Requires-Dist: uv>=0.8.2
+Dynamic: license-file
+
+# PEM - Python Execution Manager 🚀
+
+**A powerful, modern Python tool for managing, scheduling, and executing Python scripts and projects with ease.**
+
+[![Python 3.13+](https://img.shields.io/badge/python-3.13+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Built with uv](https://img.shields.io/badge/built%20with-uv-blue)](https://github.com/astral-sh/uv)
+
+## ✨ What is PEM?
+
+PEM is your all-in-one solution for Python execution management. Whether you're running one-off scripts, managing complex projects, or scheduling automated tasks, PEM makes it simple and reliable.
+
+### 🎯 Perfect for:
+- **DevOps Engineers** managing deployment scripts and automation
+- **Data Scientists** running scheduled data processing jobs
+- **Python Developers** organizing and executing multiple projects
+- **System Administrators** automating maintenance tasks
+- **Anyone** who needs reliable Python script execution with logging
+
+## 🌟 Key Features
+
+### 📋 **Job Management**
+- **Two Job Types**: Handle both standalone scripts and full Python projects
+- **Dependency Management**: Automatically install and manage script dependencies using `uv`
+- **Smart Execution**: Uses `uv run` for fast, isolated script execution
+- **Project Support**: Full support for Python projects with virtual environments
+
+### ⏰ **Flexible Scheduling**
+- **Multiple Schedule Types**:
+  - `once` - Run at a specific date/time
+  - `interval` - Run every X seconds/minutes/hours/days
+  - `cron` - Use cron expressions for complex schedules
+  - `until_done` - Keep retrying until the job succeeds
+- **Background Execution**: All scheduled jobs run in the background
+- **Persistent Storage**: Schedules survive system restarts
+
+### 📊 **Comprehensive Logging & Tracking**
+- **Detailed Logs**: Every execution is logged with timestamps and output
+- **Execution History**: Track all job runs with status, exit codes, and timing
+- **SQLite Database**: Local storage for jobs, schedules, and execution history
+- **Real-time Status**: See what's running, what succeeded, and what failed
+
+### 🛠 **Developer-Friendly CLI**
+- **Intuitive Commands**: Simple, memorable command structure
+- **Rich Output**: Colored terminal output with emojis for better UX
+- **Flexible Options**: Extensive command-line options for all use cases
+- **Built with Typer**: Modern, type-safe CLI framework
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+# Install PEM
+pip install pem
+
+# Or using uv (recommended)
+uv add pem
+```
+
+### Basic Usage
+
+```bash
+# Run a Python script with dependencies
+pem run my-data-script --script --path ./data_processor.py --with pandas --with requests
+
+# Add a project job
+pem run my-web-app --project --path ./my-flask-app --add-only
+
+# Schedule a job to run every hour
+pem schedule my-data-script --type interval --hours 1
+
+# List all jobs
+pem list
+
+# View job execution history
+pem history my-data-script
+
+# Check scheduler status
+pem status
+```
+
+## 📖 Detailed Usage
+
+### Managing Jobs
+
+#### Script Jobs
+Perfect for standalone Python scripts with specific dependencies:
+
+```bash
+# Add and run a script with dependencies
+pem run data-processor \
+  --script \
+  --path ./scripts/process_data.py \
+  --with pandas \
+  --with requests \
+  --with beautifulsoup4
+
+# Just add the job without running
+pem run backup-script --script --path ./backup.py --add-only
+
+# Run an existing job
+pem run backup-script --run-only
+```
+
+#### Project Jobs
+For full Python projects with their own environments:
+
+```bash
+# Add a Python project
+pem run my-api --project --path ./my-fastapi-project --add-only
+
+# Run the project (will use project's own dependencies)
+pem run my-api --run-only
+```
+
+### Scheduling Jobs
+
+#### One-time Execution
+```bash
+# Run once at a specific time
+pem schedule backup-job --type once --date "2025-12-31 23:59:59"
+```
+
+#### Interval-based Scheduling
+```bash
+# Every 30 minutes
+pem schedule data-sync --type interval --minutes 30
+
+# Every 2 hours
+pem schedule hourly-report --type interval --hours 2
+
+# Every day
+pem schedule daily-backup --type interval --days 1
+```
+
+#### Cron-style Scheduling
+```bash
+# Every weekday at 9 AM
+pem schedule morning-report --type cron --cron-hour 9 --cron-dow 1-5
+
+# Every Monday at midnight
+pem schedule weekly-cleanup --type cron --cron-hour 0 --cron-dow 1
+```
+
+#### Retry Until Success
+```bash
+# Keep trying every 5 minutes until it succeeds (max 20 attempts)
+pem schedule critical-task --type until_done --retry-interval 300 --max-retries 20
+```
+
+### Monitoring & Management
+
+```bash
+# List all jobs
+pem list
+
+# Show job details
+pem show my-job
+
+# View execution history
+pem history my-job
+
+# Check what's scheduled and running
+pem status
+
+# Enable/disable jobs
+pem enable my-job
+pem disable my-job
+
+# Remove jobs
+pem remove my-job
+```
+
+## 🏗 Architecture
+
+PEM is built with modern Python best practices:
+
+- **SQLAlchemy**: Robust database ORM for job and execution tracking
+- **APScheduler**: Reliable job scheduling with multiple backends
+- **Typer**: Type-safe, intuitive CLI framework
+- **uv**: Fast Python package management and script execution
+- **AsyncIO**: Efficient asynchronous execution
+
+## 📁 Project Structure
+
+```
+pem/
+├── pem/
+│   ├── cli.py          # Command-line interface
+│   ├── main.py         # Application entry point
+│   ├── settings.py     # Configuration
+│   ├── core/
+│   │   ├── executor.py # Job execution engine
+│   │   └── scheduler.py # Background scheduling
+│   └── db/
+│       ├── database.py # Database configuration
+│       └── models.py   # SQLAlchemy models
+├── logs/               # Execution logs
+├── pem.db             # SQLite database
+└── pyproject.toml     # Project configuration
+```
+
+## 🔧 Configuration
+
+PEM works out of the box with sensible defaults:
+
+- **Database**: SQLite (`pem.db`) in the current directory
+- **Logs**: Stored in `./logs/` directory
+- **Virtual Environments**: Created in project directories as `.pem_venv`
+
+## 🤝 Contributing
+
+We welcome contributions! Here's how to get started:
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b my-new-feature`
+3. Make your changes and add tests
+4. Run the test suite: `pytest`
+5. Submit a pull request
+
+## 📝 License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## 🙋‍♀️ Support
+
+- **Issues**: [GitHub Issues](https://github.com/arian24b/pem/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/arian24b/pem/discussions)
+
+## 🚀 Why Choose PEM?
+
+### vs. Cron
+- ✅ Cross-platform (works on Windows, macOS, Linux)
+- ✅ Dependency management built-in
+- ✅ Detailed logging and execution history
+- ✅ Easy job management with CLI
+- ✅ Python-native (no shell scripting needed)
+
+### vs. Other Task Runners
+- ✅ Specifically designed for Python
+- ✅ No complex configuration files
+- ✅ Built-in dependency isolation
+- ✅ Simple CLI interface
+- ✅ Local database storage (no external dependencies)
+
+### vs. Manual Script Running
+- ✅ Automated scheduling
+- ✅ Execution history and monitoring
+- ✅ Dependency management
+- ✅ Error handling and retries
+- ✅ Centralized job management
+
+---
+
+**Made with ❤️ by [Arian Omrani](https://github.com/arian24b)**
+
+*PEM - Making Python execution management simple, reliable, and powerful.*

pemexe-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pem/cli.py,sha256=JtYNdbBvWVQ6kom5wlcB80jMxHvYkRpCXwOwXtHCZIs,15076
+pem/settings.py,sha256=a0_cnoFKfLVsRI38QFy28VR9nYdhoUoQVTCHRzHfDEI,89
+pem/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pem/core/executor.py,sha256=BfZLcFonYsiT2O1BxDzXLc0Fek7MwzguSN_I8_pQZGA,3136
+pem/core/scheduler.py,sha256=v-q3UQ6jXiHiWFOvUp3X460cnCbRcGe2hEL814dM7yo,8406
+pem/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pem/db/database.py,sha256=OEw6E2Skc_Ke2IbnyxttdIFj8AsYNGbjmE1LhS0BnrE,461
+pem/db/models.py,sha256=xjAMz0WjnoYYBCiSoiNr9gnGcDr7wGs8tA7Dnl4-gpY,1656
+pemexe-0.1.0.dist-info/licenses/LICENSE,sha256=VqnjBysK1s6FLvTJ_k8ZvwDLfLm9gXnlGh-2Hj4E09I,1069
+pemexe-0.1.0.dist-info/METADATA,sha256=AnO6_odghYExyDtpER6NyRQ3-DqeOEp8rzazkbJ2qGU,8249
+pemexe-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pemexe-0.1.0.dist-info/entry_points.txt,sha256=ZG_c5NlLtD6OQ8fSXsHqxjcLEWN6vdFOoezGN0nOG4Y,36
+pemexe-0.1.0.dist-info/top_level.txt,sha256=cCeDNat8sNE5-evKrL-T6orV9hSCb4HxRUSB9Aq_rHo,4
+pemexe-0.1.0.dist-info/RECORD,,

pemexe-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pemexe-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pem = pem.cli:app

pemexe-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Arian Omrani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pemexe-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pem