dl2-tasks 0.1.0__tar.gz

dl2_tasks-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Datalys2 Tasks Contributors
+
+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.

dl2_tasks-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: dl2-tasks
+Version: 0.1.0
+Summary: A lightweight local task orchestration system built on windows task scheduler
+Author-email: Datalys2 Team <kameron@example.com>
+License: MIT License
+        
+        Copyright (c) 2026 Datalys2 Tasks Contributors
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/yourusername/datalys2-tasks
+Project-URL: Documentation, https://github.com/yourusername/datalys2-tasks/blob/main/DOCUMENTATION.md
+Project-URL: Repository, https://github.com/yourusername/datalys2-tasks.git
+Keywords: windows,task scheduler,automation,scheduling,cron
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.20.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: sqlalchemy>=2.0.0
+Dynamic: license-file
+
+# Datalys2 Tasks
+
+**A lightweight, local task orchestration system built for Windows.**
+
+`dl2-tasks` (Datalys2 Tasks) is a robust wrapper around the native **Windows Task Scheduler**. It provides a modern Python interface for scheduling, managing, and monitoring background tasks without the need for a heavy, always-on server process.
+
+## 🌟 Features
+
+- **No Background Process Required:** Leverages Windows' built-in `schtasks.exe`.
+- **Self-Scheduling Scripts:** Add `schedule_me()` to your script, run it once, and it's scheduled forever.
+- **Lightweight:** Minimal dependencies.
+- **Robust:** If Python crashes, the scheduler remains.
+
+## 📦 Installation
+
+```bash
+pip install dl2-tasks
+```
+
+## 🚀 Quick Start
+
+### Auto-Scheduling (The "Magic" Way)
+
+The easiest way to use Datalys2 Tasks is to let your scripts schedule themselves.
+
+1.  Create `my_task.py`:
+
+    ```python
+    import datetime
+    from datalys2_tasks.scheduler.autorun import schedule_me
+    
+    def job():
+        with open("log.txt", "a") as f:
+            f.write(f"Ran at {datetime.datetime.now()}\n")
+    
+    if __name__ == "__main__":
+        # Registers this script to run everyday at 08:00
+        schedule_me("MyDailyLog", frequency="DAILY", at="08:00")
+        
+        job()
+    ```
+
+2.  Run it once manually:
+    ```bash
+    python my_task.py
+    ```
+
+3.  That's it! Windows will now run this script every day at 08:00.
+
+### CLI Management
+
+You can also manage tasks via the command line.
+
+- **List tasks:** `datalys2-server schedule list`
+- **Add a task:** `datalys2-server schedule add "Backup" "C:\scripts\backup.py" --schedule DAILY --time 02:00`
+- **Run manually:** `datalys2-server schedule run "Backup"`
+
+## 🖥️ Optional Dashboard
+
+Includes a local dashboard for viewing task status.
+
+```bash
+datalys2-server start
+```
+*Opens http://localhost:8000/dashboard*
+
+---
+
+For full details, see the documentation.

dl2_tasks-0.1.0/README.md

@@ -0,0 +1,69 @@
+# Datalys2 Tasks
+
+**A lightweight, local task orchestration system built for Windows.**
+
+`dl2-tasks` (Datalys2 Tasks) is a robust wrapper around the native **Windows Task Scheduler**. It provides a modern Python interface for scheduling, managing, and monitoring background tasks without the need for a heavy, always-on server process.
+
+## 🌟 Features
+
+- **No Background Process Required:** Leverages Windows' built-in `schtasks.exe`.
+- **Self-Scheduling Scripts:** Add `schedule_me()` to your script, run it once, and it's scheduled forever.
+- **Lightweight:** Minimal dependencies.
+- **Robust:** If Python crashes, the scheduler remains.
+
+## 📦 Installation
+
+```bash
+pip install dl2-tasks
+```
+
+## 🚀 Quick Start
+
+### Auto-Scheduling (The "Magic" Way)
+
+The easiest way to use Datalys2 Tasks is to let your scripts schedule themselves.
+
+1.  Create `my_task.py`:
+
+    ```python
+    import datetime
+    from datalys2_tasks.scheduler.autorun import schedule_me
+    
+    def job():
+        with open("log.txt", "a") as f:
+            f.write(f"Ran at {datetime.datetime.now()}\n")
+    
+    if __name__ == "__main__":
+        # Registers this script to run everyday at 08:00
+        schedule_me("MyDailyLog", frequency="DAILY", at="08:00")
+        
+        job()
+    ```
+
+2.  Run it once manually:
+    ```bash
+    python my_task.py
+    ```
+
+3.  That's it! Windows will now run this script every day at 08:00.
+
+### CLI Management
+
+You can also manage tasks via the command line.
+
+- **List tasks:** `datalys2-server schedule list`
+- **Add a task:** `datalys2-server schedule add "Backup" "C:\scripts\backup.py" --schedule DAILY --time 02:00`
+- **Run manually:** `datalys2-server schedule run "Backup"`
+
+## 🖥️ Optional Dashboard
+
+Includes a local dashboard for viewing task status.
+
+```bash
+datalys2-server start
+```
+*Opens http://localhost:8000/dashboard*
+
+---
+
+For full details, see the documentation.

