py2autotask 2.0.1__tar.gz

py2autotask-2.0.1/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.5
+Name: py2autotask
+Version: 2.0.1
+Summary: Dynamic asynchronous task library
+Author: 7yokki, brt222
+License-Expression: MIT
+Requires-Python: >=3.10

py2autotask-2.0.1/py2autotask/__init__.py

@@ -0,0 +1,53 @@
+# tasks/__init__.py
+
+from .task import (
+    # Sınıflar
+    TaskScheduler,
+    TaskDef,
+    TaskResult,
+
+    # Enum'lar
+    TaskState,
+    TaskPriority,
+
+    # Global fonksiyonlar (varsayılan scheduler üzerinden)
+    task,
+    config_task,
+    stop_task,
+    cont_task,
+    restart_task,
+    remove_task,
+    trigger_task,
+    get_scheduler,
+)
+
+__version__ = "2.0.0"
+__author__  = "Sen"
+__license__ = "MIT"
+
+__all__ = [
+    # Sınıflar
+    "TaskScheduler",
+    "TaskDef",
+    "TaskResult",
+
+    # Enum'lar
+    "TaskState",
+    "TaskPriority",
+
+    # API
+    "task",
+    "config_task",
+    "stop_task",
+    "cont_task",
+    "restart_task",
+    "remove_task",
+    "trigger_task",
+    "get_scheduler",
+
+    # Meta
+    "__version__",
+]
+
+_sched = get_scheduler()
+_sched.max_concurrent   = 20

py2autotask-2.0.1/py2autotask/cli.py

