Executes all tasks in the provided DAG according to their dependencies. The method first validates the DAG and gets a topological ex

Builds the DAG from a list of "entry" ParsletFuture objects. Entry futures are typically the terminal tasks of a workflow (t

Return the current battery percentage if available.

Returns the available system RAM in Megabytes (MB). This function relies on the `psutil` library. If `psutil` is not installed or if an

Validates the DAG structure, primarily checking for cycles. If the graph is empty, validation is considered successful (vacu

Records an exception that occurred during the task's execution. This method is typically called by the `DAGRunner` if the task

Load a workflow script or module reference. The ``path`` can either be a filesystem path to a Python file or a ``module:func`` reference. In

Globally allow redefining tasks regardless of decorator flags.

Retrieves the result of the task. If the task executed successfully, its return value is provided. If the task failed, the e

Return ``True`` if *all* requirements are satisfied.

Sets the successful result of the task. This method is typically called by the `DAGRunner` once the task has completed succe

Performs a topological sort on the DAG to get a valid execution order of task IDs. Tasks with no dependencies will appear ea

Record a successfully finished task. Parameters ---------- task_id: The unique identifier of the task. st

Return the workflow entry function for a loaded module. Resolution order: 1) ``main`` function, for backwards compatibility. 2) A single

Return desired worker count given current resource probes.

Ensure the sample.png asset exists and return its path.

Returns the number of logical CPUs available to the system. This function uses `os.cpu_count()`. It is designed to always return a posit

Return the best effort :class:`PowerState` for the system. Providers are tried in order and the first non-``None`` result is used. If every p

Retrieves the `ParsletFuture` object for a given task ID. Args: task_id (str): The unique ID of the task. Retur

Block network socket creation when ``enabled`` is :data:`True`.

Saves the Parslet DAG as a PNG image file. This function requires both the `pydot` library and a functional Graphviz installation (speci

DEFCON1: scan for dangerous calls.

DEFCON2: verify DAG hash against signature.

Initializes the DAGRunner. Args: max_workers (Optional[int]): The maximum number of worker threads for t

Return ``True`` if *expr* refers to ``dask.delayed``.

Determine how many workers to use based on system resources.

Wrap a Parslet task function as a Parsl ``python_app``. This requires the ``parsl`` package to be installed. The returned function behaves li

Return the directory used for storing cache files.

Retrieves benchmark data for all tasks processed or known by the runner. The returned data includes the status of each task

Return the current view of all known detectors and overrides.

Execute a task synchronously in fallback mode.

Serialize ``obj`` into JSON-friendly structures. Non-JSON-serializable objects fall back to ``repr`` strings. Collections are processed recur

A simple Parslet task that adds two integers. Simulates some work using `time.sleep()`. Args: a (int): The first integer.

Analyze an image with tiny models. Args: image_path: Path to input image. output_dir: Directory to store outputs. ignore_

Evaluate one or more ``ParsletFuture`` objects like ``dask.compute``.

Converts a Parslet DAG to a `pydot.Dot` object using NetworkX. This function serves as the core conversion utility for generating visual

Return a simple visualisation of the DAG. If ``ascii_only`` is True or Graphviz is not available, an ASCII representation is returned

Execute a Parslet workflow using Dask. Parameters ---------- entry_futures: Terminal futures from the workflow's ``main()`` funct

Export a Parslet DAG to a Parsl-style Python script.

Finds an available port starting from ``start_port``. Args: start_port: Initial port to try. max_tries: Maximum number of increme

Returns a list of task IDs that are direct dependencies (predecessors) of the specified task. Args: task_id (str

Convert a simple Parsl workflow file to Parslet syntax. Parameters ---------- src : str Path to the Parsl script. dest : str

Derive graph edges by inspecting task parameter references. The helper assumes that if a parameter name matches another task name the latter

Return True if we can reach the given host:port within ``timeout``.

Checks if the script is currently running within a Termux environment. The detection is primarily based on the presence and specific values

Decorator to define a Python function as a Parslet task. When a function decorated with `@parslet_task` is called, it does not execute i

Return a pre-flight briefing describing contexts and tasks.

Persist ``value`` for ``key`` to the cache.

A simple Parslet task that squares an integer. Simulates some work using `time.sleep()`. Args: x (int): The integer to square.

DEFCON3: ensure files unchanged.

Topologically sort ``tasks`` given an iterable of ``edges``. A ``ValueError`` is raised if a cycle is detected. The algorithm is a tiny impl

Lazily load Parsl with a small thread pool configuration.

Adjust executor worker count based on current policy.

Provide a simple one-line remediation hint based on the exception.

Resolves the arguments for a given ParsletFuture by obtaining results from its dependency ParsletFutures. This method iterat

Callback executed when a task submitted to the ThreadPoolExecutor completes. This method retrieves the result (or exception)

Applies a Gaussian blur to a Pillow Image object.

Return a JSON-serialisable structure describing the run.