dl2_tasks-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dl2-tasks"
+version = "0.1.0"
+description = "A lightweight local task orchestration system built on windows task scheduler"
+readme = "README.md"
+authors = [
+    {name = "Datalys2 Team", email = "kameron@example.com"}
+]
+license = {file = "LICENSE"}
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: System :: Systems Administration",
+]
+keywords = ["windows", "task scheduler", "automation", "scheduling", "cron"]
+requires-python = ">=3.8"
+dependencies = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.20.0",
+    "pydantic>=2.0.0",
+    "requests>=2.28.0",
+    "sqlalchemy>=2.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/datalys2-tasks"
+Documentation = "https://github.com/yourusername/datalys2-tasks/blob/main/DOCUMENTATION.md"
+Repository = "https://github.com/yourusername/datalys2-tasks.git"
+
+
+[project.scripts]
+datalys2-server = "datalys2_tasks.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

dl2_tasks-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dl2_tasks-0.1.0/src/datalys2_tasks/cli.py

@@ -0,0 +1,107 @@
+import argparse
+import sys
+from pathlib import Path
+from .server.app import start_server
+from .server.startup import install_service, remove_service
+from .scheduler.windows import WindowsTaskScheduler
+
+def main():
+    parser = argparse.ArgumentParser(description="Datalys2 Tasks Server & Scheduler CLI")
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # --- Server Commands ---
+    # Start Server
+    subparsers.add_parser("start", help="Start the Task Server immediately")
+
+    # Install Service
+    subparsers.add_parser("install", help="Register server as a Windows startup task")
+
+    # Remove Service
+    subparsers.add_parser("remove", help="Remove the Windows startup task")
+
+    # --- Scheduler Commands ---
+    sched_parser = subparsers.add_parser("schedule", help="Manage Windows Scheduled Tasks direct execution mode")
+    sched_subs = sched_parser.add_subparsers(dest="sched_command", help="Scheduler actions")
+
+    # Schedule: Create/Add
+    add_p = sched_subs.add_parser("add", help="Create a new scheduled task")
+    add_p.add_argument("name", help="Unique name for the task")
+    add_p.add_argument("script", help="Path to the Python script to execute")
+    add_p.add_argument("--schedule", default="DAILY", choices=["DAILY", "HOURLY", "MINUTE", "ONCE", "ONLOGON"], help="Schedule type")
+    add_p.add_argument("--time", help="Start time (HH:mm)")
+    add_p.add_argument("--interval", type=int, help="Interval (minutes) if schedule is MINUTE or modifier for others")
+    add_p.add_argument("--force", action="store_true", help="Overwrite existing task")
+    add_p.add_argument("--args", nargs="*", help="Arguments to pass to the script")
+
+    # Schedule: List
+    list_p = sched_subs.add_parser("list", help="List scheduled tasks")
+    list_p.add_argument("--pattern", default="*", help="Filter tasks by name (substring)")
+
+    # Schedule: Delete
+    del_p = sched_subs.add_parser("remove", help="Delete a scheduled task")
+    del_p.add_argument("name", help="Name of the task to delete")
+
+    # Schedule: Run (Manual)
+    run_p = sched_subs.add_parser("run", help="Manually run a scheduled task now")
+    run_p.add_argument("name", help="Name of the task to run")
+
+
+    args = parser.parse_args()
+
+    if args.command == "start":
+        print("Starting Datalys2 Server...")
+        start_server()
+    elif args.command == "install":
+        install_service()
+    elif args.command == "remove":
+        remove_service()
+    elif args.command == "schedule":
+        scheduler = WindowsTaskScheduler()
+        
+        if args.sched_command == "add":
+            success = scheduler.create_task(
+                task_name=args.name,
+                script_path=args.script,
+                schedule=args.schedule,
+                start_time=args.time,
+                interval_minutes=args.interval,
+                args=args.args,
+                force=args.force
+            )
+            if success:
+                print(f"Task '{args.name}' scheduled successfully.")
+            else:
+                sys.exit(1)
+
+        elif args.sched_command == "list":
+            tasks = scheduler.list_tasks(pattern=args.pattern)
+            if not tasks:
+                print("No matching tasks found.")
+            else:
+                print(f"{'Task Name':<40} {'Next Run Time':<25} {'Status':<15}")
+                print("-" * 80)
+                for t in tasks:
+                    name = t.get('TaskName', 'N/A').replace('\\', '') # Cleanup backslashes often returned by schtasks
+                    next_run = t.get('Next Run Time', 'N/A')
+                    status = t.get('Status', 'N/A')
+                    print(f"{name:<40} {next_run:<25} {status:<15}")
+
+        elif args.sched_command == "remove":
+            if scheduler.delete_task(args.name):
+                print(f"Task '{args.name}' deleted.")
+            else:
+                sys.exit(1)
+
+        elif args.sched_command == "run":
+            if scheduler.run_task(args.name):
+                print(f"Task '{args.name}' triggered.")
+            else:
+                sys.exit(1)
+        else:
+            sched_parser.print_help()
+
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

