E_task_queue.py

import dill
import argparse
import os
import tempfile
import time
import fcntl

QUEUE_FILE = "tasks.dat"
RESULT_FILE = "results.log"


# -----------------------------
# Example functions that can be queued
# -----------------------------
def add(a, b):
    return a + b


def multiply(a, b):
    return a * b


def say_hello(name):
    return f"Hello {name}"


FUNCTIONS = {
    "add": add,
    "multiply": multiply,
    "hello": say_hello
}


# -----------------------------
# File locking
# -----------------------------
def lock_file(f):
    fcntl.flock(f, fcntl.LOCK_EX)


def unlock_file(f):
    fcntl.flock(f, fcntl.LOCK_UN)


# -----------------------------
# Load queue
# -----------------------------
def load_queue():
    if not os.path.exists(QUEUE_FILE):
        return []

    with open(QUEUE_FILE, "rb") as f:
        lock_file(f)
        try:
            data = dill.load(f)
        except Exception:
            data = []
        unlock_file(f)
        return data


# -----------------------------
# Save queue safely
# -----------------------------
def save_queue(queue):
    with tempfile.NamedTemporaryFile("wb", delete=False) as tmp:
        dill.dump(queue, tmp)
        temp_name = tmp.name

    os.replace(temp_name, QUEUE_FILE)


# -----------------------------
# Add task
# -----------------------------

def add_task(func_name, args, delay=0):
    queue = load_queue()

    run_at = time.time() + delay

    task = {
        "function": func_name,
        "args": args,
        "time": time.time(),
        "run_at": run_at
    }

    queue.append(task)
    save_queue(queue)

    print("Task added.")
    print("Scheduled for:", time.ctime(run_at))

# -----------------------------
# List tasks
# -----------------------------
def list_tasks():
    queue = load_queue()

    if not queue:
        print("No pending tasks.")
        return

    for i, task in enumerate(queue):
        print(f"{i+1}. {task['function']} {task['args']}")


# -----------------------------
# Run next task
# -----------------------------

def run_next():
    queue = load_queue()

    if not queue:
        print("No tasks in queue.")
        return

    now = time.time()

    for i, task in enumerate(queue):

        if task["run_at"] <= now:

            task_to_run = queue.pop(i)
            save_queue(queue)

            func = FUNCTIONS.get(task_to_run["function"])

            try:
                result = func(*task_to_run["args"])
                status = "SUCCESS"
            except Exception as e:
                result = str(e)
                status = "FAILED"

            with open(RESULT_FILE, "a") as f:
                f.write(f"{status} | {task_to_run} | Result: {result}\n")

            print("Executed:", task_to_run)
            print("Result:", result)
            return

    print("No tasks are ready to run yet.")

# -----------------------------
# Clear queue
# -----------------------------
def clear_queue():
    save_queue([])
    print("Queue cleared.")


# -----------------------------
# CLI
# -----------------------------
def main():
    parser = argparse.ArgumentParser(description="File-based Task Queue")

    sub = parser.add_subparsers(dest="command")

    add_cmd = sub.add_parser("add")
    add_cmd.add_argument("function")
    add_cmd.add_argument("args", nargs="*")
    add_cmd.add_argument("--delay", type=int, default=0, help="Delay execution in seconds")

    sub.add_parser("list")
    sub.add_parser("run")
    sub.add_parser("clear")

    args = parser.parse_args()

    if args.command == "add":
        func = args.function
        arguments = [eval(x) if x.isdigit() else x for x in args.args]
        add_task(func, arguments, args.delay)

    elif args.command == "list":
        list_tasks()

    elif args.command == "run":
        run_next()

    elif args.command == "clear":
        clear_queue()

    else:
        parser.print_help()


if __name__ == "__main__":
    main()