@@ -0,0 +1,388 @@
+# tasks/cli.py
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import logging
+import signal
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .task import (
+    TaskScheduler,
+    TaskPriority,
+    TaskState,
+    get_scheduler,
+)
+
+
+# ─────────────────────────────────────────────────────────────
+# YARDIMCILAR
+# ─────────────────────────────────────────────────────────────
+
+PRIORITY_MAP = {
+    "low": TaskPriority.LOW,
+    "normal": TaskPriority.NORMAL,
+    "high": TaskPriority.HIGH,
+    "critical": TaskPriority.CRITICAL,
+}
+
+
+def _load_code(args) -> str:
+    """--file veya pozisyonel koddan pycode üretir."""
+    if args.file:
+        path = Path(args.file)
+        if not path.exists():
+            raise FileNotFoundError(f"File not found: {args.file}")
+        return path.read_text(encoding="utf-8")
+    if args.code:
+        return args.code
+    raise ValueError("You must provide --file or inline code.")
+
+
+def _setup_logging(level: str):
+    logging.basicConfig(
+        level=getattr(logging, level.upper(), logging.INFO),
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+
+def _parse_priority(p: str) -> TaskPriority:
+    return PRIORITY_MAP.get(p.lower(), TaskPriority.NORMAL)
+
+
+def _print_result(res):
+    icon = {
+        TaskState.SUCCESS: "✓",
+        TaskState.FAILED: "✗",
+        TaskState.TIMEOUT: "⏱",
+        TaskState.CANCELLED: "⊘",
+        TaskState.STOPPED: "■",
+    }.get(res.state, "•")
+
+    print(
+        f"{icon} [{res.name}] {res.state.name} "
+        f"({res.duration:.3f}s, try={res.attempts}, run#{res.run_index})"
+    )
+    if res.result is not None:
+        print(f"   → result: {res.result!r}")
+    if res.error is not None:
+        print(f"   → error: {type(res.error).__name__}: {res.error}")
+
+
+# ─────────────────────────────────────────────────────────────
+# KOMUT: run
+# ─────────────────────────────────────────────────────────────
+
+async def cmd_run(args) -> int:
+    scheduler = get_scheduler()
+    scheduler.auto_start = True
+
+    code = _load_code(args)
+    name = args.name or "main"
+
+    scheduler.task(
+        name,
+        code,
+        priority=_parse_priority(args.priority),
+        delay=args.delay,
+        timeout=args.timeout,
+        interval=args.interval,
+        max_runs=args.max_runs,
+        retries=args.retries,
+        retry_delay=args.retry_delay,
+        retry_backoff=args.retry_backoff,
+        auto_start=True,
+        on_success=lambda r: _print_result(r) if args.verbose else None,
+        on_failure=lambda r: _print_result(r),
+        on_retry=lambda r, a: print(f"↻ [{r.name}] retrying (#{a})"),
+    )
+
+    td = scheduler.get_task(name)
+    print(f"▶ Task started: {name} (id={td.id})")
+
+    if td._asyncio_task:
+        try:
+            await td._asyncio_task
+        except asyncio.CancelledError:
+            pass
+
+    if td.last_result:
+        _print_result(td.last_result)
+
+    await scheduler.shutdown(timeout=2.0)
+    return 0 if (td.last_result and td.last_result.success) else 1
+
+
+
+def _parse_task_config(cfg: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "task_name": cfg["name"],
+        "pycode": cfg.get("code") or Path(cfg["file"]).read_text(encoding="utf-8"),
+        "priority": _parse_priority(cfg.get("priority", "normal")),
+        "delay": cfg.get("delay", 0.0),
+        "timeout": cfg.get("timeout"),
+        "interval": cfg.get("interval"),
+        "max_runs": cfg.get("max_runs"),
+        "retries": cfg.get("retries", 0),
+        "retry_delay": cfg.get("retry_delay", 1.0),
+        "retry_backoff": cfg.get("retry_backoff", 1.0),
+        "auto_start": cfg.get("auto_start", True),
+        "depends_on": cfg.get("depends_on", []),
+        "metadata": cfg.get("metadata", {}),
+        "tags": cfg.get("tags", []),
+    }
+
+
+def _load_config(path: str) -> List[Dict[str, Any]]:
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(f"Config not found: {path}")
+
+    text = p.read_text(encoding="utf-8")
+    if p.suffix in (".yaml", ".yml"):
+        try:
+            import yaml
+        except ImportError:
+            print("For YAML, install pyyaml: `pip install pyyaml`", file=sys.stderr)
+            sys.exit(2)
+        data = yaml.safe_load(text)
+    else:
+        data = json.loads(text)
+
+    if isinstance(data, dict) and "tasks" in data:
+        return data["tasks"]
+    if isinstance(data, list):
+        return data
+    raise ValueError("Config 'tasks:' list or array expected.")
+
+
+async def cmd_batch(args) -> int:
+    scheduler = get_scheduler()
+    scheduler.auto_start = True
+
+    tasks = _load_config(args.config)
+    print(f"→ {len(tasks)} loading")
+
+    for cfg in tasks:
+        params = _parse_task_config(cfg)
+        try:
+            scheduler.task(**params)
+            print(f"  [+] {params['task_name']}")
+        except Exception as e:
+            print(f"  [!] {params['task_name']}: {e}", file=sys.stderr)
+
+    await scheduler.wait_all(timeout=args.timeout)
+    await scheduler.shutdown(timeout=2.0)
+    return 0
+
+
+def cmd_list(args) -> int:
+    tasks = _load_config(args.config)
+    print(f"{'NAME':<20} {'INTERVAL':>10} {'TIMEOUT':>10} {'RETRIES':>8} {'PRIORITY':>10}")
+    print("-" * 62)
+    for cfg in tasks:
+        print(
+            f"{cfg['name']:<20} "
+            f"{str(cfg.get('interval', '-')):>10} "
+            f"{str(cfg.get('timeout', '-')):>10} "
+            f"{str(cfg.get('retries', 0)):>8} "
+            f"{str(cfg.get('priority', 'normal')):>10}"
+        )
+    return 0
+
+
+# ─────────────────────────────────────────────────────────────
+# KOMUT: interactive (REPL benzeri)
+# ─────────────────────────────────────────────────────────────
+
+async def cmd_shell(args) -> int:
+    scheduler = get_scheduler()
+    print("Task Shell — 'help' or 'exit'.")
+
+    loop = asyncio.get_event_loop()
+    stop_flag = {"run": True}
+
+    def _sig(*_):
+        stop_flag["run"] = False
+
+    for sig in (signal.SIGINT, signal.SIGTERM):
+        try:
+            loop.add_signal_handler(sig, _sig)
+        except NotImplementedError:
+            pass
+
+    while stop_flag["run"]:
+        try:
+            line = await loop.run_in_executor(None, input, "tasks> ")
+        except (EOFError, KeyboardInterrupt):
+            break
+
+        line = line.strip()
+        if not line:
+            continue
+
+        parts = line.split(maxsplit=2)
+        cmd = parts[0].lower()
+
+        try:
+            if cmd in ("exit", "quit"):
+                break
+
+            elif cmd == "help":
+                print(
+                    "Komutlar:\n"
+                    "  run <name> <pycode...>            create task\n"
+                    "  stop <name>                       stop\n"
+                    "  cont <name>                       continue\n"
+                    "  restart <name>                    shutdown\n"
+                    "  trigger <name>                    run now\n"
+                    "  remove <name>                     delete\n"
+                    "  config <name> <k=v> [<k=v>...]    re-config\n"
+                    "  list                              list the tasks\n"
+                    "  results <name>                    result history\n"
+                    "  summary                           summary\n"
+                    "  exit                              exit"
+                )
+
+            elif cmd == "run":
+                if len(parts) < 3:
+                    print("Use: run <name> <pycode>")
+                    continue
+                scheduler.task(parts[1], parts[2])
+                print(f"  [+] {parts[1]}")
+
+            elif cmd == "stop":
+                scheduler.stop_task(parts[1])
+
+            elif cmd == "cont":
+                scheduler.cont_task(parts[1])
+
+            elif cmd == "restart":
+                scheduler.restart_task(parts[1])
+
+            elif cmd == "trigger":
+                scheduler.trigger_task(parts[1])
+
+            elif cmd == "remove":
+                scheduler.remove_task(parts[1])
+
+            elif cmd == "config":
+                if len(parts) < 3:
+                    print("Use: config <name> k=v ...")
+                    continue
+                kwargs = {}
+                for kv in parts[2].split():
+                    if "=" not in kv:
+                        continue
+                    k, v = kv.split("=", 1)
+                    # tip dönüşümü
+                    try:
+                        v = int(v)
+                    except ValueError:
+                        try:
+                            v = float(v)
+                        except ValueError:
+                            pass
+                    kwargs[k] = v
+                scheduler.config_task(parts[1], **kwargs)
+
+            elif cmd == "list":
+                for n, s in scheduler.list_tasks().items():
+                    print(f"  {n:<20} {s.name}")
+
+            elif cmd == "results":
+                for r in scheduler.get_results(parts[1]):
+                    _print_result(r)
+
+            elif cmd == "summary":
+                for k, v in scheduler.summary().items():
+                    print(f"  {k:<10} {v}")
+
+            else:
+                print(f"Unknown command: {cmd}")
+
+        except Exception as e:
+            print(f"  [!] {type(e).__name__}: {e}", file=sys.stderr)
+
+    print("\nClosing...")
+    await scheduler.shutdown(timeout=3.0)
+    return 0
+
+
+# ─────────────────────────────────────────────────────────────
+# PARSER
+# ─────────────────────────────────────────────────────────────
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="tasks",
+        description="Asynchronous task scheduler CLI",
+    )
+    p.add_argument("--log", default="INFO", help="Log level (DEBUG/INFO/WARNING)")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    # ── run ──
+    r = sub.add_parser("run", help="Run a single task")
+    r.add_argument("name", nargs="?", default="main", help="Task name")
+    r.add_argument("code", nargs="?", help="Inline Python code")
+    r.add_argument("--file", "-f", help="Python file for execution")
+    r.add_argument("--priority", "-p", default="normal",
+                   choices=list(PRIORITY_MAP.keys()))
+    r.add_argument("--delay", type=float, default=0.0)
+    r.add_argument("--timeout", type=float, default=None)
+    r.add_argument("--interval", type=float, default=None)
+    r.add_argument("--max-runs", type=int, default=None)
+    r.add_argument("--retries", type=int, default=0)
+    r.add_argument("--retry-delay", type=float, default=1.0)
+    r.add_argument("--retry-backoff", type=float, default=1.0)
+    r.add_argument("--verbose", "-v", action="store_true")
+    r.set_defaults(func=cmd_run)
+
+    # ── batch ──
+    b = sub.add_parser("batch", help="Run in batch from config file")
+    b.add_argument("config", help="JSON or YAML config path")
+    b.add_argument("--timeout", type=float, default=None,
+                   help="Timeout for all tasks")
+    b.set_defaults(func=cmd_batch)
+
+    # ── list ──
+    l = sub.add_parser("list", help="List the tasks")
+    l.add_argument("config")
+    l.set_defaults(func=cmd_list)
+
+    # ── shell ──
+    sh = sub.add_parser("shell", help="Task Shell")
+    sh.set_defaults(func=cmd_shell)
+
+    return p
+
+
+# ─────────────────────────────────────────────────────────────
+# MAIN
+# ─────────────────────────────────────────────────────────────
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    _setup_logging(args.log)
+
+    try:
+        if asyncio.iscoroutinefunction(args.func):
+            return asyncio.run(args.func(args))
+        return args.func(args)
+    except KeyboardInterrupt:
+        print("\nCanceled.", file=sys.stderr)
+        return 130
+    except Exception as e:
+        print(f"[!] {type(e).__name__}: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

py2autotask-2.0.1/py2autotask/task.py

@@ -0,0 +1,634 @@
+# task.py
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import logging
+import time
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import Any, Awaitable, Callable, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+# ─────────────────────────────────────────────────────────────
+# ENUM & VERİ SINIFLARI
+# ─────────────────────────────────────────────────────────────
+
+class TaskState(Enum):
+    PENDING   = auto()
+    RUNNING   = auto()
+    SUCCESS   = auto()
+    FAILED    = auto()
+    CANCELLED = auto()
+    RETRYING  = auto()
+    TIMEOUT   = auto()
+    STOPPED   = auto()   # stop_task ile durduruldu (devam ettirilebilir)
+    PAUSED    = auto()   # cont_task ile devam ettirilecek
+
+
+class TaskPriority(Enum):
+    LOW      = 3
+    NORMAL   = 2
+    HIGH     = 1
+    CRITICAL = 0
+
+
+@dataclass
+class TaskResult:
+    task_id: str
+    name: str
+    state: TaskState
+    result: Any = None
+    error: Optional[Exception] = None
+    started_at: float = 0.0
+    finished_at: float = 0.0
+    attempts: int = 0
+    run_index: int = 0       # periyodik için kaçıncı çalışma
+
+    @property
+    def duration(self) -> float:
+        return self.finished_at - self.started_at if self.finished_at else 0.0
+
+    @property
+    def success(self) -> bool:
+        return self.state == TaskState.SUCCESS
+
+
+# ─────────────────────────────────────────────────────────────
+# TASK TANIMI
+# ─────────────────────────────────────────────────────────────
+
+@dataclass
+class TaskDef:
+    """Bir görevin tüm tanımını ve runtime durumunu tutar."""
+    name: str
+    code: str                                # derlenmiş kaynak kod (string)
+    func: Callable[..., Awaitable[Any]]      # derlenmiş fonksiyon
+
+    # Zamanlama
+    priority: TaskPriority = TaskPriority.NORMAL
+    delay: float = 0.0
+    timeout: Optional[float] = None
+    interval: Optional[float] = None
+    max_runs: Optional[int] = None
+    retries: int = 0
+    retry_delay: float = 1.0
+    retry_backoff: float = 1.0
+
+    # Kontrol
+    auto_start: bool = True
+    enabled: bool = True                     # stop_task / cont_task için ana bayrak
+    depends_on: List[str] = field(default_factory=list)
+
+    # Callback
+    on_success: Optional[Callable] = None
+    on_failure: Optional[Callable] = None
+    on_complete: Optional[Callable] = None
+    on_retry: Optional[Callable] = None
+
+    # Meta
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    tags: List[str] = field(default_factory=list)
+
+    # Runtime
+    id: str = field(default_factory=lambda: uuid.uuid4().hex[:12])
+    state: TaskState = TaskState.PENDING
+    run_count: int = 0
+    last_result: Optional[TaskResult] = None
+
+    _asyncio_task: Optional[asyncio.Task] = None
+    _stop_event: asyncio.Event = field(default_factory=asyncio.Event)
+    _wake_event: asyncio.Event = field(default_factory=asyncio.Event)  # periyodik bekleme için
+    _started_at: float = 0.0
+
+
+# ─────────────────────────────────────────────────────────────
+# SCHEDULER
+# ─────────────────────────────────────────────────────────────
+
+class TaskScheduler:
+    """
+    Kod string'i ile dinamik task oluşturma + isimle yönetim.
+    """
+
+    def __init__(
+        self,
+        max_concurrent: int = 10,
+        auto_start: bool = True,
+        default_timeout: Optional[float] = None,
+        namespace: Optional[Dict[str, Any]] = None,
+    ):
+        self.max_concurrent = max_concurrent
+        self.auto_start = auto_start
+        self.default_timeout = default_timeout
+        self.namespace = namespace or {}      # kod içinden erişilebilen global isim alanı
+
+        self._sem = asyncio.Semaphore(max_concurrent)
+        self._tasks: Dict[str, TaskDef] = {}          # name -> TaskDef
+        self._aliases: Dict[str, str] = {}            # alias/id -> name
+        self._results: Dict[str, List[TaskResult]] = {}
+        self._listeners: Dict[str, List[Callable]] = {}
+        self._shutdown = False
+
+    # ─────────────────────────────────────────────────────────
+    #  KOD DERLEME
+    # ─────────────────────────────────────────────────────────
+
+    def _compile(self, task_name: str, code: str) -> Callable:
+        """
+        String halindeki Python kodunu derleyip callable'a çevirir.
+        Kod şu iki formdan biri olabilir:
+            1) 'async def foo(...): ...'  → fonksiyon adı task_name olarak aranır
+            2) direkt ifade / fonksiyon bloğu (son tanımlı 'async def' kullanılır)
+        """
+        env: Dict[str, Any] = {
+            **self.namespace,
+            "asyncio": asyncio,
+            "logging": logging,
+            "logger": logger,
+            "__builtins__": __builtins__,
+        }
+
+        try:
+            compiled = compile(code, f"<task:{task_name}>", "exec")
+            exec(compiled, env)
+        except SyntaxError as e:
+            raise ValueError(f"[{task_name}] Code compilation error: {e}") from e
+
+        # Fonksiyonu bul: task_name > ilk async callable
+        func = env.get(task_name)
+        if not (callable(func) and inspect.iscoroutinefunction(func)):
+            func = next(
+                (v for v in env.values()
+                 if callable(v) and inspect.iscoroutinefunction(v)),
+                None,
+            )
+
+        if func is None:
+            raise ValueError(
+                f"[{task_name}] Code does not contain an 'async def' function."
+            )
+        return func
+
+    # ─────────────────────────────────────────────────────────
+    #  TASK() — YENİ GÖREV OLUŞTUR
+    # ─────────────────────────────────────────────────────────
+
+    def task(
+        self,
+        task_name: str,
+        pycode: str,
+        priority: TaskPriority = TaskPriority.NORMAL,
+        delay: float = 0.0,
+        timeout: Optional[float] = None,
+        interval: Optional[float] = None,
+        max_runs: Optional[int] = None,
+        retries: int = 0,
+        retry_delay: float = 1.0,
+        retry_backoff: float = 1.0,
+        auto_start: bool = True,
+        depends_on: Optional[List[str]] = None,
+        on_success: Optional[Callable] = None,
+        on_failure: Optional[Callable] = None,
+        on_complete: Optional[Callable] = None,
+        on_retry: Optional[Callable] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        tags: Optional[List[str]] = None,
+        overwrite: bool = False,
+        **extra_context,               # kod içine enjekte edilecek ek değişkenler
+    ) -> TaskDef:
+        """
+        Yeni bir task oluşturur ve (auto_start ise) hemen çalıştırır.
+
+        Örnek:
+            sched.task(
+                "fetch_users",
+                '''
+                async def fetch_users(api):
+                    await asyncio.sleep(1)
+                    return [{"id": i} for i in range(3)]
+                ''',
+                priority=TaskPriority.HIGH,
+                timeout=5, retries=2,
+            )
+        """
+        if task_name in self._tasks and not overwrite:
+            raise ValueError(f"Task '{task_name}' already exists. Use overwrite=True.")
+
+        # Kodu derle
+        if extra_context:
+            self.namespace.update(extra_context)
+        func = self._compile(task_name, pycode)
+
+        td = TaskDef(
+            name=task_name,
+            code=pycode,
+            func=func,
+            priority=priority,
+            delay=delay,
+            timeout=timeout if timeout is not None else self.default_timeout,
+            interval=interval,
+            max_runs=max_runs,
+            retries=retries,
+            retry_delay=retry_delay,
+            retry_backoff=retry_backoff,
+            auto_start=auto_start,
+            depends_on=depends_on or [],
+            on_success=on_success,
+            on_failure=on_failure,
+            on_complete=on_complete,
+            on_retry=on_retry,
+            metadata=metadata or {},
+            tags=tags or [],
+        )
+        self._tasks[task_name] = td
+        self._results[task_name] = []
+
+        logger.info(f"[+] Task created: {task_name} ({td.id})")
+
+        if self.auto_start and auto_start:
+            self._spawn(td)
+
+        return td
+
+    # ─────────────────────────────────────────────────────────
+    #  CONFIG_TASK() — RUNTIME KONFİGÜRASYON
+    # ─────────────────────────────────────────────────────────
+
+    def config_task(
+        self,
+        task_name: str,
+        *,
+        pycode: Optional[str] = None,
+        priority: Optional[TaskPriority] = None,
+        delay: Optional[float] = None,
+        timeout: Optional[float] = None,
+        interval: Optional[float] = None,
+        max_runs: Optional[int] = None,
+        retries: Optional[int] = None,
+        retry_delay: Optional[float] = None,
+        retry_backoff: Optional[float] = None,
+        enabled: Optional[bool] = None,
+        on_success: Optional[Callable] = None,
+        on_failure: Optional[Callable] = None,
+        on_complete: Optional[Callable] = None,
+        on_retry: Optional[Callable] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        tags: Optional[List[str]] = None,
+        restart: bool = False,
+    ) -> TaskDef:
+        """
+        Mevcut bir task'ı runtime'da yeniden yapılandırır.
+        Sadece verilen alanlar güncellenir.
+        restart=True ise task yeniden başlatılır (kod değişikliği için gerekli).
+        """
+        td = self._require(task_name)
+
+        if pycode is not None:
+            td.code = pycode
+            td.func = self._compile(task_name, pycode)
+            restart = True
+
+        if priority        is not None: td.priority       = priority
+        if delay           is not None: td.delay          = delay
+        if timeout         is not None: td.timeout        = timeout
+        if interval        is not None: td.interval       = interval
+        if max_runs        is not None: td.max_runs       = max_runs
+        if retries         is not None: td.retries        = retries
+        if retry_delay     is not None: td.retry_delay    = retry_delay
+        if retry_backoff   is not None: td.retry_backoff  = retry_backoff
+        if enabled         is not None: td.enabled        = enabled
+        if on_success      is not None: td.on_success     = on_success
+        if on_failure      is not None: td.on_failure     = on_failure
+        if on_complete     is not None: td.on_complete    = on_complete
+        if on_retry        is not None: td.on_retry       = on_retry
+        if metadata        is not None: td.metadata.update(metadata)
+        if tags            is not None: td.tags           = tags
+
+        logger.info(f"[~] Task configured: {task_name}")
+
+        if restart:
+            self._restart(td)
+
+        return td
+
+    # ─────────────────────────────────────────────────────────
+    #  STOP_TASK() — periyodik döngüyü durdur (ama task silinmez)
+    # ─────────────────────────────────────────────────────────
+
+    def stop_task(self, task_name: str, *, wait_current: bool = False) -> bool:
+        """
+        Task'ı durdurur.
+        - Periyodik task ise: bir sonraki döngüye geçmez.
+        - Çalışan task ise: wait_current=False ise iptal eder, True ise mevcut
+          çalışmanın bitmesini bekler.
+        - Task hâlâ kayıtlı kalır → cont_task ile devam ettirilebilir.
+        """
+        td = self._require(task_name)
+
+        td.enabled = False
+        td._stop_event.set()
+        td._wake_event.set()   # periyodik beklemeyi uyandır
+
+        at = td._asyncio_task
+        if at and not at.done():
+            if wait_current:
+                td.state = TaskState.STOPPED
+            else:
+                at.cancel()
+                td.state = TaskState.STOPPED
+        else:
+            td.state = TaskState.STOPPED
+
+        logger.info(f"[■] Task stopped: {task_name}")
+        return True
+
+    # ─────────────────────────────────────────────────────────
+    #  CONT_TASK() — durdurulan task'ı devam ettir
+    # ─────────────────────────────────────────────────────────
+
+    def cont_task(self, task_name: str) -> bool:
+        """
+        Durdurulmuş task'ı yeniden başlatır (kaldığı yerden değil, baştan).
+        Tek seferlik task için de çalışır.
+        """
+        td = self._require(task_name)
+
+        td.enabled = True
+        td._stop_event = asyncio.Event()
+        td._wake_event = asyncio.Event()
+        td.state = TaskState.PENDING
+
+        self._spawn(td)
+        logger.info(f"[▶] Task continued: {task_name}")
+        return True
+
+    # ─────────────────────────────────────────────────────────
+    #  RESTART / REMOVE / TRIGGER
+    # ─────────────────────────────────────────────────────────
+
+    def _restart(self, td: TaskDef):
+        self.stop_task(td.name)
+        td._stop_event = asyncio.Event()
+        td._wake_event = asyncio.Event()
+        td.run_count = 0
+        td.enabled = True
+        td.state = TaskState.PENDING
+        self._spawn(td)
+
+    def restart_task(self, task_name: str) -> bool:
+        """Task'ı sıfırdan yeniden başlatır."""
+        td = self._require(task_name)
+        self._restart(td)
+        logger.info(f"[↻] Task restarted: {task_name}")
+        return True
+
+    def remove_task(self, task_name: str, *, cancel_running: bool = True) -> bool:
+        """Task'ı tamamen siler."""
+        td = self._tasks.get(task_name)
+        if td is None:
+            return False
+        if cancel_running:
+            self.stop_task(task_name, wait_current=False)
+        self._tasks.pop(task_name, None)
+        self._results.pop(task_name, None)
+        logger.info(f"[-] Task removed: {task_name}")
+        return True
+
+    def trigger_task(self, task_name: str, *args, **kwargs) -> asyncio.Task:
+        """
+        Periyodik task'ı beklemeden hemen bir kez çalıştırır
+        (ana döngüyü etkilemez).
+        """
+        td = self._require(task_name)
+
+        async def _once():
+            return await self._execute_once(td, override_args=args, override_kwargs=kwargs)
+
+        return asyncio.get_event_loop().create_task(_once())
+
+    # ─────────────────────────────────────────────────────────
+    #  DURUM / LİSTE
+    # ─────────────────────────────────────────────────────────
+
+    def get_task(self, task_name: str) -> Optional[TaskDef]:
+        return self._tasks.get(task_name)
+
+    def list_tasks(self) -> Dict[str, TaskState]:
+        return {n: t.state for n, t in self._tasks.items()}
+
+    def get_results(self, task_name: str) -> List[TaskResult]:
+        return list(self._results.get(task_name, []))
+
+    def summary(self) -> Dict[str, int]:
+        s: Dict[str, int] = {}
+        for t in self._tasks.values():
+            s[t.state.name] = s.get(t.state.name, 0) + 1
+        return s
+
+    # ─────────────────────────────────────────────────────────
+    #  EVENT
+    # ─────────────────────────────────────────────────────────
+
+    def on(self, event: str, cb: Callable):
+        self._listeners.setdefault(event, []).append(cb)
+
+    async def _emit(self, event: str, payload: Any):
+        for cb in self._listeners.get(event, []):
+            try:
+                r = cb(payload)
+                if inspect.isawaitable(r):
+                    await r
+            except Exception:
+                logger.exception(f"Listener error: {event}")
+
+    # ─────────────────────────────────────────────────────────
+    #  DAHİLİ ÇALIŞTIRMA
+    # ─────────────────────────────────────────────────────────
+
+    def _spawn(self, td: TaskDef):
+        loop = asyncio.get_event_loop()
+        td._asyncio_task = loop.create_task(self._runner(td))
+
+    async def _runner(self, td: TaskDef):
+        """Periyodik veya tek seferlik akışı yönetir."""
+        if td.delay > 0:
+            try:
+                await asyncio.wait_for(td._wake_event.wait(), timeout=td.delay)
+                return   # stop edildi
+            except asyncio.TimeoutError:
+                pass
+
+        if td.interval is None:
+            # Tek seferlik
+            await self._execute_once(td)
+            return
+
+        # Periyodik
+        while td.enabled and not td._stop_event.is_set():
+            if td.max_runs is not None and td.run_count >= td.max_runs:
+                logger.info(f"[✓] max_runs completed: {td.name}")
+                break
+
+            await self._execute_once(td)
+            td.run_count += 1
+
+            if not td.enabled or td._stop_event.is_set():
+                break
+
+            # interval kadar bekle (stop/cont ile erken uyandırılabilir)
+            td._wake_event.clear()
+            try:
+                await asyncio.wait_for(td._wake_event.wait(), timeout=td.interval)
+                break   # uyandırıldı → stop
+            except asyncio.TimeoutError:
+                continue
+
+    async def _execute_once(
+        self, td: TaskDef,
+        override_args: tuple = (),
+        override_kwargs: Optional[Dict[str, Any]] = None,
+    ) -> TaskResult:
+        """Retry + timeout dahil tek çalıştırma."""
+        async with self._sem:
+            attempt = 0
+            last_err: Optional[Exception] = None
+            override_kwargs = override_kwargs or {}
+
+            while attempt <= td.retries:
+                attempt += 1
+                td.state = TaskState.RUNNING
+                started = time.time()
+                td._started_at = started
+                await self._emit("task_started", td)
+
+                try:
+                    coro = td.func(*override_args, **override_kwargs)
+                    if td.timeout:
+                        res = await asyncio.wait_for(coro, timeout=td.timeout)
+                    else:
+                        res = await coro
+
+                    tr = TaskResult(
+                        task_id=td.id, name=td.name, state=TaskState.SUCCESS,
+                        result=res, started_at=started, finished_at=time.time(),
+                        attempts=attempt, run_index=td.run_count,
+                    )
+                    td.state = TaskState.SUCCESS
+                    td.last_result = tr
+                    self._results[td.name].append(tr)
+
+                    await self._emit("task_success", tr)
+                    await self._safe(td.on_success, tr)
+                    await self._safe(td.on_complete, tr)
+                    return tr
+
+                except asyncio.CancelledError:
+                    td.state = TaskState.STOPPED
+                    raise
+
+                except asyncio.TimeoutError as e:
+                    last_err = e
+                    logger.warning(f"[!] Timeout: {td.name} (try {attempt})")
+
+                except Exception as e:
+                    last_err = e
+                    logger.exception(f"[!] Error: {td.name} (try {attempt})")
+
+                if attempt <= td.retries:
+                    td.state = TaskState.RETRYING
+                    tr = TaskResult(
+                        task_id=td.id, name=td.name, state=TaskState.RETRYING,
+                        error=last_err, started_at=started, finished_at=time.time(),
+                        attempts=attempt, run_index=td.run_count,
+                    )
+                    await self._emit("task_retry", tr)
+                    await self._safe(td.on_retry, tr, attempt)
+                    wait = td.retry_delay * (td.retry_backoff ** (attempt - 1))
+                    await asyncio.sleep(wait)
+
+            # Başarısız
+            state = (TaskState.TIMEOUT
+                     if isinstance(last_err, asyncio.TimeoutError)
+                     else TaskState.FAILED)
+            tr = TaskResult(
+                task_id=td.id, name=td.name, state=state,
+                error=last_err, started_at=td._started_at,
+                finished_at=time.time(), attempts=attempt,
+                run_index=td.run_count,
+            )
+            td.state = state
+            td.last_result = tr
+            self._results[td.name].append(tr)
+
+            await self._emit("task_failed", tr)
+            await self._safe(td.on_failure, tr)
+            await self._safe(td.on_complete, tr)
+            return tr
+
+    async def _safe(self, fn, *args):
+        if fn is None:
+            return
+        try:
+            r = fn(*args)
+            if inspect.isawaitable(r):
+                await r
+        except Exception:
+            logger.exception("Callback error")
+
+    def _require(self, task_name: str) -> TaskDef:
+        td = self._tasks.get(task_name)
+        if td is None:
+            raise KeyError(f"Task not found: {task_name}")
+        return td
+
+    # ─────────────────────────────────────────────────────────
+    #  TOPLU KAPATMA
+    # ─────────────────────────────────────────────────────────
+
+    async def shutdown(self, timeout: float = 5.0):
+        self._shutdown = True
+        for name in list(self._tasks):
+            self.stop_task(name, wait_current=False)
+        pending = [
+            t._asyncio_task for t in self._tasks.values()
+            if t._asyncio_task and not t._asyncio_task.done()
+        ]
+        if pending:
+            await asyncio.wait(pending, timeout=timeout)
+
+
+# ─────────────────────────────────────────────────────────────
+# GLOBAL VARSAYILAN SCHEDULER
+# ─────────────────────────────────────────────────────────────
+
+_default = TaskScheduler()
+
+
+def task(task_name: str, pycode: str, **kwargs) -> TaskDef:
+    return _default.task(task_name, pycode, **kwargs)
+
+def config_task(task_name: str, **kwargs) -> TaskDef:
+    return _default.config_task(task_name, **kwargs)
+
+def stop_task(task_name: str, **kwargs) -> bool:
+    return _default.stop_task(task_name, **kwargs)
+
+def cont_task(task_name: str) -> bool:
+    return _default.cont_task(task_name)
+
+def restart_task(task_name: str) -> bool:
+    return _default.restart_task(task_name)
+
+def remove_task(task_name: str, **kwargs) -> bool:
+    return _default.remove_task(task_name, **kwargs)
+
+def trigger_task(task_name: str, *a, **kw) -> asyncio.Task:
+    return _default.trigger_task(task_name, *a, **kw)
+
+def get_scheduler() -> TaskScheduler:
+    return _default

py2autotask-2.0.1/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "py2autotask"
+version = "2.0.1"
+description = "Dynamic asynchronous task library"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [
+    { name = "7yokki, brt222" }
+]
+dependencies = [
+]
+
+[project.scripts]
+pyautotask = "pyautotask.cli:main"