dl2_tasks-0.1.0/src/datalys2_tasks/client/__init__.py

@@ -0,0 +1 @@
+# Client decorators

dl2_tasks-0.1.0/src/datalys2_tasks/client/decorator.py

@@ -0,0 +1,116 @@
+import functools
+import inspect
+import os
+import sys
+from typing import Optional, List, Union, Callable
+from ..core.config import settings
+from ..scheduler.windows import WindowsTaskScheduler
+from ..server.database import SessionLocal, ScheduledTaskDB, init_db
+
+class TaskWrapper:
+    def __init__(self, func, task_name: Optional[str] = None):
+        self.func = func
+        self.default_task_name = task_name or func.__name__
+        functools.update_wrapper(self, func)
+        
+        # Determine the absolute path of the module defining the function
+        module = inspect.getmodule(func)
+        
+        # Safely get __file__, defaulting to None if it doesn't exist
+        module_file = getattr(module, '__file__', None) if module else None
+        
+        if module_file:
+            self.module_path = os.path.abspath(module_file)
+        else:
+            # Fallback (might fail in interactive shells)
+            self.module_path = os.path.abspath(sys.argv[0])
+
+    def __call__(self, *args, **kwargs):
+        """Allow normal local execution."""
+        return self.func(*args, **kwargs)
+
+    def schedule_run(
+        self, 
+        task_name: Optional[str] = None, 
+        schedule: str = "DAILY", 
+        start_time: Optional[str] = None, 
+        interval: Optional[int] = None,
+        force: bool = False,
+        cli_args: Optional[List[str]] = None
+    ) -> bool:
+        """
+        Register this function's script as a Windows Scheduled Task.
+        
+        Args:
+            task_name (str, optional): Unique identifier for the Windows Task Scheduler. 
+                                       Defaults to the name provided in @task decorator or function name.
+            schedule (str): Frequency ('DAILY', 'HOURLY', 'minute', 'ONCE', 'ONLOGON').
+            start_time (str): Time to start (HH:mm).
+            interval (int): Interval in minutes (if applicable).
+            force (bool): Overwrite existing task.
+            cli_args (List[str]): Command line arguments to pass to the script execution.
+
+        Returns:
+            bool: Success status.
+        """
+        final_task_name = task_name or self.default_task_name
+        
+        scheduler = WindowsTaskScheduler()
+        print(f"Scheduling script: {self.module_path} as '{final_task_name}'")
+        success = scheduler.create_task(
+            task_name=final_task_name,
+            script_path=self.module_path,
+            schedule=schedule,
+            start_time=start_time,
+            interval_minutes=interval,
+            args=cli_args,
+            force=force
+        )
+
+        if success:
+            # Save to SQLite DB in %APPDATA%
+            try:
+                # Ensure DB tables exist (idempotent)
+                init_db()
+                
+                db = SessionLocal()
+                # Check if exists to update or create
+                existing = db.query(ScheduledTaskDB).filter(ScheduledTaskDB.task_name == final_task_name).first()
+                if existing:
+                    existing.script_path = self.module_path
+                    existing.schedule_type = schedule
+                    existing.schedule_time = start_time
+                    existing.interval_minutes = interval
+                    existing.description = f"Scheduled via decorator from {self.func.__name__}"
+                else:
+                    new_task = ScheduledTaskDB(
+                        task_name=final_task_name,
+                        script_path=self.module_path,
+                        schedule_type=schedule,
+                        schedule_time=start_time,
+                        interval_minutes=interval,
+                        description=f"Scheduled via decorator from {self.func.__name__}"
+                    )
+                    db.add(new_task)
+                
+                db.commit()
+                db.close()
+                print("Task registration saved to local database.")
+            except Exception as e:
+                print(f"Warning: Failed to save task to local database: {e}")
+
+        return success
+
+def task(func: Union[Callable, None] = None, *, name: Optional[str] = None):
+    """
+    Decorator to wrap a function as a Datalys2 task.
+    Usage:
+        @task
+        def my_func(): ...
+        
+        @task(name="MyCustomTask")
+        def my_func(): ...
+    """
+    if func is None:
+        return functools.partial(task, name=name)
+    return TaskWrapper(func, task_name=name)

dl2_tasks-0.1.0/src/datalys2_tasks/core/__init__.py

@@ -0,0 +1 @@
+# Core shared modules

dl2_tasks-0.1.0/src/datalys2_tasks/core/config.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel
+import os
+import json
+
+class Settings(BaseModel):
+    server_host: str = "127.0.0.1"
+    server_port: int = 8000
+    database_url: str = "" # Set in __init__ or defaulting
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if not self.database_url:
+            app_data = os.getenv('APPDATA') or os.path.expanduser('~')
+            app_dir = os.path.join(app_data, 'datalys2-tasks')
+            os.makedirs(app_dir, exist_ok=True)
+            db_path = os.path.join(app_dir, 'datalys2.db')
+            self.database_url = f"sqlite:///{db_path}"
+
+    @classmethod
+    def load(cls, config_path: str = "datalys_config.json") -> "Settings":
+        if os.path.exists(config_path):
+            with open(config_path, "r") as f:
+                data = json.load(f)
+                return cls(**data)
+        return cls()
+
+settings = Settings.load()

dl2_tasks-0.1.0/src/datalys2_tasks/core/models.py

@@ -0,0 +1,7 @@
+from enum import Enum
+from typing import List, Optional, Any, Dict
+from pydantic import BaseModel
+from datetime import datetime
+
+# Future models can be added here
+

dl2_tasks-0.1.0/src/datalys2_tasks/scheduler/__init__.py

@@ -0,0 +1 @@
+from .windows import WindowsTaskScheduler

dl2_tasks-0.1.0/src/datalys2_tasks/scheduler/autorun.py

@@ -0,0 +1,139 @@
+import sys
+import os
+import logging
+from typing import Optional, List
+from .windows import WindowsTaskScheduler
+
+# Use a logger instead of print where appropriate, but fallback to print for visibility in CLI usage
+logger = logging.getLogger("datalys2.autorun")
+
+def schedule_me(
+    name: str,
+    frequency: str = "DAILY",
+    at: Optional[str] = None,
+    interval: Optional[int] = None,
+    args: Optional[List[str]] = None,
+    overwrite: bool = False
+) -> bool:
+    """
+    Automatically schedules the current script as a Windows Task.
+    
+    This function is designed to be the "one-line" setup for your periodic tasks.
+    It checks if the task is already scheduled (by name). If not, it creates it.
+    If it is, it does nothing (unless `overwrite=True`).
+
+    It is best placed at the very top of your main execution block.
+
+    Example:
+        >>> if __name__ == "__main__":
+        ...     from datalys2_tasks.scheduler import autorun
+        ...     # Run this script every day at 08:30 AM
+        ...     autorun.schedule_me("daily-report-job", at="08:30")
+        ...     # ... Rest of your script logic
+
+    Args:
+        name (str): 
+            A unique name for this task. It will be stored in the Windows Task Scheduler
+            under the '\\datalys2\\' folder. 
+            Example: "sales-report-generator"
+
+        frequency (str, optional): 
+            How often the task should run. 
+            Options:
+            - "DAILY": Runs once every day (default).
+            - "ONCE": Runs a single time (useful for deferred tasks).
+            - "ONLOGON": Runs when the user logs in.
+            - "MINUTE": Runs every `interval` minutes.
+            - "HOURLY": Runs every hour.
+            Defaults to "DAILY".
+
+        at (str, optional): 
+            The start time for the schedule in "HH:MM" 24-hour format.
+            Required for "DAILY" and "ONCE" if you want a specific time.
+            If None, defaults to current time.
+            Example: "14:00" for 2:00 PM.
+
+        interval (int, optional): 
+            Used when frequency is "MINUTE". Specifies the number of minutes between runs.
+            Example: 15 (run every 15 minutes).
+
+        args (List[str], optional): 
+            A list of command-line arguments to pass to the script when the scheduler runs it.
+            Example: ["--mode", "production", "--verbose"]
+
+        overwrite (bool, optional): 
+            If True, forces the task to be updated in the Windows Task Scheduler even if it
+            already exists. Use this if you've changed the schedule or arguments. 
+            Defaults to False (safe mode).
+
+    Returns:
+        bool: True if the task is successfully scheduled (or was already there). 
+              False if something went wrong during scheduling.
+    """
+    
+    # 1. Normalize inputs
+    frequency = frequency.upper()
+    
+    # 2. Initialize Scheduler Interface
+    scheduler = WindowsTaskScheduler()
+    
+    # 3. Check for existing task
+    # The scheduler handles the folder prefix (e.g. \\datalys2\\) internal to query_task
+    print(f"✨ [Datalys2] Checking status for task: '{name}'")
+    existing_task = scheduler.query_task(name)
+    
+    if existing_task and not overwrite:
+        print(f"✅ [Datalys2] Task '{name}' is already scheduled. Continuing execution...")
+        return True
+        
+    # 4. Prepare Context
+    # We need the absolute path to this script so the scheduler knows what to run.
+    # Note: This relies on sys.argv[0] being the script path.
+    script_path = os.path.abspath(sys.argv[0])
+    
+    action_verb = "Updating" if existing_task else "Registering"
+    print(f"⚙️  [Datalys2] {action_verb} '{name}' to run {frequency}...")
+    if at:
+        print(f"   🕒 Time: {at}")
+    if interval:
+        print(f"   ⏱️ Interval: {interval} minutes")
+    
+    # 5. Execute Creation/Update
+    success = scheduler.create_task(
+        task_name=name,
+        script_path=script_path,
+        schedule=frequency,
+        start_time=at,
+        interval_minutes=interval,
+        args=args,
+        force=True # We force here because we've already decided to update/create
+    )
+    
+    if success:
+        print(f"🚀 [Datalys2] Success! '{name}' is scheduled.")
+    else:
+        print(f"❌ [Datalys2] Failed to schedule '{name}'. Check permissions or logs.")
+        
+    return success
+
+# Alias for backward compatibility
+def ensure_task(
+    task_name: str,
+    schedule: str = "DAILY",
+    start_time: Optional[str] = None,
+    interval_minutes: Optional[int] = None,
+    script_args: Optional[List[str]] = None,
+    force_update: bool = False
+) -> bool:
+    """
+    Deprecated alias for `schedule_me`.
+    Please use `datalys2_tasks.scheduler.autorun.schedule_me` instead.
+    """
+    return schedule_me(
+        name=task_name,
+        frequency=schedule,
+        at=start_time,
+        interval=interval_minutes,
+        args=script_args,
+        overwrite=force_update
+    )